text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|><|fim_prefix|>"us<|fim_middle|>e strict";
module.exports = [];
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { existsSync } from "./lib";
it("compiles with an external e<|fim_suffix|>
<|fim_middle|>xcluded from concatenation", () => {
expect(typeof existsSync).toBe("function");
});<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export { existsSync } from "external<|fim_middle|>-mod"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>= concatenated._createConcatenationList;
concatenated._createConcatenationList = () =>
baseList.map((info) =>
info === externalInfo
? { ...info, runtimeCondition: overrideRuntimeCondition }
: info
);
try {
const hash = createHash("xxhash64");
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "./loader!!";
import {url as url2} fro<|fim_suffix|>ld compile and run", () => {
expect(url).toBe("webpack:///a.txt");
expect(url2.toString()).toMatch(/^file:/);
});
<|fim_middle|>m "./module1";
it("shou<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function () {
const callback = this.asy<|fim_suffix|>(null, `module.exports = ${JSON.stringify(exports.url)}`);
});
};
<|fim_middle|>nc();
this.importModule("./module1", { baseUri: "webpack://" }, (err, exports) => {
if (err) ret... | fim | webpack/webpack | javascript |
<|fim_suffix|>mport.meta.url);
export { url }
<|fim_prefix|>const url = new<|fim_middle|> URL("./a.txt", i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
assetMod<|fim_suffix|>xt]"
}
};
<|fim_middle|>uleFilename: "[name][e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const doc = console;
const setTim<|fim_suffix|>
export default 1;
<|fim_middle|>eout = 1;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./a";
setTimeout(() => <|fim_suffix|>nsole;
export default 1;
it("should compile and run", () => {
expect(doc).toBe(console);
});
<|fim_middle|>{}, 0);
const doc = co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
entry: {
index: <|fim_suffix|>(__dirname, "./index.js")
},
output: {
library: "[name]",
libraryExport: "default"
},
optimization: {
concatenateModules: true
}
... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>i<|fim_middle|>mport "./c";
export default import("./b")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export de<|fim_middle|>fault 'b'<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>export<|fim_middle|> default 'c';<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
import b from "./b";
it("should load fine", () => {
expect(b).toBe("b");
return a.then(a => expect(a).toEqual(nsObj({ default: "b" })));
});
<|fim_prefix|><|fim_middle|>import a from "./a";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import a from "./a";
it("should load fine", () => {
return a.then<|fim_suffix|>expect(a).toEqual(nsObj({ default: "b" })));
});
<|fim_middle|>(a => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e() {
return ["entry1.js", "entry2.js"];
}
};
<|fim_prefix|>"use strict";
module.e<|fim_middle|>xports = {
findBundl<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Co<|fim_suffix|>tion} */
module.exports = {
entry: {
entry1: "./entry1",
entry2: "./entry2"
},
output: {
filename: "[name].js"
},
optimization: {
concatenateModules: true
}
};
<|fim_middle|>nfigura<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}
<|fim_prefix|>export cl<|fim_middle|>ass A {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ss B {}
<|fim_prefix|>expor<|fim_middle|>t cla<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{}
<|fim_prefix|>import { B as BB } from "./B";
const X = 0;
var Y = 0;
export class C extends (function() {
var A = 0;
var B = 0;
return BB;
})()<|fim_middle|> <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>{}
<|fim_prefix|>export<|fim_middle|> class D <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}
<|fim_prefix|>import { D as DD } fro<|fim_middle|>m "./D";
export class E extends (function() {
var D = 0;
return DD;
})() {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { A } from "./A";
ex<|fim_suffix|>} from "./B";
export { C as CC } from "./C";
export { D } from "./D";
export { E } from "./E";
<|fim_middle|>port { A };
export { B <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e).toBe("C");
expect(D.name).toBe("D");
expect(E.name).toBe("E");
});
<|fim_prefix|>import { A, B, CC, D, E } from "./all";
require("./all");
require("./D");
it("should <|fim_middle|>not rename classes unnecessary", () => {
expect(A.name).toBe("A");
expect(B.name).toBe("B_B");
expect(CC.nam<|endoft... | fim | webpack/webpack | javascript |
<|fim_suffix|>catenateModules: true
}
};
<|fim_prefix|>"use strict";
/** <|fim_middle|>@type {import("../../../../").Configuration} */
module.exports = {
optimization: {
con<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { b, a, c } from "dep";
c.cc();
b.bbb();
a.aa();
import { order } fr<|fim_suffix|> deterministic order (usage order)", () => {
expect(order).toEqual(["c", "b", "a"]);
});
<|fim_middle|>om "dep/order.js";
it("should import side-effect-free modules in<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/").Configuration} */
module.exports = {
optimization: {
concatenateModules: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../<|fim_middle|>../../..<|endoftext|> | fim | webpack/webpack | javascript |
import './b';
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>imp<|fim_suffix|>';
it("should compile and evaluate fine", () => {});
<|fim_middle|>ort './a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.<|fim_suffix|>xports = {
findBundle() {
return ["runtime.js", "common-index_js.js", "main.js"];
}
};
<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: {
main: "./index"
},
target: "web",
output: {
filename: "[name].js"
},
optimization: {
concatenateModules: true,
chunkIds: "named",
runtimeChunk: "single",
splitChunks: {
minSize: <|fim_suffix... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { getValue } from "./module";
const l<|fim_suffix|>alDecl = 1;
it("should compile and run", () => {
expect(getValue() + localDecl).toBe(43);
});
<|fim_middle|>oc<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
export function getValue() {
return innerDecl;
}
<|fim_prefix|>let inner<|fim_middle|>Decl = 41;
innerDecl++<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ns).toContain("getValue");
}
expect(found).toBe(true);
});
});
}
]
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
optimization: {
concatenateModules: true,
minimize: false
},
plugins: [
function testP... | fim | webpack/webpack | javascript |
<|fim_suffix|>etValue()).toBe(42);
const source = fs.readFileSync(__filename, "utf-8");
// string split to not match this test's own source
expect(source).toContain(
"declares 'MyLib' on top-level, " + "which conflicts with the current library output"
);
});
<|fim_prefix|>import fs from "fs";
import { getValue } ... | fim | webpack/webpack | javascript |
let innerDecl = 40;
innerDecl++;
function MyLib(x) {
return x + 1;
}
export function getValue() {
return innerDecl + MyLib(0);
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
output: {
librar<|fim_suffix|> { name: "MyLib", type: "var" }
},
optimization: {
concatenateModules: true,
minimize: false
}
};
<|fim_middle|>y:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t () => {
return `App rendered with [${React()}] and [${ComponentA()}]`;
};
<|fim_prefix|>import React from "react";
import<|fim_middle|> ComponentA from "containerA/ComponentA";
export defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t()}]`;
};
<|fim_prefix|>import React from "react";
export default () => {
return `Comp<|fim_middle|>onentA rendered with [${Reac<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>urn import("./upgrade-react").then(({ default: upgrade }) => {
upgrade();
const rendered = App();
expect(rendered).toBe(
"App rendered with [This is react 1.2.3] and [ComponentA rendered with [This is react 1.2.3]]"
);
});
});
});
<|fim_prefix|>it("should load the component from contain... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
modu<|fim_suffix|>e.exports = {
findBundle(i) {
return i === 0 ? "./main.js" : "./module/main.mjs";
}
};
<|fim_middle|>l<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>on("1.2.3");
}
<|fim_prefix|>i<|fim_middle|>mport { setVersion } from "react";
export default function upgrade() {
setVersi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> },
...common
})
],
target: "node14"
}
];
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {ConstructorParameters<typeof ModuleFederationPlugin>[0]} */
const common = {
name: "container",
exposes: {
"./ComponentA": {
import... | fim | webpack/webpack | javascript |
<|fim_suffix|>xport default App;
<|fim_prefix|>import { emitter } from "./emitter.js";
f<|fim_middle|>unction App() {
return emitter;
}
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>emitter'
const emitter = new TinyEmitter()
emitter.on('hello', () => console.log('hello[service]'))
export {
emitter,
}
<|fim_prefix|>import { T<|fim_middle|>inyEmitter } from 'tiny-<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>BeDefined();
});
});
<|fim_prefix|>it("should allow to import exposed modules sync", () => {
return import("./App").then(({ defau<|fim_middle|>lt: App }) => {
expect(App().e.hello).to<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
const { dependencies } = require("./package.json");
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
chunkIds: "named",
moduleIds: "named"
},
plugins: [
new ModuleFederationPlugin({
na... | fim | webpack/webpack | javascript |
<|fim_suffix|>t * from "./b";
<|fim_prefix|><|fim_middle|>expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|> from "./shared";
<|fim_middle|>export *<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should work normally (a)", () => {
return import(<|fim_suffix|>.then(({ value }) => {
expect(value).toBe("shared");
});
});
it("should work normally (b)", () => {
return import("./b").then(({ value }) => {
expect(value).toBe("shared");
});
});
it("should work normally (container-with-shared/... | fim | webpack/webpack | javascript |
<|fim_suffix|>_webpack_modules__).sort();
<|fim_prefix|>export default Obj<|fim_middle|>ect.keys(_<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "shared";
<|fim_prefix|>exp<|fim_middle|>ort const value =<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
chunkIds: "named",
moduleIds: "named"
},
plugins: [
new ModuleFederationPlugin({
name: "container-with-shared",
library: { type: "co... | fim | webpack/webpack | javascript |
import React from "react";
import ComponentA from "containerA/ComponentA";
import ComponentB from "containerB/ComponentB";
import LocalComponentB from "./ComponentB";
export default () => {
return `App rendered with [${React()}] and [${ComponentA()}] and [${ComponentB()}]`;
};
expect(ComponentB).not.toBe(LocalCompon... | fim | webpack/webpack | javascript |
<|fim_suffix|>efault () => {
return `ComponentB rendered with [${React()}]`;
};
<|fim_prefix|>import React from "react";
e<|fim_middle|>xport d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>act()}] and [${ComponentA()}] and [${ComponentB()}]`;
};
<|fim_prefix|>import React from "react";
import ComponentA from "containerA/ComponentA";
import ComponentB from "containerB/ComponentB";
export default<|fim_middle|> () => {
return `ComponentC rendered with [${Re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load the component from container", () => {
return import("./App").then(({ default: App }) => {
const re<|fim_suffix|>});
});
});
<|fim_middle|>ndered = App();
expect(rendered).toBe(
"App rendered with [This is react 2.1.0] and [ComponentA rendered with [This is react 2.1.0]] and [Comp... | fim | webpack/webpack | javascript |
<|fim_suffix|>0 ? "./main.js" : "./module/main.mjs";
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle(<|fim_middle|>i) {
return i === <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { setVersion } from "react";
export default func<|fim_suffix|>) {
setVersion("3.2.1");
}
<|fim_middle|>tion upgrade(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
const common = {
entry: {
main: "./index.js"
},
optimization: {
runtimeChunk: "single"
}
};
/** @type {ConstructorParameters<typeof ModuleFederationPlugin>[0]} */
const commonMF = {
runtime: false,
exposes: {
... | fim | webpack/webpack | javascript |
export * from "container-with-shared/b";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>rom "./shared";
<|fim_middle|> * f<|endoftext|> | fim | webpack/webpack | javascript |
it("should work normally (a)", () => {
return import("./a").then(({ value }) => {
expect(value).toBe("shared");
});
});
it("should work normally (b)", () => {
return import("./b").then(({ value }) => {
expect(value).toBe("shared");
});
});
it("should work normally (container-with-shared/a)", () => {
return i... | fim | webpack/webpack | javascript |
<|fim_suffix|>hared/modules";
<|fim_prefix|>export { default } from "con<|fim_middle|>tainer-with-s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t Object.keys(__webpack_modules__).sort();
<|fim_prefix|>export defau<|fim_middle|>l<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t value = "shared";
<|fim_prefix|>export con<|fim_middle|>s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
modul<|fim_suffix|>ionPlugin({
name: "container-no-shared",
library: { type: "commonjs-module" },
filename: "container-no-shared.js",
exposes: ["./a", "./b"... | fim | webpack/webpack | javascript |
<|fim_suffix|>=> {
return `App rendered with [${React()}] and [${OldReact()}] and [${OldReactSingleton()}] and [${ComponentC()}]`;
};
<|fim_prefix|>import OldReact from "old-react";
import OldReactSingleton from "old-react-singleton";
import <|fim_middle|>React from "react";
import ComponentC from "containerB/Componen... | fim | webpack/webpack | javascript |
export default {
in: __filename
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>quired \^2\)/
);
const rendered = App();
expect(rendered).toBe(
"App rendered with [This is react 8] and [This is react 2.1.0] and [This is react 8] and [ComponentC rendered with [This is react 8] and [ComponentA rendered with [This is react 8]] and [ComponentB rendered with [This is react 8]]]"
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import <|fim_suffix|>sion } from "react";
export default function upgrade() {
setVersion("9");
}
<|fim_middle|>{ setVer<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
uniqueName: "2-container-full"
},
plugins: [
new ModuleFederationPlugin({
name: "main",
librar<|fim_suffix|>,
"old-react":... | fim | webpack/webpack | javascript |
<|fim_suffix|>e"
]);
});
<|fim_prefix|>it("should allow transitive overrides (container-no-shared/a)", () => {
return import("container-no-shared/a").then(({ value }) => {
expect(value).toBe("new shared");
});
});
it("should not override non-overridables (container-no-shared/b)", () => {
return import("container... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export const value =<|fim_middle|> "new shared"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
chunkIds: "named",
moduleIds: "named"
},
plugins: [
<|fim_suffix|> remotes: {
"container-no-shared":
"../1-transiti... | fim | webpack/webpack | javascript |
<|fim_suffix|>containerB/ComponentC";
export default () => {
return `App rendered with [${React()}] and [${ComponentC()}]`;
};
<|fim_prefix|>import React from "react";<|fim_middle|>
import ComponentC from "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load the component from container", () => {
return import("./App").then(({ default: App }) => {
const rendered = App();
expect(rendered).toBe(
"App rendered with [This is react 2.1.0] and [ComponentC rendered with [This is react 2.1.0] and [ComponentA rendered with [This is react 2.1.0]... | fim | webpack/webpack | javascript |
<|fim_suffix|>setVersion("9");
}
<|fim_prefix|>import { setVersion } from<|fim_middle|> "react";
export default function upgrade() {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>remoteType: "commonjs-module",
remotes: {
containerB: "../1-container-full/container.js"
},
shared: ["react"]
})
]
};
<|fim_prefix|>"use strict";
const { Modul<|fim_middle|>eFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default "a";
e<|fim_suffix|>ult as b, a as ba } from "container2/b";
<|fim_middle|>xport { defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>as ab } from "container/a";
<|fim_prefix|>export default "b";
export { default as<|fim_middle|> a, b <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow circular de<|fim_suffix|>toBe("a");
expect(b).toBe("b");
expect(ba).toBe("a");
});
it("should allow circular dependencies between containers (b)", async () => {
const { default: value, a, ab } = await import("container2/b");
expect(value).toBe("b");
expect(a).toBe("a");
expect(ab).... | fim | webpack/webpack | javascript |
<|fim_suffix|>ndBundle() {
return "./main.js";
}
};
<|fim_prefix|>"use strict";
module.exports = {
<|fim_middle|>fi<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/**
* @returns {import("../../../../").Configuration} configuration
*/
function createConfig() {
return {
output: {
filename: "[name].js"
},
plugins: [
new ModuleFederationPlugin({
name: "container",
library: { ... | fim | webpack/webpack | javascript |
<|fim_suffix|>le.js");
expect(container).toBeTypeOf("object");
expect(container.get).toBeTypeOf("function");
const testFactory = await container.get("./test");
expect(testFactory).toBeTypeOf("function");
expect(testFactory()).toBe("test");
const mainFactory = await container.get(".");
expect(mainFactory).toBeTyp... | fim | webpack/webpack | javascript |
<|fim_suffix|>et("ok");
<|fim_prefix|>import { set } from ".<|fim_middle|>/state";
s<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = "main";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lue = v;
}
<|fim_prefix|>export let v<|fim_middle|>alue = "";
export function set(v) {
va<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>module.expor<|fim_middle|>ts = "test";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lue).toBe("ok");
<|fim_prefix|>import { value } from "./s<|fim_middle|>tate";
export default "test2";
export const other = "other";
expect(va<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|>ile.js",
library: {
type: "commonjs-module"
},
exposes: {
"./test": "./test",
"./test2": ["./init-module", "./test2"],
".": "./main"
}
})
]
};
<|fim_middle|>const { ContainerPlugin } = require("../../../../").container;
/** @type {import("../../... | fim | webpack/webpack | javascript |
<|fim_suffix|>estFactory = await container.get("./test");
expect(testFactory).toBeTypeOf("function");
expect(testFactory()).toEqual(
nsObj({
default: "test overridden-value"
})
);
});
<|fim_prefix|>it("should expose modules from the container", async () => {
const cont<|fim_middle|>ainer = __non_webpack_requ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "./value";
export def<|fim_suffix|>{value}`;
<|fim_middle|>ault `test $<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export defau<|fim_suffix|>lue";
<|fim_middle|>lt "va<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ContainerPlugin } = require("../../../../").container;
const { ConsumeSharedPlugin } = require("../../../../").sharing;
/** @type {import("../../../../").Configuration} */
module.exports = {
plugins: [
new Con<|fim_suffix|>/test"
}
}),
new ConsumeSharedPlugin({
consume... | fim | webpack/webpack | javascript |
<|fim_suffix|> test }) => test());
});
<|fim_prefix|>it("should import the correct modules", () => {
return import("./module").then<|fim_middle|>(({<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e("./hello/other/world");
}
<|fim_prefix|>import abc from "abc/hello-world";
import main from "abc";
import def, { module } from <|fim_middle|>"def/hello-world";
import def2, { module as module2 } from "def/hello/other/world";
export function test() {
expect(abc).toBe("abc ./hello-world");
expect(main)... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
scope.ABC = {
get(module) {
return new Promise((resolve) => {
setTimeout(() => {
resolve(() => `abc ${modu<|fim_suffix|>(() => {
resolve(() => ({
__esModule: true,
module,
default: "def"
}));
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ContainerReferencePlugin } = require("../../../../").container;
/** @t<|fim_suffix|>
})
]
};
<|fim_middle|>ype {import("../../../../").Configuration} */
module.exports = {
plugins: [
new ContainerReferencePlugin({
remoteType: "var",
remotes: {
abc: "ABC",
def: "... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.