text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|><|fim_suffix|>'
<|fim_middle|>export default '[success] worker<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>resolve(
import.meta.dirname,
'dist/worker/entry-worker.js',
),
port,
modules: true,
compatibilityFlags: ['nodejs_compat'],
})
await mf.ready
return { mf }
}
if (!isTest) {
createServer(5173).then(() => console.log('http://localhost:5173'))
}
<|fim_prefix|>import path ... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { editFile, getColor, isServe, page, untilBrowserLogAfter } from '~utils'
test('should render', async () => {
expect(await page.textContent('#pagetitle')).toBe('Page title')
})
test.runIf(isServe)(
'full reload happens when the HTML is changed',
async (... | fim | vitejs/vite | typescript |
<|fim_suffix|>nt1"]').forEach((d) => {
d.outerHTML = mod.component1
})
})
<|fim_prefix|>export const component1 = /* html */ `
<div id="component1" data-id="component1" class="text-red-600">component1</div>
`
import.meta.hot?.accept((mod) => {
doc<|fim_middle|>ument.querySelectorAll('[data-id="compone<|endof... | fim | vitejs/vite | javascript |
<|fim_suffix|>.innerHTML = main(mod.view1)
})
<|fim_prefix|>import { view1 } from './views/view1'
export const main = (view1Content) => /* html */ `
<h1 id="pagetitle" class="text-3xl t<|fim_middle|>ext-violet-600">Page title</h1>
${view1Content}
<!-- used in postcss-plugins-different-dir -->
<div id="tailwind... | fim | vitejs/vite | javascript |
<|fim_suffix|>mponents/component1'
export const view1 = /* html */ `
<div data-id="view1">
<div id="view1-text" class="text-green-600">|view1|</div>
${component1}
</div>
`
<|fim_prefix|>import { component1 } fro<|fim_middle|>m '../co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import type { Config } from 'tailwindcss'
export default {
content: [
// Before editing this section, make sure no paths are matching with `/src/main.js`
// See https://github.com/vitejs/vite/pull/6959 for more details
imp<|fim_suffix|>irname + '/src/main.js',
import.meta.dirname + '/in... | fim | vitejs/vite | typescript |
<|fim_suffix|>code, id) {
if (id.includes('views/view1.js')) {
await new Promise((resolve) => setTimeout(resolve, 100))
}
},
},
delayIndexCssPlugin(),
tailwindcss(),
],
})
<|fim_prefix|>import { defineConfig } from 'vite'
import type { Plugin } from 'vite'
import tailwindcs... | fim | vitejs/vite | typescript |
<|fim_suffix|> warning (#4939)', () => {
serverLogs.forEach((log) => {
expect(log).not.toMatch('Sourcemap is likely to be incorrect')
})
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { isBuild, serverLogs } from '~utils'
test.runIf(!isBuild)('should not output missing source file warning', () =... | fim | vitejs/vite | typescript |
<|fim_suffix|>t postcss integration
'@tailwindcss/postcss': {},
},
}
<|fim_prefix|>export <|fim_middle|>default {
plugins: {
// using postcss tailwind as we want to tes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rcemap: true,
},
build: {
sourcemap: true,
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineCon<|fim_middle|>fig({
css: {
devSou<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> updated: /src/main.js'],
false,
)
await expect.poll(() => getColor(el)).toBe('rgb(8, 145, 178)')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { editFile, getColor, isServe, page, untilBrowserLogAfter } from '~utils'
test('should render', async () => {
expect(await page.textCon... | fim | vitejs/vite | typescript |
<|fim_prefix|>// postcss.config.ts
import { fileURLToPath } from 'node:url'
export default {
plugins: {
tailwindcss: {
config: fileURLToPath(new URL(<|fim_suffix|> },
autoprefixer: {},
},
}
<|fim_middle|>'./tailwind.config.ts', import.meta.url)),
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const component1 = /* <|fim_suffix|>ySelectorAll('[data-id="component1"]').forEach((d) => {
d.outerHTML = mod.component1
})
})
<|fim_middle|>html */ `
<div id="component1" data-id="component1" class="text-red-600">component1</div>
`
import.meta.hot?.accept((mod) => {
document.quer<|endof... | fim | vitejs/vite | javascript |
<|fim_suffix|> main(view1)
import.meta.hot?.accept((mod) => {
document.getElementById('app').innerHTML = mod.main(view1)
})
import.meta.hot?.accept(['./views/view1'], ([mod]) => {
document.getElementById('app').innerHTML = main(mod.view1)
})
<|fim_prefix|>import { view1 } from './views/view1'
export const main =... | fim | vitejs/vite | javascript |
<|fim_suffix|>iv>
${component1}
</div>
`
<|fim_prefix|>import { component1 } from '../c<|fim_middle|>omponents/component1'
export const view1 = /* html */ `
<div data-id="view1">
<div id="view1-text" class="text-green-600">|view1|</d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>/**/*.js',
__dirname + '/src/main.js',
],
theme: {
extend: {},
},
variants: {
extend: {},
},
plugins: [],
} satisfies Config
<|fim_prefix|>import type { Config } from 'tailwindcss'
// NOTE: tailwind does not seem to support `import.meta.dirname` on Node 20
export default {
cont... | fim | vitejs/vite | typescript |
import { defineConfig } from 'vite'
import type { Plugin } from 'vite'
function delayIndexCssPlugin(): Plugin {
let server
return {
name: 'delay-index-css',
enforce: 'pre',
configureServer(_server) {
server = _server
},
async load(id) {
if (server && id.includes('index.css')) {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>// test utils used in e2e tests for playgrounds.
// `import { getColor } from '~utils'`
import fs from 'node:fs'
import path from 'node:path'
import colors from 'css-color-names'
import type {
ConsoleMessage,
ElementHandle,
Locator,
} from 'playwright-chromium'
import type { DepOptimizationMetadata... | fim | vitejs/vite | typescript |
<|fim_prefix|>// NOTE: a sepa<|fim_suffix|> tests } from '../tests'
tests()
<|fim_middle|>rate directory from `playground/transform-plugin` is created by playground/vitestGlobalSetup.ts
import {<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> })
}
<|fim_prefix|>import { expect, test } from 'vitest'
import { editFile, isBuild, page } from '~utils'
export const tests = () => {
test('should re-run transform when dependencies are edited', async () => {
expect(await page.textContent('<|fim_middle|>#transform-count')).toBe('1')
if (isB... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { tests } from './tests'
import { page } from '~utils'
test('modul<|fim_suffix|>lazy hook filter should be applied', async () => {
expect(await page.textContent('#lazy-hook-filter')).toBe('success')
})
tests()
<|fim_middle|>e type should be supported', asyn... | fim | vitejs/vite | typescript |
<|fim_prefix|>import barJson from 'virtual:/bar.json'
import fooJson from './foo.json'
// 'TRANSFORM_COUNT' is injected by the transform plugin
document.getElementById('transform-count').innerHTML = TRANSFORM_COUNT
document.getElementById('module-type-json-pre').innerHTML =
fooJson.moduleTypePre
document.getElement... | fim | vitejs/vite | javascript |
<|fim_prefix|>// Empty file for detecting changes in <|fim_suffix|>
<|fim_middle|>tests<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Empty file for detecting chan<|fim_suffix|>sts
<|fim_middle|>ges in te<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>defineConfig({
...baseConfig,
base: '/vite/',
})
<|fim_prefix|>import { define<|fim_middle|>Config } from 'vite'
import baseConfig from './vite.config.js'
export default <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>d(id) {
if (id === 'virtual:/bar.json') {
return '\0/bar.json'
}
},
load(id) {
if (id.endsWith('\0/bar.json')) {
return JSON.stringify({
moduleTypePre: 'MODULE_TYPE_PRE',
moduleTypePost: 'MODULE_TYPE_POST',
})
}
},
},
]
con... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import fs from 'node:fs'
import { transformWithEsbuild } from 'vite'
import { describe, expect, test } from 'vitest'
import { browserLogs, isServe, serverLogs } from '~utils'
test('should respected each `tsconfig.json`s compilerOptions', () => {
// main side effect should b... | fim | vitejs/vite | typescript |
<|fim_prefix|>// @ts-nocheck
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
import { NestedTypeOnlyClass } from './not-used-type'
class NestedBase {
set data(val<|fim_suffix|> = new NestedDerived()
<|fim_middle|>ue: string) {
console.log('data setter in NestedBase')
}
}
class NestedDeri... | fim | vitejs/vite | typescript |
<|fim_prefix|>console.log('nested side effect')
export <|fim_suffix|>lass {}
<|fim_middle|>class NestedTypeOnlyC<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// @ts-nocheck
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
import { NestedWithExtendsTypeOnlyClass } from './not-used-type'
class NestedWithExtendsBase {
set data(value: string) {
console.log('data setter in NestedWithExtendsBase')
}
}
class<|fim_suffix|>ata = 10
foo... | fim | vitejs/vite | typescript |
<|fim_prefix|>console.log('nested-with-ex<|fim_suffix|>
<|fim_middle|>tends side effect')
export class NestedWithExtendsTypeOnlyClass {}<|endoftext|> | fim | vitejs/vite | typescript |
// @ts-nocheck playground/tsconfig.json does not have decorators enabled
function first() {
return function (...args: any[]) {}
}
export class Foo {
@first()
method(@first() test: string) {
return test
}
}
<|endoftext|> | fim | vitejs/vite | typescript |
// @ts-nocheck
import '../nested/main'
import '../nested-with-extends/main'
import './decorator'
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
import { MainTypeOnlyClass } from './not-used-type'
class MainBase {
set data(value: string) {
console.log('data setter in MainBase')
}
}
clas... | fim | vitejs/vite | typescript |
<|fim_suffix|>nTypeOnlyClass {}
<|fim_prefix|>console.log(<|fim_middle|>'main side effect')
export class Mai<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> undefined
export async function serve() {
try {
await startDefaultServe()
} catch (e) {
serveError = e
}
}
export function clearServeError() {
serveError = undefined
}
afterAll(() => {
if (serveError) {
throw serveError
}
})
<|fim_prefix|>import { afterAll } from 'vitest'
impor... | fim | vitejs/vite | typescript |
<|fim_suffix|>g.json', (content) => {
return content.replace('"compilerOptions":', '"compilerOptions":{}')
})
await expect
.poll(() => browserLogs)
.toContain('tsconfig error fixed, file loaded')
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { clearServeError, se... | fim | vitejs/vite | typescript |
console.log('tsconfig error fixed, file loaded')
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>../has-error/main'
<|fim_prefix|>// @ts<|fim_middle|>-nocheck
import '<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>it browserServer?.close()
if (!process.env.VITE_PRESERVE_BUILD_ARTIFACTS) {
await fs.rm(path.resolve(import.meta.dirname, '../playground-temp'), {
recursive: true,
})
}
}
function copyWithFriendlyError(
src: string,
dest: string,
opts?: CopyOptions,
): Promise<void> {
return fs.... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type * as http from 'node:http'
import fs from 'node:fs'
import path from 'node:path'
import { chromium } from 'playwright-chromium'
import type {
ConfigEnv,
InlineConfig,
Logger,
PluginOption,
ResolvedConfig,
UserConfig,
ViteDevServer,
} from 'vite'
import {
build,
createBuilder,... | fim | vitejs/vite | typescript |
<|fim_suffix|>extContent('.worker-wasm .result')).toMatch('3')
})
test('direct wasm import', async () => {
await expect.poll(() => page.textContent('.direct-wasm .result')).toMatch('3')
})
test('direct wasm import with wasm imports', async () => {
await expect
.poll(() => page.textContent('.direct-wasm-with-i... | fim | vitejs/vite | typescript |
<|fim_prefix|>let lastResult
export fu<|fim_suffix|> result
}
export function getResult() {
return lastResult
}
<|fim_middle|>nction imported_func(result) {
lastResult =<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ineLimit: 80,
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
// make cannot emit light.wasm
// and emi<|fim_middle|>t add.wasm
assetsInl<|endoftext|> | fim | vitejs/vite | typescript |
import init from './add.wasm?init'
init().then(({ exports }) => {
self.postMessage({ result: exports.add(1, 2) })
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { describe, expect, test } from 'vitest'
import { isBuild, page, testDir } from '~utils'
test('normal', async () => {
await expect.poll(() => page.textContent('.pong')).toMatch('pong')
await expect
.poll(() => page.textContent('.mode'))... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { describe, expect, test } from 'vitest'
import {
extractSourcemap,
formatSourcemapForSnapshot,
isBuild,
isServe,
page,
readManifest,
testDir,
viteTestUrl,
} from '~utils'
test('normal', async () => {
await expect.poll(() => p... | fim | vitejs/vite | typescript |
<|fim_suffix|>await expect
.poll(() => page.textContent('.nested-worker-module'))
.toMatch('"type":"module"')
await expect
.poll(() => page.textContent('.nested-worker-constructor'))
.toMatch('"type":"constructor"')
})
})
test('module worker', async () => {
await expect
.poll(() => ... | fim | vitejs/vite | typescript |
<|fim_suffix|>))
.toMatch(isBuild ? '/worker-assets/worker_asset-vite' : '/vite.svg')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { <|fim_middle|>isBuild, page } from '~utils'
test('asset url', async () => {
await expect
.poll(() => page.textContent('.asset-url'<|endoftext|> | fim | vitejs/vite | typescript |
import fs from 'node:fs'
import path from 'node:path'
import { describe, expect, test } from 'vitest'
import { isBuild, testDir } from '~utils'
describe.runIf(isBuild)('build', () => {
// assert correct files
test('sourcemap generation for web workers', async () => {
const assetsDir = path.resolve(testDir, 'di... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { describe, expect, test } from 'vitest'
import { isBuild, testDir } from '~utils'
describe.runIf(isBuild)('build', () => {
// assert correct files
test('sourcemap generation for web workers', async () => {
const assetsDir = path.resolv... | fim | vitejs/vite | typescript |
<|fim_suffix|>t sharedWorkerContent = fs.readFileSync(
path.resolve(assetsDir, sharedWorker),
'utf-8',
)
const sharedWorkerSourcemap = getSourceMapUrl(sharedWorkerContent)
const possibleTsOutputWorker = files.find((f) =>
/^possible-ts-output-worker-[-\w]+\.js$/.test(f),
)
const pos... | fim | vitejs/vite | typescript |
<|fim_suffix|>ssic-esm'
<|fim_prefix|>export const msg = '[<|fim_middle|>success] cla<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>let base = `/${self.location.pathname.split('/')[1]}`
i<|fim_suffix|>for sourcemap
console.log('classic-shared-worker.js')
<|fim_middle|>f (base.endsWith('.js') || base === `/worker-entries`) base = '' // for dev
importScripts(`${base}/classic.js`)
self.onconnect = (event) => {
const port = event.port... | fim | vitejs/vite | javascript |
<|fim_prefix|>(() => {})() // this is to test `importScripts` injection doesn't break the code
let base = `/${self.location.pat<|fim_suffix|> in classic workers.
// NOTE: this test only works in dev.
const importPath = `${base}/classic-esm.js`
const { msg } = await import(/* @vite-ignore */ importPat... | fim | vitejs/vite | javascript |
<|fim_prefix|>self.postMessage({
type: 'deeplyNestedSecondWorker',
data: [
'Hello from second level nested worker',
import.meta.env.BASE_URL,
self.location.url,
import.meta.url,
].join(' '),
})
const deeplyNestedThirdWorker = new Worker(
new URL('deeply-nested-third-worker.js', import.meta.url)... | fim | vitejs/vite | javascript |
<|fim_suffix|>llo from third level nested worker',
import.meta.env.BASE_URL,
self.location.url,
import.meta.url,
].join(' '),
})
console.log('deeply-nested-third-worker.js')
<|fim_prefix|>self.postMessage({
typ<|fim_middle|>e: 'deeplyNestedThirdWorker',
data: [
'He<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>self.postMessage({
type: 'd<|fim_suffix|>r('message', (ev) => {
self.postMessage(ev.data)
})
console.log('deeply-nested-worker.js')
<|fim_middle|>eeplyNestedWorker',
data: [
'Hello from root worker',
import.meta.env.BASE_URL,
self.location.url,
import.meta.url,
].join(' '),
})
co... | fim | vitejs/vite | javascript |
<|fim_suffix|>r(e)
})
}
<|fim_prefix|>export function startWorker(handler) {
const worker = new Worker(new URL('./worker.js', import.m<|fim_middle|>eta.url), {
type: 'module',
})
worker.postMessage('main')
worker.addEventListener('message', (e) => {
handle<|endoftext|> | fim | vitejs/vite | javascript |
// copy of playground/worker/self-reference-url-worker.js
self.addEventListener('message', (e) => {
if (e.data === 'main') {
const selfWorker = new Worker(new URL('./worker.js', import.meta.url), {
type: 'module',
})
selfWorker.postMessage('nested')
selfWorker.addEventListener('message', (e) => ... | fim | vitejs/vite | javascript |
<|fim_suffix|>= 'dep-to-optimize'
<|fim_prefix|>expo<|fim_middle|>rt const msg <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import module1Url from './modules/module1.js?url'
imp<|fim_suffix|>r sourcemap
console.log('emit-chunk-dynamic-import-worker.js')
<|fim_middle|>ort('./modules/module0').then((module) => {
import(/* @vite-ignore */ module1Url).then((module1) => {
self.postMessage(module.default + module1.msg1 + impo... | fim | vitejs/vite | javascript |
import SubWorker from './emit-chunk-sub-worker?worker'
const subWorker = new SubWorker()
subWorker.onmessage = (event) => {
self.postMessage({
type: 'emit-chunk-sub-worker',
data: event.data,
})
}
const moduleWorker = new Worker(
new URL('./module-and-worker.js', import.meta.url),
{ type: 'module' },
... | fim | vitejs/vite | javascript |
<|fim_suffix|>ata[1], ...data[2] }
self.postMessage(_data)
})
// for sourcemap
console.log('emit-chunk-sub-worker.js')
<|fim_prefix|>Promise.all([
import('./module-and-worker'),
<|fim_middle|> import('./modules/module2'),
import('./modules/module3'),
]).then((data) => {
const _data = { ...data[0], ...d<|endof... | fim | vitejs/vite | javascript |
<|fim_prefix|>const modules = import.meta.glob('./modules/*js')
self.onmessage = function (e) {
self.postMessage(Objec<|fim_suffix|>les))
}
// for sourcemap
console.log('importMetaGlob.worker.js')
<|fim_middle|>t.keys(modu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const modules = import.meta.glob('./modules/*js', { eager: true })
self.onmessage = function (e) {
self.postMessage(Object.keys(modules))
}
// for sourcemap
console.log('imp<|fim_suffix|>s')
<|fim_middle|>ortMetaGlobEager.worker.j<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>odule-and-worker.js')
<|fim_prefix|>import constant from './modules/module0'
self.postMessage(constant)
export const module = 'module and worker'
// for sourcemap
c<|fim_middle|>onsole.log('m<|endoftext|> | fim | vitejs/vite | javascript |
export default 'A string'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>msg1 = 'module1'
<|fim_middle|>rt const <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export * from './module0'
export * from './module<|fim_suffix|>2 = 'module2'
<|fim_middle|>1'
export const msg<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>3'
<|fim_prefix|>export * from './modul<|fim_middle|>e0'
export const msg3 = 'module<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>export const bundleWithP<|fim_middle|>lugin = 'worker bundle with plugin fail. '<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>NV
<|fim_prefix|>export const msg = 'pong'
export const mode = process.env.N<|fim_middle|>ODE_E<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>nsole.log('my-inline-shared-worker.js')
<|fim_prefix|>let inlineSharedWorkerCount = 0
// @t<|fim_middle|>s-expect-error onconnect exists in worker
self.onconnect = (event) => {
inlineSharedWorkerCount++
const port = event.ports[0]
if (inlineSharedWorkerCount >= 2) {
port.postMessage('pong')
}... | fim | vitejs/vite | typescript |
<|fim_suffix|>console.log('my-shared-worker.js')
<|fim_prefix|>let sharedWorkerCount = 0
// @ts-expect-error onconnect exists in worker
self.onconnect = (event) => {
sharedWorkerCount++
const port = event.ports[0]
i<|fim_middle|>f (sharedWorkerCount >= 2) {
port.postMessage('pong')
}
}
// for sourcemap
<|... | fim | vitejs/vite | typescript |
import { msg as msgFromDep } from '@vitejs/test-dep-to-optimize'
import depCjs from '@vitejs/test-worker-dep-cjs'
import { mode, msg } from './modules/workerImport.js'
import { bundleWithPlugin } from './modules/test-plugin'
import viteSvg from './vite.svg'
const metaUrl = import.meta.url
self.onmessage = (e) => {
i... | fim | vitejs/vite | typescript |
import { mode, msg } from './modules/workerImport'
self.onmessage = (e) => {
self.postMessage({ msg, mode })
}
self.postMessage({ msg, mode })
// for sourcemap
console.log('possible-ts-output-worker.mjs')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>self.co<|fim_suffix|> classic'
<|fim_middle|>nstant = 'A<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>self.addEventListener('message', (e) => {
if (e.data === 'main') {
const selfWorker = new Worker(
new URL('./self-reference-url-worker.js', import.meta.url),
{
type: 'module',
},
)
selfWorker.postMessage('nested')
selfW<|fim_suffix|>self.postMessage(`pong: ${e.d... | fim | vitejs/vite | javascript |
<|fim_suffix|>ostMessage(e.data)
})
}
self.postMessage(`pong: ${e.data}`)
})
<|fim_prefix|>import SelfWorker from './self-reference-worker?worker'
self.addEventListener('message', (e) => {
if (e.data === 'main') {
const selfWorker = new SelfW<|fim_middle|>orker()
selfWorker.postMessage('nested')
... | fim | vitejs/vite | javascript |
<|fim_suffix|>rker!')
<|fim_prefix|>self.postMessage('Hello from <|fim_middle|>simple wo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t) => {
if (event.data === 'ping') {
self.postMessage(`pong ${self.location.href}`)
}
}
// for sourcemap
console.log('sub-worker.js')
<|fim_prefix|>self.onm<|fim_middle|>essage = (even<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import constant from './modules/module0.js'
self.onc<|fim_suffix|>nstant)
}
// for sourcemap
console.log('url-shared-worker.js')
<|fim_middle|>onnect = (event) => {
const port = event.ports[0]
port.postMessage(co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>self.postMessage(
[
'A string',
import.me<|fim_suffix|>meta.url,
].join(' '),
)
// for sourcemap
console.log('url-worker.js')
<|fim_middle|>ta.env.BASE_URL,
self.location.url,
import.meta && import.meta.url,
import.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> name: 'resolve-format-es',
transform(code, id) {
if (id.includes('main.js')) {
return code.replace(
`/* flag: will replace in vite config import("./format-es.js") */`,
`import("./main-format-es")`,
)
}
},
},
],
cacheDir: ... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
import workerPluginTestPlugin from './worker-plugin-test-plugin'
export default defineConfig({
base: '/iife/',
resolve: {
alias: {
'@': import.meta.dirname,
},
},
worker: {
<|fim_suffix|> worker: {
rolldownOptions: {
... | fim | vitejs/vite | javascript |
<|fim_suffix|>ldownOptions: {
output: {
assetFileNames: 'other-assets/[name]-[hash].[ext]',
chunkFileNames: 'chunks/[name]-[hash].js',
entryFileNames: 'entries/[name]-[hash].js',
},
},
},
plugins: [workerPluginTestPlugin()],
cacheDir: 'node_modules/.vite-relative-base-iife'... | fim | vitejs/vite | javascript |
import { defineConfig } from 'vite'
import workerPluginTestPlugin from './worker-plugin-test-plugin'
export default defineConfig(({ isPreview }) => ({
base: !isPreview ? './' : '/relative-base/',
resolve: {
alias: {
'@': import.meta.dirname,
},
},
worker: {
format: 'es',
plugins: () => [w... | fim | vitejs/vite | javascript |
<|fim_suffix|>ap('hidden')
<|fim_prefix|>import sourcemap from './worker-sourcemap-<|fim_middle|>config.js'
export default sourcem<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>map('inline')
<|fim_prefix|>import sourcemap from './worker-sourcemap-config.js'<|fim_middle|>
export default source<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import sourcemap from './worker-s<|fim_suffix|>map-config.js'
export default sourcemap(true)
<|fim_middle|>ource<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// prettier-ignore
function text(el, text) {
document.querySelector(el).textContent <|fim_suffix|>cWorker.postMessage('test-import')
// prettier-ignore
// test trailing comma
const classicSharedWorker = new SharedWorker(
new URL('../classic-shared-worker.js', import.meta.url),
{
type: 'classic'... | fim | vitejs/vite | javascript |
<|fim_prefix|>const worker = new Worker(
new URL('../deeply-nested-worker.js', import.meta.url),
{ type: 'module' },
)
function text(el, text) {
document.querySelector(el).textContent = text
}
worker.addEventListener('message', (ev) => {
if (ev.data.type === 'deeplyNestedSecondWorker') {
text('.deeply-nes... | fim | vitejs/vite | javascript |
<|fim_suffix|>)
dynamicImportWorker.addEventListener('message', (ev) => {
text('.emit-chunk-dynamic-import-worker', JSON.stringify(ev.data))
})
const moduleWorker = new Worker(
new URL('../module-and-worker.js', import.meta.url),
{ type: 'module' },
)
moduleWorker.addEventListener('message', (ev) => {
text('.... | fim | vitejs/vite | javascript |
import * as depSelfReferenceUrlWorker from '@vitejs/test-dep-self-reference-url-worker'
import myWorker from '../my-worker.ts?worker'
import InlineWorker from '../my-worker.ts?worker&inline'
import InlineSharedWorker from '../my-inline-shared-worker?sharedworker&inline'
import mySharedWorker from '../my-shared-worker?s... | fim | vitejs/vite | javascript |
<|fim_prefix|>import workerUrl from '../simple-worker?worker&url'
function text(el, text) {
document.querySelector(el).textContent = text
}
const worker = new Worker(workerUrl, { type: 'module' })
worker.addEventListener('message', (<|fim_suffix|>
})
<|fim_middle|>ev) => {
text('.simple-worker-url', JSON.stringi... | fim | vitejs/vite | javascript |
<|fim_prefix|>/* flag: will replace in vite config import("./format-es.js") */
import('./main-module')
import(<|fim_suffix|>mport('./main-url')
import('./main-deeply-nested')
<|fim_middle|>'./main-classic')
i<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import ImportMetaGlobEagerWorker from './importMetaGlobEager.worker?worker'
import SubWorker from './sub-worker?worker'
const subWorker = new SubWorker()
self.onmessage = (event) => {
if (event.data === 'ping') {
subWorker.postMessage('ping')
}
}
self.postMessage(self.location.href)
subWorker.... | fim | vitejs/vite | javascript |
<|fim_suffix|> ', 'plugin success!'),
map: null,
}
}
},
})
<|fim_prefix|>export default () => ({
name<|fim_middle|>: 'plugin-for-worker',
transform(code, id) {
if (id.includes('worker/modules/test-plugin.js')) {
return {
// keep length for sourcemap
code: code.replace... | fim | vitejs/vite | javascript |
<|fim_suffix|>nt: JSON.stringify(mod.content) })
})
.catch((err) => {
self.postMessage({ ok: false, error: String(err) })
})
<|fim_prefix|>import('./dep-cjs-with-json/im<|fim_middle|>porter.cjs')
.then((mod) => {
self.postMessage({ ok: true, conte<|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.