text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import * as dep from <|fim_suffix|>);
export { dep };
__configCases__deferImport__proposal.push("END reexport-async.js");
<|fim_middle|>/* webpackDefer: true */ "./reexport-async-dep.js";
__configCases__deferImport__proposal.push("START reexport-async.js"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
modu<|fim_suffix|>nc-node${process.versions.node.split(".").map(Number)[0]}`],
mode: "none",
experiments: {
deferImport: true
}
};
<|fim_middle|>le.exports = {
target: [`asy<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fullSync = await import(/* webpackDefer: true */ "../async-in-graph/full-sync.js");
const asyncMod = await import(/* webpackDefer: true */ "../async-in-graph/async-mod.js");
const deepAsync = await import(/* webpackDefer: true */ "../async-in-graph/deep-async.js");
const reexportAsync = await import... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should compile", async () => {
const logs = global.__configCases__deferImport__proposal = [];
let mod = import("./entry.js");
expect(mod).toBeInstanceOf(Promise);
let { default: namespaces } = await mod;
expect(logs).toEqual([
"START async-mod-dep.js",
"END async-mod-dep.js",
"START asyn... | fim | webpack/webpack | javascript |
<|fim_suffix|>ort: true
}
};
<|fim_prefix|>"<|fim_middle|>use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
mode: "none",
experiments: {
deferImp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>__deferImport__proposal.push("END entry.js");
<|fim_prefix|>let file;
file = "full-sync.js";
const fullSync = await import(/* webpackDefer: true */ "../async-in-graph/" + file);
file = "async-mod.js";
const asyncMod = await import(/* webpackDefer: true */ "../async-in-graph/" + file);
file = "deep-async.j... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should compile", async () => {
debugger;
const logs = global.__configCases__deferImport__proposal = [];
let mod = import("./entry.js");
expect(mod).toBeInstanceOf(Promise);
let { default: namespaces } = await mod;
expect(logs).toEqual([
"START async-mod-dep.js",
"END async-mod-dep.js",
... | fim | webpack/webpack | javascript |
<|fim_suffix|>port: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node<|fim_middle|>${process.versions.node.split(".").map(Number)[0]}`],
mode: "none",
experiments: {
deferIm<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mod.js"; // error
export default [f, f2, f3, f4, f5];
export { f3 }
<|fim_prefix|>import { f } from /* webpackDefer: true */ "./mod.js"; // error
import f2 from /* webpackDefer: true */ "./mod.js"; // error
import * as f3 from /* webpackDefer: true */ "./mod.js";
import f4, { f as f5 } from /* webpackD... | fim | webpack/webpack | javascript |
<|fim_prefix|>export funct<|fim_suffix|>{}
export default function f2() {}
<|fim_middle|>ion f() <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
experiment<|fim_middle|>s: {
deferImport: true<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a } from 'mod'
Object.keys(a).forEach<|fim_suffix|>> { })
<|fim_middle|>(() =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import defer * as m from 'm<|fim_suffix|>
Object.keys(m).forEach(() => {})
<|fim_middle|>od'<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it('sho<|fim_suffix|>, () => {
require('./main.js');
})
<|fim_middle|>uld compile and load'<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import './a<|fim_suffix|>'./b'
<|fim_middle|>'
import <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** <|fim_suffix|>ort: true
}
};
<|fim_middle|>@type {import("../../../../types").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
optimization: {
concatenateModules: true
},
experiments: {
deferImp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>import defer * as mod from 'mod'
export functio<|fim_middle|>n b() {
mod.fn()
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it('sh<|fim_suffix|>main.js');
})
<|fim_middle|>ould compile and load', () => {
require('./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fn } from 'mod'
import { <|fim_suffix|>./a'
fn()
b()
<|fim_middle|>b } from '<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types<|fim_suffix|> experiments: {
deferImport: true
}
};
<|fim_middle|>").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
optimization: {
concatenateModules: true
},
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ue = dyn.default;
assertTouched();
expect(typeof value).toBe("string");
expect(value).toContain(".defer-text-class");
});
it("should defer CSS exportType: 'css-style-sheet' (dynamic `import.defer`)", async () => {
reset();
const dyn = await import.defer(
/* webpackMode: "eager" */ "./wrapper-dyn-... | fim | webpack/webpack | javascript |
<|fim_suffix|> at v22+. Earlier versions either reject the attribute or flag it.
module.exports = () => {
const [major] = process.versions.node.split(".").map(Number);
return major >= 22;
};
<|fim_prefix|>"use strict";
// `with { type: "css" }` (TC39 stage-3 import attributes for CSS modules)
// landed in the defaul... | fim | webpack/webpack | javascript |
<|fim_suffix|>s is imported with `with { type: "css" }`, which the
// default rules in lib/config/defaults.js route to exportType
// "css-style-sheet".
]
},
experiments: {
deferImport: true,
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {... | fim | webpack/webpack | javascript |
<|fim_prefix|>import css from "./style-attr.css" with { type: "css" };
import { touch } from "./<|fim_suffix|>
export default css;
<|fim_middle|>side-effect-counter.cjs";
touch();<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t css;
<|fim_prefix|>import css from "./style-stylesheet.css?dyn";
import { to<|fim_middle|>uch } from "./side-effect-counter.cjs";
touch();
export defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import css from "./style-text.css?dyn";
import { touch } from "./side-effect-counter.cjs";
touch();
exp<|fim_suffix|>default css;
<|fim_middle|>ort <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import css from "./styl<|fim_suffix|>touch();
export default css;
<|fim_middle|>e-stylesheet.css";
import { touch } from "./side-effect-counter.cjs";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// JS wrapper around an asset/synthetic module so w<|fim_suffix|>ually happened. The TC39 import-defer proposal says
// evaluation must be delayed until the first observable access on the
// namespace; we observe that here by checking whether `touch()` ran.
import css from "./style-text.css";
import { tou... | fim | webpack/webpack | javascript |
<|fim_suffix|>if (data !== undefined)
throw new Error("No module should be executed before this one.");
setData("0.js");
<|fim_prefix|>import { data, setData } from "./side-effect-coun<|fim_middle|>ter";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nst x = ns;
<|fim_prefix|>import "./0.js";
import * as ns from ".<|fim_middle|>/deferred.js";
export co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { data, setData } from "./side-effect-counter";
if (da<|fim_suffix|>s to be executed first.");
setData("deferred");
export {};
<|fim_middle|>ta !== "0.js") throw new Error("Expected 0.j<|endoftext|> | fim | webpack/webpack | javascript |
import * as ns from /* webpackDefer: true */ "./deferred.js";
import "./1.js";
if (Math.random() > 1) {
console.log(ns);
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("execution order should be correct.", () => {
return import("./entry<|fim_suffix|>;
<|fim_middle|>.js");
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export let d<|fim_suffix|>setData(d) {
data = d;
}
<|fim_middle|>ata;
export function <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.<|fim_suffix|>e
}
};
<|fim_middle|>exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
experiments: {
deferImport: tru<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
assertTouched as a,
assertUntouched as b,
reset as c
} from "./side-effect-counter.js";
const [assertTouched, assertUntouched, reset] = [a, b, c];
it("should defer the module until first use", async () => {
let file;
file = "dynamic_default.cjs";
const dynamic_default = await import.... | fim | webpack/webpack | javascript |
<|fim_suffix|>ect(new reexport_cjs_ns.T().x).toBe(1);
assertTouched();
});
function assertIsNamespaceObject(ns) {
if (typeof ns !== "object" || !ns)
throw new TypeError("namespace is not an object.");
if (!ns[Symbol.toStringTag])
throw new Error(
"namespace object does not have a Symbol.toStringTag ... | fim | webpack/webpack | javascript |
<|fim_suffix|>th_ns, "default");
assertTouched();
expect(Reflect.get(flagged_both_ns, "default")()).toBe("func");
expect(Reflect.get(flagged_both_ns, "x")).toBe(1);
expect(new flagged_both_ns.T().x).toBe(1);
assertTouched();
// then esm with namespace
reset();
assertIsNamespaceObject(esm_default_ns);
assertUn... | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
assertTouched as a,
assertUntouched as b,
reset as c
} from "./side-effect-counter.js";
const [assertTouched, assertUntouched, reset] = [a, b, c];
it("should defer the module until first use", async () => {
const dynamic_default = await import(/* webpackDefer: true */ "./commonjs/dynamic... | fim | webpack/webpack | javascript |
<|fim_suffix|>agged_named_ns, "f");
assertTouched();
expect(Reflect.get(flagged_named_ns, "f")()).toBe("func");
expect(new flagged_named_ns.T().x).toBe(1);
assertTouched();
reset();
assertIsNamespaceObject(flagged_both_ns);
assertUntouched();
Reflect.get(flagged_both_ns, "default");
assertTouched();
expect(R... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as dynamic_default from /* webpackDefer: true */ "./commonjs/dynamic_default.cjs";
import * as dynamic_default_ns from /* webpackDefer: true */ "./commonjs/dynamic_default_ns.cjs";
import * as dynamic_named from /* webpackDefer: true */ "./commonjs/dynamic_named.cjs"<|fim_suffix|> expect(esm_defa... | fim | webpack/webpack | javascript |
<|fim_prefix|>const { touch } = require("../side-effect-counter");
module.exports.__es<|fim_suffix|>rue;
module.exports.default = f;
module.exports.x = 1;
module.exports.T = class T {
constructor() {
this.x = 1;
}
}
function f() {
return "func";
}
touch();
<|fim_middle|>Module = t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
module.exports.x = 1;
module.exports.T = class T {
constructor() {
this.x = 1;
}
}
function f() {
return "func";
}
touch();
<|fim_prefix|>const { touch } = require("../side-effect-counter");
module.exports.__esModu<|fim_middle|>le = true;
module.exports.default = f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const { touch } = require("../side-effect-counter");
module.exports.__esModule = true;
module.exports.default =<|fim_suffix|>f() {
return "func";
}
touch();
<|fim_middle|> f;
function <|endoftext|> | fim | webpack/webpack | javascript |
const { touch } = require("../side-effect-counter");
module.exports.__esModule = true;
module.exports.default = f;
function f() {
return "func";
}
touch();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"func";
}
touch();
<|fim_prefix|>const { touch } = require("../side-effect-counter");
module.exports.__esModule = true;
module.exports<|fim_middle|>.f = f;
module.exports.T = class T {
constructor() {
this.x = 1;
}
}
function f() {
return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const { touch } = require("../side-eff<|fim_suffix|>ass T {
constructor() {
this.x = 1;
}
}
function f() {
return "func";
}
touch();
<|fim_middle|>ect-counter");
module.exports.__esModule = true;
module.exports.f = f;
module.exports.T = cl<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { touch } from "../side-effect-counter.js";
touch();
export defa<|fim_suffix|>this.x = 1;
}
}
<|fim_middle|>ult function () {
return "func";
}
export const x = 1;
export class T {
constructor() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { touch } from "../side-effect-counter.js";
touch();
export default <|fim_suffix|>() {
return "func";
}
export const x = 1;
export class T {
constructor() {
this.x = 1;
}
}
<|fim_middle|>function <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { touch } from "../side-effect-counter.js";
<|fim_suffix|>default function () {
return "func";
}
<|fim_middle|>touch();
export <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { touch } from<|fim_suffix|>ouch();
export default function () {
return "func";
}
<|fim_middle|> "../side-effect-counter.js";
t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { touc<|fim_suffix|>"func";
}
export class T {
constructor() {
this.x = 1;
}
}
touch();
<|fim_middle|>h } from "../side-effect-counter.js";
export function f() {
return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> class T {
constructor() {
this.x = 1;
}
}
touch();
<|fim_prefix|>import { touch } from "../side-effect-counter.js";
export function f() {
return "func";
}
expor<|fim_middle|>t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> should never be evaluated.')
<|fim_prefix|>throw new Error(<|fim_middle|>'this file<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ructor() {
this.x = 1;
}
}
touch();
<|fim_prefix|>import<|fim_middle|> { touch } from "../side-effect-counter.js";
export function f() {
return "func";
}
export class T {
const<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port_cjs_ns };
<|fim_prefix|>import * as reexport_ns from /* webpackDefer: true */ "./reexport-deep<|fim_middle|>.mjs";
import * as reexport_cjs_ns from /* webpackDefer: true */ "./reexport-deep.cjs";
export { reexport_ns, reex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>let count = 0;
export function touch() {
count++;
}
export function reset() {
count = 0;
}
export function assertTouched() {
if (count === 0) throw new Error("Side effect not triggered.");
if (count > 1) th<|fim_suffix|>expected.");
}
export function assertUntouched() {
if (count !== 0) throw new Err... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Co<|fim_suffix|>Modules: false
},
experiments: {
deferImport: true
}
};
<|fim_middle|>nfiguration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: ["./all.js"],
optimization: {
concatenate<|en... | fim | webpack/webpack | javascript |
<|fim_suffix|>get: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: ["../defer-runtime/all.js"],
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use stri<|fim_middle|>ct";
/** @type {import("../../../../").Configuration} */
module.exports = {
tar<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict<|fim_suffix|>.js/,
type: "javascript/esm"
}
]
},
experiments: {
deferImport: true
}
};
<|fim_middle|>";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: ["../defer-runtime/al... | fim | webpack/webpack | javascript |
<|fim_suffix|>).map(Number)[0]}`],
entry: ["../defer-runtime/all-dynamic-import.js"],
optimization: {
concatenateModules: false
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
ta<|fim_middle|>rget: [`async-node${proce... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: ["../defer-runti<|fim_suffix|>ents: {
deferImport: true
}
};
<|fim_middle|>me/all-dynamic-import-context.js"],
optimization: {
conc... | fim | webpack/webpack | javascript |
<|fim_suffix|>me/all-dynamic-import-context-native-syntax.js"],
optimization: {
concatenateModules: false
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configu<|fim_middle|>ration} */
module.exports = {
target: [`async-node${process.versions.node.split(... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.<|fim_suffix|>]}`],
entry: ["../defer-runtime/all-dynamic-import-native-syntax.js"],
optimization: {
concatenateModules: false
},
experiments: {
deferImport: true
}
};
<|fim_middle... | fim | webpack/webpack | javascript |
<|fim_suffix|>ules: false
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry<|fim_middle|>: ["../defer-runtime/all-native-syntax.js"],
optimiz... | fim | webpack/webpack | javascript |
<|fim_suffix|>: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import(".<|fim_middle|>./../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: ["../defer-runtime/all.js"],
optimization: {
concatenateModules: false
},
... | fim | webpack/webpack | javascript |
<|fim_suffix|>deferred.js';
import { order } from './order.js';
order.push([0, deferred][0]);
<|fim_prefix|>import * as deferred fr<|fim_middle|>om /* webpackDefer: true */ './<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>import './deferred.js';
import { order } from './order.js'<|fim_middle|>;
order.push(1<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as deferred from /* webpackDefer: true */ './deferred.1.js';
import { order } from './order.js';
order.push(['a', deferred]<|fim_suffix|> avoidAnalyze(params) {
return params;
}
<|fim_middle|>[0]);
export function next() {
if (typeof avoidAnalyze(deferred).then !== 'undefined') {
throw new E... | fim | webpack/webpack | javascript |
<|fim_suffix|>be a deferred namespace object.');
}
function avoidAnalyze(params) {
return params;
}
<|fim_prefix|>import * as ns from './deferred.1.js';
import { order } from './order.js';
order.push(['b', ns][0]);
if (typeof avoidAnalyze(ns).then === 'undefined') {
throw new Error('ns should not<|fim_middle|> <|endo... | fim | webpack/webpack | javascript |
<|fim_suffix|>{}
<|fim_prefix|>import { order <|fim_middle|>} from "./order";
order.push("deferred.1");
export function then() <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>import { order } from "./order<|fim_middle|>";
order.push("deferred");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"${expected}", but got "${order.join(' ')}"`
);
}
next();
<|fim_prefix|>import { order } from "./order";
import './0.js';
import './1.js';
import './a.js';
import './b.js';
import { next } from "./a.js";
const expected = "0 deferred 1 a deferred.1 b";<|fim_middle|>
if (order.join(' ') !== expected) {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("execution order should be correct.", () => {
return imp<|fim_suffix|>");
});
<|fim_middle|>ort("./entry.js<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|><|fim_middle|>export const order = []<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>n: {
concatenateModules: true
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use <|fim_middle|>strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
optimizatio<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { data,<|fim_suffix|>ta !== "entry")
throw new Error("Expected entry.js to be executed first.");
setData("deferred");
export {};
<|fim_middle|> setData } from "./side-effect-counter";
if (da<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"entry");
await import("./sync-access.js");
if (Math.random() > 1) {
console.log(ns);
}
<|fim_prefix|>import<|fim_middle|> * as ns from /* webpackDefer: true */ "./deferred.js";
import { data, setData } from "./side-effect-counter.js";
if (data !== undefined)
throw new Error("No side effect should be ... | fim | webpack/webpack | javascript |
<|fim_prefix|>it(<|fim_suffix|>eturn import("./entry.js");
});
<|fim_middle|>"execution order should be correct.", () => {
r<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>xport function setData(d) {
data = d;
}
<|fim_prefix|><|fim_middle|>export let data;
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as ns from "./deferred.js";
import { data } from "./side-effect-cou<|fim_suffix|>");
Object.entries(ns);
<|fim_middle|>nter.js";
if (data !== "deferred")
throw new Error("Expected deferred.js to be executed first.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>r)[0]}`],
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: [`async-node${process.versions.node<|fim_middle|>.split(".").map(Numbe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { defaultValue, deferredValue } from "./reexport"
it<|fim_suffix|>on modules", () => {
expect(defaultValue).toBe(deferredValue);
});
<|fim_middle|>("should have correct default export with concatenati<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import defer * as n from "./dynamic.cjs";
import nDef from "./dyn<|fim_suffix|>ultValue = nDef.value;
<|fim_middle|>amic.cjs";
export const deferredValue = n.value;
export const defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mber)[0]}`],
optimization: {
concatenateModules: true
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
target: [`asyn<|fim_middle|>c-node${process.versions.node.split(".").map(Nu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const value = await <|fim_suffix|>c";
<|fim_middle|>"shared-value-asyn<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { value as directValue } from "./shared.js"; // non-defer import
import * as deferredShared from /* webpackDefer: true<|fim_suffix|>(deferredShared.value).toBe("shared-value");
// Both should access the same underlying value
expect(directValue).toBe(deferredShared.value);
});
it("should handl... | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>ync";
<|fim_middle|> * from "./as<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lue"; <|fim_prefix|>// This module wil<|fim_middle|>l be imported both as defer and non-defer
export const value = "shared-va<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsAsync<|fim_suffix|>s = () => supportsAsync();
<|fim_middle|> = require("../../../helpers/supportsAsync");
module.export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
optimization: {
concatenateModules: true
},
experiments: {
deferImport: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.ex<|fim_middle|>ports = {
targe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port default "default-value";
<|fim_prefix|>expo<|fim_middle|>rt const value = 42;
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ce across call sites in the same file", () => {
expect(deferred1).toBe(deferred2);
});
it("shares the deferred namespace across files", () => {
expect(deferred1).toBe(deferredFromOtherFile);
});
it("keeps the deferred namespace distinct from the eager namespace", () => {
expect(deferred1).not.toBe(ea... | fim | webpack/webpack | javascript |
<|fim_prefix|>import defer * as deferredNs f<|fim_suffix|>ns = deferredNs;
<|fim_middle|>rom "./dep.js";
export const <|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const supportsAsync = require("../../../helpers/supportsAsync");
module.exports = () => supportsAsync();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuratio<|fim_suffix|>e${process.versions.node.split(".").map(Number)[0]}`],
optimization: {
concatenateModules: false
},
experiments: {
deferImport: true
}
};
<|fim_middle|>n} */
module.exports = {
target: [`async-nod<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import defer * as mod1 from "./file.ext" with { type: "bytes" };
import defer * as mod2 from "./file.ext" with { type: "json" };
import * as mod3 from "./file.ext" with { type: "bytes" };
import * as mod4 from "./file.ext" with { type: "json" };
it("should work with defer and import attributes", () => {
... | fim | webpack/webpack | javascript |
<|fim_suffix|>pportsTextDecoder");
module.exports = () => supportsTextDecoder();
<|fim_prefix|>"use strict";
const supportsTextDecoder<|fim_middle|> = require("../../../helpers/su<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
mod<|fim_suffix|> {
deferImport: true
}
};
<|fim_middle|>ule.exports = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
experiments:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import defer * as data from "./config.json" with { type: "json" };
import defer * as dataStr from "./config.json" with { "type": "json" };
import defer * as wrapped from "./wrapper.js";
import {
assertTouched,
assertUntouched,
reset
} from "./side-effect-counter.cjs";
function assertIsNamespaceObject... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.