text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ry')
<|fim_prefix|>i<|fim_middle|>mport './test.css'
console.log('ent<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>n main() {
console.log('test')
}
main()
<|fim_prefix|>functi<|fim_middle|>o<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export defau<|fim_suffix|>dir/index.default.js'
<|fim_middle|>lt '<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expor<|fim_suffix|>ault 'dir/index.module.js'
<|fim_middle|>t def<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>x.browser.js'
<|fim_prefix|><|fim_middle|>export default 'inde<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> 'index.custom1.js'
<|fim_prefix|>exp<|fim_middle|>ort default<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> 'index.default.js'
<|fim_prefix|>exp<|fim_middle|>ort default<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default 'i<|fim_suffix|>.js'
<|fim_middle|>ndex.worker<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import dep fro<|fim_suffix|>st-dep-conditions/with-module'
export default dep
<|fim_middle|>m '@vitejs/te<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>tions'
export default dep
<|fim_prefix|>i<|fim_middle|>mport dep from '@vitejs/test-dep-condi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>console.<|fim_suffix|>dep.js')
<|fim_middle|>log('<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>import('./dep.js'))
<|fim_prefix|>console.log('entry.js')
console<|fim_middle|>.log(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default '<|fim_suffix|>'
<|fim_middle|>dynamic ok<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>= e.data
}
worker.postMessage('hi')
<|fim_prefix|>document.querySelecto<|fim_middle|>r('#app').innerHTML = `
<div>
<h1>Test worker</h1>
<div id="worker">???</div>
</div>
`
const worker = new Worker(new URL('./worker.js', import.meta.url))
worker.onmessage = (e) => {
document.querySelector('... | fim | vitejs/vite | javascript |
<|fim_prefix|>self.onmessage <|fim_suffix|>Message('hello from worker: ' + mod.default)
}
<|fim_middle|>= async () => {
const mod = await import('./dynamic')
self.post<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import type { OutputBundle, OutputChunk } from 'rolldown'
import { getCssFilesForChunk } from '../plugins/html'
function createChunk(
fileName: string,
imports: string[],
importedCss: string[],
): OutputChunk {
return {
type: 'chunk',
fileNa... | fim | vitejs/vite | typescript |
<|fim_suffix|>)
const address = viteServer.httpServer!.address()
expect(address).toStrictEqual(expect.objectContaining({ port: BASE_PORT }))
})
test('throws error when port is blocked and strictPort is true', async () => {
await using _blockingServer = await createSimpleServer(
BASE_PORT,
... | fim | vitejs/vite | typescript |
import type * as esbuild from 'esbuild'
import { describe, expect, test } from 'vitest'
import { convertEsbuildPluginToRolldownPlugin } from '../../optimizer/pluginConverter'
import type { Plugin } from '../../plugin'
type ConvertedPluginHooks = {
options: Extract<Plugin['options'], Function>
generateBundle: Extra... | fim | vitejs/vite | typescript |
<|fim_suffix|>ynamic template strings', async () => {
expect(
await transform(
'new URL(`./${name}.js`, import.meta.url)',
'/root/node_modules/my-lib/index.js',
),
).toBeUndefined()
})
test('handles backticks for static relative strings', async () => {
expect(
await tr... | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>export defa<|fim_middle|>ult true<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>not typed
import child from '@vitejs/child'
export default {
child,
}
<|fim_prefix|>// @ts-expect<|fim_middle|>-error <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { parseAst } from 'rollup/parseAst'
import { assetImportMe<|fim_suffix|>) => {
expect(
await transform('new URL(`${file}.js`, import.meta.url)'),
).toMatchInlineSnapshot(`"new URL(\`\${file}.js\`, import.meta.url)"`)
})
})
<|fim_middle... | fim | vitejs/vite | typescript |
<|fim_suffix|>= 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.lib = {})));
})(this, function(exports) {
//#region entry.js
(async () => {
await new Promise((re... | fim | vitejs/vite | typescript |
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import type { ChildProcess } from 'node:child_process'
import { describe, expect, test } from 'vitest'
import { createServer } from '../../index'
const getActiveHandles = (): unknown[] => (process as any)._getActiveHandles()
const runningS... | fim | vitejs/vite | typescript |
<|fim_suffix|>? 'ssr' : 'client', config)
return async (code: string) => {
if (isSsrDev) {
// @ts-expect-error transform.handler should exist
const result = await instance.transform.handler.call(
{ environment },
code,
'foo.ts',
)
return result?.code || result
... | fim | vitejs/vite | typescript |
<|fim_prefix|>export function hello() {
<|fim_suffix|>hello'
}
<|fim_middle|> return '<|endoftext|> | fim | vitejs/vite | javascript |
export function hi() {
return 'hi'
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t('with query url', async () => {
expect(await run('`./mods/${base}.js?url`')).toMatchSnapshot()
})
it('? in variables', async () => {
expect(await run('`./mods/${base ?? foo}.js?raw`')).toMatchSnapshot()
})
// ? is not escaped on windows (? cannot be used as a filename on windows)
it.... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { describe, expect, test } from 'vitest'
import type { ResolvedConfig, UserConfig } from '../../config'
import {
injectEsbuildHelpers,
resolveEsbuildTranspileOptions,
transformWithEsbuild,
} from '../../plugins/esbuild'
import { normalizePath } from '../../utils'
... | fim | vitejs/vite | typescript |
<|fim_suffix|>00
console.log()
export default 'ok'
<|fim_prefix|>// Avoid to be inlined completely: https://github.com/rolldown/<|fim_middle|>rolldown/issues/81<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>tedDep
<|fim_prefix|>import nestedDep from '@vitejs/test-dep-nested-license-isc'
export defa<|fim_middle|>ult 'ok' + nes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Avoid to be inlined complete<|fim_suffix|>down/rolldown/issues/8100
console.log()
export default 'ok'
<|fim_middle|>ly: https://github.com/roll<|endoftext|> | fim | vitejs/vite | javascript |
import workerUrl from './worker?worker&url'
console.log(workerUrl)
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ge(msg)
<|fim_prefix|>/* global self */
const msg = 'hello from worker'
sel<|fim_middle|>f.postMessa<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ct.assertions(4)
const { promise, resolve } = promiseWithResolvers<void>()
const server = await createServerWithPlugin({
name: 'test',
hotUpdate() {
if (this.environment.name !== 'client') return
expect(this).toMatchObject({
debug: expect.any(Function),
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { beforeEach, describe, expect, test, vi } from 'vitest'
import { transformCjsImport } from '../../plugins/importAnalysis'
describe('runTransform', () => {
const config: any = {
command: 'serve',
logger: {
warn: vi.fn(),
},
}
function runTransformCjsImport(importExp: strin... | fim | vitejs/vite | typescript |
<|fim_prefix|>export co<|fim_suffix|>dot-folder-test'
<|fim_middle|>nst msg = '<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>es/*.ts',
'../fixture-b/*.ts',
'!**/index.ts',
])
export const customBase = import.meta.glob('./**/*.ts', { base: './' })
export const customRootBase = import.meta.glob('./**/*.ts', {
base: '/fixture-b',
})
export const customBaseParent = import.meta.glob('/fixture-b/**/*.ts', {
base: '/fixture... | fim | vitejs/vite | typescript |
<|fim_prefix|>export c<|fim_suffix|>a'
<|fim_middle|>onst name = '<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>e<|fim_suffix|>ame = 'b'
<|fim_middle|>xport const n<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export { name as a } from './a'
export<|fim_suffix|>
<|fim_middle|> { name as b } from './b'
export const name = 'index'
export default 'indexDefault'<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|><|fim_suffix|>sibling!'
<|fim_middle|>export const name = 'I am your <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>const name = 'a'
<|fim_prefix|>expo<|fim_middle|>rt <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>e<|fim_suffix|>ame = 'b'
<|fim_middle|>xport const n<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export { name a<|fim_suffix|>b } from './b'
<|fim_middle|>s a } from './a'
export { name as <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { resolve } from 'node:path'
import { promises as fs } from 'node:fs'
import { describe, expect, it } from 'vitest'
import { transformGlobImport } from '../../../plugins/importMetaGlob'
import { transformWithEsbuild } from '../../../plugins/esbuild'
describe('fixture', async () => {
const resolv... | fim | vitejs/vite | typescript |
<|fim_suffix|>ring', async () => {
expect(await runError('"import.meta.glob()"')).toBeUndefined()
})
it('variable', async () => {
expect(await runError('import.meta.glob(hey)')).toMatchInlineSnapshot(
'[Error: Invalid glob import syntax: Could only use literals]',
)
})
it('template', async (... | fim | vitejs/vite | typescript |
<|fim_suffix|> expect(getCommonBase(['/a/b/c/*.vue'])).toBe('/a/b/c')
expect(getCommonBase(['/a/b/c/foo.vue'])).toBe('/a/b/c')
})
it('no common base', () => {
expect(getCommonBase(['/a/b/*.js', '/c/a/b/*.js'])).toBe('/')
})
})
<|fim_prefix|>import { describe, expect, it } from 'vitest'
import { getCommon... | fim | vitejs/vite | typescript |
<|fim_suffix|>s"\n' + 'import_meta'
}
if (id === 'foo.ts') {
return 'import.meta'
}
},
},
],
['foo.js', 'foo.ts'],
)
await build(config)
test('resolveId', async () => {
expect(resolveId).toHaveBeenCalledTimes(1)
expect(resolveId).toHaveBeenC... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { fileURLToPath } from 'node:url'
import type { Out<|fim_suffix|>upOutput } from 'rollup'
import { expect, test } from 'vitest'
import { build } from '../../build'
test('markdown', async () => {
const result = (await build({
root: fileURLToPath(new URL('./fixtures/license', import.meta.url))... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, it } from 'vitest'
import type { ModuleFormat, RolldownOutput } from 'rolldown'
import { build } from '../../../build'
import { modulePreloadPolyfillId } from '../../../plugins/modulePreloadPolyfill'
const buildProject = ({ format = 'es' as ModuleFormat } = {}) =>
build({
logLeve... | fim | vitejs/vite | typescript |
<|fim_suffix|> true', async () => {
const actual = await transformClassCode(
'es2022',
'./fixtures/oxc-tsconfigs/target-es2022',
)
expect(actual).toBe(defineForClassFieldsTrueTransformedCode)
})
test('target: es2022 and tsconfig.target: undefined => false', async () => {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import util from 'node:util'
import path from 'node:path'
import { describe, expect, test } from 'vitest'
import type { ModuleTypeFilter } from 'rolldown'
import {
type StringFilter,
createCodeFilter,
createFilterForTransform,
createIdFilter,
} from '../../plugins/pluginFilter'
describe('createId... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { resolve } from 'node:path'
import { describe, expect, test } from 'vitest'
import { build } from 'vite'
import type { RollupOutput } from 'rollup'
import type { TerserOptions } from '../../plugins/terser'
describe('terser', () => {
const run = async (terserOptions: TerserOptions) => {
cons... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { assetUrlRE } from '../../plugins/asset'
describe('wasm plugin assetUrlRE usage', () => {
// Regression test: assetUrlRE has the /g flag, which makes .test()
// stateful via lastIndex. When the wasm plugin called assetUrlRE.test()
// on consec... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { resolve } from 'node:path'
import { expect, test } from 'vitest'
import type { OutputChunk, RolldownOutput } from 'rolldown'
import { build } from '../../build'
const fixturesDir = resolve(import.meta.dirname, 'fixtures')
test('?worker&url should produce the same hash in client and SSR builds',... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { parseAst } from 'rollup/parseAst'
import { workerImportMetaUrlPlugin } from '../../plugins/workerImportMetaUrl'
import { resolveConfig } from '../../config'
import { PartialEnvironment } from '../../baseEnvironment'
async function createWorkerImpor... | fim | vitejs/vite | typescript |
<|fim_suffix|>e)
})
test('default to node-like builtins for ssr environment', async () => {
const resolved = await run({
idToResolve: 'node:fs',
testEnv: 'ssr',
})
expect(resolved?.external).toBe(true)
})
test('no default to node-like builtins for client environment',... | fim | vitejs/vite | typescript |
<|fim_suffix|> => {
await expect(() =>
runnerImport<typeof import('./fixtures/runner-import/basic')>(
fixture('cjs.js'),
),
).rejects.toThrow('module is not defined')
})
test('can import vite config', async () => {
const { module, dependencies } = await runnerImport<
typeof im... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { describe, expect, test } from 'vitest'
import {
commentRE,
devToScanEnvironment,
importsRE,
scanImports,
scriptRE,
} from '../optimizer/scan'
import { multilineCommentsRE, singlelineCommentsRE } from '../utils'
import { createServer, createServerModuleRunner... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { Mock } from 'vitest'
import { describe, expect, test, vi } from 'vitest'
import { createServer } from '../server'
import { preview } from '../preview'
import { bindCLIShortcuts } from '../shortcuts'
describe('bindCLIShortcuts', () => {
test.each([
['dev server', () => createServer()],... | fim | vitejs/vite | typescript |
<|fim_suffix|>estConfig = () => ({
options: { https: true } as any,
hostname: { host: '127.0.0.1', name: 'localhost' } as any,
config: { rawBase: '/' } as any,
})
test('should handle no certificate', () => {
const mockServer = createMockServer()
const { options, hostname, config } = createTestC... | fim | vitejs/vite | typescript |
<|fim_suffix|>quire `as const` here
},
server: {
proxy: {
'/test': {
bypass: () => false as const, // ideally we don't want to require `as const` here
},
},
},
unknownProperty: 1, // we cannot catch invalid option for this case, ideally we should
}))
// @ts-expect-error --- nested i... | fim | vitejs/vite | typescript |
<|fim_prefix|>/* eslint-disable @typescript-eslint/no-unused-vars */
import type { Equal, ExpectTrue } from '@type-challenges/utils'
import type { ImportGlobFunction } from '#types/importGlob'
const importGlobFunction: ImportGlobFunction = () => ({})
const importGlobEagerReturn = importGlobFunction('', {
eager: tru... | fim | vitejs/vite | typescript |
<|fim_prefix|>/**
* This is a development only file for testing types.
*/
import type { Plugin as RolldownPlugin } from 'rolldown'
import type { Equal, ExpectExtends, ExpectTrue } from '@type-challenges/utils'
import type { Plugin as RollupPlugin } from 'rollup'
import type { Plugin, PluginContextExtension, PluginOpt... | fim | vitejs/vite | typescript |
<|fim_prefix|>// This file tests `ViteTypeOptions` in `packages/vite/types/importMeta.d.ts`
import type { ExpectFalse, ExpectTru<|fim_suffix|> extends string> = Key extends keyof Opts ? true : false
export type cases = [
ExpectFalse<IsEnabled<TypeOptions1, 'strictImportMetaEnv'>>,
ExpectTrue<IsEnabled<TypeOptions2... | fim | vitejs/vite | typescript |
/* eslint-disable @typescript-eslint/no-unused-vars */
import type { Equal, ExpectTrue } from '@type-challenges/utils'
import { mergeWithDefaults } from '../utils'
const useDefaultTypeForUndefined1 = mergeWithDefaults(
{
foo: 1,
},
{},
)
const useDefaultTypeForUndefined2 = mergeWithDefaults(
{
foo: 1,... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { DefaultTreeAdapterMap, Token } from 'parse5'
/**
* Defines which attributes of an HTML element should be treated as asset sources.
* Used in `html.additionalAssetSources` configuration.
*/
export interface HtmlAssetSource {
/**
* Attributes that contain a single asset URL.
* @exa... | fim | vitejs/vite | typescript |
<|fim_suffix|>pts,
environment: infoColor(environment),
})
},
warn(msg, opts) {
return topLevelConfig.logger.warn(msg, {
...opts,
environment: colors.yellow(environment),
})
},
warnOnce(msg, opts) {
return topLevelConfig.logger.warnOn... | fim | vitejs/vite | typescript |
<|fim_suffix|> : merged.modulePreload === true
? defaultModulePreload
: {
...defaultModulePreload,
...merged.modulePreload,
},
}
return resolved
}
export function resolveBuildPlugins(config: ResolvedConfig): {
pre: Plugin[]
post: Plugin[]
} {
const... | fim | vitejs/vite | typescript |
<|fim_suffix|>[convertHost] })
.option('--port <port>', `[number] specify port`)
.option('--strictPort', `[boolean] exit if specified port is already in use`)
.option('--open [path]', `[boolean | string] open browser on startup`)
.option('--outDir <dir>', `[string] output directory (default: dist)`)
.action(
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import fsp from 'node:fs/promises'
import { pathToFileURL } from 'node:url'
import { inspect, promisify } from 'node:util'
import { performance } from 'node:perf_hooks'
import { createRequire } from 'node:module'
import crypto from 'node:crypto'
import... | fim | vitejs/vite | typescript |
<|fim_suffix|> 'browser', 'node', DEV_PROD_CONDITION]
export const DEFAULT_CLIENT_CONDITIONS: readonly string[] = Object.freeze(
DEFAULT_CONDITIONS.filter((c) => c !== 'node'),
)
export const DEFAULT_SERVER_CONDITIONS: readonly string[] = Object.freeze(
DEFAULT_CONDITIONS.filter((c) => c !== 'browser'),
)
export c... | fim | vitejs/vite | typescript |
<|fim_prefix|>import colors from 'picocolors'
import type { FutureOptions, ResolvedConfig } from './config'
const docsURL = 'https://vite.dev'
const deprecationCode = {
removePluginHookSsrArgument: 'this-environment-in-hooks',
removePluginHookHandleHotUpdate: 'hotupdate-hook',
removeServerModuleGraph: 'per-env... | fim | vitejs/vite | typescript |
<|fim_suffix|>)
const env: Record<string, string> = {}
const envFiles = getEnvFilesForMode(mode, envDir)
debug?.(`loading env files: %O`, envFiles)
const parsed = Object.fromEntries(
envFiles.flatMap((filePath) => {
const stat = tryStatSync(filePath)
// Support FIFOs (named pipes) for apps lik... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { PluginContext } from 'rolldown'
import type { DevEnvironment } from './server/environment'
import type { BuildEnvironment } from './build'
import type { ScanEnvironment } from './optimizer/scan'
import type { UnknownEnvironment } from './baseEnvironment'
export type Environment =
| DevEnv... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import type { InternalResolveOptions } from './plugins/resolve'
import { tryNodeResolve } from './plugins/resolve'
import {
bareImportRE,
createDebugger,
createFilter,
getNpmPackageName,
isBuiltin,
isInNodeModules,
} from './utils'
import type { Environment } from ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fsp from 'node:fs/promises'
import net from 'node:net'
import path from 'node:path'
import type { OutgoingHttpHeaders as HttpServerHeaders } from 'node:http'
import type { ServerOptions as HttpsServerOptions } from 'node:https'
import colors from 'picocolors'
import type { Connect } from '#dep-type... | fim | vitejs/vite | typescript |
<|fim_suffix|>aliasPlugin and resolvePlugin are implemented to function with a Environment only,
// we cast it as PluginEnvironment to be able to use the pluginContainer
const resolved = await resolveFn(environment, id, importer)
return resolved?.id
}
}
<|fim_prefix|>import type { PartialResolvedId } from... | fim | vitejs/vite | typescript |
<|fim_suffix|>ts'
export type {
HMRPayload,
HotPayload,
ConnectedPayload,
UpdatePayload,
Update,
FullReloadPayload,
CustomPayload,
PrunePayload,
ErrorPayload,
} from '#types/hmrPayload'
export type {
CustomEventMap,
InferCustomEventPayload,
InvalidatePayload,
} from '#types/customEvent'
export ... | fim | vitejs/vite | typescript |
<|fim_prefix|>export { viteRea<|fim_suffix|>pperPlugin } from 'rolldown/experimental'
<|fim_middle|>ctRefreshWrapperPlugin as reactRefreshWra<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>/* eslint no-console: 0 */
import readline from 'node:readline'
import colors from 'picocolors'
import type { RollupError } from 'rolldown'
import type { ResolvedServer<|fim_suffix|>
info(` ${colors.green('➜')} ${colors.bold('Network')}: ${colorUrl(url)}`)
}
if (urls.network.length === 0 && opt... | fim | vitejs/vite | typescript |
<|fim_suffix|> nodeLikeBuiltins,
disableOptionalPeerDepHandling: true,
})?.id
}
<|fim_prefix|>import isModuleSyncConditionEnabled from '#module-sync-enabled'
import { DEFAULT_EXTENSIONS } from './constants'
import { tryNodeResolve } from './plugins/resolve'
import { nodeLikeBuiltins } from './utils'
export inter... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import fsp from 'node:fs/promises'
import path from 'node:path'
import { promisify } from 'node:util'
import { performance } from 'node:perf_hooks'
import { ignoreInput, ignoreOutput } from '@voidzero-dev/vite-task-client'
import colors from 'picocolors'
import { init, parse } fro... | fim | vitejs/vite | typescript |
<|fim_prefix|>import colors from 'picocolors'
import { createDebugger, getHash } from '../utils'
import {
type PromiseWithResolvers,
promiseWithResolvers,
} from '../../shared/utils'
import type { DevEnvironment } from '../server/environment'
import { devToScanEnvironment } from './scan'
import {
addManuallyInclu... | fim | vitejs/vite | typescript |
<|fim_suffix|> for (const file of result.watchFiles ?? []) {
this.addWatchFile(file)
}
return {
code:
typeof result.contents === 'string'
? result.contents
: textDecoder.decode(result.contents),
moduleType: result.loader,
}
}
}
function idToPathAndNamespace(... | fim | vitejs/vite | typescript |
<|fim_suffix|>, basedir, preserveSymlinks)?.dir || basedir
}
return basedir
}
<|fim_prefix|>import path from 'node:path'
import picomatch from 'picomatch'
import { globSync } from 'tinyglobby'
import type { ResolvedConfig } from '../config'
import { escapeRegex, getNpmPackageName } from '../utils'
import { resolveP... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import type { ImportKind, Plugin, RolldownPlugin } from 'rolldown'
import { prefixRegex } from 'rolldown/filter'
import MagicString from 'magic-string'
import { stripLiteral } from 'strip-literal'
import { JS_TYPES_RE, KNOWN_ASSET_TYPES } from '../constants'
import type { Pack... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import fsp from 'node:fs/promises'
import path from 'node:path'
import { performance } from 'node:perf_hooks'
import { scan } from 'rolldown/experimental'
import type { TransformOptions as OxcTransformOptions } from 'rolldown/utils'
import { transformSync } from 'rolldown/utils'
i... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { createRequire } from 'node:module'
import<|fim_suffix|>ath)?.isDirectory()) {
return pkgPath
}
const nextBasedir = path.dirname(basedir)
if (nextBasedir === basedir) break
basedir = nextBasedir
}
return null
}
expo... | fim | vitejs/vite | typescript |
<|fim_suffix|>] = []
for (const plugin of environment.getTopLevelConfig().plugins) {
if (plugin.applyToEnvironment) {
const applied = await plugin.applyToEnvironment(environment)
if (!applied) {
continue
}
if (applied !== true) {
environmentPlugins.push(
...((awai... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import fsp from 'node:fs/promises'
import { Buffer } from 'node:buffer'
import { pathToFileURL } from 'node:url'
import * as mrmime from 'mrmime'
import type {
NormalizedOutputOptions,
PluginContext,
RenderedChunk,
} from 'rolldown'
import MagicString from 'magic-string'... | fim | vitejs/vite | typescript |
import path from 'node:path'
import MagicString from 'magic-string'
import { stripLiteral } from 'strip-literal'
import { exactRegex } from 'rolldown/filter'
import type { Plugin } from '../plugin'
import type { ResolvedConfig } from '../config'
import {
injectQuery,
isDataUrl,
isParentDirectory,
transformStabl... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import fs from 'node:fs'
import type { Plugin } from '../plugin'
import type { ResolvedConfig } from '../config'
import { CLIENT_ENTRY, ENV_ENTRY } from '../constants'
import { isObject, normalizePath, resolveHostname } from '../utils'
import { cleanUrl } from '../../shared/ut... | fim | vitejs/vite | typescript |
<|fim_suffix|> if (!pattern.test(code)) return
const result = replaceDefine(this.environment, code, id, define)
return result
},
},
}
}
export function replaceDefine(
environment: Environment,
code: string,
id: string,
define: Record<string, string>,
): {
code: string
map: R... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { posix } from 'node:path'
import MagicString from 'magic-string'
import { init, parse as parseImports } from 'es-module-lexer'
import type { ImportSpecifier } from 'es-module-lexer'
import { parseAst } from 'rolldown/parseAst'
import { dynamicImportToGlob } from '@rollup/plugin-dynamic-import-vars... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import colors from 'picocolors'
import type { RawSourceMap } from '@jridgewell/remapping'
import type { InternalModuleFormat, SourceMap } from 'rolldown'
import { resolveTsconfig } from 'rolldown/experimental'
import { TsconfigCache } from 'rolldown/utils'
import type {
Esbu... | fim | vitejs/vite | typescript |
<|fim_prefix|>import MagicString from 'magic-string'
import type { Plugin } from '../plugin'
import type { ResolvedConfig } from '../config'
import { createFilter } from '../utils'
impo<|fim_suffix|> }
if (footer) {
code = `${code}\n${footer}`
}
return code
}
... | fim | vitejs/vite | typescript |
<|fim_suffix|>e vitest uses this option to skip internal files by default.
// https://github.com/vitest-dev/vitest/blob/4783137cd8d766cf998bdf2d638890eaa51e08d9/packages/utils/src/source-map.ts#L17
ignoreStackEntries: [],
})
const nearest = stacks.find((stack) => {
const modules = environment.moduleGra... | fim | vitejs/vite | typescript |
import path from 'node:path'
import { URL } from 'node:url'
import type {
OutputAsset,
OutputBundle,
OutputChunk,
RollupError,
SourceMapInput,
} from 'rolldown'
import MagicString from 'magic-string'
import colors from 'picocolors'
import type {
DefaultTreeAdapterMap,
ErrorCodes,
ParserError,
Token,
}... | fim | vitejs/vite | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.