text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import { virtual } from 'virtual:file'
import { virtual as virtualDep } from 'virtual:file-dep'
import { foo as depFoo, nestedFoo } from './hmrDep'
import './importing-updated'
import './invalidation-circular-deps'
import './file-delete-restore'
import './optional-chaining/parent'
import './intermediate-f... | fim | vitejs/vite | typescript |
<|fim_suffix|>{
console.log(`(dep) foo from dispose: ${data.fromDispose}`)
}
import.meta.hot.dispose((data) => {
console.log(`(dep) foo was: ${foo}`)
data.fromDispose = foo
})
}
<|fim_prefix|>export const foo = 1
export { foo as nestedF<|fim_middle|>oo } from './hmrNestedDep'
if (import.meta.hot) {
... | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export co<|fim_middle|>nst foo = 1
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export const virtual = '[success]'
<|fim_middle|><|endoftext|> | fim | vitejs/vite | javascript |
const val = 'a0'
document.querySelector('.importing-reloaded').innerHTML += `a.js: ${val}<br>`
export default val
if (import.meta.hot) {
import.meta.hot.accept()
}
<|endoftext|> | fim | vitejs/vite | javascript |
import a from './a.js'
const val = `b0,${a}`
document.querySelector('.importing-reloaded').innerHTML += `b.js: ${val}<br>`
if (import.meta.hot) {
import.meta.hot.accept()
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './a'
im<|fim_suffix|>
<|fim_middle|>port './b'<|endoftext|> | fim | vitejs/vite | javascript |
export const displayCount = (count) => `count is ${count}`
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>a.hot.accept()
<|fim_prefix|>import { displayCount } from './re-export.js'
const button = document.querySelector('.intermediate-file-delete-increment')
const render = ()<|fim_middle|> => {
document.querySelector('.intermediate-file-delete-display').textContent =
displayCount(Number(button.textCont... | fim | vitejs/vite | javascript |
<|fim_prefix|>e<|fim_suffix|>splay.js'
<|fim_middle|>xport * from './di<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>if (impo<|fim_suffix|>import.meta.hot.invalidate()
})
}
export const value = 'child'
<|fim_middle|>rt.meta.hot) {
// Need to accept, to register a callback for HMR
import.meta.hot.accept(() => {
// Trigger HMR in importers
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>nt.querySelector('.invalidation-parent').innerHTML = value
<|fim_prefix|>import { value } from './child'
<|fim_middle|>if (import.meta.hot) {
import.meta.hot.accept()
}
console.log('(invalidation) parent is executing')
docume<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>dation-root')
// Non HMR-able behaviour
if (!root.innerHTML) {
root.innerHTML = 'Init'
}
<|fim_middle|>import './parent.js'
if (import.meta.hot) {
// Need to accept, to register a callback for HMR
import.meta.hot.accept(() => {
// Triggers full page reload because no importers
... | fim | vitejs/vite | javascript |
<|fim_prefix|>import './parent'
i<|fim_suffix|>
import.meta.hot.invalidate()
})
}
export const value = 'child'
<|fim_middle|>f (import.meta.hot) {
import.meta.hot.accept(() => {<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.log('(invalidation circular deps) parent is executing')
setTimeout(() => {
document.querySelector('.invalidation-circular-deps').innerHTML = value
})
<|fim_prefix|>import { value } from '.<|fim_middle|>/child'
if (import.meta.hot) {
import.meta.hot.accept(() => {
import.meta.hot.invalidate()
}... | fim | vitejs/vite | javascript |
import './circular-invalidate/parent'
import './invalidate-handled-in-circle/parent'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>idate()
})
}
export const value = 'child'
<|fim_prefix|>im<|fim_middle|>port './parent'
if (import.meta.hot) {
import.meta.hot.accept(() => {
import.meta.hot.inval<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { value } from './child'
if (import.meta.hot) {
import.meta.hot.accept(() => <|fim_suffix|>r('.invalidation-circular-deps-handled').innerHTML =
value
})
<|fim_middle|>{})
}
console.log('(invalidation circular deps handled) parent is executing')
setTimeout(() => {
document.querySelecto<|en... | fim | vitejs/vite | javascript |
<|fim_suffix|>ort './a.js'
<|fim_prefix|><|fim_middle|>imp<|endoftext|> | fim | vitejs/vite | javascript |
import 'missing-modules'
console.log('missing test')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>impo<|fim_middle|>rt './a.js'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>declare module 'virtual:file' {
export const virtual: string
}
declare module 'virtual:file-dep' {
export con<|fim_suffix|>ng
}
<|fim_middle|>st virtual: stri<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const fo<|fim_suffix|>= 1
<|fim_middle|>o <|endoftext|> | fim | vitejs/vite | javascript |
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import { foo } from './child'
import.meta.hot?.accept('./child', ({ foo }) => {
console.log('(optional-chaining) child update')
document.querySelector('.optional-chaining').textContent = foo
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './d<|fim_suffix|>.js'
<|fim_middle|>ep2.js'
import './dep3<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>if (import.meta.hot) {
import.meta.hot.dispose(() => {
document.querySelector('.prune').textContent += '|dep2-disposed'
})
import.me<|fim_suffix|>.prune').textContent += '|dep2-pruned'
})
}
<|fim_middle|>ta.hot.prune(() => {
document.querySelector('<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>if (import.meta.hot) {
import.meta.hot.dispose(() => {
document.querySelector('.prune').textContent += '|dep3-disposed'
})
import.meta.hot.prune(() => {
document.querySelector('.prun<|fim_suffix|>tent += '|dep3-pruned'
})
}
<|fim_middle|>e').textCon<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> import.meta.hot.accept(() => {})
}
<|fim_prefix|>import './dep1.js'
if (import.meta.hot) {<|fim_middle|>
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>m './b'
export const a = {
b,
}
<|fim_prefix|>import { b } fr<|fim_middle|>o<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>}
<|fim_prefix|>import { c } from<|fim_middle|> './c'
const b = {
c,
}
export { b <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>n-circular').textContent = content
}
render(c)
import.meta.hot?.accept((nextExports) => {
render(nextExports.c)
})
<|fim_prefix|>import './b'
export const c = 'c'
function render(content) {
document.querySelector('.s<|fim_middle|>elf-accept-withi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>impo<|fim_suffix|>{ a } from './a'
console.log(a)
<|fim_middle|>rt <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>const foo = 'bar'
<|fim_middle|>export <|endoftext|> | fim | vitejs/vite | javascript |
import { foo } from './child'
// @ts-expect-error global
export const msg = `soft-invalidation/index.js is transformed ${__TRANSFORM_COUNT__} times. child is ${foo}`
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs/promises'
import path from 'node:path'
import { defineConfig } from 'vite'
import type { Plugin } from 'vite'
import { TestCssLinkPlugin } from './css-link/plugin'
export default defineConfig(({ command }) => ({
experimental: {
hmrPartialAccept: true,
},
build: {
rol... | fim | vitejs/vite | typescript |
import { setTimeout } from 'node:timers/promises'
import { expect, test } from 'vitest'
import { editFile, isBuild, page } from '~utils'
const assetUrl = /asset-[\w-]+\.png/
if (isBuild) {
test('should render', async () => {
expect(await page.textContent('h1')).toContain('HMR Full Bundle Mode')
await expect... | fim | vitejs/vite | typescript |
<|fim_suffix|>tor(el).textContent = text
}
<|fim_prefix|>text('.dynamic', 'loaded')
function text(el, text)<|fim_middle|> {
document.querySelec<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rySelector(el).textContent = text
}
import.meta.hot?.accept((mod) => {
if (mod) {
text('.hmr', mod.foo)
text('.asset', mod.assetUrl)
}
})
<|fim_prefix|>export const foo = 'hello'
text('.hmr', foo)
import assetUrlImported from './asset.png'
export const assetUrl = assetUrlImported
text('.ass... | fim | vitejs/vite | javascript |
import './hmr.js'
import assetUrl from './asset.png'
import WorkerQuery from './worker-query.js?worker'
text('.app', 'hello')
text('.asset', assetUrl)
const workerQuery = new WorkerQuery()
workerQuery.postMessage('ping')
workerQuery.addEventListener('message', (e) => {
text('.worker-query', e.data)
})
const worker... | fim | vitejs/vite | javascript |
<|fim_suffix|>form')) {
await new Promise<void>((resolve) => setTimeout(resolve, 300))
}
},
}
}
interface PromiseWithResolvers<T> {
promise: Promise<T>
resolve: (value: T | PromiseLike<T>) => void
reject: (reason?: any) => void
}
function promiseWithResolvers<T>(): PromiseWithResolvers<T> {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>const msg = 'worker-query'
self.onmessage = (e) => {
if (e.dat<|fim_suffix|> self.postMessage(msg)
}
}
<|fim_middle|>a === 'ping') {
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const msg = 'worker-url'
<|fim_suffix|>f.postMessage(msg)
}
}
<|fim_middle|>self.onmessage = (e) => {
if (e.data === 'ping') {
sel<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>lace("'foo'", "'foobar'"))
await page.waitForEvent('load')
await expect.poll(() => page.textContent('#foo')).toBe('foobar')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { editFile, isServe, page } from '~utils'
test.<|fim_middle|>runIf(isServe)('should watch files outside root', asy... | fim | vitejs/vite | typescript |
<|fim_prefix|>export const <|fim_suffix|>o'
<|fim_middle|>foo = 'fo<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import path from 'node:path'
import { defineConfig } from 'vite'
export default defineConfig({
root: path.join(import.meta<|fim_suffix|>),
})
<|fim_middle|>.dirname, './root'<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>lobalThis.__HMR__['.delete-intermediate-file']()
await expect
.poll(() => hmr('.intermediate-file-delete-display'))
.toMatch('count is 2')
// update import, hmr works
editFile('intermediate-file-delete/index.js', (code) =>
code.replace("from './re-export.js'", "from './display.js'"),
... | fim | vitejs/vite | typescript |
<|fim_suffix|>as c }
export default 'default0'
log(`all >>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a', 'b', 'c', 'default'])
}
<|fim_prefix|>ex<|fim_middle|>port const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export con<|fim_suffix|>${b}, ${aliased}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a', 'b', 'default'])
}
<|fim_middle|>st a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased as c }
export default 'default0'
log(`some >>>>>> ${a}, <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>Promise.all([import('./deps-all-accepted'), import('./deps-some-accepted')])
.then(([all, some]) => {
log<|fim_suffix|> .catch((err) => {
log(err)
})
<|fim_middle|>('loaded:all:' + all.a + all.b + all.c + all.default)
log('loaded:some:' + some.a + some.b + some.c + some.default)
log('>... | fim | vitejs/vite | typescript |
<|fim_suffix|>dynamic-imports.ts'
<|fim_prefix|>im<|fim_middle|>port './<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>'
<|fim_prefix|>export cons<|fim_middle|>t a = 'Ax<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { a } from './hub'
log(a)
if (import.meta.hot) {
imp<|fim_suffix|><|fim_middle|>ort.meta.hot.accept()
} else {
}
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>pA'
<|fim_prefix|>ex<|fim_middle|>port * from './de<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>)
}
<|fim_prefix|>export const x = 'X'
if (import.meta.hot) {
import.meta.hot.acceptExports(['x'], (m) => {
log(`reloaded >>> ${m.x}`)
<|fim_middle|>}<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export defau<|fim_suffix|>ep0'
<|fim_middle|>lt 'd<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>'
<|fim_prefix|>import './main-acce<|fim_middle|>pted<|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) log(x)
log(`>>>>>> ${a} ${def}`)
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import dep from './dep'
export const a = 'A0'
const bValue = 'B0'
export { bValue as b }
const def = 'D0'
export default def
log(`<<|fim_suffix|>', 'default'])
}
<|fim_middle|><<<<< ${a} ${bValue} ${def} ; ${dep}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const x = 'y'
const def = 'def0'
export defaul<|fim_suffix|> import.meta.hot.acceptExports(['x'])
}
<|fim_middle|>t def
log(`<<< default: ${def}`)
if (import.meta.hot) {
<|endoftext|> | fim | vitejs/vite | typescript |
export default 'dep0'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import<|fim_suffix|>'
<|fim_middle|> './main-non-accepted.ts<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { a } from '<|fim_suffix|>t'
log(`>>>>>> ${a} ${def}`)
<|fim_middle|>./named'
import def from './defaul<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> a = 'A0'
export const b = 'B0'
log(`<<< named: ${a} ; ${dep}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['b'])
}
<|fim_prefix|>im<|fim_middle|>port dep from './dep'
export const<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>eta.hot.acceptExports('a', (m) => {
log(`accept-named reexport:${m.a},${m.b}`)
})
}
<|fim_prefix|>export { a, b } from './source'
if (import.meta.hot) {
// import.meta.hot.accept('./source', (m) => {
// log(`accept-named reexport:${m.a},${m.b}`)
// })
<|fim_middle|>import.m<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { a } from './accept-named'
log('accept-named:' + a)
log('>>><|fim_suffix|>y')
<|fim_middle|> read<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>'b0'
<|fim_prefix|>export const a = 'a0'
export con<|fim_middle|>st b = <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>'
<|fim_prefix|>import './side-e<|fim_middle|>ffects.ts<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const x = 'x'
export const y = 'y'
expo<|fim_suffix|>cceptExports(['default'])
}
<|fim_middle|>rt default 'z'
log('>>> side FX')
globalThis.__HMR__['.app'] = 'hey'
if (import.meta.hot) {
import.meta.hot.a<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliase<|fim_suffix|>>>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.hot) {
import.meta.hot.acceptExports(['a', 'b', 'c', 'default'])
}
<|fim_middle|>d as c }
export default 'default0'
log(`all <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>b', 'default'])
}
<|fim_prefix|>export const a = 'a0'
export const b = 'b0'
const aliased = 'c0'
export { aliased as c }
export default 'default0'
log(`some >>>>>> ${a}, ${b}, ${aliased}`)
if (import.meta.ho<|fim_middle|>t) {
import.meta.hot.acceptExports(['a', '<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ts'
<|fim_prefix|>impo<|fim_middle|>rt './star-imports.<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>+ all.a + all.b + all.c + all.default)
log('loaded:some:' + some.a + some.b + some.c + some.default)
log('>>> ready <<<')
<|fim_prefix|>import * as all from './deps-all-accepted'
import * as some from './deps-some-a<|fim_middle|>ccepted'
log('loaded:all:' <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>import './unused'
<|fim_middle|>import { foo } from './used'
log('used:' + foo)<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const x = 'x'
export const y = 'y'
export default 'z'
log('-- unused <|fim_suffix|>.meta.hot.acceptExports([])
}
<|fim_middle|>--')
if (import.meta.hot) {
import<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export c<|fim_suffix|>
export const bar = 'bar0'
log('-- used --')
if (import.meta.hot) {
import.meta.hot.acceptExports([])
}
<|fim_middle|>onst foo = 'foo0'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { msg } from './mod-a'
globalThis.__HMR__['.circular'] = msg
i<|fim_suffix|>accept()
}
<|fim_middle|>f (import.meta.hot) {
import.meta.hot.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>'mod-a'
import { value as _value } from './mod-b'
export const msg = `mod-a -> ${_value}`
<|fim_prefix|>e<|fim_middle|>xport const value = <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { value as _value } from './mod-c'
export c<|fim_suffix|>}`
<|fim_middle|>onst value = `mod-b -> ${_value<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>od-c -> ${__value}`
<|fim_prefix|>import { value as _value } from './mod-a'
// Should error as `_value` is not defined yet within the circular imports
let __value
try {
__value = `${_value} (expected no error)`
} catch {
__value = 'mod-a (unexpect<|fim_middle|>ed error)'
}
export const value = `m<|e... | fim | vitejs/vite | javascript |
<|fim_prefix|>// This file is never loaded
if (import.meta.hot) {
import.meta<|fim_suffix|>{})
}
<|fim_middle|>.hot.accept(() => <|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>let count = 0
export function<|fim_suffix|>) {
import('./dep')
}
<|fim_middle|> increment() {
count++
}
export function getCount() {
return count
}
// @ts-expect-error not used but this is to test that it works
function neverCalled(<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>exp<|fim_suffix|>nst msg = 'custom'
<|fim_middle|>ort co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> debug: (...msg: unknown[]) => void
}
}
<|fim_prefix|>import 'vite/types/customEvent'
declare module 'vite/types/customEvent' {
interface CustomEventMap {
'custom:foo': { msg: string }
'custom:remote-add': { a: num<|fim_middle|>ber; b: number }
'custom:remote-add-result': { result: str... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { rerender } from './runtime'
export const <|fim_suffix|>)
})
}
<|fim_middle|>value = 'child'
if (import.meta.hot) {
import.meta.hot.accept((newMod) => {
if (!newMod) return
rerender({ child: newMod.value })
})
import.meta.hot.dispose(() => {
log('file-delete-restore/child.j... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { render } from './runtime'
import { childValue, parentValue } from './parent'
render({ parent: pa<|fim_suffix|><|fim_middle|>rentValue, child: childValue })
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { rerender<|fim_suffix|>return
rerender({ child: newMod.childValue, parent: newMod.parentValue })
})
}
<|fim_middle|> } from './runtime'
export const parentValue = 'parent'
export { value as childValue } from './child'
if (import.meta.hot) {
import.meta.hot.accept((newMod) => {
if (!... | fim | vitejs/vite | javascript |
<|fim_prefix|>let state = {}
export const render = (newState) => {
state = newState
apply()
}
export const rerender = <|fim_suffix|>join(':')
}
<|fim_middle|>(updates) => {
state = { ...state, ...updates }
apply()
}
const apply = () => {
globalThis.__HMR__['.file-delete-restore'] = Object.values(state).<|e... | fim | vitejs/vite | javascript |
<|fim_suffix|> (event) => {
log(`>>> vite:afterUpdate -- ${event.type}`)
})
import.meta.hot.on('vite:beforeUpdate', (event) => {
log(`>>> vite:beforeUpdate -- ${event.type}`)
const cssUpdate = event.updates.find(
(update) =>
update.type === 'css-update' && update.path.includes('global.cs... | fim | vitejs/vite | typescript |
<|fim_suffix|>
log(`(dep) foo from dispose: ${data.fromDispose}`)
}
import.meta.hot.dispose((data) => {
log(`(dep) foo was: ${foo}`)
data.fromDispose = foo
})
}
<|fim_prefix|>export const foo = 1
export { foo as n<|fim_middle|>estedFoo } from './hmrNestedDep'
if (import.meta.hot) {
const data = im... | fim | vitejs/vite | javascript |
<|fim_suffix|>1
<|fim_prefix|>export<|fim_middle|> const foo = <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ual = '[success]'
<|fim_prefix|>ex<|fim_middle|>port const virt<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>const val = 'a0'
globalThis.__HMR__['.importing-reloaded'] <|fim_suffix|>) {
import.meta.hot.accept()
}
<|fim_middle|>??= ''
globalThis.__HMR__['.importing-reloaded'] += `a.js: ${val}<br>`
export default val
if (import.meta.hot<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>'] += `b.js: ${val}<br>`
if (import.meta.hot) {
import.meta.hot.accept()
}
<|fim_prefix|>import a from './a.js'
const val = `b0,${a}`
<|fim_middle|>
globalThis.__HMR__['.importing-reloaded'] ??= ''
globalThis.__HMR__['.importing-reloaded<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>import './a'
i<|fim_middle|>mport './b'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export cons<|fim_suffix|>unt is ${count}`
<|fim_middle|>t displayCount = (count) => `co<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { displayCount } from './re-export.js'
const incrementValue = () =>
globalThis.__HMR__['.intermediate-file-delete-increment']
const render =<|fim_suffix|>rmediate-file-delete-increment'] = `${
Number(incrementValue()) + 1
}`
render()
}
if (import.meta.hot) import.meta.hot.accept()
<|fi... | fim | vitejs/vite | javascript |
<|fim_suffix|>* from './display.js'
<|fim_prefix|>export<|fim_middle|> <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> = 'child'
<|fim_prefix|>if (import.meta.hot) {
// Need to accept, to register<|fim_middle|> a callback for HMR
import.meta.hot.accept(() => {
// Trigger HMR in importers
import.meta.hot.invalidate()
})
}
export const value<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>.__HMR__['.invalidation'] = value
<|fim_prefix|>import { value } from './child'
if (import.meta.hot) {
import.meta.hot.accept()
}
log('(invalidation) paren<|fim_middle|>t is executing')
globalThis<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t const value = 'child'
<|fim_prefix|>import './parent'
if (import.meta.hot) {
import.meta.hot.accept(() => {
<|fim_middle|> import.meta.hot.invalidate()
})
}
expor<|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.