text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
export default 'edge.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>exp<|fim_middle|>ort default 'node.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>ex<|fim_suffix|>ed.js'
<|fim_middle|>port default 'node.unbundl<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default<|fim_suffix|>s'
<|fim_middle|> 'browser.j<|endoftext|> | fim | vitejs/vite | javascript |
export default 'default.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>lt 'edge.js'
<|fim_prefix|>ex<|fim_middle|>port defau<|endoftext|> | fim | vitejs/vite | javascript |
export default 'node.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>node.unbundled.js'
<|fim_prefix|>export defa<|fim_middle|>ult '<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import express from 'express'
import sirv from 'sirv'
const isTest = process.env.VITEST
export async function createServer(
root = process.cwd(),
isProd = process.env.NODE_ENV === 'production',
hmrPort,
) {
const resolve = (p) => path.resolve... | fim | vitejs/vite | javascript |
<|fim_suffix|>let html = ''
html += `\n<p class="no-external-react-server">${noExternalReactServerMessage}</p>`
html += `\n<p class="browser-no-external-react-server"></p>`
html += `\n<p class="external-react-server">${externalReactServerMessage}</p>`
html += `\n<p class="browser-external-react-server"></p>... | fim | vitejs/vite | javascript |
<|fim_suffix|>conditions: [...defaultServerConditions, 'react-server'],
externalConditions: ['node', 'workerd', 'react-server'],
},
},
})
<|fim_prefix|>import { def<|fim_middle|>aultServerConditions, defineConfig } from 'vite'
export default defineConfig({
ssr: {
external: ['@vitejs/test-ssr-conditio... | fim | vitejs/vite | javascript |
<|fim_suffix|>) {
await vite.close()
}
},
})
})
} catch (e) {
reject(e)
}
})
}
<|fim_prefix|>// this is automatically dete<|fim_middle|>cted by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import path from 'node:path... | fim | vitejs/vite | typescript |
<|fim_suffix|>src/isomorphic-module-browser.js', (code) =>
code.replace('[browser]', '[browser-hmr]'),
)
await page.waitForNavigation()
await expect
.poll(async () => {
return page.textContent('.isomorphic-module-browser')
})
.toMatch('[browser-hmr]')
editFile('src/isomo... | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>// prettier-ignore
Objec<|fim_middle|>t.defineProperties ( exports , {
hello: {
value() {
return 'Hello World!'
}
}
})<|endoftext|> | fim | vitejs/vite | javascript |
Object.defineProperty(exports, 'hello', {
value() {
return 'Hello World!'
},
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Module with state, to check that it is properly externalized and
// not bundled in the optimized deps
le<|fim_suffix|>rnalMsg) {
msg = externalMsg
}
export default function getMessage() {
return msg
}
<|fim_middle|>t msg
export function setMessage(exte<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>fined
<|fim_prefix|>export <|fim_middle|>default unde<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import getMessage from 'external<|fim_suffix|>e()
},
}
<|fim_middle|>-entry/entry'
export default {
hello() {
return getMessag<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>assigned-exports')
module.exports = original
<|fim_prefix|><|fim_middle|>const original = require('object-<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>exports.stream = require('node:stream')
exports.hello = function () {
<|fim_middle|> return 'Hello World!'
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>V ? 'development' : 'production'
}!`
}
<|fim_prefix|>export cons<|fim_middle|>t hello = function () {
// make sure linked package is not externalized so Vite features like
// import.meta.env works (or handling TS files)
return `Hello World from ${
import.meta.env.DE<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>lt '[success]'
<|fim_prefix|>expo<|fim_middle|>rt defau<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> this file.
export default '[fail] should not load me'
<|fim_prefix|>// this is written in ESM but the file extension implie<|fim_middle|>s this is evaluated as CJS.
// BUT this doesn't matter in practice as the `module` condition is not used in node.
// hence SSR should not load<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ejs/test-nested-include'
export default 'nested-exclude'
<|fim_prefix|>export { default as nestedInclude } from '@vi<|fim_middle|>t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>sg) {
msg = externalMsg
}
export default function getMessage() {
return msg
}
<|fim_prefix|>// Module with state, to check t<|fim_middle|>hat it is properly externalized and
// not bundled in the optimized deps
let msg
export function setMessage(externalM<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Module with state, to check that it is properly externalized and
// not bundled in the optimized deps
let msg
module.expor<|fim_suffix|>g
},
getMessage() {
return msg
},
}
<|fim_middle|>ts = {
setMessage(externalMsg) {
msg = externalMs<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>d-include'
<|fim_prefix|>// written in cjs, optimization should convert this to esm
module.export<|fim_middle|>s = 'neste<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exports<|fim_suffix|> return 'Hello World!'
}
<|fim_middle|>.hello = function () {
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>xternal from 'nested-external-cjs'
setMessage('Hello World!')
external.setMessage('Hello World!')
<|fim_prefix|>import { setMessage } from 'nested-external'
import<|fim_middle|> e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>Object.defineProperty(exports, '__esModule', { value: true })
const obj = {
hello() {
return 'Hell<|fim_suffix|>ssign(exports, obj)
<|fim_middle|>o World!'
},
}
Object.a<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>Object.assign(exports, {
he<|fim_suffix|>() {
return 'Hello World!'
},
})
<|fim_middle|>llo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const getMessage <|fim_suffix|>rts = {
hello: getMessage,
}
<|fim_middle|>= require('nested-external')
module.expo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import getMessage from 'nested-external'
<|fim_suffix|>sage()
}
<|fim_middle|>
export function hello() {
return getMes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>d
<|fim_prefix|><|fim_middle|>export default undefine<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>module.exports = 'Hello<|fim_suffix|>d!'
<|fim_middle|> Worl<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> return await fs.readFile(path.resolve(filePath), 'utf-8')
}
<|fim_prefix|>const path = require('node:path')
module.exports = async function readFileContent(filePath) {
const fs = re<|fim_middle|>quire('node:fs/promises')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>lo = 'Hello World!'
<|fim_prefix|>module.exp<|fim_middle|>orts.hel<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const path = require('node:path')
module.exports.hello = (<|fim_suffix|>ello
<|fim_middle|>) => require(path.resolve(__dirname, './foo.js')).h<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// @ts-check
import fs from 'node:fs'
import path from 'node:path'
import express from 'express'
const isTest = process.env.VITEST
const noExternal = [
'@vitejs/test-no-external-cjs',
'@vitejs/test-import-builtin-cjs',
'@vitejs/test-no-external-css',
'@vitejs/test-external-entry',
]
export asyn... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import readFileContent from '@vitejs/test-read-file-content'
import primitiveExport from '@vitejs/test-primitive-export'
import tsDefaultExport, {
hello as tsNamedExport,
} from '@vitejs/test-ts-transpiled-exports'
import objectAssignedExports from '@vitejs/test-object-assig... | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>const message = 'message from isomorphic-mod<|fim_middle|>ule (browser): [browser]'
export default message<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const message = '<|fim_suffix|>ver): [server]'
export default message
<|fim_middle|>message from isomorphic-module (ser<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>'use strict'
Object.defineProperty(exports, '__esModule', { value: true })
exports.hello = void 0
function<|fim_suffix|>orts.default = hello
<|fim_middle|> hello() {
return 'Hello World!'
}
exports.hello = hello
exp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>atch (e) {
reject(e)
}
})
}
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import path from 'node:path'
import kill from 'kill-port'
import { createInMemoryLogger, hmrPorts<|fim_middle|>, ports, rootDir } fr... | fim | vitejs/vite | typescript |
import { execFile } from 'node:child_process'
import { promisify } from 'node:util'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import { setTimeout } from 'node:timers/promises'
import { describe, expect, test } from 'vitest'
import { port, serverLogs } from './serve'
import { editFile, isServ... | fim | vitejs/vite | typescript |
<|fim_suffix|>get:t[r],enumerable:!0})},u=(e,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of x(t))!p.call(e,n)&&n!==r&&d(e,n,{get:()=>t[n],enumerable:!(i=m(t,n))||i.enumerable});return e},o=(e,t,r)=>(u(e,t,"default"),r&&u(r,t,"default")),c=(e,t,r)=>(r=e!=null?a(g(e)):{},u(t||!e||!e.__esModule?d(r,"... | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import express from 'express'
const isTest = process.env.VITEST
const DYNAMIC_SCRIPTS = `
<script type="module">
const p = document.createElement('p');
p.innerHTML = '✅ Dynamically injected inline script';
document.body.appendChild(p);
... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { virtual } from 'virtual:file'
const p = document.createElement('p')
p.innerHTML = '✅ Dynamically injected script from file'
document.body.appendChild(p)
text('.virtual', virtual)
function text(el, text) {
d<|fim_suffix|>= text
}
<|fim_middle|>ocument.querySelector(el).textContent <|endoftext... | fim | vitejs/vite | javascript |
<|fim_prefix|>ex<|fim_suffix|>'e')
}
<|fim_middle|>port function error() {
throw new Error(<|endoftext|> | fim | vitejs/vite | javascript |
export function error() {
throw new Error('e')
}
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>d {
crash('crash')
}
<|fim_prefix|>function crash(message: string) {
throw new Error(message)
}
export function main()<|fim_middle|>: voi<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const virtual = '[s<|fim_suffix|>
<|fim_middle|>uccess]'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// same port as `ports["ssr-html"]` in playground/<|fim_suffix|>0.js'
// or test without local server
// import slash from 'https://esm.sh/slash@3.0.0'
export { slash }
<|fim_middle|>test-utils.ts
import slash from 'http://localhost:9602/slash@3.0.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import assert from 'node:assert'
import { fileURLToPath } from 'node:url'
import { createServer, createServerModuleRunner } from 'vite'
async function runTest(userRunner) {
const server = await createServer({
configFile: false,
root: fileURLToPath(new URL('.', import.meta.url)),
server: {
... | fim | vitejs/vite | javascript |
<|fim_prefix|>imp<|fim_suffix|> await server.close()
}
assert.match(error?.stack, /has-error-deep.ts:6:3/)
<|fim_middle|>ort { fileURLToPath } from 'node:url'
import assert from 'node:assert'
import { createServer, createServerModuleRunner } from 'vite'
// same test case as packages/vite/src/node/ssr/runtime/__tests_... | fim | vitejs/vite | javascript |
<|fim_suffix|>od of [abs1, abs2, relative]) {
try {
mod.error()
} catch (e) {
// this should not be called
// when sourcemap support for `new Function` is supported and sourcemap is enabled
// because the stacktrace is already rewritten by Node.js
if (!isSourceMapEnabled) {
vite.ssrFixStac... | fim | vitejs/vite | javascript |
<|fim_prefix|>document.<|fim_suffix|>ule loaded'
<|fim_middle|>querySelector('.relative-script').textContent =
'relative mod<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rent-script').textContent =
'relative parent module loaded'
<|fim_prefix|>document.querySelec<|fim_middle|>tor('.relative-pa<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will r<|fim_suffix|>rts['ssr-noexternal'],
)
return new Promise((resolve, reject) => {
try {
const server = app.listen(port, () => {
resolve({
// for test teardown
async close() {
awai... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { port } from './serve'
import { isBuild, page } from '~utils'
const url = `http://localhost:${port}`
test.runIf(!isBuild)('message from require-external-cjs', <|fim_suffix|>equire-external-cjs')).toMatch('foo')
})
<|fim_middle|>async () => {
await page.got... | fim | vitejs/vite | typescript |
<|fim_prefix|>thr<|fim_suffix|>ouldnt be loaded')
<|fim_middle|>ow new Error('sh<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>module.exports = require('@vitejs/test-external-cj<|fim_suffix|>
<|fim_middle|>s')<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import express from 'express'
const isTest = process.env.VITEST
export async function createServer(
root = process.cwd(),
isProd = process.env.NODE_ENV === 'production',
hmrPort,
) {
const resolve = (p) => path.resolve(import.meta.dirname, p)... | fim | vitejs/vite | javascript |
import requireExternalCjs from '@vitejs/test-require-external-cjs'
export async function render(url) {
let html = ''
html += `\n<p class="require-external-cjs">message from require-external-cjs: ${requireExternalCjs}</p>`
return html + '\n'
}
<|endoftext|> | fim | vitejs/vite | javascript |
import { defineConfig } from 'vite'
const noExternal = ['@vitejs/test-require-external-cjs']
export default defineConfig({
ssr: {
noExternal,
external: ['@vitejs/test-external-cjs'],
optimizeDeps: {
include: noExternal,
},
},
build: {
target: 'esnext',
minify: false,
rolldownOpt... | fim | vitejs/vite | javascript |
<|fim_prefix|>// this is automatically detected by playgr<|fim_suffix|>(resolve) => {
server.close(resolve)
})
if (vite) {
await vite.close()
}
},
})
})
} catch (e) {
reject(e)
}
})
}
<|fim_middle|>ound/vitestSetup.t... | fim | vitejs/vite | typescript |
<|fim_suffix|> })
.map((n) => n.getAttribute('src')),
)
// assert at least 1 proxied script exists
expect(proxiedScripts).not.toHaveLength(0)
const scriptContents = await Promise.all(
proxiedScripts.map((src) => fetch(url + src).then((res) => res.text())),
)
// all proxied... | fim | vitejs/vite | typescript |
<|fim_prefix|>// @ts-check
import path from 'node:path'
import pug from 'pug'
import express from 'express'
const isTest = process.env.VITEST
const DYNAMIC_SCRIPTS = `
<script type="module">
const p = document.createElement('p');
p.innerHTML = '✅ Dynamically injected inline script';
document.body.append... | fim | vitejs/vite | javascript |
<|fim_suffix|>pendChild(p)
<|fim_prefix|>const p = document.createElement('p')
<|fim_middle|>p.innerHTML = '✅ Dynamically injected script from file'
document.body.ap<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { execFile } from 'node:child_process'
import { promisify } from 'node:util'
import { expect,<|fim_suffix|>port/utils/bar.js${_}`),
// )
expect(contents).toMatch(new RegExp(`from ${_}@vitejs/test-module-sync${_}`))
await execFileAsync('node', [`${testDir}/dist/main.mjs`])
})
test.runIf(isB... | fim | vitejs/vite | typescript |
export default 'foo'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>al-nested'
<|fim_prefix|>export { default as foo } from '<|fim_middle|>./foo'
export { default as bar } from './bar'
export default 'extern<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>e<|fim_suffix|>fault 'bar'
<|fim_middle|>xport de<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>('entries'))
<|fim_prefix|>module.exports = __filename.slice(__filename.last<|fim_middle|>IndexOf<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>module.exports = __filena<|fim_middle|>me.slice(__filename.lastIndexOf('entries'))<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// no `exports` key, should resolve to entries/dir/index.js
import dirEntry from '@vitejs/test-entries/dir'
// no `exports` key, should resolve to entries/file.js
import fileEntry from '@vitejs/test-entries/file'
// has `exports` key, should resolve to pkg-exports/entry
import pkgExportsEntry from '@vitej... | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>module.exports <|fim_middle|>= 'pkg-exports entry'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>undefined
<|fim_prefix|>module.expor<|fim_middle|>ts = <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default '<|fim_suffix|>
<|fim_middle|>module-sync'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>tion treeshaken(s) {
return pathToFileURL(s)
}
<|fim_prefix|>import { pathToFileURL } from 'node<|fim_middle|>:url'
export function used(s) {
return s
}
// This is not used, so `node:url` should not be bundled
export func<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
ssr: './main.js<|fim_suffix|>,
})
<|fim_middle|>',
}<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> } catch (e) {
reject(e)
}
})
}
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import path from 'node:path'
import kill from 'kill-port'
import { build } from 'vite'
import { hmrPorts, isBuild, ports, rootDi... | fim | vitejs/vite | typescript |
import { expect, test } from 'vitest'
import { port } from './serve'
import { findAssetFile, isBuild, listAssets, page } from '~utils'
const url = `http://localhost:${port}`
test('should work when inlined', async () => {
await page.goto(`${url}/static-light`)
expect(await page.textContent('.static-light')).toMatc... | fim | vitejs/vite | typescript |
<|fim_prefix|>import express from 'express'
const isTest = pro<|fim_suffix|>, so enforce polling for consistency
usePolling: true,
interval: 100,
},
hmr: {
port: hmrPort,
},
},
appType: 'custom',
})
// use vite's connect instance as middleware
... | fim | vitejs/vite | javascript |
<|fim_prefix|>export async function render(url) {
switch (url) {
case '/':
return `<ul>${[
'/static-light',
'/static-heavy',
'/direct-add',
'/direct-light',
]
.map((name) => `<li><a href="${name}">${name}</a></li>`)
.join('')}</ul>`
case '/static-lig... | fim | vitejs/vite | javascript |
<|fim_suffix|>xport async function render() {
return `<div class="direct-add">${add(1, 2)}</div>`
}
<|fim_prefix|>import { add } from './add.wasm'<|fim_middle|>
e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>nder() {
exported_func()
return `<div class="direct-light">${getResult()}</div>`
}
<|fim_prefix|>import { exported_func } from './light-with-<|fim_middle|>imports.wasm'
import { getResult } from './imports.js'
export async function re<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>let lastResult
expor<|fim_suffix|>lastResult
}
<|fim_middle|>t function imported_func(result) {
lastResult = result
}
export function getResult() {
return <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import h<|fim_suffix|>ts: {
imported_func: (res) => (result = res),
},
}).then((i) => i.exports)
exported_func()
return `<div class="static-heavy">${result}</div>`
}
<|fim_middle|>eavy from './heavy.wasm?init'
export async function render() {
let result
const { exported_func } = await... | fim | vitejs/vite | javascript |
import light from './light.wasm?init'
export async function render() {
let result
const { exported_func } = await light({
imports: {
imported_func: (res) => (result = res),
},
}).then((i) => i.exports)
exported_func()
return `<div class="static-light">${result}</div>`
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> },
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
// make cannot emit light.wasm
assetsInlineLi<|fim_middle|>mit: 80,
ssr: './src/app.js',
ssrEmitAssets: true,
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import path from 'node:path'
import kill from 'kill-port'
import { ports, rootDir } from '~utils'
export const port = ports['ssr-webworker']
export async function serve(): Promise<{ cl... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { port } from './serve'
import { findAssetFile, isBuild, page } from '~utils'
const url = `http://localhost:${port}`
test('/', async () => {
await page.goto(url + '/')
expect(aw<|fim_suffix|>rkerContent).not.toContain('createRequire')
})
test.runIf(isBui... | fim | vitejs/vite | typescript |
export default '[success] browser'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export <|fim_suffix|>load me'
<|fim_middle|>default '[fail] should not <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>'foo'
<|fim_prefix|>e<|fim_middle|>xport const foo = <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { equal } from 'node:assert'
import { msg as linkedMsg } from '@vitejs/test-resolve-linked'
import browserExportsMessage from '@vitejs/test-browser-exports'
import workerExportsMessage from '@vitejs/test-worker-exports'
import React from 'react'
let loaded = false
import<|fim_suffix|>'a') || '[suc... | fim | vitejs/vite | javascript |
<|fim_suffix|>as they may be implemented
// in the runtime, and so we can externalize it when bundling.
external: ['node:assert'],
resolve: {
conditions: [...defaultClientConditions, 'worker'],
},
},
plugins: [
{
name: '@vitejs/test-ssr-webworker/no-external',
config() {
... | fim | vitejs/vite | javascript |
<|fim_suffix|>e'
<|fim_prefix|>// conditions are set to<|fim_middle|> worker, and worker is higher up in the exports object in package.json, so should be preferred
export default '[fail] should not load m<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>efault '[fail] should not load me'
<|fim_middle|>rt d<|endoftext|> | fim | vitejs/vite | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.