text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>impor<|fim_suffix|>n style
}
<|fim_middle|>t style from './a.module.css'
export function a() {
retur<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>module.css'
export function b() {
return style
}
<|fim_prefix|>impor<|fim_middle|>t style from './b.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export { a } from<|fim_suffix|> b } from './b.js'
<|fim_middle|> './a.js'
export {<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ion a() {
return 'treeshake-scoped-a'
}
<|fim_prefix|>import './a-scoped.css' <|fim_middle|>// should be treeshaken away if `a` is not used
export default funct<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './b-scoped.css' // should be treeshaken<|fim_suffix|> return 'treeshake-scoped-b'
}
<|fim_middle|> away if `b` is not used
export default function b() {
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>s
return 'c-used'
}
<|fim_prefix|>import './c-scoped.css' // should be treeshaken away if `b` is not used
export default function c() {
return 'treeshake-scoped-c'
}
export function cUsed() {
// used but does not depend on scoped c<|fim_middle|>s<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './d-scoped.css' // should be treeshaken away if `d` is not used
export de<|fim_suffix|>() {
return 'treeshake-scoped-d'
}
<|fim_middle|>fault function d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>om './d.js'
<|fim_prefix|>export { d<|fim_middle|>efault as a } from './a.js'
export { default as b } from './b.js'
export { default as c, cUsed } from './c.js'
export { default as d } fr<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './b<|fim_suffix|>ault function a() {
return 'treeshake-scoped-order-a'
}
<|fim_middle|>efore.css'
import './a-scoped.css'
import './after.css'
export def<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>'lightningcss',
lightningcss: {
cssModules: {
pattern: '[name]__[local]___[hash]',
},
visitor: composeVisitors([
nestedLikePlugin(),
testDirDep,
testSourceInput(),
testInjectUrl(),
]),
},
},
cacheDir: 'node_modules/.vite-no-css-mi... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
import ba<|fim_suffix|>node_modules/.vite-no-css-minify',
})
<|fim_middle|>seConfig from './vite.config.js'
export default defineConfig({
...baseConfig,
build: {
...baseConfig.build,
outDir: 'dist/no-css-minify',
minify: true,
cssMinify: false,
},... | fim | vitejs/vite | javascript |
<|fim_suffix|>Config.build,
outDir: 'dist/relative-base',
watch: null,
minify: false,
assetsInlineLimit: 0,
rolldownOptions: {
output: {
entryFileNames: 'entries/[name].js',
chunkFileNames: 'chunks/[name]-[hash].js',
assetFileNames: 'other-assets/[name]-[hash][extname]'... | fim | vitejs/vite | javascript |
<|fim_suffix|>t]',
},
},
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
import baseConfig from './vite.config.js'
export default defineConfig({
...baseConfig,
build: {
...baseConfig.build,
outDir: 'dist/same-file-name',
r<|fim_middle|>olldownOptions: {
output: {
entry... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import { defineConfig } from 'vite'
export default defineConfig({
build: {
outDir: 'dist/sass-modern-compiler-build',
rolldownOptions: {
input: {
entry1: path.join(
import.meta.dirname,
<|fim_suffix|>.meta.dirname,
'sass-moder... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import { pathToFileURL } from 'node:url'
import stylus from 'stylus'
import { defineConfig } from 'vite'
// trigger scss bug: https://github.com/sass/dart-sass/issues/710
// make sure Vite handles safely
// @ts-expect-error refer to https://github.com/vitejs/vite/pull/11079
g... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { beforeEach, describe, expect, test } from 'vitest'
import { findAssetFile, isBuild, startDefaultServe } from '~utils'
beforeEach(async () => {
await startDefaultServe()
})
for (let i = 0<|fim_suffix|>Build)('css-codesplit build', () => {
test('should be consistent with same content', () =... | fim | vitejs/vite | typescript |
<|fim_suffix|>pure css chunk', () => {
expect(findAssetFile(/chunk-.*\.js$/)).toBeTruthy()
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import {
findAssetFile,
getColor,
isBuild,
listAssets,
page,
readManifest,
} from '~utils'
test('should load all stylesheets', async () => {
... | fim | vitejs/vite | typescript |
<|fim_suffix|> imports CSS files
import './async-js.css'
<|fim_prefix|>// a JS file that becomes <|fim_middle|>an empty file but<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './style.css'
import './main.css'
import './order'
import './chunk.css'
import chunkCssUrl from './chunk.css?url'
// use this to not trees<|fim_suffix|>(css) => {
document.querySelector('.dynamic-module').textContent = JSON.stringify(
css.default,
)
document.querySelector('.mod').classL... | fim | vitejs/vite | javascript |
<|fim_suffix|> includes "color: green"
})
<|fim_prefix|>import './<|fim_middle|>insert' // inserts "color: orange"
import './base.css' // includes "color: blue"
document.querySelector('.order-bulk-update').addEventListener('click', () => {
import('./dynamic.css') //<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>lor: orange; }'
document.head.appendChild(style)
<|fim_prefix|>const style = document<|fim_middle|>.createElement('style')
style.textContent = '.order-bulk { co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ssUrl from './chunk.css?url'
// use this to not treeshake
globalThis.__test_chunkCssUrl = chunkCssUrl
<|fim_prefix|>import './s<|fim_middle|>tyle.css'
import './chunk.css'
import chunkC<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>corresponding to the HTML entrypoint.
}
<|fim_prefix|>function shouldBeTreeshaken_1() {
// This function should be treeshaken, even if { moduleSi<|fim_middle|>deEffects: 'no-treeshake' }
// was used in the JS <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export def<|fim_suffix|>
}
<|fim_middle|>ault function shouldBeTreeshaken_2() {
// This function should be treeshaken, even if { moduleSideEffects: 'no-treeshake' }
// was used in the JS corresponding to the HTML entrypoint.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import shouldTreeshake from './shared-css-empty-2.js'
<|fim_suffix|>HTML = `
<div>
<h1>Shared CSS, with JS</h1>
</div>
`
function shouldBeTreeshaken_0() {
// This function should be treeshaken, even if { moduleSideEffects: 'no-treeshake' }
// was used in the JS corresponding to the HTML entryp... | fim | vitejs/vite | javascript |
<|fim_suffix|>ss'
<|fim_prefix|>import <|fim_middle|>'./style2.c<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> test: 'chunk.css',
},
],
},
},
},
},
})
<|fim_prefix|>import { resolve } from 'node:path'
import { defineConfig } from 'vite'
const dirname = import.meta.dirname
export default defineConfig({
build: {
manifest: true,
rolldownOptions: {
input:... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { findAssetFile, getColor, isBuild, readManifest } from '~utils<|fim_suffix|>est['other.js'].css.length).toBe(1)
})
})
<|fim_middle|>'
test.skip('should load both stylesheets', async () => {
expect(await getColor('h1')).toBe('red')
expect(await... | fim | vitejs/vite | typescript |
<|fim_prefix|>import './style.css'
imp<|fim_suffix|>>This should be red</h1><h2>This should be blue</h2>`
<|fim_middle|>ort './main.css'
document.getElementById('app').innerHTML =
`<h1<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>s'
<|fim_prefix|>im<|fim_middle|>port './style.cs<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { resolve } from 'node:p<|fim_suffix|>er.js'),
},
treeshake: false,
output: {
format: 'cjs',
// freeze: false,
externalLiveBindings: false,
},
},
},
})
<|fim_middle|>ath'
import { defineConfig } from 'vite'
export default defineConfig({
build... | fim | vitejs/vite | javascript |
<|fim_prefix|>import type { InlineConfig } from 'vite'
import { build, createServer, preview } from 'vite'
import { expect, test } from 'vitest'
import { getColor, isBuild, isServe, page, ports, rootDir } from '~utils'
const baseOptions = [
{ base: '', label: 'relative' },
{ base: '/', label: 'absolute' },
]
cons... | fim | vitejs/vite | typescript |
<|fim_suffix|>ve
// function or a default server will be created
export async function serve() {
return {
close: () => Promise.resolve(),
}
}
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e<|fim_middle|>2e test serve behavior
// The server is start... | fim | vitejs/vite | typescript |
<|fim_prefix|>import './dynamic.css'
export const lazyLoad = async () => {
await import('./sta<|fim_suffix|>('loaded')
}
<|fim_middle|>tic.js')
document.body.classList.add<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './static.js'
co<|fim_suffix|>mport.meta.url).href
import('./dynamic.js').then(async ({ lazyLoad }) => {
await lazyLoad()
})
<|fim_middle|>nst link = document.head.appendChild(document.createElement('link'))
link.rel = 'preload'
link.as = 'style'
link.href = new URL('./dynamic.css', i<|endoftex... | fim | vitejs/vite | javascript |
<|fim_prefix|>import <|fim_suffix|>static.css'
export const foo = 'foo'
<|fim_middle|>'./<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ync () => {
const css = await page.$('.external')
expect(await getBg(css)).toMatch('url("https://vite.dev/logo.svg")')
})
test('nested css with relative asset', async () => {
const css = await page.$('.nested-css-relative-asset')
expect(await getBg(css)).toMatch(
isBuild ? /ok-[-\w]+\.png/ : ... | fim | vitejs/vite | typescript |
<|fim_suffix|>eta.hot.accept('./mod.module.css', (newMod) => {
const list = document.querySelector('.modules').classList
list.remove(mod.applyColor)
list.add(newMod.applyColor)
text('.modules-code', JSON.stringify(newMod.default, null, 2))
})
}
<|fim_prefix|>import './minify.css'
import './imported.cs... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import { defineConfig } from 'vite'
export default defineConfig({
css: {
transformer: 'lightningcss',
},
resolve:<|fim_suffix|>fy: 'lightningcss',
},
})
<|fim_middle|> {
alias: {
'@': path.resolve(import.meta.dirname, 'nested'),
},
},
build: {
... | fim | vitejs/vite | javascript |
<|fim_suffix|>('.ssr-proxy')
expect(await getColor(el)).toBe('coral')
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { port } from './serve'
import { getColor, isServe, page } from '~utils'
const url = `http://localhost:${port}`
describe.runIf(isServe)('injected inline style', () => ... | fim | vitejs/vite | typescript |
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the def<|fim_suffix|>Promise((resolve, reject) => {
try {
const server = app.listen(port, () => {
resolve({
// for test teardown
async close() {
await new Promise((resolve) ... | fim | vitejs/vite | typescript |
<|fim_suffix|>tml('/', template)
res.status(200).set({ 'Content-Type': 'text/html' }).end(html)
} catch (e) {
vite && vite.ssrFixStacktrace(e)
console.log(e.stack)
res.status(500).end(e.stack)
}
})
return { app, vite }
}
if (!isTest) {
createServer().then(({ app }) =>
app.li... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { getBg, isBuild, page, viteTestUrl } from '~utils'
test('url dependen<|fim_suffix|>url-dep')
expect(await getBg(css)).toMatch(
isBuild ? /ok-[-\w]+\.png/ : `${viteTestUrl}/ok.png`,
)
})
<|fim_middle|>cy', async () => {
const css = await page.$('.<|e... | fim | vitejs/vite | typescript |
<|fim_prefix|>import './url<|fim_suffix|>dep.css'
<|fim_middle|>-<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } fr<|fim_suffix|>ot: 'root',
css: {
transformer: 'lightningcss',
},
})
<|fim_middle|>om 'vite'
export default defineConfig({
ro<|endoftext|> | fim | vitejs/vite | javascript |
import { describe, expect, test } from 'vitest'
import { getColor, isBuild, listAssets } from '~utils'
test('should load all stylesheets', async () => {
expect(await getColor('.shared-linked')).toBe('blue')
await expect.poll(() => getColor('.async-js')).toBe('blue')
})
describe.runIf(isBuild)('build', () => {
t... | fim | vitejs/vite | typescript |
<|fim_prefix|>// a JS file that bec<|fim_suffix|>async-js.css'
<|fim_middle|>omes an empty file but imports CSS files
import './<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rt('./async-js')
<|fim_prefix|>imp<|fim_middle|>o<|endoftext|> | fim | vitejs/vite | javascript |
import { resolve } from 'node:path'
import { defineConfig } from 'vite'
export default defineConfig({
build: {
cssCodeSplit: false,
rolldownOptions: {
input: {
index: resolve(import.meta.dirname, './index.html'),
sub: resolve(import.meta.dirname, './sub.html'),
},
},
},
})
<... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { URL } from 'node:url'
import { describe, expect, test } from 'vitest'
import {
extractSourcemap,
formatSourcemapForSnapshot,
isBuild,
isServe,
page,
serverLogs,
} from '~utils'
test.runIf(isBuild)('should not output sourcemap warning (#4939)', () => {
serverLogs.forEach((log) => {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { findAssetFile, isBuild } from '~utils'
desc<|fim_suffix|>linked.js.map', 'lib-entry', './')).toBeUndefined()
})
})
<|fim_middle|>ribe.runIf(isBuild)('css lib entry', () => {
test('remove useless js sourcemap', async () => {
expect(findAsset... | fim | vitejs/vite | typescript |
<|fim_suffix|>ref,
{
headers: {
accept: 'text/css',
},
},
)
const css = await res.text()
const map = extractSourcemap(css)
expect(formatSourcemapForSnapshot(map, css)).toMatchInlineSnapshot(`
SourceMap {
content: {
"mappings": "ACAA;;;;ADEA",... | fim | vitejs/vite | typescript |
<|fim_prefix|>export <|fim_suffix|>'
<|fim_middle|>default 'hello<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
cssCodeSplit: true,
sourcemap: true,
outDir: 'dist/lib-entry',
l<|fim_suffix|>nked.css'],
formats: ['es'],
},
},
})
<|fim_middle|>ib: {
entry: ['./index.js', './li<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>fig(
baseConfig,
defineConfig({
css: {
transformer: 'lightningcss',
},
}),
)
<|fim_prefix|>import { defineConfig, mergeConfig } from 'vite'
import baseConfig fro<|fim_middle|>m './vite.config.js'
export default mergeCon<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>, { filename })
const willBeReplaced = 'blue-red-mixed'
const start = content.indexOf(willBeReplaced)
ms.overwrite(start, start + willBeReplaced.length, 'purple')
const map = ms.generateMap({ hires: 'boundary' })
map.file = filename
map.sources... | fim | vitejs/vite | javascript |
<|fim_suffix|>height).toBe(100)
})
test.runIf(isBuild)('should compile away the import for build', async () => {
const file = findAssetFile('index')
expect(file).not.toMatch('import')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { findAssetFile, isBuild, page } from '~utils'
test('plain', async (... | fim | vitejs/vite | typescript |
<|fim_suffix|>ad failed" />
`
document.querySelector('#dqssqs').innerHTML = `
<img data-testid="dqssqs" src="${dqssqs}" class="dqssqs" alt="load failed" />
`
<|fim_prefix|>import sqdqs from './single-quote-in-double-quotes.svg'
import sqsdqs from './single-quotes-in-double-quotes.svg'
import dqsqs from './double-quot... | fim | vitejs/vite | javascript |
<|fim_suffix|>ace(/\?.*$/, '') === 'comma/foo') {
return `export const comma = 'hi'`
}
},
},
],
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
plugins: [
{
name: 'post-plugin',
enforce: 'post',
resolveId(id) {
if (id.repl... | fim | vitejs/vite | javascript |
<|fim_suffix|>textContent(
'.replaces-constants-in-template-literal-expressions .process-env-dot',
),
).toBe(JSON.parse(defines['process.env.SOMEVAR']))
expect(
await page.textContent(
'.replaces-constants-in-template-literal-expressions .process-env-NODE_ENV',
),
).toBe('dev')
})
test('r... | fim | vitejs/vite | typescript |
<|fim_prefix|>module.e<|fim_suffix|>J__,
}
<|fim_middle|>xports = {
defined: __STRINGIFIED_OB<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>export default process?.env?.SOMEVAR
<|fim_prefix|>// separate file to test pattern fi<|fim_middle|>lter
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
/**
* Plugin to test that env imports with query parameters work correctly (#20997)
*/
function testEnvQueryParamsPlugin() {
let isBuild = true
return {
name: 'test-env-query-params',
configResolved(config) {
isBuild = config.command === 'build'
... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { ref } from 'vue'
export function useCounter() {
const count = ref(0)
function increment() {<|fim_suffix|>crement,
}
}
<|fim_middle|>
count.value++
}
function decrement() {
count.value--
}
return {
count,
increment,
de<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>> {
document.querySelector('#app')!.textContent = `${count.value}`
})
const timer = setInterval(() => {
if (count.value < 6) {
increment()
} else {
decrement()
clearInterval(timer)
}
}, 1000)
<|fim_prefix|>import { watchEffect } from 'vue'
import { useCounter } f<|fim_middle|>rom './c... | fim | vitejs/vite | typescript |
<|fim_prefix|>// no test exists, this should be tested manually
import { defineConfig } from 'vite'
export defaul<|fim_suffix|>
})
<|fim_middle|>t defineConfig({
base: '/',
devtools: {
enabled: false,
port: 5173,
},<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export function hello() {
return '<|fim_suffix|>ic-import-with-vars-contains-parenthesis'
}
<|fim_middle|>dynam<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>c<|fim_suffix|>c-import-with-vars-contains-parenthesis',
).textContent = mod.hello()
})
<|fim_middle|>onst base = 'main'
import(`../${base}.js`).then((mod) => {
document.querySelector(
'.dynami<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vitest'
import {
browserLogs,
findAssetFile,
getColor,
isBuild,
page,
serverLogs,
} from '~utils'
test('should load literal dynamic import', async () => {
await page.click('.baz')
await expect.poll(() => page.textContent('.view')).toMatch('Baz view')
})
test... | fim | vitejs/vite | typescript |
<|fim_suffix|>) {
return 'hello'
}
console.log('hello.js')
<|fim_prefix|>export function he<|fim_middle|>llo(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export function hi<|fim_suffix|>s')
<|fim_middle|>() {
return 'hi'
}
console.log('hi.j<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>= 'load url'
<|fim_middle|>rt const url <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>self.onmessage = (event) => {
self.postMessag<|fim_suffix|> worker',
})
}
<|fim_middle|>e({
msg: 'load<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ion () {}
<|fim_prefix|>export default f<|fim_middle|>unct<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>/* don't include dynamic import inside this file */
<|fim_suffix|>@vitejs/test-pkg'
<|fim_middle|>import '<|endoftext|> | fim | vitejs/vite | javascript |
export function hello() {
return 'hello'
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
})
// prettier-ignore
import(
/* this messes with */
`../alias/${base}.js`
/* es-module-lexer */
).then((mod) => {
text('.dynamic-import-with-vars-multiline', mod.hello())
})
import(`../alias/${base}.js?raw`).then((mod) => {
text('.dynamic-import-with-vars-raw', JSON.stringify(mod))
})
base ... | fim | vitejs/vite | javascript |
<|fim_prefix|>export const sel<|fim_suffix|>rt-nested-self-content'
<|fim_middle|>f = 'dynamic-impo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>elf = 'dynamic-import-self-content'
<|fim_middle|>export const s<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>ex<|fim_middle|>port const n = 1<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>static'
<|fim_prefix|>export const self =<|fim_middle|> 'dynamic-import-<|endoftext|> | fim | vitejs/vite | javascript |
export const foo = () => {
console.log('treeshaken syntax foo')
}
export default () => {
console.log('treeshaken syntax default')
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const foo = () => {
console.log('treeshaken foo')
}
export const bar = () => {
console.log('treeshaken bar')
}
export const baz1 = () => {
console.log('treeshaken baz1')
}
export const baz2 = {
log: () => {
console.log('treeshaken baz2')
},
}
export const baz3 = {
log: () => {
c... | fim | vitejs/vite | javascript |
<|fim_prefix|>import('<|fim_suffix|>g.css')
<|fim_middle|>./pk<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expor<|fim_suffix|>iew'
<|fim_middle|>t const msg = 'Bar v<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>impo<|fim_suffix|> const msg = 'Baz view'
<|fim_middle|>rt { n } from '../nested/shared'
console.log('baz' + n)
export<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { n } from '../nested/<|fim_suffix|> view'
<|fim_middle|>shared'
console.log('foo' + n)
export const msg = 'Foo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>e<|fim_suffix|>port const msg = 'Qux view'
<|fim_middle|>x<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { defineConfig } from 'vite'
const dirname = import.meta.dirname
export default defineConfig({
plugins: [
{
name: 'copy',
writeBundle() {
fs.mkdirSync(path.resolve(dirname, 'dist/views'))
fs.mkdirSync(path.res... | fim | vitejs/vite | javascript |
<|fim_suffix|> )
},
)
<|fim_prefix|>import { expect, test } from 'vitest'
import { isBuild, serverLogs } from '~utils'
test.runIf(isBuild)(
"don't warn when codeSplitting is set to false",
async () => {
const log = serverLogs.join('\n')
expect(log).not.toCo<|fim_middle|>ntain(
'dynamic import wi... | fim | vitejs/vite | typescript |
<|fim_suffix|>) {
return 'foo'
}
<|fim_prefix|>exp<|fim_middle|>ort default function foo(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import foo from './foo'
const asyncImport = async () => {
const { foo } = awai<|fim_suffix|>ort()
<|fim_middle|>t import('./foo.js')
foo()
}
foo()
asyncImp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>': path.resolve(import.meta.dirname, 'alias'),
},
},
build: {
sourcemap: true,
rolldownOptions: {
output: {
codeSplitting: false,
},
},
},
})
<|fim_prefix|>import path from 'node:path'
import { defineConfig } from 'vite'
export de<|fim_middle|>fault defineConfig(... | fim | vitejs/vite | javascript |
<|fim_suffix|>wait page.textContent('.custom-template-literal-exp')).toBe('1')
})
test('custom-prefix', async () => {
expect(await page.textContent('.custom-prefix')).toBe('1')
})
test('mode file override', async () => {
expect(await page.textContent('.mode-file')).toBe(`.env.${mode}`)
})
test('inline variables'... | fim | vitejs/vite | typescript |
<|fim_prefix|>text('.url', import.meta.url)
function text(el, text) <|fim_suffix|>nt = text
}
<|fim_middle|>{
document.querySelector(el).textConte<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>: JSON.stringify('{"123",}'),
'import.meta.env.VITE_STRINGIFY_OBJECT': JSON.stringify({ a: '1', b: '2' }),
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
process.env.EXPAND = 'expand'
export default defineConfig({
base: '/env/',
envPrefix: ['VITE_', 'CU<|fim_middle|>STOM_PREFIX_'],
... | fim | vitejs/vite | javascript |
<|fim_suffix|>ode}`)
})
test('should not load parent .env file', async () => {
expect(await page.textContent('.parent-env')).not.toBe('dont_load_me')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { isBuild, page } from '~utils'
const mode = isBuild ? `production` : `development`
test(<|fim_middle|>... | fim | vitejs/vite | typescript |
<|fim_suffix|>t default defineConfig({
envDir: './envs',
})
<|fim_prefix|>import { de<|fim_middle|>fineConfig } from 'vite'
expor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { stripVTControlCharacters } from 'node:util'
import { describe, expect, onTestFinished, test } from 'vitest'
import {
isBuild,
page,
readDepOptimizationMetadata,
readFile,
serverLogs,
testDir,
} from '~utils'
test('basic', async ()... | fim | vitejs/vite | typescript |
<|fim_suffix|>ReactDomClient.hydrateRoot(el!, <Root />)
})
}
main()
<|fim_prefix|>import ReactDomClient from 'react-dom/client'
import React from 'react'
import Root from './root'
async f<|fim_middle|>unction main() {
const el = document.getElementById('root')
React.startTransition(() => {
<|endoftext|> | fim | vitejs/vite | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.