text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>export async f<|fim_suffix|>ort(/* @vite-ignore */ id)
}
<|fim_middle|>unction setupCyclic() {
const mod = await import('./entry-cyclic.js')
await mod.default()
}
export async function importAction(id) {
return await imp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export const dep1 = { o<|fim_middle|>k: true }
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1 } from './index.js'
e<|fim_suffix|>: dep1.ok }
<|fim_middle|>xport const dep2 = { ok<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ep2.js'
export { dep2 }
<|fim_prefix|>import { dep1 } from './dep1.js'
export { dep1 }
import { dep2 } from '.<|fim_middle|>/d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>}
<|fim_middle|>ort const dep1 = { ok: true <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1 } from '.<|fim_suffix|>
export const dep2 = { ok: dep1.ok }
<|fim_middle|>/index.js'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>m './dep2.js'
<|fim_prefix|>export { dep1 } from './dep1<|fim_middle|>.js'
export { dep2 } fro<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export c<|fim_suffix|>p1 = { ok: true }
<|fim_middle|>onst de<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1 } from './index.js'
exp<|fim_suffix|>const dep2 = { ok: dep1.ok }
<|fim_middle|>ort <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.js'
import { dep2 } from './dep2.js'
export { dep1 }
export { dep2 }
<|fim_prefix|>import { de<|fim_middle|>p1 } from './dep1<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>dep1 = { ok: true }
<|fim_middle|>ort const <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1 } <|fim_suffix|>ok: dep1.ok }
<|fim_middle|>from './index.js'
export const dep2 = { <|endoftext|> | fim | vitejs/vite | javascript |
export * from './dep1.js'
export * from './dep2.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rue }
<|fim_prefix|>expor<|fim_middle|>t const dep1 = { ok: t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1 } from './index.js'
export const <|fim_suffix|>.ok }
<|fim_middle|>dep2 = { ok: dep1<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>}
<|fim_prefix|>im<|fim_middle|>port { dep2 } from './dep2.js'
export { dep2 }
import { dep1 } from './dep1.js'
export { dep1 <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep2 } from '<|fim_suffix|>1: ' + dep2
<|fim_middle|>./dep2.js'
export const dep1 = 'dep<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { dep1<|fim_suffix|>ep2 = 'dep2: ' + dep1
<|fim_middle|> } from './dep1.js'
export const d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>dep1 } from './dep1.js'
export { dep1 }
<|fim_prefix|>impo<|fim_middle|>rt { <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export { IonTypes } from './IonTypes.js'
import * as dom from './dom/index.js'
export { <|fim_suffix|><|fim_middle|>dom }
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export con<|fim_suffix|>,
}
<|fim_middle|>st IonTypes = {
BLOB: 'Blob'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { IonTypes } from '../Ion.js'
export const Blo<|fim_suffix|>Types.BLOB
<|fim_middle|>b = Ion<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export { Blob } fro<|fim_suffix|>
<|fim_middle|>m './Blob.js'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>default dep
<|fim_prefix|>import dep from './i<|fim_middle|>ndex.js'
export <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ult dep
<|fim_prefix|>import dep from './dep.js'
<|fim_middle|>export defa<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t d')
})
<|fim_prefix|>export { c as d } from './c'
im<|fim_middle|>port.meta.hot?.accept(() => {
console.log('accep<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>const str: string = 'h<|fim_suffix|>rld'
export default str
<|fim_middle|>ello wo<|endoftext|> | fim | vitejs/vite | typescript |
import path from 'node:path'
import * as staticModule from './simple'
import { pathToFileURL } from 'node:url'
export const initialize = async () => {
const nameRelative = './simple'
const nameAbsolute = '/fixtures/simple'
const nameAbsoluteExtension = '/fixtures/simple.js'
const absolutePath = path.join(impor... | fim | vitejs/vite | javascript |
<|fim_suffix|>ld'
<|fim_prefix|><|fim_middle|>export const hello = () => 'wor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>impo<|fim_suffix|>} from '@vitejs/esm-external'
export const result = hello()
<|fim_middle|>rt { hello <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>xternal'
console.log(nonExisting)
<|fim_prefix|><|fim_middle|>import { nonExisting } from '@vitejs/esm-e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>console.log('dep1')
export {}
<|fim_middle|><|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>cons<|fim_suffix|>('dep2')
export {}
<|fim_middle|>ole.log<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>dep1.js'
import './dep2.js'
<|fim_middle|>ort * from './<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>function crash(message: string) {
throw new Error(message<|fim_suffix|> crash('crash')
}
<|fim_middle|>)
}
export function main(): void {
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// comment
throw <|fim_suffix|>_')
<|fim_middle|>new Error('__TEST_<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|><|fim_prefix|>th<|fim_middle|>row new Error('__TEST__')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|> comment
throw new Error('module error')
<|fim_middle|>//<|endoftext|> | fim | vitejs/vite | javascript |
await globalThis.__vite_ssr_hmr_reexport_race__?.wait?.()
export function createThing(value) {
return value
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ot?.accept()
<|fim_prefix|>import { createThing } from './shared.js'
export const result = createThing('a<|fim_middle|>')
import.meta.h<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>i<|fim_suffix|>m './shared.js'
export const result = createThing('b')
import.meta.hot?.accept()
<|fim_middle|>mport { createThing } fro<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import<|fim_suffix|>ore.js'
<|fim_middle|> './entry-a.js'
export * from './c<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const<|fim_suffix|>ot
<|fim_middle|> hmr = import.meta.h<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>nyglobby'
<|fim_prefix|>impor<|fim_middle|>t 'ti<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|><|fim_prefix|>export * from 'tinyspy<|fim_middle|>'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export async function test() {
try {
const<|fim_suffix|>{
return { ok: false, data: e }
}
}
<|fim_middle|> result = await import('test-dep-invalid-exports')
return { ok: true, data: result }
} catch (e) <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default function f() {
return 0
}
f<|fim_suffix|> 1
f = () => 2
export function update() {
f = () => 3
}
<|fim_middle|> = () =><|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import f, { update } from './dep.js'
const x = f()
update()
cons<|fim_suffix|>xport default [x, y]
<|fim_middle|>t y = f()
e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>function f() {
return 0
}
<|fim_suffix|>}
<|fim_middle|>f = () => 1
export default f
f = () => 2
export function update() {
f = () => 3
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>const y = f()
export default [x, y]
<|fim_prefix|>import f, { update } from './dep.js'
const x = f()
up<|fim_middle|>date()
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>fun<|fim_suffix|> return 0
}
f = () => 1
export { f as default }
f = () => 2
export function update() {
f = () => 3
}
<|fim_middle|>ction f() {
<|endoftext|> | fim | vitejs/vite | javascript |
import f, { update } from './dep.js'
const x = f()
update()
const y = f()
export default [x, y]
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> static f = () => 3
}
}
<|fim_prefix|>export default class C {
static f = () => 0
}
C = class <|fim_middle|>{
static f = () => 1
}
C = class {
static f = () => 2
}
export function update() {
C = class {
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>xport default [x, y]
<|fim_prefix|>import C, { update<|fim_middle|> } from './dep.js'
const x = C.f()
update()
const y = C.f()
e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ithout node prefix works
export { readdirSync } from 'fs'
<|fim_prefix|>export { existsSync } from 'node:fs'
// eslint-disable-next-line n/prefer-node-protocol -- testing that i<|fim_middle|>mporting w<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export function f<|fim_suffix|>}
<|fim_middle|>oo() {
return this
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { foo } from './importee.js'
export c<|fim_suffix|>nst result = foo()
<|fim_middle|>o<|endoftext|> | fim | vitejs/vite | javascript |
function html(strings: TemplateStringsArray, ...values: unknown[]) {
return strings.join('')
}
export const result = html`<script>
console.log('hi')
</script>`
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>YXBwaW5ncyI6ICJBQUFBLE9BQU87QUFVUCx3QkFBd0IsWUFBWTtBQUNsQyxpQkFBZTtBQUNqQjtBQUVBLE9BQU87QUFNUCxTQUFTLGlCQUFpQjtBQUN4QixRQUFNLElBQUksTUFBTSxrQ0FBa0M7QUFDcEQ7IiwKICAibmFtZXMiOiBbXQp9Cg==
<|fim_prefix|>import 'node:path'
export default function testStack() {
innerTestStack()
}
import 'node:util'
function i... | fim | vitejs/vite | javascript |
<|fim_suffix|>.meta.hot?.accept()
<|fim_prefix|>export const test = 'I am initialized'
impo<|fim_middle|>rt<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// This file contains sourceMappingURL pattern in string literals
// which should not crash the<|fim_suffix|>alidbase64'
export function getMessage() {
return text
}
export function throwError() {
throw new Error('Test error for stacktrace')
}
<|fim_middle|> module runner
const text = '//# sourceMa... | fim | vitejs/vite | typescript |
<|fim_prefix|>interface Foo {
bar: string
}
export functio<|fim_suffix|>ew Error('method error')
}
<|fim_middle|>n throwError(foo?: Foo): void {
throw n<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>const Object = 'my<|fim_suffix|>xport { Object }
<|fim_middle|>-object'
e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { msg as msg0 } f<|fim_suffix|>ual:test'
export { msg0, msg }
<|fim_middle|>rom 'virtual0:test'
import { msg } from 'virt<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// @ts-check
import { BroadcastChannel, parentPort } from 'node:worker_threads'
import {
ESModulesEvaluator,
ModuleRunner,
cr<|fim_suffix|>nel = new BroadcastChannel('vite-worker:invoke')
channel.onmessage = async (message) => {
try {
const mod = await runner.import(message.data.id)
chann... | fim | vitejs/vite | javascript |
<|fim_suffix|> createImportMeta: createNodeImportMeta,
},
new ESModulesEvaluator(),
)
const channel = new BroadcastChannel('vite-worker')
channel.onmessage = async (message) => {
try {
const mod = await runner.import(message.data.id)
channel.postMessage({ result: mod.default })
} catch (e) {
chan... | fim | vitejs/vite | javascript |
<|fim_suffix|> '/fixtures/hmr-reexport-race/entry-b.js',
)
expect(sharedModule).toBeDefined()
expect(coreModule).toBeDefined()
expect(entryAModule).toBeDefined()
expect(entryBModule).toBeDefined()
let waitStarted!: () => void
const waitStartedPromise = new Promise<void>((res... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect } from 'vitest'
import { createModuleRunnerTester } from './utils'
describe('module runner hmr works as expected', async () => {
const it = await createModuleRunnerTester({
server: {
<|fim_suffix|> is not defined if it's disabled", async ({ runner }) => {
expect(runn... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { existsSync, readdirSync } from 'node:fs'
import { posix, resolve, win32 } from 'node:path'
import { fileURLToPath } from 'node:url'
import { setTimeout } from 'node:timers/promises'
import { describe, expect, it, vi } from 'vitest'
import { isWindows } from '../../../../shared/utils'
import type ... | fim | vitejs/vite | typescript |
<|fim_suffix|>lumn', async ({
runner,
}) => {
const error = await runner.import('/fixtures/a.ts').catch((err) => err)
expect(() =>
error.stack.includes('.stack access triggers the bug'),
).not.toThrow()
})
})
<|fim_prefix|>import { runInThisContext } from 'node:vm'
import { resolve } from 'no... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { BroadcastChannel, Worker } from 'node:worker_threads'
import path from 'node:path'
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import type { BirpcReturn } from 'birpc'
import { createBirpc } from 'birpc'
import { DevEnvironment } from '../../..'
import { type ViteDevServer,... | fim | vitejs/vite | typescript |
<|fim_suffix|> worker.off('exit', listener)
handlerToWorkerListener.delete(handler)
}
return
}
const listener = handlerToWorkerListener.get(handler)
if (listener) {
worker.off('message', listener)
handlerToWorkerListener.delete(handler)
}
},
}
}
... | fim | vitejs/vite | typescript |
import fs from 'node:fs'
import { dirname, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'
import type { TestAPI } from 'vitest'
import { afterEach, beforeEach, onTestFinished, test } from 'vitest'
import type { ModuleRunner } from 'vite/module-runner'
import type { ServerModuleRunnerOptions } from ... | fim | vitejs/vite | typescript |
<|fim_suffix|> hmrClient,
)
},
}
}
/**
* Create an instance of the Vite SSR runtime that support HMR.
* @experimental
*/
export function createServerModuleRunner(
environment: DevEnvironment,
options: ServerModuleRunnerOptions = {},
): ModuleRunner {
const hmr = createHMROptions(environment, optio... | fim | vitejs/vite | typescript |
<|fim_suffix|>: string[] = []
const ownerFilename = chunk.fileName
// literal import - trace direct imports and add to deps
const analyzed: Set<string> = new Set<string>()
const addDeps = (filename: string) => {
if (filename === ownerFile... | fim | vitejs/vite | typescript |
<|fim_prefix|>import colors from 'picocolors'
import type { EvaluatedModuleNode } from 'vite/module-runner'
import {
ESModulesEvaluator,
ModuleRunner,
createNodeImportMeta,
} from 'vite/module-runner'
import type { ViteDevServer } from '../server'
import { unwrapId } from '../../shared/utils'
import type { DevEnv... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping'
import type { EnvironmentModuleGraph } from '..'
let offset: number
function calculateOffsetOnce() {
if (offset !== undefined) {
return
}
try {
new Function('throw new Error(1)')()
} c... | fim | vitejs/vite | typescript |
<|fim_suffix|>xport(name)
}
}
}
s.remove(node.start, node.declaration.start)
} else {
if (node.source) {
// export { foo, bar } from './foo'
const importId = reExportImportIdMap.get(node)!
for (const spec of node.specifiers) {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import ty<|fim_suffix|>rt type GetHookContextMap<Plugin> = {
[K in keyof Plugin]-?: Plugin[K] extends ObjectHook<infer T, unknown>
? T extends (this: infer This, ...args: any[]) => any
? This extends RolldownMinimalPluginContext
? This
: never
: never
: never
}
type ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import os from 'node:os'
import net from 'node:net'
import path from 'node:path'
import { exec } from 'node:child_process'
import crypto from 'node:crypto'
import { fileURLToPath } from 'node:url'
import type { ServerOptions as HttpsServerOptions } from 'node:https'
import { built... | fim | vitejs/vite | typescript |
<|fim_suffix|>rn this
}
unwatch() {
return this
}
getWatched() {
return {}
}
ref() {
return this
}
unref() {
return this
}
async close() {
// noop
}
}
export function createNoopWatcher(options: WatchOptions): FSWatcher {
return new NoopWatcher(options)
}
<|fim_prefix|>i... | fim | vitejs/vite | typescript |
<|fim_suffix|>dler(
transport,
{
enabled: true,
unhandledErrors: false,
logLevels: ['log'],
},
console,
)
console.log('hi')
await setTimeout(50)
expect(console.error).not.toHaveBeenCalled()
})
test('log errors from transport.send', async () => {
... | fim | vitejs/vite | typescript |
<|fim_suffix|>
)
const regexBuiltins = builtins.filter(
(builtin) => typeof builtin !== 'string',
)
return (id: string) =>
plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id))
}
<|fim_prefix|>export function createIsBuiltin(
builtins: (string | RegExp)[],
): <|fim_middle|>(id: ... | fim | vitejs/vite | typescript |
<|fim_prefix|>/**
* Prefix for resolved Ids that are not valid browser import specifiers
*/
export const VALID_ID_PREFIX = `/@id/`
/**
* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
* module ID with `\0`, a convention from the rollup ecosystem.
* This prevents other plugins from tryi... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { ForwardConsolePayload } from '#types/customEvent'
import {
type NormalizedModuleRunnerTransport,
SendBeforeConnectError,
} from './moduleRunnerTransport'
export type ForwardConsoleLogLevel =
| 'error'
| 'warn'
| 'info'
| 'log'
| 'debug'
| (string & {})
export interface Forw... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { HotPayload, Update } from '#types/hmrPayload'
import type { ModuleNamespace, ViteHotContext } from '#types/hot'
import type { InferCustomEventPayload } from '#types/customEvent'
import type { NormalizedModuleRunnerTransport } from './moduleRunnerTransport'
type CustomListenersMap = Map<stri... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { HotPayload } from '#types/hmrPayload'
// updates to HMR should go one after another. It is possible to trigger another update during the invalidation for example.
export function createHMRHandler(
handler: (payload: HotPayload) => Promise<void>,
): (payload: HotPayload) => Promise<void> {... | fim | vitejs/vite | typescript |
<|fim_prefix|>export interface FetchFunctionOptions {
cached?: boolean
startOffset?: number
}
export type FetchResult =
| CachedFetchResult
| ExternalFetchResult
| ViteFetchResult
export interface CachedFetchResult {
/**
* If the module is cached in the runner, this confirms
* it was not invalidated... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { nanoid } from 'nanoid/non-secure'
import type { CustomPayload, HotPayload } from '#types/hmrPayload'
import { promiseWithResolvers } from './utils'
import type {
InvokeMethods,
InvokeResponseData,
InvokeSendData,
} from './invokeMethods'
export type ModuleRunnerTransportHandlers = {
onMe... | fim | vitejs/vite | typescript |
export interface DefineImportMetadata {
/**
* Imported names before being transformed to `ssrImportKey`
*
* import foo, { bar as baz, qux } from 'hello'
* => ['default', 'bar', 'qux']
*
* import * as namespace from 'world
* => undefined
*/
importedNames?: string[]
}
export interface SSRImpo... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX } from './constants'
export const isWindows: boolean =
typeof process !== 'undefined' && process.platform === 'win32'
/**
* Prepend `/@id/` and replace null byte so the id is URL-safe.
* This is prepended to resolved ids that are not valid browser
* i... | fim | vitejs/vite | typescript |
<|fim_prefix|>/**
Types from https://github.com/rollup/plugins/blob/master/packages/alias/types/index.d.ts
Inlined because the plugin is bundled.
https://github.com/rollup/plugins/blob/master/LICENSE
The MIT License (MIT)
Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contr... | fim | vitejs/vite | typescript |
<|fim_suffix|>rn = string | RegExp | AnymatchFn
type AnymatchMatcher = AnymatchPattern | AnymatchPattern[]
export { AnymatchMatcher as Matcher }
<|fim_prefix|>export type AnymatchFn = (testString:<|fim_middle|> string) => boolean
export type AnymatchPatte<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ent rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
* you can override it by setting `atomic` to a custom value, in milliseconds.
*/
atomic?: boolean | number
/**
* can be set to an object in order to adjust timing params:
*/
awaitWriteFinish?: Awai... | fim | vitejs/vite | typescript |
<|fim_suffix|>ormed to imports in mixed modules, or `false` if the
* `require` expressions should survive the transformation. The latter can be
* important if the code contains environment detection, or you are coding
* for an environment with special treatment for `require` calls such as
* ElectronJS. See ... | fim | vitejs/vite | typescript |
<|fim_suffix|>res: http.ServerResponse,
next: NextFunction,
) => void
export type ErrorHandleFunction = (
err: any,
req: IncomingMessage,
res: http.ServerResponse,
next: NextFunction,
) => void
export type HandleFunction =
| SimpleHandleFunction
| NextHandleFunction
| ErrorHandle... | fim | vitejs/vite | typescript |
<|fim_prefix|>export interface RollupDynamicImportVarsOptions {
/**
* File<|fim_suffix|>ated This option is no-op and will be removed in future versions.
*/
warnOnError?: boolean
}
<|fim_middle|>s to include in this plugin (default all).
* @default []
*/
include?: string | RegExp | (string | RegExp)[]... | fim | vitejs/vite | typescript |
<|fim_prefix|>declare module 'connect' {
const connect: () =<|fim_suffix|>time: number | undefined
<|fim_middle|>> any
export = connect
}
declare module 'cors' {
function cors(options: any): any
export = cors
}
declare module 'postcss-import' {
import type { Plugin } from 'postcss'
const plugin: (options:... | fim | vitejs/vite | typescript |
<|fim_prefix|>// Modified and inlined to avoid extra dependency
// Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
// Type definitions for ws 8.5
// Project: https://github.com/websockets/ws
// Definitions by: Paul Loyd <https://github.com/loyd>
// Margus Lamp... | fim | vitejs/vite | typescript |
<|fim_suffix|>nd this useful, please open an issue with details so we can discuss and make it stable API.
*/
// eslint-disable-next-line n/no-unsupported-features/node-builtins
webSocket: WebSocket
}
export interface InvalidatePayload {
path: string
message: string | undefined
firstInvalidatedBy: string
}... | fim | vitejs/vite | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.