text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>turn 1;
}
<|fim_prefix|>export { existsSync } from "fs";
export function doSomething<|fim_middle|>WithFs() {
re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = function<|fim_suffix|>ber(process.versions.node.split(".")[0]);
return major >= 20;
};
<|fim_middle|> filter() {
const major = Num<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production<|fim_suffix|>true,
minimize: false
}
};
<|fim_middle|>",
target: "async-node",
externalsType: "module",
externals: {
fs: "module fs"
},
experiments: {
outputModule: true
},
optimization: ... | fim | webpack/webpack | javascript |
export default 1;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import imported from "./imported.mjs";
it("should allow to use externals in concatenated modules", (<|fim_suffix|>pect(imported).toBe(1);
});
export { imported }<|fim_middle|>) => {
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|> {
return "./main.mjs";
}
};
<|fim_middle|>module.exports = {
findBundle()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"[name].mjs",
module: true,
library: {
type: "module"
}
},
externals: "./imported.mjs",
externalsType: "module",
experiments: {
outputModule: true
},
optimization: {
concatenateModules: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
modu... | fim | webpack/webpack | javascript |
<|fim_suffix|>rom './lib'
it('should have correect reexport', () => {
expect(ns).toHaveProperty('readFile');
expect(ns).toHaveProperty('resolve');
expect(typeof ns.sep).toBe('string');
})<|fim_prefix|>i<|fim_middle|>mport * as ns f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// 2 external modules, the external module exportsType is unkown
// so the exports of current module can only be known at runtime
exp<|fim_suffix|>port * from 'fs'<|fim_middle|>ort * from 'path'
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nst: false
}
}
};
<|fim_prefix|>"use strict";
module.exports = {
target: ["node"],
output: {
environment: {
arrowFunction: tru<|fim_middle|>e,
co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rk with export a object", function(done) {
const myFs = require("fs");
expect(typeof myFs).toBe("object");
expect(myFs.readFileSync).toBeDefined();
done()
});<|fim_prefix|>it("Should work with export a function", function(done) {
const myModule = require("module");
expect(typeof myModule)<|fim_middl... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @ty<|fim_suffix|>ule",
fs: "commonjs fs"
}
};
<|fim_middle|>pe {import("../../../../types").Configuration} */
module.exports = {
externals: {
module: "commonjs mod<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>o'<|fim_prefix|>ex<|fim_middle|>port const foo = 'fo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import<|fim_suffix|>reateFakeNamespaceObjectRuntimeModule", async function(done) {
const myFs = await import("fs");
expect(typeof myFs).toBe("object");
expect(myFs.readFileSync).toBeDefined();
done()
});<|fim_middle|> { foo } from "./foo.mjs"
it("Should work with export a function when using CreateFa... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
externals: {
module: "commonjs modul<|fim_suffix|>monjs fs"
}
};
<|fim_middle|>e",
fs: "com<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ED);
});
<|fim_prefix|>it("shoul<|fim_middle|>d not fail on optional externals", function() {
const external = require("external");
expect(external).toBe(EXPECT<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>const webpack = require("../../../../");
/** @type {import("../../../../types").Configuration[]} */
module.exports = [
{
output: {
libraryTarget: "global"
},
externals: {
external: ["process", "version"]
},
plugins: [
new webpack.DefinePlugin({
EXPECTED: JSON.stringify(process.ver... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
import { join, __WEBPACK_EXTERNAL_MODULE_path_join__ as collision } from "./nested";
const nodePath = requir<|fim_suffix|>n).toBe(nodePath.join);
expect(collision).toBe("collision");
});
<|fim_middle|>e("path");
it("should handle naming conflict and trigger ExternalsPlugin remapping", ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
import { join } from "path";
export { join };
export const __WEBPACK_EXTERNAL_MODULE_path_jo<|fim_suffix|>n__ = "collision";
<|fim_middle|>i<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = () => {
const majorVersion = Number.parseInt(process.versions.node.split(".")[0], 10);
return majorVersion >= 14;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode:<|fim_suffix|>zation: {
minimize: false,
concatenateModules: true
},
externals: {
path: "module path"
},
externalsType: "module",
experiments: {
outputModule: true
},
output: {
module: true,
libr... | fim | webpack/webpack | javascript |
<|fim_prefix|>exports.a = require("external");
exports.b =<|fim_suffix|>ort("./chunk2");
<|fim_middle|> imp<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = require("external2");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should move externals in chunks into entry chunk", function(done) {
var fs = require("fs");
var source = f<|fim_suffix|>.b.then(function(chunk2) {
expect(chunk2.default).toBe(7);
import("external3").then(function(ex) {
expect(ex.default).toBe(11);
done();
});
});
});
});
<|fim_mi... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";<|fim_suffix|>: "5+6"
},
node: {
__dirname: false,
__filename: false
}
};
<|fim_middle|>
/** @type {import("../../../../").Configuration} */
module.exports = {
externals: {
external: "1+2",
external2: "3+4",
external3<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not move externals into the commons chunk", function() {
var fs = require("fs");
var source1 = fs.readFileSync(__d<|fim_suffix|>quire("external2");
require("./module");
});
<|fim_middle|>irname + "/main.js", "utf-8");
var source2 = fs.readFileSync(__dirname + "/other.js", "utf-8... | fim | webpack/webpack | javascript |
<|fim_suffix|>");
require("./module");
<|fim_prefix|>require("external");
require("extern<|fim_middle|>al3<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./common.js", "./main.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> external: "1+2",
external2: "3+4",
external3: "5+6"
},
target: "web",
output: {
filename: "[name].js"
},
node: {
__dirname: false,
__filename: false
},
optimization: {
minimize: false,
splitChunks: {
cacheGroups: {
common: {
chunks: "initial",
minSize: 0,
name: ... | fim | webpack/webpack | javascript |
<|fim_suffix|>efault export");
expect(external5.namedThing).toBe("the external5 named export");
});
<|fim_prefix|>import external3Default, { namedThing } from "external3";
import "external4";
/* This test verifies that webpack externals are properly indicated as dependencies to System.
* Also that when System provid... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from "external5";
export { <|fim_suffix|>ult } from "external5";
<|fim_middle|>defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const System = require("../../../helpers/fakeSystem");
module.exports = {
beforeExecute: () => {
System.init({
external1: {
default: "the external1 value"
},
external2: {
default: "the external2 value"
},
external3: {
default: "the external3 default export",
... | fim | webpack/webpack | javascript |
<|fim_suffix|>l3: "external3",
external4: "external4",
external5: "external5"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
mo<|fim_middle|>dule.exports = {
output: {
libraryTarget: "system"
},
externals: {
external1: "external1",
external2: "external2",
externa<|... | fim | webpack/webpack | javascript |
<|fim_prefix|>// This test verif<|fim_suffix|>andle externals of different type", function() {
expect(require("rootExt")).toEqual("works");
expect(require("varExt")).toEqual("works");
expect(require("windowExt")).toEqual("works");
});
<|fim_middle|>ies that the System.register context is made available to webpack bu... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const System = require("../../../helpers/fakeSystem");
module.exports = {
target: "web",
beforeExecute: () => <|fim_suffix|>eScope(scope) {
scope.window.windowExt = "works";
scope.rootExt = "works";
scope.varExt = "works";
scope.System = System;
},
afterExecute: () => {
Syste... | fim | webpack/webpack | javascript |
<|fim_suffix|>,
externals: {
rootExt: "root rootExt",
varExt: "var varExt",
windowExt: "window windowExt"
}
};
<|fim_prefix|>"use strict<|fim_middle|>";
/** @type {import("../../../../types").Configuration} */
module.exports = {
output: {
libraryTarget: "system"
},
target: "web",
node: {
__dirname: fal... | fim | webpack/webpack | javascript |
<|fim_suffix|>-next-line n/no-missing-require
const result = require("external");
expect(result).toBe(42);
});
<|fim_prefix|>afterEach(done => {
delete global.EXTERNAL_TEST_GLOBAL;
done();
});
it("should move externals in chunks int<|fim_middle|>o entry chunk", function() {
global.EXTERNAL_TEST_GLOBAL = 42;
// e... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configurat<|fim_suffix|>dule.exports = {
externals: {
external: "global EXTERNAL_TEST_GLOBAL"
}
};
<|fim_middle|>ion} */
mo<|endoftext|> | fim | webpack/webpack | javascript |
import external from "external";
it("should harmony import a dependency", function() {
expect(external).toBe("abc");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../.<|fim_suffix|>exports = {
externals: {
external: "var 'abc'"
}
};
<|fim_middle|>./").Configuration} */
module.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rPkg.default.foo).toBe("eager");
await import("./weak.json", {
assert: { type: "json" }
});
const weakPkg = await import(/* webpackMode: "weak" */ "./weak.json", {
assert: { type: "json" }
});
expect(weakPkg.default.foo).toBe("weak");
const pkg = "pkg.json";
const nested = await import(`./ne... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from "./<|fim_suffix|>rt { type: "json" };
<|fim_middle|>re-export.json" asse<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"<|fim_suffix|>s = () => /^v(?:1[6-9]|21)/.test(process.version);
<|fim_middle|>use strict";
module.export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "eager.json",
"weak.json",
"./nested/pkg.json",
"re-export.json",
"re-export-directly.json"
]) {
const resolvedFilename = path.resolve(__dirname, filename);
const content = fs.readFileSync(resolvedFilename);
compilation.emitAsset(
fi... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as staticPkg from "./static-package.json" with { type: "json" };
import * as staticPkgStr from "./static-package-str.json" with { "type": "json" };
import * as staticPkgModuleImport from "./static-package-module-import.json" with { "type": "json" };
it("should allow async externals", async () =>... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from "./re<|fim_suffix|>n" with { type: "json" };
<|fim_middle|>-export.jso<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/^v2[2-9]/.test(process.version);
<|fim_prefix|>"use strict";
<|fim_middle|>module.exports = () => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>tr.json": "import ./dynamic-package-str.json",
"./eager.json": "import ./eager.json",
"./weak.json": "import ./weak.json",
"./pkg.json": "import ./pkg.json",
"./pkg": "import ./pkg.json",
"./re-export.json": "module ./re-export.json",
"./re-export-directly.json": "module ./re-export-directly.j... | fim | webpack/webpack | javascript |
<|fim_suffix|> from "external2";
export const readFile = external.readFile;
export const readFileSync = external2.readFileSync;
<|fim_prefix|>impo<|fim_middle|>rt external from "external";
import external2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ternal"]).toBeDefined();
expect(__webpack_modules__["external2"]).toBeDefined();
expect(ns.readFileSync).toBe(fs.readFileSync);
expect(ns.readFile).toBe(fs.readFile);
import("external3").then((ns) => {
expect(ns.writeFile).toBe(fs.writeFile);
done();
});
});
});
<|fim_prefix|>it("Should... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsRequireInModule = require("../../../helpers/<|fim_suffix|>supportsRequireInModule();
<|fim_middle|>supportsRequireInModule");
module.exports = () => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
externals: {
external: "fs",
external2: "node:fs",
external3: "fs"
},
exter<|fim_suffix|>ation: {
moduleIds: "named",
concatenateModules: false
}
};
<|fim_middle|>nalsType: "module-import",
experiments: {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import external0 from "external0"; // module
const external1 = require("external1"); // module
const external2 = require("external2"); // node-commonjs
import external3_1 from "external3";<|fim_suffix|>.log(external0, external1, external3_1, external3_2);
console.log(internalHelper(), internalConstant);
... | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = require("path");
it("module-import should correctly get fallback type", function() {
const content = fs.readFileSync(path.resolve(__dirname, "a.js"), "utf-8");
expect(content).toContain(`import { default as __WEBPACK_EXTERNAL_MODULE_external0_default__ } from "e<|... | fim | webpack/webpack | javascript |
<|fim_suffix|>ternalHelper() {
return "internal";
}
export const internalConstant = 100;<|fim_prefix|>// Trigger c<|fim_middle|>oncatenation with a.js
export function in<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>=> ["main.js"]
};
<|fim_prefix|>"use strict";
module.exports = {
<|fim_middle|> findBundle: () <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
ta<|fim_suffix|> outputModule: true
},
externalsType: "module-import",
externals: [
function externals({ request }, callback) {
if (request === "external2") {
return callback(null, "node-commonjs exter... | fim | webpack/webpack | javascript |
<|fim_prefix|>function getMajorVersion(versionStr) {
const match = versionStr.match(/^v?(\d+)\./);
if (match) {
return parseInt(match[1], 10);
}
return null;
}
it("should not fail on optional externa<|fim_suffix|> // The behavior of jest mock's require is different from that of node require, so it works fine he... | fim | webpack/webpack | javascript |
<|fim_suffix|>]
};
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../types").Configuration} */
module.exports = {
output: {
libraryTarget: "commonjs2"
},
externals: {
external: ["webpack", "version"]
},
plugins: [
new webpack.Defi<|fim_middle|>nePlugin({
... | fim | webpack/webpack | javascript |
<|fim_prefix|>var fs = require("fs");
var path = require("path");
var dependencyArrayRegex = /define\((\[[^\]]*\]), (function)?\(/;
var source = fs.readFileSync(path.join(__dirname, "bundle0.js"), "utf-8");
var [, deps] = dependencyArrayRegex.exec(source);
it("should correctly import a AMD external", function() {
va... | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
modules: {
external0: "module 0"
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> require(dep))); }\n"
})
]
};
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
libraryTarget: "amd"
},
externals: {
external0: "external0"<|fim_middle|>,
external1: "var 'abc'"
},
node: {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>var fs =<|fim_suffix|>ect(external).toBe("module 0");
});
it("should contain `require()` statements for the UMD external", function() {
var source = fs.readFileSync(path.join(__dirname, "bundle0.js"), "utf-8");
expect(source).toMatch("require(\"external0\")");
});
it("should correctly import a non-UMD... | fim | webpack/webpack | javascript |
<|fim_suffix|>
external0: "module 0"
}
};
<|fim_prefix|>"use strict";
module.exports = {
modules: <|fim_middle|>{<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>bc'"
},
node: {
__dirname: false,
__filename: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
libraryTarget: "umd"
}<|fim_middle|>,
externals: {
external0: "external0",
external1: "var 'a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var fs = require("fs");
var path = require("path");
it("should correctly import a UMD2 external", function() {
var external = require("external0");
expect(external).toBe("module 0");
});
it("should contain `require()` statements for the UMD2 external", function() {
var source = fs.readFileSync(path.j... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
modules: {
external0: "module 0<|fim_suffix|>};
<|fim_middle|>"
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>1: "var 'abc'"
},
node: {
__dirname: false,
__filename: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../..<|fim_middle|>/").Configuration} */
module.exports = {
output: {
libraryTarget: "umd2"
},
externals: {
external0: "external0",
external<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Error);
expect(e.code).toBe("MODULE_NOT_FOUND");
return;
}
throw new Error("It doesn't fail");
});
<|fim_prefix|>it("should not <|fim_middle|>fail on optional externals", function() {
try {
require("external");
} catch(e) {
expect(e).toBeInstanceOf(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nfiguration} */
module.exports = {
output: {
libraryTarget: "commonjs2"
},
externals: {
external: "external"
}
};
<|fim_prefix|>"use st<|fim_middle|>rict";
/** @type {import("../../../../").Co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>oBe("MODULE_NOT_FOUND");
return;
}
throw new Error("It doesn't fail");
});
<|fim_prefix|>it("should not fail on optional ext<|fim_middle|>ernals", function() {
try {
require("external");
} catch(e) {
expect(e).toBeInstanceOf(Error);
expect(e.code).t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */<|fim_suffix|> {
external: "external"
}
};
<|fim_middle|>
module.exports = {
externalsType: "var",
externals:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not fail on optional externals", function() {
try {
require("external");
} catch<|fim_suffix|>;
<|fim_middle|>(e) {
expect(e).toBeInstanceOf(Error);
expect(e.code).toBe("MODULE_NOT_FOUND");
return;
}
throw new Error("It doesn't fail");
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>al: "external"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
libraryTarget: "umd"
},
exte<|fim_middle|>rnals: {
extern<|endoftext|> | fim | webpack/webpack | javascript |
it("should not fail on optional externals", function() {
try {
require("external");
} catch(e) {
expect(e).toBeInstanceOf(Error);
expect(e.code).toBe("MODULE_NOT_FOUND");
return;
}
throw new Error("It doesn't fail");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
libraryTarget: "umd2"
},
externals: {
external<|fim_middle|>: "external"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>it("should not fail on optional externals", function() {
require("external2");
try {
require("external");
} catch(e) {
expect(e<|fim_middle|>).toBeInstanceOf(Error);
expect(e.code).toBe("MODULE_NOT_FOUND");
return;
}
throw new Error("It doesn't fail");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Con<|fim_suffix|>t: {
libraryTarget: "umd2"
},
externals: {
external: "external",
external2: "fs"
}
};
<|fim_middle|>figuration} */
module.exports = {
outpu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// Sync `var` external — defer should produce a `/* deferred harmony import */`
// runtime statement because `buildMeta.async` is not set.
import * as syncDeferNs from /* webpackDefer: true */ "ext-var-sync";
// Async `promise` external —<|fim_suffix|>c (`buildMeta.async === true`).
import * as asyncDefe... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>"use strict";
const fs = require("fs");
const <|fim_middle|>path = require("path");
const bundle = path.resolve(__dirname, "bundle.js");
it("should generate a deferred runtime import for a sync external", () => {
const content = fs.readFileSync(bundle, "utf-8");
expect(content).toCon... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stri<|fim_suffix|>;
module.exports = (options) => {
const opt = Array.isArray(options) ? options[0] : options;
if (opt && opt.cache && opt.cache.type === "filesystem") {
return [/Pack got invalid because of write to/];
}
return [];
};
<|fim_middle|>ct"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>"use stric<|fim_middle|>t";
module.exports = {
findBundle: () => ["main.js"]
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>xt-promise-async": "promise Promise.resolve('async-value')"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exp<|fim_middle|>orts = {
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: {
main: "./index.js",
bundle: "./bundle... | fim | webpack/webpack | javascript |
// `module` externals — static phase imports become real native
// `import defer * as …` / `import source … from …` statements.
import defer * as modDeferNs from "ext-mod-defer";
import source modSrcDefault from "ext-mod-source";
// `import` externals — dynamic `import.defer(…)` / `import.source(…)`.
const importDefer... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const fs = require("fs");
const pa<|fim_suffix|>.toMatch(
/import defer \* as __WEBPACK_EXTERNAL_MODULE_ext_both_phases\w* from "ext-both-phases";/
);
expect(content).toMatch(
/import source __WEBPACK_EXTERNAL_MODULE_ext_both_phases\w* from "ext-both-phases";/
);
});
<|fim_middle|>th... | fim | webpack/webpack | javascript |
<|fim_suffix|>> ["main.js"]
};
<|fim_prefix|>"us<|fim_middle|>e strict";
module.exports = {
findBundle: () =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rnals — used at dynamic `import(…)` sites.
"ext-import-defer": "import ext-import-defer",
"ext-import-source": "import ext-import-source",
// `module-import` externals resolve to `module` for static imports
// and to `import` for dynamic imports based on the consumer.
"ext-mi-defer-static":... | fim | webpack/webpack | javascript |
<|fim_suffix|>c };
<|fim_prefix|>// Source-phase static import of a sync `var` external.
import source srcSync from "ext-var-sync";
// Source-phase static import of an async `promise` external.
import source srcAsync f<|fim_middle|>rom "ext-promise-async";
export { srcSync, srcAsyn<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const fs = require("fs");
const path = require("path");
it("should generate runtime code for source-phase imports of externals", () => {
const content = fs.readFileSync(
path.resolve(__dirname, "bundle.js"),
"utf-8"
);
// The init-fragment key <|fim_suffix|> regular harmony
// imp... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
find<|fim_suffix|>> ["main.js"]
};
<|fim_middle|>Bundle: () =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mise Promise.resolve('async-value')"
}
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = [
{
target: [`async-node${process.versions.node.split(".").map(Number)[0]}`],
entry: {
main: "./index.js",
bundle: "./bundle.js"
},
output: {
f... | fim | webpack/webpack | javascript |
<|fim_prefix|>import http from "http";
it("prefer provided over built-in", () => {
expect(ht<|fim_suffix|>;
<|fim_middle|>tp).toBe(3);
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>",
externals: {
http: "1+2"
}
};
<|fim_prefix|>"<|fim_middle|>use strict";
module.exports = {
target: "node<|endoftext|> | fim | webpack/webpack | javascript |
it("should allow functions as externals with promise and resolver", function () {
const result = require("external");
expect(result).toMatch(/^[a-z]:\\|\//i);
expect(result).toMatch(/resolve.node_modules.external\.js$/);
const result2 = require("external-promise");
expect(result2).toMatch(/^[a-z]:\\|\//i);
expect... | fim | webpack/webpack | javascript |
<|fim_suffix|>ternalItemFunctionDataGetResolve} */
(getResolve)()
);
const resolved = await resolve(/** @type {string} */ (context), request);
return `var ${JSON.stringify(resolved)}`;
}
]
};
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").ExternalItemFunctionData} ExternalItemFuncti... | fim | webpack/webpack | javascript |
<|fim_suffix|>lback.node_modules.external\.js$/);
const result1 = require("external-false");
expect(JSON.stringify(result1)).toBe('{}');
});
<|fim_prefix|>it("should allow functions as externals with promise and resolver", function () {
const result = require("external");
expect(result).toMatch(/^[a-z]:\\|\//i);
e... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use s<|fim_suffix|>lItemFunctionData} ExternalItemFunctionData */
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
concatenateModules: true
},
externals: [
({ context: _context, request, getResolve }, callback) => {
if (request !== "external" && request !=... | fim | webpack/webpack | javascript |
<|fim_prefix|>afterEach(done => {
(function() { delete this.EXTERNAL_TEST_GLOBAL; })();
done();
});
it("should import an external value ass<|fim_suffix|>require
const result = require("external");
expect(result).toBe(42);
});
<|fim_middle|>igned to global this", function() {
(function() { this.EXTERNAL_TEST_GLOBA... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
concatenateModules: true
},
externals: {
external: "this EXTERNAL_TEST_GLOBAL"
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>es.toMatchObject({ default: 1 });
});
<|fim_prefix|>it("should be able to load a chunk", async () => {
await expect(
import(/* webpackChun<|fim_middle|>kName: "1" */ "./chunk1")
).resolv<|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.