text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>/** @deprecated use HotPayload */
export type HMRPa<|fim_suffix|>edBy?: string
/** @internal */
invalidates?: string[]
}
export interface PrunePayload {
type: 'prune'
paths: string[]
}
export interface FullReloadPayload {
type: 'full-reload'
path?: string
/** @internal */
triggeredBy?: s... | fim | vitejs/vite | typescript |
<|fim_suffix|>d<T>) => void,
): void
off<T extends CustomEventName>(
event: T,
cb: (payload: InferCustomEventPayload<T>) => void,
): void
send<T extends CustomEventName>(
event: T,
data?: InferCustomEventPayload<T>,
): void
}
<|fim_prefix|>import type { CustomEventName, InferCustomEventPayload... | fim | vitejs/vite | typescript |
<|fim_prefix|>/// <reference p<|fim_suffix|>. This file provides a workaround for now.
<|fim_middle|>ath="./importMeta.d.ts" />
// https://github.com/microsoft/TypeScript/issues/45096
// TypeScript has a bug that makes <reference types="vite/types/importMeta" />
// not possible in userland<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>r the glob pattern matching should be case-sensitive. Defaults to `true`.
*/
caseSensitive?: boolean
}
export type ImportGlobOptionsWithoutAs<
Eager extends boolean,
QueryType extends BaseQueryType,
> = Omit<ImportGlobOptions<Eager, string, QueryType>, 'as'> & {
as?: never
}
export type Gener... | fim | vitejs/vite | typescript |
<|fim_prefix|>// This file is an augmentation to the built-in ImportMeta interface
// Thus cannot contain any top-level imports
// <https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation>
// This is tested in `packages/vite/src/node/__tests_dts__/typeOptions.ts`
// eslint-disable-nex... | fim | vitejs/vite | typescript |
<|fim_suffix|>OptionsAsync = SassEmbedded.StringOptions<'async'>
type SassStringOptionsAsync =
IsAny<SassEmbeddedStringOptionsAsync> extends false
? SassEmbeddedStringOptionsAsync
: DartSassStringOptionsAsync
export type SassModernPreprocessBaseOptions = Omit<
SassStringOptionsAsync,
'url' | 'sourceMap'
... | fim | vitejs/vite | typescript |
<|fim_prefix|>/* eslint-disable @typescript-eslint/ban-ts-comment */
// @ts-ignore `esbuil<|fim_suffix|>TransformOptions
export type EsbuildTransformResult = esbuild.TransformResult
export type EsbuildMessage = esbuild.Message
export type DepsOptimizerEsbuildOptions = Omit<
esbuild.BuildOptions,
| 'bundle'
| '... | fim | vitejs/vite | typescript |
<|fim_prefix|>/* eslint-disable @typescript-esl<|fim_suffix|>cies'
// properties not overridden by Vite, but does not make sense to set by end users
| 'inputSourceMap'
| 'projectRoot'
>
<|fim_middle|>int/ban-ts-comment */
// @ts-ignore `lightningcss` may not be installed
import type Lightningcss from 'lightningc... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type * as Rolldown from 'rolldown'
export * from 'rolldown'
<|fim_suffix|>/** @deprecated use RolldownOutput instead */
export type RollupOutput = Rolldown.RolldownOutput
/** @deprecated use RolldownPlugin instead */
export type RollupPlugin = Rolldown.RolldownPlugin
/** @deprecated use Rolldown... | fim | vitejs/vite | typescript |
<|fim_prefix|>/* eslint-disable @typescript-e<|fim_suffix|> type * as Terser from 'terser'
// @ts-ignore `terser` may not be installed
import type * as Terser from 'terser'
/* eslint-enable @typescript-eslint/ban-ts-comment */
export type TerserMinifyOptions = Terser.MinifyOptions
export type TerserMinifyOutput = Ter... | fim | vitejs/vite | typescript |
<|fim_suffix|> interface CustomPluginOptions {
vite?: CustomPluginOptionsVite
}
}
<|fim_prefix|>export interface AssetMetadata {
importedAssets: Set<string>
importedCss: Set<string>
}
export interface ChunkMetadata {
importedAssets: Set<string>
importedCss: Set<string>
/** @internal */
__modules: any... | fim | vitejs/vite | typescript |
<|fim_suffix|>t('.custom-resolver')).toMatch(
'[success] alias to custom-resolver path',
)
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { editFile, getColor, isBuild, page } from '~utils'
test('fs', async () => {
expect(await page.textContent('.fs')).toMatch('[success] alias to fs path')
})
t... | fim | vitejs/vite | typescript |
<|fim_prefix|>e<|fim_suffix|>esolver path`
<|fim_middle|>xport const msg = `[success] alias to custom-r<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.<|fim_suffix|>uccess] from script src'
<|fim_middle|>querySelector('.from-script-src').textContent =
'[s<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const msg = `[s<|fim_suffix|>module`
<|fim_middle|>uccess] aliased <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ias to directory`
<|fim_prefix|>expor<|fim_middle|>t const msg = `[success] al<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const msg = `[success] url confl<|fim_suffix|>t alias`
<|fim_middle|>ic<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const msg = `<|fim_suffix|> path`
<|fim_middle|>[success] alias to fs<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import module from 'node:module'
import { defineConfig } from 'vite'
const require = module.createRequire(import.meta.url)
export default defineConfig({
resolve: {
alias: [
{ find: 'fs', replacement: path.resolve(import.meta.dirname, 'test.js') },
{ find: '... | fim | vitejs/vite | javascript |
<|fim_suffix|>).toMatch(
'text/javascript',
)
}
})
test('from /public (mts)', async () => {
expect(await page.textContent('.public-mts-import')).toMatch(
'/foo/bar/raw.mts',
)
expect(await page.textContent('.public-mts-import-content'))
.toMatchInlineSnapshot(`
"expo... | fim | vitejs/vite | typescript |
<|fim_suffix|>h)
expect(bg).toMatch(iconMatch)
})
test('aliased', async () => {
const bg = await getBg('.css-url-aliased')
expect(bg).toMatch(urlAssetMatch)
})
})
describe.runIf(isBuild)('index.css URLs', () => {
let css: string
beforeAll(() => {
css = findAssetFile(/index.*\.css$/, 'encoded... | fim | vitejs/vite | typescript |
<|fim_suffix|>foreAll(() => {
css = findAssetFile(/index.*\.css$/, 'relative-base', 'other-assets')
})
test('relative asset URL', () => {
expect(css).toMatch(`./asset-`)
})
test('preserve postfix query/hash', () => {
expect(css).toMatch(`woff2?#iefix`)
})
})
describe('image', () => {
test('sr... | fim | vitejs/vite | typescript |
<|fim_suffix|>ontent('.non-existent-import-meta-url')).toMatch(
'/non-existent',
)
})
test('inline style test', async () => {
expect(await getBg('.inline-style')).toMatch(cssBgAssetMatch)
expect(await getBg('.style-url-assets')).toMatch(cssBgAssetMatch)
})
test('html import word boundary', async () => {
e... | fim | vitejs/vite | typescript |
import { beforeAll, describe, expect, test } from 'vitest'
import {
browserLogs,
findAssetFile,
getBg,
getColor,
isBuild,
page,
} from '~utils'
const urlAssetMatch = isBuild
? /http:\/\/localhost:\d+\/other-assets\/asset-[-\w]{8}\.png/
: '/nested/asset.png'
const iconMatch = '/icon.png'
const absolut... | fim | vitejs/vite | typescript |
<|fim_suffix|>extContent = text
}
text('.relative-js', 'hello')
<|fim_prefix|>function text(el, text) {
docu<|fim_middle|>ment.querySelector(el).t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>function text(el, text) {
document.querySele<|fim_suffix|>t('.update-content', 'hello')
<|fim_middle|>ctor(el).textContent = text
}
tex<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>')
<|fim_prefix|>console.<|fim_middle|>log('hi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Test for multil<|fim_suffix|> detects and processes multiline expressions that span multiple lines.
export const multilineUrl = new URL(
'./nested/asset.png',
import.meta.url,
)
<|fim_middle|>ine expressions
// This is a separate file to ensure the regex filter in assetImportMetaUrlPlugin
// corre... | fim | vitejs/vite | javascript |
<|fim_prefix|>export default cla<|fim_suffix|> name = 'a'
}
<|fim_middle|>ss a {
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>extContent += '[success]'
<|fim_prefix|>document.querySelector('.<|fim_middle|>import-expression').t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>document.querySelector('.raw-js').textContent =
<|fim_suffix|>'[success] Raw js from /public loaded'
<|fim_middle|> <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default function other() {
r<|fim_suffix|>urn 1 + 2
}
<|fim_middle|>et<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { defineConfig } from 'vite'
import baseConfig from './vite.config.js'
/** see `ports` variable in test-utils.ts */
const port = 9524
export default defineConfig({
...baseConfig,
// Vite should auto-encode this as `/foo%20bar/` internally
base: '/foo bar/',
server: {
<|fim_suffix|>: fals... | fim | vitejs/vite | javascript |
<|fim_suffix|>udes('css/manual-chunks.css')) {
// return 'css/manual-chunks'
// }
// },
},
},
},
cacheDir: 'node_modules/.vite-relative-base',
}))
<|fim_prefix|>import { defineConfig } from 'vite'
import baseConfig from './vite.config.js'
export default defineConfig(({ isPre... | fim | vitejs/vite | javascript |
<|fim_suffix|>seAssetsCode,
},
]
}
},
},
],
experimental: {
renderBuiltUrl(filename, { hostType, type }) {
if (type === 'asset') {
if (hostType === 'js') {
return {
runtime: `globalThis.__toAssetUrl(${JSON.stringify(filename)})`,
... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
import baseConfig from './vite.config.js'
/** see `ports` variable in test-utils.ts */
const port = 9525
export default defineConfig({
...baseConfig,
base: `http://localhost:${port}/`,
server: {
port,
strictPort: true,
},
build: {
...baseConfig.b... | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>import path from 'node:path'
import { defineConfig } from 'vite'
export default defineConfig({
base: '/foo/bar',
publicDir: 'static',
resolve: {
alias: {
'@': path.resolve(import.meta.dirname, 'nested'),
fragment: path.resolve(import.meta.dirname, 'nested/fragment-bg.... | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>console.log('test Unicode')<|fim_middle|>
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vites<|fim_suffix|> readManifest } from '~utils'
if (!isBuild) {
test('importing asset with special char in filename works in dev', async () => {
expect(await getBg('.plus-circle')).toContain('+circle.svg')
expect(await page.textContent('.plus-circle')).toMatch('+c... | fim | vitejs/vite | typescript |
<|fim_suffix|>a(classname, file) {
const el = document.body.querySelector(classname)
el.style.backgroundImage = `url(${file})`
el.textContent = file
}
setData('.plus-circle', plusCircle)
setData('.underscore-circle', underscoreCircle)
<|fim_prefix|>im<|fim_middle|>port plusCircle from './+circle.svg'
import under... | fim | vitejs/vite | javascript |
<|fim_suffix|>target: 'esnext',
assetsInlineLimit: 0,
manifest: true,
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default <|fim_middle|>defineConfig({
build: {
//speed up build
minify: false,
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>xpect(mainTsEntryCss[0].replace('assets/', '')).not.toContain('/')
})
test('entrypoint assets should not generate empty JS file', () => {
expect(serverLogs).not.toContainEqual(
'Generated an empty chunk: "icon.png".',
)
const assets = listAssets('dev')
expect(assets).not.toCont... | fim | vitejs/vite | typescript |
<|fim_prefix|>import 'vite/modulepreload-polyfill'
import cssUrl from '../styles/url.css?url'
import waterContainer from './water-container.svg'
const cssLi<|fim_suffix|>lement('link')
cssLink.rel = 'stylesheet'
cssLink.href = cssUrl
document.querySelector('head').prepend(cssLink)
const dummyMeta = document.createEle... | fim | vitejs/vite | typescript |
<|fim_suffix|>./styles/imported.css'
<|fim_prefix|>import '.<|fim_middle|>./.<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> = path.join(projectRoot, 'frontend')
const root = path.join(sourceCodeDir, 'entrypoints')
const outDir = path.relative(root, path.join(projectRoot, 'dist/dev'))
const entrypoints = globSync(`${normalizePath(root)}/**/*`, {
absolute: true,
expandDirectories: false,
... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } f<|fim_suffix|>ep base prefix', async () => {
await expect.poll(() => page.textContent('.message')).toBe('absolute import')
})
<|fim_middle|>rom 'vitest'
import { page } from '~utils'
test('absolute imports ke<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|><|fim_suffix|>
<|fim_middle|>export default 'absolute import'<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import message from 'absolute-importer'
document.querySelector('.m<|fim_suffix|>sage')!.textContent = message
<|fim_middle|>es<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|><|fim_suffix|>nst msg: string
export default msg
}
<|fim_middle|>declare module 'absolute-importer' {
co<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ootPath}/src/importee.ts`
export default defineConfig({
base,
plugins: [
{
name: 'absolute-path-import',
resolveId(id) {
if (id === VIRTUAL_MODULE_ID) {
return RESOLVED_VIRTUAL_MODULE_ID
}
},
load(id) {
if (id === RESOLVED_VIRTUAL_MODULE_ID... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { findAssetFile, isBuild, page } from '~utils'
describe('syntax preserve', () => {
test('import.meta.url', async () => {
await expect.poll(() => page.textContent('.import-meta-url')).toBe('string')
})
test('dynamic import'<|fim_suffix|> ... | fim | vitejs/vite | typescript |
<|fim_suffix|><|fim_prefix|>export defau<|fim_middle|>lt 'success'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
export default defi<|fim_suffix|>
<|fim_middle|>neConfig({
build: {
// old browsers only
target: ['chrome60'],
},
})<|endoftext|> | fim | vitejs/vite | javascript |
import { expect, test } from 'vitest'
import { port, streams } from './serve'
import { editFile, isServe, page } from '~utils'
test('cli should work', async () => {
// this test uses a custom serve implementation, so regular helpers for browserLogs and goto don't work
// do the same thing manually
const logs = [... | fim | vitejs/vite | typescript |
<|fim_suffix|> ms)
}),
]).finally(() => {
clearTimeout(timer)
timer = null
})
}
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import { stripVTControlCharacters } from 'node:util'
import { execaCommand } f<|fim_middle... | fim | vitejs/vite | typescript |
<|fim_suffix|>)
<|fim_prefix|>c<|fim_middle|>onsole.log('vite cli works!'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>peed up build
minify: false,
target: 'esnext',
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export de<|fim_middle|>fault defineConfig({
server: {
host: 'localhost',
headers: {
'Cache-Control': 'no-store',
},
},
build: {
//s<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { port } from './serve'
import {<|fim_suffix|> await page.goto(`http://localhost:${port}/`)
expect(await page.textContent('.app')).toBe(
'vite cli in "type":"module" package works!',
)
expect(
logs.some((msg) =>
msg.match('vite ... | fim | vitejs/vite | typescript |
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
import { stripVTControlCharacters } from 'node:util'
import { execaCommand } from 'execa'
import kill from 'kill-port'
import {
isBuild,
isWindows,
killProcess,
ports,
rootDir,... | fim | vitejs/vite | typescript |
<|fim_suffix|>:"module" package works!')
<|fim_prefix|>console.log('vite cli in<|fim_middle|> "type"<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>_test_url = URL
export default defineConfig({
server: {
host: 'localhost',
},
build: {
//speed up build
minify: false,
target: 'esnext',
},
})
<|fim_prefix|>// eslint-disable-next-line n/prefer-node-protocol
import { URL } from 'url'
import { defineConfig } from 'vite'
// make su... | fim | vitejs/vite | javascript |
import path from 'node:path'
import { type ServerOptions, type ViteDevServer, createServer } from 'vite'
import { afterEach, describe, expect, test } from 'vitest'
import { hmrPorts, isServe, page, ports } from '~utils'
let server: ViteDevServer
afterEach(async () => {
await server?.close()
})
async function testC... | fim | vitejs/vite | typescript |
<|fim_prefix|>// do nothing here sin<|fim_suffix|> close(): Promise<void> }> {
return {
close: () => Promise.resolve(),
}
}
<|fim_middle|>ce server is managed inside spec
export async function serve(): Promise<{<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>nfig({
server: {},
})
<|fim_prefix|>import <|fim_middle|>{ defineConfig } from 'vite'
export default defineCo<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ine-js: ok')
})
test('nonce attributes are not repeated', async () => {
const htmlSource = await page.content()
expect(htmlSource).not.toContain(/nonce=""[^>]*nonce=""/)
await expect
.poll(() => page.textContent('.double-nonce-js'))
.toBe('double-nonce-js: ok')
})
test('meta[property=csp-n... | fim | vitejs/vite | typescript |
<|fim_prefix|>import<|fim_suffix|>'./dynamic.css'
document.querySelector('.dynamic-js').textContent = 'dynamic-js: ok'
<|fim_middle|> <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>import './from-js.css'
document.<|fim_middle|>querySelector('.js').textContent = 'js: ok'
import('./dynamic.js')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs/promises'
import path from 'node:path'
import crypto from 'node:crypto'
import { defineConfig } from 'vite'
const noncePlaceholder = '#$NONCE$#'
const createNonce = () => crypto.randomBytes(16).toString('base64')
/**
* @param {import('node:http').ServerResponse} res
* @param {s... | fim | vitejs/vite | javascript |
<|fim_prefix|>import './tests'
<|fim_suffix|><|fim_middle|><|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// NOTE: <|fim_suffix|>tests'
<|fim_middle|>a separate directory from `playground/css` is created by playground/vitestGlobalSetup.ts
import '../<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>, 'no-css-minify')).not.toMatch(
'(function polyfill() {',
)
expect(findAssetFile(/index-[-\w]+\.css$/, 'no-css-minify')).toMatch(`\
.test-minify {
color: rgba(255, 255, 0, 0.7);
}`)
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { findAssetFile, isBuild } fro... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { createServer } from 'vite'
import { expect, test } from 'vitest'
import { getBgColor, getColor, isServe, page, ports } from '~utils'
// Regression test for https://github.com/vitejs/vite/issues/4000
test.runIf(isServe)('postcss plugins in different dir', async () => ... | fim | vitejs/vite | typescript |
// this is automatically detected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
// The server is started in the test, so we need to have a custom serve
// function or a default server will be created
export async function serve(): Promise<{ close(): Promise<void> }> {
return {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { beforeEach, describe, expect, test } from 'vitest'
import { findAssetFile, isBuild, startDefaultServe } from '~utils'
beforeEach(async () => {
await startDefaultServe()
})
for (let i = 0; i < 5; i++) {
<|fim_suffix|>', () => {
test('emit file name should consistent', () => {
expect... | fim | vitejs/vite | typescript |
<|fim_suffix|>
"
`)
expect(findAssetFile(/entry2/, 'sass-modern-compiler-build'))
.toMatchInlineSnapshot(`
".entry2{color:#00f}
"
`)
})
<|fim_prefix|>imp<|fim_middle|>ort { expect, test } from 'vitest'
import { findAssetFile, isBuild } from '~utils'
test.runIf(isBuild)('sass modern compiler build... | fim | vitejs/vite | typescript |
<|fim_suffix|> () => {
const imported = await page.$('.path-resolved-modules-sass')
expect(await getColor(imported)).toBe('orangered')
// check if the generated CSS module class name is indeed using the
// format specified in vite.config.js
expect(await imported.getAttribute('class')).toMatch(
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { readFileSync } from 'node:fs'
import { expect, test } from 'vitest'
import { sassModuleTests, sassOtherTests, sassTest } from './sass-tests'
import {
editFile,
findAssetFile,
getBg,
getBgColor,
getColor,
isBuild,
page,
removeFile,
serverLogs,
viteTestUrl,
} from '~utils'
// n... | fim | vitejs/vite | typescript |
<|fim_suffix|>s'
createButton('async-blue')
<|fim_prefix|>import { createButton } from './base'<|fim_middle|>
import './async-1.cs<|endoftext|> | fim | vitejs/vite | javascript |
import { createButton } from './base'
import './async-2.css'
createButton('async-green')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { createButton } from './base'
import styles from './async<|fim_suffix|>['async-pink']} modules-pink`)
<|fim_middle|>-3.module.css'
createButton(`${styles<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './base.css'
export function createButton(className) {
const button = document.createElement('button')
button.className = `btn ${className}`
document.body.appendChild(button)
button.textContent = `button ${getComputedStyl<|fim_suffix|>or}`
}
<|fim_middle|>e(button).col<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>mport('./async-3.js')
<|fim_prefix|>import('./async-1.js')
imp<|fim_middle|>ort('./async-2.js')
i<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './async-treeshaken.css'
const div = document.createElement('div')
div.className = 'async-treeshaken'
div.text<|fim_suffix|>chunk (this should be plum and should not show up in prod)'
document.body.appendChild(div)
<|fim_middle|>Content =
'async treeshaken <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './async.cs<|fim_suffix|>ould be teal) ${
getComputedStyle(div).color
}`
<|fim_middle|>s'
const div = document.createElement('div')
div.className = 'async'
document.body.appendChild(div)
div.textContent = `async chunk (this sh<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>throw new Error('should no<|fim_suffix|> be imported')
<|fim_middle|>t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rted')
<|fim_prefix|>throw new Error('should<|fim_middle|> not be impo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> barModuleClasses }
<|fim_prefix|>import './foo.css'
import barModuleClasses from './bar.module.css'
<|fim_middle|>export {<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ort default message
<|fim_prefix|>c<|fim_middle|>onst message = 'from jsfile.css.js'
exp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>functions.a<|fim_suffix|>AAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdjYGD4/x8AAwIB/8myre4AAAAASUVORK5CYII='
return `url(${transparentPng})`
})
<|fim_middle|>dd('test', function test() {
const transparentPng =
'data:image/png;base64,iVBORw0KGgo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> value: {
url: '=/ok.png',
loc: rule.loc,
},
},
],
},
],
},
loc: rule.loc,
... | fim | vitejs/vite | javascript |
import './minify.css'
import './imported.css'
import './sugarss.sss'
import './sass.scss'
import './less.less'
import './less-plugin.less'
import './stylus.styl'
import './manual-chunk.css'
import './postcss-inject-url.css'
import urlCss from './url-imported.css?url'
appendLinkStylesheet(urlCss)
import rawCss from '.... | fim | vitejs/vite | javascript |
import './imported.css'
import css from './imported.css?inline'
text('.imported-css', css)
function text(el, text) {
document.querySelector(el).textContent = text
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default {
plugins: [replacePinkWithBlue],
}
function <|fim_suffix|>lue'
}
},
}
}
replacePinkWithBlue.postcss = true
<|fim_middle|>replacePinkWithBlue() {
return {
postcssPlugin: 'replace-pink-with-blue',
Declaration(decl) {
if (decl.value === 'pink') {
decl.va... | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import { createServer } from 'vite'
import { expect, test } from 'vitest'
import { getColor, isServe, page, ports } from '~utils'
test.runIf(isServe)('postcss config', as<|fim_suffix|> hmrConnectionPromise = page.waitForEvent('console', (msg) =>
msg.text().includes('con... | fim | vitejs/vite | typescript |
<|fim_prefix|>import './imported.css'
import css from './imported.css<|fim_suffix|> {
document.querySelector(el).textContent = text
}
<|fim_middle|>?inline'
text('.imported-css', css)
function text(el, text)<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>n'
}
},
}
}
replacePinkWithGreen.postcss = true
<|fim_prefix|>export default {
plugins: [replacePinkWithGreen],
}
function replacePinkWith<|fim_middle|>Green() {
return {
postcssPlugin: 'replace-pink-with-green',
Declaration(decl) {
if (decl.value === 'pink') {
decl.... | fim | vitejs/vite | javascript |
<|fim_prefix|>// this is automatically d<|fim_suffix|> or a default server will be created
export async function serve(): Promise<{ close(): Promise<void> }> {
return {
close: () => Promise.resolve(),
}
}
<|fim_middle|>etected by playground/vitestSetup.ts and will replace
// the default e2e test serve behavior
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { globSync } from 'tinyglobby'
import { normalizePath } from 'vite'
import postcssNested from 'postcss-nested'
export default {
plugins: [postcssNested, testDirDep, testSourceInput, testInjectUrl],
}
/**
* A plugin for testing the `dir-depe... | fim | vitejs/vite | javascript |
<|fim_prefix|>import './sub.css<|fim_suffix|>port default 'sub1-name'
<|fim_middle|>'
ex<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>b.css'
export default 'sub2-name'
<|fim_prefix|>import './<|fim_middle|>su<|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.