text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import ReactDomServer from 'react-dom/server'
import type { Connect, ViteDevServer } from 'vite'
import Root from './root'<|fim_suffix|>.NextHandleFunction = async (_req, res) => {
const ssrHtml = ReactDomServer.renderToString(<Root />)
let html = await importHtml()
html = html.replace(/<body>/, `<b... | fim | vitejs/vite | typescript |
<|fim_prefix|>import React from 'react'
export default function Root() {
const [count, setCount] = React.useState(0)
const [hydrated, setHydrated] = React.useState(false)
React.useEffect(() => {
setH<|fim_suffix|> v + 1)}>+1</button>
</div>
)
}
<|fim_middle|>ydrated(true)
}, [])
return (
<div... | fim | vitejs/vite | typescript |
<|fim_suffix|>
export function vitePluginSsrMiddleware({
entry,
preview,
}: {
entry: string
preview?: string
}): PluginOption {
const plugin: Plugin = {
name: vitePluginSsrMiddleware.name,
configureServer(server) {
const runner = createServerModuleRunner(server.environments.ssr, {
hmr: ... | fim | vitejs/vite | typescript |
<|fim_suffix|>forEach((msg) => {
expect(msg).not.toMatch('404')
})
})
test('not contain `.mjs`', async () => {
const appHtml = await page.content()
expect(appHtml).toMatch('Hello Vite!')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { browserLogs, page } from '~utils'
test('should have no 40... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
resolve: {
<|fim_suffix|>,
})
<|fim_middle|> alias: [{ find: 'vue', replacement: 'vue/dist/vue.esm-bundler.js' }],
extensions: ['.js'],
}<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> expect(await page.textContent('#imported-vue-version')).toBe('3.4.38')
})
test('should externalize required packages', async () => {
// If `vue` is successfully externalized, the page should use the version from the import map
expect(await page.textContent('#required-vue-version')).toBe('3... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { version } from 'v<|fim_suffix|>rted-vue-version').textContent = version
document.querySelector('#imported-slash5-exists').textContent =
!!slash5('foo/bar')
document.querySelector('#imported-slash3-exists').textContent =
!!slash3('foo/bar')
<|fim_middle|>ue'
import slash5 from 'slash5'
import ... | fim | vitejs/vite | javascript |
<|fim_suffix|>slash3('foo/bar')
<|fim_prefix|>const { version } = require('vue')
// require('slash5') // cannot require ESM
const slash3 = require('slash3')
document.querySelector('#required-vue-version').textContent = version
document.query<|fim_middle|>Selector('#required-slash3-exists').textContent =
!!<|endoftex... | fim | vitejs/vite | javascript |
<|fim_suffix|>orts,t),t.exports),E=(e,t)=>{for(var r in t)d(e,r,{get:t[r],enumerable:!0})},u=(e,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of x(t))!p.call(e,n)&&n!==r&&d(e,n,{get:()=>t[n],enumerable:!(i=m(t,n))||i.enumerable});return e},o=(e,t,r)=>(u(e,t,"default"),r&&u(r,t,"default")),c=(e,t,r)=... | fim | vitejs/vite | javascript |
<|fim_prefix|>import './require-polyfill'
import '@vite<|fim_suffix|>equires'
<|fim_middle|>js/test-dep-that-imports'
import '@vitejs/test-dep-that-r<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import * as vue from 'vue'
import slash<|fim_suffix|> slash3
throw new Error(`Cannot require "${id}"`)
}
<|fim_middle|>3 from 'slash3'
export default (id) => {
if (id === 'vue') return vue
if (id === 'slash3') return<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs/promises'
import path from 'node:path'
import { defineConfig } from 'vite<|fim_suffix|> esmExternals: ['vue', 'slash5'],
dynamicRequireTargets: ['test-no-op-fdir-glob'],
},
},
plugins: [
{
name: 'serve-npm-code-directly',
configureServer({ middlew... | fim | vitejs/vite | javascript |
<|fim_suffix|>logIndex)))
.toContain(`\
[Unhandled error] Error: this is test dependency error
> throwDepError ../../node_modules/.pnpm/<normalized>/node_modules/@vitejs/test-forward-console-throw-dep/index.js:2:8
> testDepError src/main.ts:38:2
36 |
37 | function testDepError() {
38 | throwDepErr... | fim | vitejs/vite | typescript |
<|fim_prefix|>ex<|fim_suffix|>ror')
}
<|fim_middle|>port function throwDepError() {
throw new Error('this is test dependency er<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>tElementById('test-console-error').addEventListener('click', () => {
testConsoleError()
})
document.getElementById('test-dep-error').addEventListener('click', () => {
testDepError()
})
export type AnotherPadding = {
there: boolean
}
function testError() {
throw new Error('this is test error')
}... | fim | vitejs/vite | typescript |
<|fim_suffix|>ig } from 'vite'
export default defineConfig({
server: {
forwardConsole: true,
},
})
<|fim_prefix|>import <|fim_middle|>{ defineConf<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import '<|fim_suffix|>./commonTests'
<|fim_middle|>.<|endoftext|> | fim | vitejs/vite | typescript |
import http from 'node:http'
import path from 'node:path'
import fs from 'node:fs'
import { pathToFileURL } from 'node:url'
import { setTimeout } from 'node:timers/promises'
import {
afterEach,
beforeAll,
beforeEach,
describe,
expect,
test,
} from 'vitest'
import type { Page } from 'playwright-chromium'
imp... | fim | vitejs/vite | typescript |
<|fim_suffix|>deny/.deny?.svg?import',
},
]) {
test(`**/deny/** should deny ${name}`, async () => {
const res = await page.request.fetch(new URL(urlPath, viteTestUrl).href)
expect(res.status()).toBe(403)
})
}
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { isServe, ... | fim | vitejs/vite | typescript |
<|fim_suffix|>st(name, async () => {
const response = await sendRawRequest(viteTestUrl, target)
expect(response).toContain(status)
if (content !== undefined) {
expect(response).toContain(content)
}
})
}
})
<|fim_prefix|>import net from 'node:net'
import path from 'node:path'
import... | fim | vitejs/vite | typescript |
<|fim_suffix|>'.nested-entry').textContent = fullmsg
<|fim_prefix|>import { msg } from './nested/foo'<|fim_middle|>
export const fullmsg = msg + 'bar'
document.querySelector(<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t const msg = 'foo'
<|fim_prefix|>expo<|fim_middle|>r<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import type { Plugin } from 'vite'
import escapeHtml from 'escape-html'
const testIds = [
'safe',
'safe-query',
'safe-subdir',
'safe-subdir-special-characters',
'safe-subdir-special-characters2',
'safe-imported',
'safe-imported-query',
'unsafe',
'unsafe-json',
'unsafe-html',
'unsafe... | fim | vitejs/vite | typescript |
<|fim_prefix|>// <|fim_suffix|>de.js
<|fim_middle|>co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> }
},
async load(id, _options) {
if (id === resolvedSvgVirtualModuleId) {
return `export default '<svg><rect width="100" height="100"></svg>'`
}
},
enforce: 'pre',
}
}
<|fim_prefix|>import<|fim_middle|> type { Plugin } from 'vite'
const svgVirtualModuleId = 'virtu... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
impo<|fim_suffix|> overlay: false,
},
headers: {
'x-served-by': 'vite',
},
},
preview: {
headers: {
'x-served-by': 'vite',
},
},
define: {
ROOT: JSON.stringify(path.dirname(import.meta.dirname).replace(/\\/g, '/')),
BASE: JSON... | fim | vitejs/vite | javascript |
import path from 'node:path'
import { defineConfig } from 'vite'
import svgVirtualModulePlugin from './svgVirtualModulePlugin'
export default defineConfig({
build: {
rolldownOptions: {
input: {
main: path.resolve(import.meta.dirname, 'src/index.html'),
},
},
outDir: 'dist/deny',
},
... | fim | vitejs/vite | javascript |
<|fim_suffix|>olve(import.meta.dirname, 'src/index.html'),
},
},
outDir: 'dist/main',
},
server: {
fs: {
strict: true,
allow: [path.resolve(import.meta.dirname, 'src')],
},
hmr: {
overlay: false,
},
headers: {
'x-served-by': 'vite',
},
},
preview: {
... | fim | vitejs/vite | javascript |
import { execSync } from 'node:child_process'
import path from 'node:path'
function getWindows83ShortName(inputPath: string): string | undefined {
try {
const result = execSync(
`powershell -Command "(New-Object -ComObject Scripting.FileSystemObject).GetFile('${inputPath}').ShortPath"`,
{ encoding: '... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { readdir } from 'node:fs/promises'
import { expect, test } from 'vitest'
import {
addFile,
editFile,
findAssetFile,
isBuild,
page,
removeFile,
} from '~utils'
const filteredResult = {
'./alias.js': {
default: 'hi',
},
'./foo.js': {
msg: 'foo'... | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>export const msg = 'h<|fim_middle|>ello from x'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const msg = <|fim_suffix|>'
<|fim_middle|>'hello from y<|endoftext|> | fim | vitejs/vite | javascript |
export default 'a'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export<|fim_suffix|>fault 'b'
<|fim_middle|> de<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default<|fim_suffix|>ded'
<|fim_middle|> 'exclu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>'
<|fim_middle|>rt default 'included<|endoftext|> | fim | vitejs/vite | javascript |
export default 'DATA-OTHER'
<|endoftext|> | fim | vitejs/vite | javascript |
export default 'data-test'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>lt 'hi'
<|fim_middle|>export defau<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const m<|fim_suffix|>'
<|fim_middle|>sg = 'foo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.meta.glob(['@dir/*.js', '!@dir/x.js'])
import.meta.glob(['!@dir/x.js', '@dir/*.js'])
// test for sourcemap
console.log('hello')
export { modules, globWithAlias }
<|fim_prefix|>const modules = import.<|fim_middle|>meta.glob('./*.{js,ts}', { eager: true })
const globWithAlias = import.meta.glob('@dir/al*... | fim | vitejs/vite | javascript |
<|fim_suffix|>odules = import.meta.glob('../*.json', { eager: true })
export const msg = 'bar'
export { modules }
<|fim_prefix|>con<|fim_middle|>st m<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export co<|fim_suffix|>st msg = 'single-quote'
<|fim_middle|>n<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const relative = import.meta.glob('./**/*.js', { eager: true })
const alias = import.m<|fim_suffix|>b('@escape_(parenthesis)_mod/**/*.js', {
eager: true,
})
export { relative, alias }
<|fim_middle|>eta.glo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>
<|fim_middle|>rt const msg = 'foo'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> relative, alias }
<|fim_prefix|>const relative = import.meta.glob('./**/*.js', { eager: true })
const alias = import.meta.glo<|fim_middle|>b('@escape_[brackets]_mod/**/*.js', {
eager: true,
})
export {<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>t const msg = 'foo'
<|fim_middle|>expor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.meta.glob('@escape_{curlies}_mod/**/*.js', { eager: true })
export { relative, alias }
<|fim_prefix|>const<|fim_middle|> relative = import.meta.glob('./**/*.js', { eager: true })
const alias = import<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const<|fim_suffix|>
<|fim_middle|> msg = 'foo'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>t 'a'
<|fim_middle|>export defaul<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expor<|fim_suffix|>
<|fim_middle|>t default 'b'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
)
<|fim_prefix|>export const g = import.meta.glob('/pkg-pages/*.js')
document.querySelector('.in-package').textContent = JSON.stringify(
Object.keys(g).sort()<|fim_middle|>,<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ault 'bar'
<|fim_prefix|>expo<|fim_middle|>rt def<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>ault 'foo'
<|fim_middle|>ort def<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>/ empty
<|fim_prefix|><|fim_middle|>/<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>xtContent =
'Hello from side effect')
<|fim_prefix|>/* global document */
document &&
<|fim_middle|>(document.querySelector('.side-effect-result').te<|endoftext|> | fim | vitejs/vite | javascript |
/* global document */
document &&
(document.querySelector('.side-effect-result').textContent =
'Hello from side effect')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const globbed = import.meta.<|fim_suffix|>ob('#imports/*', { eager: true })
<|fim_middle|>gl<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>}.js`)
<|fim_prefix|>cons<|fim_middle|>t name = 'foo'
export const globResult = import.meta.glob('./dir/*.js')
export const dynamicResult = import(`./dir/${name<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { defineConfig } from 'vite'
const escapeAliases = fs
.readdirSync(path.join(import.meta.dirname, 'escape'), {
withFileTypes: true,
})
.filter((f) => f.isDirectory())
.map((f) => f.name)
.reduce((aliases: Record<string, string>, d... | fim | vitejs/vite | typescript |
<|fim_suffix|> not reload if no accepted within circular imported files', async () => {
await page.goto(viteTestUrl + '/circular/index.html')
const el = await page.$('.circular')
expect(await el.textContent()).toBe(
'mod-a -> mod-b -> mod-c -> mod-a (expected error)',
)
editFile('circular/mod-... | fim | vitejs/vite | typescript |
<|fim_suffix|>t'])
}
<|fim_prefix|>export const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased as c }
export default 'default0'
console.log(`all >>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.hot) {
import.meta.hot.a<|fim_middle|>cceptExports(['a', 'b', 'c', 'defaul<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>expor<|fim_suffix|>ta.hot) {
import.meta.hot.acceptExports(['a', 'b', 'default'])
}
<|fim_middle|>t const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased as c }
export default 'default0'
console.log(`some >>>>>> ${a}, ${b}, ${aliased}`)
if (import.me<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>Promise.all([import('./deps-all-accepted'), import('./deps-some-accepted')])
.then(([all, some]) => {
console.log('loaded:a<|fim_suffix|>((err) => {
console.error(err)
})
<|fim_middle|>ll:' + all.a + all.b + all.c + all.default)
console.log('loaded:some:' + some.a + some.b + some.c + some.... | fim | vitejs/vite | typescript |
<|fim_suffix|>const a = 'Ax'
<|fim_prefix|>export<|fim_middle|> <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>rt { a } from './hub'
console.log(a)
if (import.meta.hot) {
import.meta.hot.accept()
} else {
}
<|fim_prefix|>i<|fim_middle|>mpo<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export<|fim_suffix|>'
<|fim_middle|> * from './depA<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const x = 'X'
if (import.meta.hot) {
import.meta.hot.acceptExports(['x'], (m) => {
conso<|fim_suffix|>{m.x}`)
})
}
<|fim_middle|>le.log(`reloaded >>> $<|endoftext|> | fim | vitejs/vite | typescript |
export default 'dep0'
<|endoftext|> | fim | vitejs/vite | typescript |
import def, { a } from './target'
import { x } from './callback'
// we don't want to pollute other checks' logs...
if (0 > 1) console.log(x)
console.log(`>>>>>> ${a} ${def}`)
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>}
const def = 'D0'
export default def
console.log(`<<<<<< ${a} ${bValue} ${def} ; ${dep}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a', 'default'])
}
<|fim_prefix|>import dep from './dep'
export const <|fim_middle|>a = 'A0'
const bValue = 'B0'
export { bValue as b <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const x = 'y'
const def = 'def0'
export default de<|fim_suffix|> {
import.meta.hot.acceptExports(['x'])
}
<|fim_middle|>f
console.log(`<<< default: ${def}`)
if (import.meta.hot)<|endoftext|> | fim | vitejs/vite | typescript |
export default 'dep0'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { a } from './na<|fim_suffix|>${def}`)
<|fim_middle|>med'
import def from './default'
console.log(`>>>>>> ${a} <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import dep from './dep'
export const a = 'A0'
export const b = 'B0'
console.log(`<<< named: ${a<|fim_suffix|>a.hot) {
import.meta.hot.acceptExports(['b'])
}
<|fim_middle|>} ; ${dep}`)
if (import.met<|endoftext|> | fim | vitejs/vite | typescript |
export { a, b } from './source'
if (import.meta.hot) {
// import.meta.hot.accept('./source', (m) => {
// console.log(`accept-named reexport:${m.a},${m.b}`)
// })
import.meta.hot.acceptExports('a', (m) => {
console.log(`accept-named reexport:${m.a},${m.b}`)
})
}
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { <|fim_suffix|>('>>> ready')
<|fim_middle|>a } from './accept-named'
console.log('accept-named:' + a)
console.log<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>st b = 'b0'
<|fim_prefix|>export const a = 'a0<|fim_middle|>'
export con<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const<|fim_suffix|>(['default'])
}
<|fim_middle|> x = 'x'
export const y = 'y'
export default 'z'
console.log('>>> side FX')
document.querySelector('.app').textContent = 'hey'
if (import.meta.hot) {
import.meta.hot.acceptExports<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>d = 'c0'
export { aliased as c }
export default 'default0'
console.log(`all >>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a', 'b', 'c', 'default'])
}
<|fim_prefix|>export const a = 'a0'
export const b = 'b0'
const <|fim_middle|>aliase<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased as c }
exp<|fim_suffix|> {
import.meta.hot.acceptExports(['a', 'b', 'default'])
}
<|fim_middle|>ort default 'default0'
console.log(`some >>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.hot)<|endoftext|> | fim | vitejs/vite | typescript |
import * as all from './deps-all-accepted'
import * as some from './deps-some-accepted'
console.log('loaded:all:' + all.a + all.b + all.c + all.default)
console.log('loaded:some:' + some.a + some.b + some.c + some.default)
console.log('>>> ready <<<')
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>e.log('used:' + foo)
<|fim_prefix|>import './unused'
import { foo } <|fim_middle|>from './used'
consol<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>if (import.meta.hot) {
import.meta.hot.acceptExports([])
}
<|fim_prefix|>export const x = 'x'
export const y = 'y'
export default 'z'
cons<|fim_middle|>ole.log('-- unused --')
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const foo = 'foo0'
export const bar = '<|fim_suffix|>s([])
}
<|fim_middle|>bar0'
console.log('-- used --')
if (import.meta.hot) {
import.meta.hot.acceptExport<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>import.meta.hot) {
import.meta.hot.accept()
}
<|fim_prefix|>import { msg } <|fim_middle|>from './mod-a'
document.querySelector('.circular').textContent = msg
if (<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
export const msg = `mod-a -> ${_value}`
<|fim_prefix|>export const value = 'mod-a'
import { value a<|fim_middle|>s _value } from './mod-b'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { value a<|fim_suffix|>const value = `mod-b -> ${_value}`
<|fim_middle|>s _value } from './mod-c'
export <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { value<|fim_suffix|>yet within the circular imports
let __value
try {
__value = `${_value} (unexpected no error)`
} catch {
__value = 'mod-a (expected error)'
}
export const value = `mod-c -> ${__value}`
<|fim_middle|> as _value } from './mod-a'
// Should error as `_value` is not defined <|e... | fim | vitejs/vite | javascript |
<|fim_prefix|>// This file is never loaded
if (import.meta.hot) {
import.<|fim_suffix|>ot.accept(() => {})
}
<|fim_middle|>meta.h<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> `Counter ${count}`
}
btn.onclick = () => {
count++
update()
}
function neverCalled() {
import('./dep')
}
<|fim_prefix|>const btn = document.querySelector('<|fim_middle|>button')
let count = 0
const update = () => {
btn.textContent =<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>// This file is depend<|fim_suffix|>meta.hot.accept()
}
<|fim_middle|>ed by main.css via this.addWatchFile
export const color = 'red'
// Self-accept so that updating this file would not trigger a page reload.
// We only want to observe main.css updating itself.
if (import.meta.hot) {
import.<|endoftext... | fim | vitejs/vite | javascript |
<|fim_suffix|>t.meta.hot.accept()
}
<|fim_prefix|>import './styles.css'
if (import.m<|fim_middle|>eta.hot) {
impor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> },
},
]
},
},
}
}
<|fim_prefix|>import path from 'node:path'
import { type Plugin, normalizePath } from 'vite'
// use plugin to simulate server rendered css link
export function TestCssLinkPlugin(): Plugin {
return {
name: 'test-css-link',
transformIndexHtml: {
... | fim | vitejs/vite | typescript |
export const msg = 'custom'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>}
'custom:remote-add': { a: number; b: number }
'custom:remote-add-result': { result: string }
}
}
<|fim_prefix|>import 'vite/types/customEven<|fim_middle|>t'
declare module 'vite/types/customEvent' {
interface CustomEventMap {
'custom:foo': { msg: string <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { rerender } from './runtime'
export const value = 'child'
if (import.meta.hot) {
<|fim_suffix|>e-restore/child.js is pruned')
})
}
<|fim_middle|> import.meta.hot.accept((newMod) => {
if (!newMod) return
rerender({ child: newMod.value })
})
import.meta.hot.dispose(() => {
con... | fim | vitejs/vite | javascript |
<|fim_suffix|>ue, child: childValue })
<|fim_prefix|>import { render } from './runtime'
import { childValue, parentValue } from './pare<|fim_middle|>nt'
render({ parent: parentVal<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>parentValue })
})
}
<|fim_prefix|>import { rerender } from './runtime'
export const parentValue = 'parent'
export { value <|fim_middle|>as childValue } from './child'
if (import.meta.hot) {
import.meta.hot.accept((newMod) => {
if (!newMod) return
rerender({ child: newMod.childValue, parent:... | fim | vitejs/vite | javascript |
<|fim_prefix|>let state = {}
export const render = (newState) => {
state = new<|fim_suffix|> {
document.querySelector('.file-delete-restore').textContent =
Object.values(state).join(':')
}
<|fim_middle|>State
apply()
}
export const rerender = (updates) => {
state = { ...state, ...updates }
apply()
}
co... | fim | vitejs/vite | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.