text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>(({ test }) => test());
});
<|fim_prefix|>it(<|fim_middle|>"should import the correct modules", () => {
return import("./module").then<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
}
<|fim_prefix|>import abc from "abc/hello-world";
import other from "abc/other";
export function test() {
expect(abc).toBe("ok ./hello-world");
expect(o<|fim_middle|>ther).toBe("ok ./other");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}`;
<|fim_prefix|>module.exports <|fim_middle|>= x => `ok ${x<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> async init(shareScope) {
ss = shareScope;
}
};
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
let ss;
scope.ABC = {
async get(module) {
const testFactory = await ss.test[Object.keys(ss.test)[0]].get();
const test = testFactory();
return () => tes... | fim | webpack/webpack | javascript |
<|fim_suffix|>shareKey: "test",
version: false
}
}
})
]
};
<|fim_prefix|>"use strict";
const { ContainerReferencePlugin } = require("../../../../").container;
const { ProvideSharedPlugin } = require("../../../../").sharing;
/<|fim_middle|>** @type {import("../../../../").Configuration} */
module.export... | fim | webpack/webpack | javascript |
<|fim_suffix|>, () => {
const emitter = new TinyEmitter()
emitter.on('hello', () => {})
expect(emitter.e.hello).toBeDefined();
return import('service/emitter').then(({ emitter }) => {
expect(emitter.e.hello).toBeDefined();
})
});
<|fim_prefix|>import TinyEmitter from 'tiny-emitter'
it("should load the compon... | 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({
re... | fim | webpack/webpack | javascript |
<|fim_prefix|>export let error;
try {
require("remote/module"<|fim_suffix|>r) {
error = err;
}
<|fim_middle|>);
} catch (er<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>wait import("remote/module");
} catch (err) {
error = err;
}
<|fim_prefix|>ex<|fim_middle|>port let error;
try {
a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>"remote/module";
<|fim_middle|>rt <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rror).toEqual(
expect.objectContaining({
message:
'Module "./invalid" does not exist in container.\nwhile loading "./invalid" from webpack/container/reference/remote'
})
);
});
it("should allow to handle invalid remote module error with top-level-await import()", async () => {
const { error ... | fim | webpack/webpack | javascript |
export let error;
try {
require("remote/invalid");
} catch (err) {
error = err;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export let error;
try {
await import("remote/invalid");
} catch (err<|fim_suffix|> error = err;
}
<|fim_middle|>) {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>valid";
<|fim_prefix|>import "remote/<|fim_middle|>in<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>alid/module");
} catch (err) {
error = err;
}
<|fim_prefix|>export let error;
<|fim_middle|>try {
require("inv<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export let error;
try {<|fim_suffix|>rror = err;
}
<|fim_middle|>
await import("invalid/module");
} catch (err) {
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nvalid/module";
<|fim_prefix|>im<|fim_middle|>port "i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>throw new Error("<|fim_suffix|>n error");
<|fim_middle|>evaluatio<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>poses: ["./module"],
remotes: {
remote: "./container.js",
invalid: "./invalid.js"
}
})
]
};
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
chunkId... | fim | webpack/webpack | javascript |
<|fim_prefix|>import LocalButton from "./Button";
import React from "react";
function App() {
ret<|fim_suffix|>ct;
}
export default App;
<|fim_middle|>urn LocalButton() + Rea<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>rom "react";
const Button = () => "Button" + React;
export default Button;
<|fim_middle|>import React f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should all<|fim_suffix|>quire("./App");
expect(App()).toBe("ButtonReactReact");
});
<|fim_middle|>ow to import exposed modules sync", () => {
const { default: App } = re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"./Button"
},
shared: {
react: {
eager: true
}
}
})
]
};
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
plugins: [
new ModuleFederationPlugin({
name: "... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>module.exports = "dep<|fim_middle|>"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should import the correct modules", () => {
r<|fim_suffix|> test());
});
<|fim_middle|>eturn import("./module").then(({ test }) =><|endoftext|> | fim | webpack/webpack | javascript |
import abc from "abc/system-hello-world";
import def, { module } from "def/system-hello-world";
import def2, { module as module2 } from "def/system-hello/other/world";
import other from "other/other";
import otherSelf from "other/self";
import self from "self/self";
import selfOther from "self/other";
export function ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import andBack from "other/<|fim_suffix|>ault `other and ${andBack}`;
<|fim_middle|>dep";
export def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
export default `self and ${andBack}`;
<|fim_prefix|>i<|fim_middle|>mport andBack from "self/dep"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const System = require("../../../helpers/fakeSystem");
module.exports = {
beforeExecute: () => {
System.init();
},
moduleScope(scope) {
System.setRequire(scope.require);
scope.System = Sy<|fim_suffix|>}, 100);
});
}
});
System.set("DEF", {
get(module) {
return ne... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/**
* @returns {import("../../../../").Configuration} configuration
*/
function createConfig() {
return {
output: {
libraryTarget: "system"
},
plugins: [
new ModuleFederationPlugin({
name: "container",... | fim | webpack/webpack | javascript |
<|fim_prefix|>import React from "react";
import ComponentA from "containerA/ComponentA";
import ComponentB from "containerB/ComponentB";
import Lo<|fim_suffix|>onentB";
export default () => {
return `App rendered with [${React()}] and [${ComponentA()}] and [${ComponentB()}]`;
};
expect(ComponentB).not.toBe(LocalComp... | fim | webpack/webpack | javascript |
<|fim_suffix|>}]`;
};
<|fim_prefix|>import React from "react";
export def<|fim_middle|>ault () => {
return `ComponentB rendered with [${React()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>d [${ComponentA()}] and [${ComponentB()}]`;
};
<|fim_prefix|>import React<|fim_middle|> from "react";
import ComponentA from "containerA/ComponentA";
import ComponentB from "containerB/ComponentB";
export default () => {
return `ComponentC rendered with [${React()}] an<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>entA rendered with [This is react 3.2.1]] and [ComponentB rendered with [This is react 3.2.1]]"
);
});
});
});
<|fim_prefix|>it("should load the component from container", async <|fim_middle|>() => {
await __webpack_init_sharing__("test-scope");
// 2 scopes for "0-container-full-mjs" & "mf-with-s... | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle(i) {
return i === 0 ? "./main.js" : "./module/main.mjs";
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>ault function upgrade() {
setVersion("3.2.1");
}
<|fim_middle|>rt { setVersion } from "react";
export def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
const common = {
entry: {
main: "./index.js"
},
optimization: {
runtimeCh<|fim_suffix|> "module" },
filename: "module/container.mjs",
remotes: {
containerA: "../../0-container-full/module/container.mj... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow to work without shared modules", async () => {
await __webpack_init_sharing__("de<|fim_suffix|>("./container.js");
container.init(__webpack_share_scopes__.default);
const moduleFactory = await container.get("./module");
expect(moduleFactory().ok).toBe(true);
});
<|fim_middle|>fault");... | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|>onst ok = true;
<|fim_middle|>c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlug<|fim_suffix|>tainer",
filename: "container.js",
library: { type: "commonjs-module" },
exposes: ["./module"]
})
]
};
<|fim_middle|>in } = require("../../../../").container;
/** @type {import("../../../../").Configuration} */
module.exports = {
plugi... | fim | webpack/webpack | javascript |
<|fim_suffix|> return `App rendered with [${React()}] and [${ComponentA()}]`;
};
<|fim_prefix|>import React from "react";
import ComponentA from "containerA/ComponentA";
expor<|fim_middle|>t default () => {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>export default () => {
return `ComponentA rendered with [${React()}]`;
};
<|fim_prefix|>import Reac<|fim_middle|>t from "react";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>im<|fim_suffix|>t('containerB/ComponentA')
<|fim_middle|>por<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should have the hoisted container references", () => {
const wpm = __webpack_modules__;
expect(wpm).toHaveProperty("webpack/container/reference/containerA"<|fim_suffix|> expect(rendered).toBe(
"App rendered with [This is react 1.2.3] and [ComponentA rendered with [This is react 1.2.3]]"
);
... | fim | webpack/webpack | javascript |
<|fim_suffix|>urn i === 0 ? "./main.js" : "./module/main.mjs";
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle(i) {
r<|fim_middle|>et<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { setVersion } from "react";
export <|fim_suffix|>
setVersion("1.2.3");
}
<|fim_middle|>default function upgrade() {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {ConstructorParameters<typeof ModuleFederationPlugin>[0]} */
const common = {
name: "container",
exposes: {
"./ComponentA": <|fim_suffix|>},
containerB: {
external: "../0-container-full/container... | fim | webpack/webpack | javascript |
<|fim_prefix|>import React <|fim_suffix|>om "react";
import ComponentA from "containerA/ComponentA";
export default () => {
return `App rendered with [${React()}] and [${ComponentA()}]`;
};
<|fim_middle|>fr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import React from "react";
export default () => {
return `ComponentA<|fim_suffix|>red with [${React()}]`;
};
<|fim_middle|> rende<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>om "react"
console.log(React)
<|fim_prefix|>import Rea<|fim_middle|>ct fr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>bpack_modules__;
// Verify that tracker contains hoisted container references
expect(tracker).not.toHaveLength(0);
});
it("should load the component from container", () => {
return import("./App").then(({ default: App }) => {
const rendered = App();
expect(rendered).toBe(
"App rendered with [T... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle(i) {
return i === 0 ? "./main.js" : "./module/main.mj<|fim_suffix|>";
}
};
<|fim_middle|>s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { setVersion } from "react";
export default function upgrade() {
setVersion("1.<|fim_suffix|>.3");
}
<|fim_middle|>2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const { ModuleFederationPlugin } = require("../../../../").container;
/** @type {ConstructorParameters<typeof ModuleFederationP<|fim_suffix|>.common
})
],
target: "node14"
}
];
<|fim_middle|>lugin>[0]} */
const common = {
name: "container",
exposes: {
"./ComponentA": {
impor... | fim | webpack/webpack | javascript |
<|fim_prefix|>import img from "./1.jpg";
it("should compile", () => {
expect(typeof img).toBe("string<|fim_suffix|>;
<|fim_middle|>");
})<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const findOutputFiles = require("../../../helpers/findOutputFiles");
const allAssets = new Set();
const allBundles = new Set();
module.exports = {
findBundle(i, options) {
const bundle = findOutputFiles(options, new RegExp(`^bundle${i}`))[0];
allBundles.add(/\.([^.]+)\./.exec(bundle)[1]);
let a... | fim | webpack/webpack | javascript |
<|fim_suffix|>}
]
}
},
{
output: {
filename: "bundle6.[contenthash].js",
assetModuleFilename: "asset/[name].[contenthash][ext]"
},
module: {
rules: [
{
test: /\.jpg$/,
type: "asset/resource",
generator: {
// should result in same hash as bundle2
publicPath: () => "/p... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should compile", async () => {
await import("./style.module.css");
// The real test is in test.config.js a<|fim_suffix|>Execute
expect(true).toBe(true);
});
<|fim_middle|>fter<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const findOutputFiles = require("../../../helpers/findOutputFiles");
const allCss = new Set();
const allBundles = new Set();
module.exports = {
findBundle(i, options) {
co<|fim_suffix|>llCss.size).toBe(7);
}
};
<|fim_middle|>nst bundle = findOutputFiles(options, new RegExp(`^bundle${i... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
const common = {
target: "web",
optimization: {
realContentHash: false
},
experiments: {
css: true
}
};
/** @typedef {import("../../../../").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
/** @type {import("../../../.... | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>it("should compile", async () => {
await import("./style.<|fim_middle|>module.css");
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const findOutput<|fim_suffix|>${i}/${async}`, `./${bundle}`];
},
afterExecute: () => {
expect(allBundles.size).toBe(2);
expect(allCss.size).toBe(1);
}
};
<|fim_middle|>Files = require("../../../helpers/findOutputFiles");
const allCss = new Set();
const allBundles = new Set();
modul... | fim | webpack/webpack | javascript |
<|fim_suffix|>optimization: {
realContentHash: false
},
experiments: {
css: true
}
};
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
...common,
output: {
filename: "bundle0.[contenthash].js",
chunkFilename: "css0/[name].[contenthash].js",
cssChunkFilename: "css0/[name].... | fim | webpack/webpack | javascript |
export const value = "async-loaded";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rt("./async.css").then((mod) => {
expect(mod).toEqual({});
done();
}, done);
});
<|fim_prefix|>import "./style.css";
import "./page.html";
it("should emit hashed bundles and load an async chunk", (done) => {
import("./async.js").then((mod) => {
expect(mod.value).toBe("async-loaded");
done();
}... | fim | webpack/webpack | javascript |
"use strict";
const fs = require("fs");
const path = require("path");
const findOutputFiles = require("../../../helpers/findOutputFiles");
// Each config in webpack.config.js emits its assets under `cfg${i}/`. The
// matchers below pin the exact filename shape each template should produce
// once webpack has substit... | fim | webpack/webpack | javascript |
<|fim_suffix|>hunkhash]", "[contenthash]", false),
// [fullhash] is the compilation-wide hash — the same string in every
// filename within one compile. Verifies the placeholder is accepted and
// substituted everywhere it's supposed to resolve (JS/CSS/HTML).
make(4, "[fullhash]", "[fullhash]", true),
make(5, "[fu... | fim | webpack/webpack | javascript |
<|fim_suffix|>exports = "chunk";
<|fim_prefix|>modu<|fim_middle|>le.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nk");
}
<|fim_prefix|>it("should compile and run the test", function () {});
if(Math.random() < -1) {
import(/* webpackC<|fim_middle|>hunkName: "chunk" */ "./chu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> = findOutputFiles(options, new RegExp(`^chunk${i}`))[0];
const chunkHash = /\.([a-f0-9]+)\.js$/.exec(chunk)[1];
allChunkHashes.add(chunkHash);
return `./${filename}`;
},
afterExecute: () => {
expect(allFilenameHashes.size).toBe(2);
expect(allChunkHashes.size).toBe(2);
}
};
<|fim_prefix|>"us... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
mode: "production",
name: "normal-ids",
output: {
filename: "bundle0.[contenthash:6].js",
chunkFilename: "chunk0.[contenthash:6].js"
},
optimization: {
chunkIds: "size",
moduleIds: "named"
}
},
{
mode:... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function test() {
const a = 1;
co<|fim_suffix|> e = 6;
return a + b + c + d + f + e;
}
<|fim_middle|>nst b = 2;
const c = 3;
const d = 4;
const f = 5;
const<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>asy<|fim_suffix|>;
const e = 6;
await import("./async.js");
return a + b + c + d + f + e;
}
test();
export { test }
export default test;
test();
<|fim_middle|>nc function test() {
const a = 1;
const b = 2;
const c = 3;
const d = 4;
const f = 5<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { test } from "./file-1.j<|fim_suffix|>unction foobar() {
return "test" + test();
}
<|fim_middle|>s";
export default f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
module.exports = "test";
<|fim_prefix|>function test() {
retu<|fim_middle|>rn "test";
}
test(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import file from "./file-1.js";
import file2 from "./file-2.js";
async function test() {
const a = 1;
const b = 2;
const c = 3;
const d = 4;
c<|fim_suffix|>(/* webpackMode: "eager" */"./async.js");
await import(/* webpackMode: "eager" */"./file-3.js");
return a + b + c + d + f + e;
}
test();
ex... | fim | webpack/webpack | javascript |
<|fim_suffix|>");
expect(typeof file).toBe("function");
});
<|fim_prefix|>import img from "./1.jpg";
import file from "./file.js";
it("should compile", () => {
expect(typeof img).toBe("strin<|fim_middle|>g<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const findOutputFiles = require("../../../helpers/findOutputFiles");
const allAssets =<|fim_suffix|>;
},
afterExecute: () => {
// Bundles have the same contenthash
expect(allBundles.size).toBe(1);
}
};
<|fim_middle|> new Set();
const allBundles = new Set();
module.exports = {
find... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = [
{
output: {
<|fim_suffix|>hash][ext]"
},
optimization: {
moduleIds: "size"
},
module: {
rules: [
{
test: /\.jpg$/,
type: "asset/resource"
}
]
}
}
];
<|fim_middle|> filename: "bu... | fim | webpack/webpack | javascript |
<|fim_prefix|>import img from "./img.jpg";
it("should comp<|fim_suffix|> {
expect(typeof img).toBe("string");
});
<|fim_middle|>ile", () =><|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>).toBe(2);
expect(allAssets.size).toBe(2);
}
};
<|fim_prefix|>"use strict";
const findOutputFiles = require("../../../helpers/findOutputFiles");
const allAssets = new Set();
const allBundles = new Set();
module.exports = {
findBundle(i, options) {
const bundle = findOutputFiles(options, new RegEx... | fim | webpack/webpack | javascript |
<|fim_suffix|>et/resource"
}
]
}
},
{
output: {
filename: "bundle2.[contenthash].js",
assetModuleFilename: "[name].[contenthash][ext]",
hashSalt: "2"
},
module: {
rules: [
{
test: /\.jpg$/,
type: "asset/resource"
}
]
}
}
];
<|fim_prefix|>"use strict";
/** @type {imp... | fim | webpack/webpack | javascript |
<|fim_suffix|>ault "a";
<|fim_prefix|>exp<|fim_middle|>ort def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export d<|fim_suffix|><|fim_middle|>efault "b";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export default<|fim_middle|> "c"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>async function loadModule(name) {
return import("./dir/" + name);
}
async function loadModuleWithExclude(name) {
return import(/* webpackExclude: /module-b\.js$/ */ "./dir/" + name);
}
async function loadModuleWithInclude(name) {
return import(/* webpackInclude: /module-b\.js$/ */ "./dir/" + name);
}... | fim | webpack/webpack | javascript |
<|fim_suffix|>*/
module.exports = {};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configurati<|fim_middle|>on} <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>eInContext("check-here/dont-check-here/file")).toThrow(/Cannot find module '.\/check-here\/dont-check-here\/file'/);
});
<|fim_prefix|>function requireInContext(someVariable) {
return require(`./some-dir/${someVariable}`);
}
it("should not exclude paths not matching the exclusion pattern", function() {
... | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = "thats good";
<|fim_prefix|>mod<|fim_middle|>ule.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ad";
<|fim_prefix|>modul<|fim_middle|>e.exports = "thats b<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports<|fim_suffix|> good";
<|fim_middle|> = "thats<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = "thats bad";
<|fim_prefix|>module.exp<|fim_middle|>o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exp<|fim_suffix|>"thats bad";
<|fim_middle|>orts = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = "that<|fim_suffix|>d";
<|fim_middle|>s goo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @<|fim_suffix|>nPlugin(/dont/)]
};
<|fim_middle|>type {import("../../../../").Configuration} */
module.exports = {
plugins: [new webpack.ContextExclusio<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
expect(JSON.parse(text)).toEqual({ foo: "bar" });
const otherLoadedMod = (await import(`./files/${mod}`, { with: { type: "json" } })).default;
expect(otherLoadedMod.foo).toBe("bar");
});
<|fim_prefix|>it("show override request", async () => {
const decoder = new Tex<|fim_middle|>tDecoder('utf-8');... | fim | webpack/webpack | javascript |
"use strict";
const supportsTextDecoder = require("../../../helpers/supportsTextDecoder");
module.exports = () => supportsTextDecoder();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {<|fim_suffix|>mport("../../../../").Configuration} */
module.exports = {};
<|fim_middle|>i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>", async () => {
expect((await load("a")).default).toBe("override/a");
});
<|fim_prefix|>const load = id => import(`app/${id}?query#hash`);
it("show override reque<|fim_middle|>st<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default "f<|fim_suffix|>
<|fim_middle|>oo/a";<|endoftext|> | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.