text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>> {
globalThis.__HMR__['.invalidation-circular-deps'] = value
})
<|fim_prefix|>import { value } from './ch<|fim_middle|>ild'
if (import.meta.hot) {
import.meta.hot.accept(() => {
import.meta.hot.invalidate()
})
}
log('(invalidation circular deps) parent is executing')
setTimeout(() =<|endoftex... | fim | vitejs/vite | javascript |
<|fim_suffix|>
import './invalidate-handled-in-circle/parent'
<|fim_prefix|>import './circular-invalidate/<|fim_middle|>parent'<|endoftext|> | fim | vitejs/vite | javascript |
import './parent'
if (import.meta.hot) {
import.meta.hot.accept(() => {
import.meta.hot.invalidate()
})
}
export const value = 'child'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { value } from '.<|fim_suffix|>> {
globalThis.__HMR__['.invalidation-circular-deps-handled'] = value
})
<|fim_middle|>/child'
if (import.meta.hot) {
import.meta.hot.accept(() => {})
}
log('(invalidation circular deps handled) parent is executing')
setTimeout(() =<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>log('missing test')
<|fim_prefix|>import 'missing-mo<|fim_middle|>dules'
<|endoftext|> | fim | vitejs/vite | javascript |
import './main.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import '<|fim_suffix|>.js'
<|fim_middle|>./a<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>g: string
export default string
}
declare module '*?query2' {
const string: string
export default string
}
<|fim_prefix|>declare module 'vir<|fim_middle|>tual:file' {
export const virtual: string
}
declare module '*?query1' {
const strin<|endoftext|> | fim | vitejs/vite | typescript |
export const test = 'true'
import.meta.hot.accept()
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { test } from '<|fim_suffix|>/dep.js')
<|fim_middle|>./dep.js'
function main() {
test()
}
main()
import.meta.hot.accept('.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>e<|fim_suffix|> = 1
<|fim_middle|>xport const foo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>og('(optional-chaining) child update')
globalThis.__HMR__['.optional-chaining'] = foo
})
<|fim_prefix|>// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import { foo } from './child'
import.meta.hot?.accept('./child', ({ <|fim_middle|>foo }) => {
l<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>e)
}
<|fim_prefix|>import query1 from './multi-query?query1'
import query2 from './multi-query?query2'
hmr('<|fim_middle|>query1', query1)
hmr('query2', query2)
function hmr(key, value) {
globalThis.__HMR__[key] = String(valu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> const a = {
b,
}
<|fim_prefix|>import { b } from './b'
e<|fim_middle|>xport<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>onst b = {
c,
}
export { b }
<|fim_prefix|>import { c } from <|fim_middle|>'./c'
c<|endoftext|> | fim | vitejs/vite | javascript |
import './b'
export const c = 'c'
function render(content) {
globalThis.__HMR__['.self-accept-within-circular'] = content
}
render(c)
import.meta.hot?.accept((nextExports) => {
render(nextExports?.c)
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>(a)
<|fim_prefix|>import { a } <|fim_middle|>from './a'
log<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const <|fim_suffix|>ar'
<|fim_middle|>foo = 'b<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { foo } from './child'
// @ts-e<|fim_suffix|>pect-error global
export const msg = `soft-invalidation/index.js is transformed ${__TRANSFORM_COUNT__} times. child is ${foo}`
<|fim_middle|>x<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>e)
}
<|fim_prefix|>export const foo = 1
hmr('.app', foo)
if (import.meta.hot) {
import.meta.hot.accept(({ foo }) => {
log('(self-accepting 1) foo is now:', foo)
})
import.meta.hot.accept(({ foo }) => {
log('(self-accepting 2) foo is now:', foo)
})
import.meta.hot.dispose(() => {
l... | fim | vitejs/vite | typescript |
<|fim_suffix|>{JSON.stringify(code + 'query1')}`
}
if (id.includes('?query2')) {
return `export default ${JSON.stringify(code + 'query2')}`
}
},
}
}
function transformCountPlugin(): Plugin {
let num = 0
return {
name: 'transform-count',
transform(code) {
if (code.incl... | fim | vitejs/vite | typescript |
import { beforeAll, describe, expect, test } from 'vitest'
import {
browserLogs,
editFile,
getColor,
isBuild,
isServe,
page,
serverLogs,
untilBrowserLogAfter,
viteServer,
viteTestUrl,
} from '~utils'
function fetchHtml(p: string) {
return fetch(viteTestUrl + p, {
headers: { Accept: 'text/html... | fim | vitejs/vite | typescript |
import './dep1'
import './dep2'
export function log(name) {
document.getElementById('output').innerHTML += name + ' '
}
log('common')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ep1')
<|fim_prefix|>import { log } from './common'
<|fim_middle|>log('d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>from './common'
log('dep2')
<|fim_prefix|>imp<|fim_middle|>ort { log } <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>imp<|fim_suffix|>'
import { log } from './common'
log('dep3')
<|fim_middle|>ort './dep2<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './dep3'
import { log } fr<|fim_suffix|>shared')
<|fim_middle|>om './common'
log('<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>e')
<|fim_prefix|>impo<|fim_middle|>rt { log } from './common'
import './dep2'
log('uniqu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>sole.log(msg + ' from main')
<|fim_prefix|>im<|fim_middle|>port { msg } from './shared'
import './common.css'
con<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>function text(el, text) {
do<|fim_suffix|>ent.querySelector(el).textContent = text
}
text('.relative-js', 'hello')
<|fim_middle|>cum<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>port { msg } from '../shared'
import '../common.css'
console.log(msg + ' from nested')
<|fim_middle|>im<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.querySelector('.relative-input').te<|fim_suffix|>'OK'
<|fim_middle|>xtContent = <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>export con<|fim_middle|>st msg = 'shared'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>console.log('message <|fim_suffix|>ts script')
<|fim_middle|>from sideEffec<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// This file is used to test https://github.com/vitejs/vite/issues/20705
// The dev server should NOT serve this file when navigating to /test
export const message =
<|fim_suffix|>served for /test navigation'
<|fim_middle|> 'This is test.js - should not be <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.getE<|fim_suffix|>ementById(`no-quotes-on-attr`).innerHTML =
`No quotes on Attr working`
<|fim_middle|>l<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> Math.random().toString(36).slice(2),
)
},
},
},
serveExternalPathPlugin(),
],
})
/** @returns {import('vite').Plugin} */
function serveExternalPathPlugin() {
const handler = (req, res, next) => {
if (req.url === '/external-path.js') {
res.setHeader... | fim | vitejs/vite | javascript |
<|fim_prefix|>conso<|fim_suffix|>('From warm.js')
<|fim_middle|>le.log<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>nt('.dep'), 'world')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { page } from '~utils'
test('from source code', async () => {
<|fim_middle|>expect(await page.textContent('.src'), 'bar')
})
test('from dependency', async () => {
expect(await page.textConte<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>on.hello
<|fim_prefix|>import json from './data.json' assert { ty<|fim_middle|>pe: 'json' }
export const hello = js<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { URL, fileURLToPath } from 'node:url'
import { promisify } from 'node:util'
import { execFile } from 'node:child_process'
import { existsSync } from 'node:fs'
import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping'
import { describe, expect, test } from 'vitest'
import { mapFileC... | fim | vitejs/vite | typescript |
<|fim_prefix|>// hashbang is injected via rolldownOptions.output.banner
import('./dynamic/dynamic-foo')
console.log('after preload dynamic <|fim_suffix|>ashbang')
<|fim_middle|>h<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>le.log('after preload dynamic no dep')
<|fim_prefix|>import('./dynamic/dynamic-no-dep'<|fim_middle|>)
conso<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>fter preload dynamic')
<|fim_prefix|>import('./dynamic/dynamic-foo')
<|fim_middle|>
console.log('a<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ort const bar = 'bar'
<|fim_prefix|>e<|fim_middle|>xp<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> }
<|fim_prefix|>const x = () => 1
class C {
prop = x()
constructor(x) {
console.log(x)
}
}
ex<|fim_middle|>port { C<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>}
<|fim_prefix|>const x = () => 1
class C {
prop = x()
constructor<|fim_middle|>(x) {
console.log(x)
}
}
export { C <|endoftext|> | fim | vitejs/vite | javascript |
export const malicious = 'value'
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BsYXlncm91bmQvanMtc291cmNlbWFwL3ZpdGUuY29uZmlnLmpzIl0sInNvdXJjZXNDb250ZW50IjpbbnVsbF0sIm1hcHBpbmdzIjoiQUFBQSIsIm5hbWVzIjpbXX0=
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const optimizedMalicious = 'value'
module.exports = { optimizedMalicious }<|fim_suffix|>Db250ZW50IjpbbnVsbF0sIm1hcHBpbmdzIjoiQUFBQSIsIm5hbWVzIjpbXX0=
<|fim_middle|>
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BsYXlncm91bmQvanMtc291cmNlbWFwL3Z... | fim | vitejs/vite | javascript |
<|fim_suffix|>mic/dynamic-foo')
<|fim_prefix|>im<|fim_middle|>port './dynamic-foo.css'
console.log('dyna<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>)
<|fim_prefix|>console.log('dynamic/<|fim_middle|>dynamic-no-dep'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
'// default boundary sourcemap with magic-string',
'//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHIn0=',
].join('\n')
export default function transformFooWi... | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>export const <|fim_middle|>foo = 'foo'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>ex<|fim_suffix|>t foo = 'foo'
<|fim_middle|>port cons<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>// eslint-disab<|fim_middle|>le-next-line import-x/no-commonjs
exports.foo = 'foo'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ious-import', malicious)
<|fim_prefix|>import { malicious<|fim_middle|> } from '@vitejs/test-dep-malicious-sourcemap'
console.log('malic<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { C } from '@vitejs/test-dep-class-field-sourcemap-babel'
co<|fim_suffix|>)
<|fim_middle|>nsole.log('optimized-class-field-import-babel', C<|endoftext|> | fim | vitejs/vite | javascript |
import { C } from '@vitejs/test-dep-class-field-sourcemap-oxc'
console.log('optimized-class-field-import-oxc', C)
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { optimizedMalic<|fim_suffix|>s'
console.log('optimized-malicious-import', optimizedMalicious)
<|fim_middle|>ious } from '@vitejs/test-dep-optimized-maliciou<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>o = 'foo'
<|fim_prefix|>export const f<|fim_middle|>o<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>f) {
let error
try {
await f()
} catch (e) {
error = e
}
assert.ok(error)
return error
}
runTest()
<|fim_prefix|>import assert from 'node:assert'
import { fileURLToPath } from 'node:url'
import { createServer } from 'vite'
async function runTest() {
const server = await createServe... | fim | vitejs/vite | javascript |
<|fim_suffix|> },
sourcemapDebugIds: true,
},
},
},
define: {
__testDefineObject: '{ "hello": "test" }',
},
})
<|fim_prefix|>import { fileURLToPath } from 'node:url'
import babel from '@babel/core'
import MagicString from 'magic-string'
import { Visitor, parseSync } from 'oxc-parser'
imp... | fim | vitejs/vite | javascript |
<|fim_prefix|>export function error() {
errorInner()
}
function errorInner() {
// @ts-expect-error "define"
throw new Error('with-define-object: ' + JSON.stringify(__test<|fim_suffix|>))
}
<|fim_middle|>DefineObject<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>
console.trace('with-define-object', __testDefineObject)
}
main()
<|fim_prefix|>// test complicated stack since broken sourcemap
/<|fim_middle|>/ might still look correct with a simple case
function main() {
mainInner()
}
function mainInner() {
// @ts-expect-error "define"<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// prettier-ignore
import {
foo
} from '<|fim_suffix|>sole.log('with-multiline-import', foo)
<|fim_middle|>@vitejs/test-importee-pkg'
con<|endoftext|> | fim | vitejs/vite | typescript |
import MagicString from 'magic-string'
import type { Plugin } from 'vite'
export const transformZooWithSourcemapPlugin: () => Plugin = () => ({
name: 'sourcemap',
transform(code, id) {
if (id.includes('zoo.js')) {
const ms = new MagicString(code)
ms.append('// add comment')
return {
c... | fim | vitejs/vite | typescript |
<|fim_suffix|>= 'zoo'
<|fim_prefix|>e<|fim_middle|>xport const zoo <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>)).toMatch(
isBuild ? 'data:application/json' : '/test.json',
)
})
test('?raw', async () => {
expect(await page.textContent('.raw')).toBe(
readFileSync(require.resolve('../../test.json'), 'utf-8'),
)
})
test('require(json) returns object without default export', async () => {
expect(awai... | fim | vitejs/vite | typescript |
<|fim_prefix|>const content = require('./content.json'<|fim_suffix|>nt }
<|fim_middle|>)
module.exports = { conte<|endoftext|> | fim | vitejs/vite | javascript |
import { describe, expect, test } from 'vitest'
import { port } from './serve'
import { isBuild, page } from '~utils'
const url = `http://localhost:${port}`
describe.runIf(isBuild)('client-legacy-ssr-sequential-builds', () => {
test('should work', async () => {
await page.goto(url)
expect(await page.textCon... | 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 { ports, rootDir } from '~utils'
export const port = ports['legacy/client-and-ssr']
export async function serve(): Promise<{ close(): Promise<void> }... | fim | vitejs/vite | typescript |
<|fim_suffix|>'-legacy') &&
readFile(`dist/assets/${filename}`).includes('Unable to preload'),
),
).toStrictEqual([])
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import {
findAssetFile,
getColor,
isBuild,
listAssets,
page,
readFile,
readManifest,
} from '~util... | fim | vitejs/vite | typescript |
<|fim_suffix|>tUrl + '/no-polyfills.html')
expect(await page.content()).not.toContain('modulepreload')
},
)
<|fim_prefix|>import { expect, test } fro<|fim_middle|>m 'vitest'
import { isBuild, page, viteTestUrl } from '~utils'
test('should load and execute the JS file', async () => {
await page.goto(viteTestUrl... | fim | vitejs/vite | typescript |
<|fim_suffix|> .poll(() => page.getAttribute('#vite-legacy-entry', 'data-src'))
.toMatch(/.\/assets\/index-legacy-(.+)\.js/)
expect(await page.locator('script').count()).toBe(1)
expect(await page.locator('#vite-legacy-polyfill').count()).toBe(0)
expect(await page.locator('#vite-legacy-entry').count()).toBe... | fim | vitejs/vite | typescript |
<|fim_suffix|><|fim_prefix|>import { describe, expect, test } from 'vitest'
import { port } from './serve'
import { isBuild, page } from '~utils'
const url = `http://localhost:${port}`
describe.runIf(isBuild)('legacy-ssr', () => {
test('should work', async () => {
await page.goto(url)
expect(await page.text... | fim | vitejs/vite | typescript |
<|fim_suffix|>es) => {
const { render } = await import(
path.resolve(rootDir, './dist/server/entry-server.js')
)
const html = await render()
res.status(200).set({ 'Content-Type': 'text/html' }).end(html)
})
return new Promise((resolve, reject) => {
try {
const server = app.listen(po... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import {
editFile,
findAssetFile,
isBuild,
notifyRebuildComplete,
readManifest,
watcher,
} from '~utils'
test.runIf(isBuild)('rebuilds styles only entry on change', async () => {
expect(findAssetFile(/style-only-entry-.+\.css/, 'watch')).toContain(
... | fim | vitejs/vite | typescript |
<|fim_prefix|>export function fn() {
const m = new Map()
m.set('foo', 'Hello<|fim_suffix|>t = m.get('foo')
}
<|fim_middle|>')
document.querySelector('#app').textConten<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export co<|fim_suffix|>bar'
<|fim_middle|>nst foo = '<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expor<|fim_suffix|> foo = 'bar'
<|fim_middle|>t const<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>oo = 'bar'
<|fim_prefix|>expo<|fim_middle|>rt const f<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// This counts as 'server-side' rendering, yes?
exp<|fim_suffix|> <div id="app">Hello</div>
<div id="mode">${import.meta.env.MODE}</div>
`
}
<|fim_middle|>ort async function render() {
return /* html */ `
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>"env">${import.meta.env.LEGACY}</div>
`
}
<|fim_prefix|>// This counts as 'server-side' rendering, yes?
expor<|fim_middle|>t async function render() {
return /* html */ `
<div id="app">Hello</div>
<div id=<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const chunks = [
'index',
'index-legacy',
'chunk-async',
'chunk-async-legacy',
'immutable-chunk',
'immutable-chunk-legacy',
'polyfills-legacy',
]
export function fn() {
return Promise.all(
chunks.map(async (name) => {
const respons<|fim_suffix|>aders.get('Content-Type')}`
})... | fim | vitejs/vite | javascript |
<|fim_suffix|>port.meta.env.LEGACY === metaEnvObj.LEGACY)
// Iterators
text('#iterators', [...new Set(['hello'])].join(''))
// structuredClone is supported core.js v3.20.0+
text(
'#features-after-corejs-3',
JSON.stringify(structuredClone({ foo: 'foo' })),
)
// async generator
async function* asyncGenerator() {
... | fim | vitejs/vite | javascript |
<|fim_suffix|>le'
<|fim_prefix|>export co<|fim_middle|>nst module = 'modu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.querySelec<|fim_suffix|>'main').innerHTML = '👋'
<|fim_middle|>tor(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.querySelect<|fim_suffix|>'main').innerHTML = '👋'
<|fim_middle|>or(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
import legacy from '@vitejs/plugin-legacy'
export default defineConfig({
plugins: [legacy({ modernPolyfill<|fim_suffix|>mes: `assets/[name].js`,
chunkFileNames: `assets/[name].js`,
},
},
},
})
<|fim_middle|>s: true })],
build: {
manifest: tr... | fim | vitejs/vite | javascript |
<|fim_suffix|> chunkFileNames: `assets/anotherSubdir/[name].js`,
},
],
},
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
import legacy from '@vitejs/plugin-legacy'
export default defineConfig({
plugins: [legacy({ modernPolyfills: true })],
build: {
manifest: true,
minify: fals... | fim | vitejs/vite | javascript |
<|fim_suffix|>ove crossorigin attribute',
transformIndexHtml: (html) => html.replaceAll('crossorigin', ''),
enforce: 'post',
},
],
build: {
outDir: 'dist/no-polyfills-no-systemjs',
rolldownOptions: {
input: {
index: path.resolve(
import.meta.dirname,
'no-po... | fim | vitejs/vite | javascript |
import path from 'node:path'
import legacy from '@vitejs/plugin-legacy'
import { defineConfig } from 'vite'
export default defineConfig(({ isPreview }) => ({
base: !isPreview ? './' : '/no-polyfills/',
plugins: [
legacy({
renderModernChunks: false,
polyfills: false,
}),
{
name: 'remov... | fim | vitejs/vite | javascript |
<|fim_suffix|>downOptions: {
input: {
'style-only-entry': resolve(
import.meta.dirname,
'style-only-entry.css',
),
},
},
watch: {},
outDir: 'dist/watch',
},
})
<|fim_prefix|>import { resolve } from 'node:path'
import legacy from '@vitejs/plugin-legacy'
impor... | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import legacy from '@vitejs/plugin-legacy'
import { defineConfig } from 'vite'
export default defineConfig({
base: './',
plugins: [
legacy({
targets: 'IE 11',
modernPolyfills: true,
}),
],
build: {
cssCodeSplit: false,... | fim | vitejs/vite | javascript |
<|fim_suffix|>}
<|fim_prefix|>import { module } from './module'
self.onmessage = () => {
<|fim_middle|> self.postMessage(module)
<|endoftext|> | fim | vitejs/vite | javascript |
import { describe, expect, test } from 'vitest'
import { isBuild, isServe, page, readFile, serverLogs } from '~utils'
describe.runIf(isBuild)('build', () => {
test('es', async () => {
expect(await page.textContent('.es')).toBe('It works')
})
test('umd', async () => {
expect(await page.textContent('.umd'... | fim | vitejs/vite | typescript |
<|fim_suffix|>${port}`)
resolve({
// for test teardown
async close() {
await new Promise((resolve) => {
server.close(resolve)
})
},
})
})
} catch (e) {
reject(e)
}
})
}
}
function setup... | fim | vitejs/vite | typescript |
import './entry-1.css'
export default 'css-entry-1'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>export default 'css-entry-2'
<|fim_prefix|>im<|fim_middle|>port './entry-2.css'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.log(getEvalledConstructor(0))
})()
<|fim_prefix|>// Trigger wrong helpers injection if not properly constrained
;(function () {
var getEvalledConstructor = function (expressionSyntax) {
try {
return $Function(
'"use strict"; return (' + expres<|fim_middle|>sionSyntax + ').constructor;... | fim | vitejs/vite | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.