text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import url from "../_images/file.png";
it("should interpolate multiple [fullhash] and [fullhash:N] in output.publicPath", () => {
const match = url.match(
/^<|fim_suffix|>;
});
<|fim_middle|>c\/([a-f0-9]+)\/sub\/([a-f0-9]{6})\/file\.png$/
);
expect(match).not.toBeNull();
const [, full, full6] = /**... | fim | webpack/webpack | javascript |
import url from "../_images/file.png";
it("should support function-form output.publicPath consuming data.hash", () => {
expect(url).toMatch(/^fnhash\/[a-f0-9]+\/file\.png$/);
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>\/[a-f0-9]{8}\/file\.png$/);
});
<|fim_prefix|>import url from "../_images/file.png";
it("should su<|fim_middle|>pport function-form output.publicPath returning a string with [fullhash:N]", () => {
expect(url).toMatch(/^fnph<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "../_images/file.png";
it("should support function-form output.publicPath returning a plain string", () => {
expect(<|fim_suffix|>l).toBe("fnstr/file.png");
});
<|fim_middle|>ur<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ng$/);
});
<|fim_prefix|>import url from "../_images/file.png";
it("should interpolate [<|fim_middle|>fullhash] in output.publicPath", () => {
expect(url).toMatch(/^fh\/[a-f0-9]+\/file\.p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "../_images/file.png";
it("should interpolate [fullhash:N] in output.<|fim_suffix|>ct(url).toMatch(/^fhl\/[a-f0-9]{8}\/file\.png$/);
});
<|fim_middle|>publicPath", () => {
expe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import url fro<|fim_suffix|>file.png";
it("should support plain string output.publicPath", () => {
expect(url).toBe("plain/file.png");
});
<|fim_middle|>m "../_images/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports =<|fim_suffix|>d.js",
"./fnString.js",
"./fnHash.js",
"./fnPlaceholder.js"
];
}
};
<|fim_middle|> {
findBundle() {
return [
"./plain.js",
"./fullhash.js",
"./fullhashLen.js",
"./combine<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
target: "web",
entry:<|fim_suffix|>blicPath: (data) => `fnhash/${data.hash}/`
},
fnPlaceholder: {
import: "./fnPlaceholder.js",
publicPath: () => "fnph/[fullhash:8]/"
}
},
output: {
... | fim | webpack/webpack | javascript |
import url from "../_images/file.png";
import index from "../_static/file.html";
it("should output asset with path", () => {
expect(url).toEqual("images/file.png");
expect(index).toEqual("static/index.html");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>png$/,
type: "asset"
},
{
test: /\.html$/,
type: "asset/resource",
generator: {
filename: "static/index.html"
}
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
assetModuleFi... | fim | webpack/webpack | javascript |
<|fim_suffix|>});
<|fim_prefix|>import url from "../_images/file.png";
it("should output asset with path", () => {
expect(url).toEqual("ima<|fim_middle|>ges/file.png");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode<|fim_suffix|>ule: {
rules: [
{
test: /\.png$/,
type: "asset"
}
]
}
};
<|fim_middle|>: "development",
output: {
assetModuleFilename: "images/file[ext]"
},
mod<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import <|fim_suffix|>/file.png");
});
<|fim_middle|>url from "../_images/file.png";
it("should import asset with correct publicPath", () => {
expect(url).toEqual("assets<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
publicPath: "assets/",
assetModuleFilename: "fi<|fim_suffix|>lateLiteral: true
}
},
module: {
rules: [
{
test: /\.png$/,
type: "asset"
}
]
}
};
<|fim_middle|>le... | fim | webpack/webpack | javascript |
<|fim_prefix|>import png from "../_images/file.png?foo=bar";
import svg from "../_images/file.svg";
import jpg from "../_images/file.jpg?foo=bar#hash";
it("should output various asset typ<|fim_suffix|>Contain("data:image/png;base64,");
expect(svg).toMatch(/^[\da-f]{20}\.svg$/);
expect(jpg).toContain("data:image/jpeg... | fim | webpack/webpack | javascript |
<|fim_suffix|>OptionsByModuleTypeKnown */
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
module: {
rules: [
{
test: /\.(png|svg|jpg)$/,
type: "asset",
/** @type {ParserOptionsByModuleTypeKnown['asset']} */
parser: {
dataUrlCondition: (source, { f... | fim | webpack/webpack | javascript |
<|fim_suffix|>jpeg;base64,[0-9a-zA-Z+/]+=*$/);
});
<|fim_prefix|>import png from "../_imag<|fim_middle|>es/file.png";
import svg from "../_images/file.svg?foo=bar";
import jpg from "../_images/file.jpg";
it("should output various asset types", () => {
expect(png).toMatch(/^data:image\/png;base64,[0-9a-zA-Z+/]+=*$/);
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const svgToMiniDataURI = require("mini-svg-data-uri");
const mimeType<|fim_suffix|>peKnown */
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
module: {
rules: [
{
test: /\.(png|svg|jpg)$/,
type: "asset/inline",
/** @type {Gener... | fim | webpack/webpack | javascript |
<|fim_prefix|>import png from "../_images/file.png?foo=bar";
import svg from "../_images/file.svg?";
import jpg from "../_images/file.jpg?foo=bar#hash";
import copy from "../_images/file_copy.png#hash";
import fs from "fs";
it("should output various asset types", () => {
expect(png).toMatch(/^[\da-f]{20}\.png\?foo=ba... | fim | webpack/webpack | javascript |
<|fim_suffix|> type: "asset/resource"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
environment: {
templateLiteral: false
}
<|fim_middle|> },
module: {
rules: [
{
test: /\.(png|svg|jpg)$/,
<|endofte... | fim | webpack/webpack | javascript |
import a from "../_images/file.png";
import b from "../_images/file_copy.png";
it("should use a real content hash for assets", () => {
expect(a).toBe(b);
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
publicPath: "assets/",
assetModuleFilename: "file[ext]"
},
module: {
rules: [
{
<|fim_suffix|> type: "asset/resource"
}
]
}
};
<|fim_middle|> test: /\.png$/,
<|endo... | fim | webpack/webpack | javascript |
<|fim_prefix|>import asset from <|fim_suffix|>]{20}\.[0-9a-zA-Z]{8}\.svg/);
});
<|fim_middle|>"data:image/svg+xml;utf8,<svg><title>icon-square-small</title></svg>"
it("should compile with correct filename", () => {
expect(asset).toMatch(/public\/media\/[0-9a-zA-Z<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = {
output: {
assetModuleFilename: "media/[name].[contenthash:8][ext]",
publicPath: "public/"
},
module: {
rules: [
{
mimetype: "image/svg+xml",
type: "asset/resource"
}
]
},
target: "web"
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../")<|fim_middle|>.Config... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "../_images/file.png";
import fs from "fs";
import path from "path";
it("should emit asset with module.generator.asset.outputPath", () => {
expect(url).toEqual("ht<|fim_suffix|>S__.outputPath, "cdn-assets/file.png")
expect(fs.existsSync(emitPath)).toBe(true);
});
<|fim_middle|>tps://cdn... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configu<|fim_suffix|>: /\.png$/,
type: "asset/resource",
generator: {
publicPath: "https://cdn/assets/",
outputPath: "cdn-assets/"
}
}
]
}
};
<|fim_middle|>ration} */
module.exports = {
mode: "development",
output: {
assetMod... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "../_images/file.png";
it("should import ass<|fim_suffix|>("assets/file.png");
});
<|fim_middle|>et with rule.generator.publicPath", () => {
expect(url).toEqual<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configur<|fim_suffix|> assetModuleFilename: "file[ext]"
},
module: {
rules: [
{
test: /\.png$/,
type: "asset",
generator: {
publicPath: () => "assets/"
}
}
]
}
};
<|fim_middle|>ation} */
module.exports = {
mode: "developme... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "../_images/file.png";
it("should import asset with empt<|fim_suffix|>e.png");
});
<|fim_middle|>y string rule.generator.publicPath", () => {
expect(url).toEqual("fil<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
mode: "development",
output: {
assetModuleFilename: "file[ext]",
publicPath: "assets/"
},
module: {
rules: [
{
test: /\.png$/,
type: "asset",
generator: {
publicPath: ""
}
}
]
}
};
<|endoft... | fim | webpack/webpack | javascript |
<|fim_suffix|> in rule.generator.publicPath", () => {
expect(jpgUrl).toMatch(new RegExp(`^jpg/${HEX}{10}/file\\.jpg/file\\.jpg$`));
});
it("should interpolate placeholders for non-png assets (.svg) in rule.generator.publicPath", () => {
expect(svgUrl).toMatch(new RegExp(`^svg/${HEX}+/\\.svg/file\\.svg$`));
});
<|fim... | fim | webpack/webpack | javascript |
<|fim_suffix|>fn/[contenthash:8]/"
}
},
{
test: /\.png$/,
resourceQuery: /^\?combined$/,
type: "asset/resource",
generator: {
publicPath: "c/[runtime]/[id]/[contenthash:6]/"
}
},
{
test: /\.jpg$/,
type: "asset/resource",
generator: {
publicPath: "jpg/[contenthas... | fim | webpack/webpack | javascript |
<|fim_prefix|>import svg from "../_images/file.svg";
it("sho<|fim_suffix|>asset source", () => {
expect(svg).toMatch(/^<svg.+<\/svg>\s*$/);
});
<|fim_middle|>uld receive <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
module: {
rules<|fim_middle|>: [
{
test: /\.svg$/,
type: "asset/source"
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Match(/^<svg.+<\/svg>\s*$/);
});
<|fim_prefix|>import svg from "../_images/file.svg" with { type: "text" };
it("should receive asset source", () => {
expec<|fim_middle|>t(svg).to<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} *<|fim_suffix|>};
<|fim_middle|>/
module.exports = {<|endoftext|> | fim | webpack/webpack | javascript |
// This file contains invalid JavaScript on purpose.
// When imported with { type: "text" }, it should be treated as a string, not parsed as JS.
invalid { javascript
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>(typeof value).toBe("string");
expect(value).toContain("invalid { javascript");
});
<|fim_prefix|>import value from "./fixture.js" with { type: "text" };
it("should import .js file as text string when usin<|fim_middle|>g with { type: 'text' }", () => {
expect<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ch(/^[\da-f]{20}\.png$/);
expect(svg).toMatch(/^[\da-f]{20}\.svg$/);
expect(jpg).toMatch(/^[\da-f]{20}\.jpg$/);
});
<|fim_prefix|>import png from "../_images/file.png";
import svg from ".<|fim_middle|>./_images/file.svg";
import jpg from "../_images/file.jpg";
it("should output various asset types", ()... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").C<|fim_suffix|> "development",
module: {
rules: [
{
test: /\.(png|svg)$/,
type: "asset/resource"
},
{
test: /\.jpg$/,
type: "asset/resource"
}
]
}
};
<|fim_middle|>onfiguration} */
module.exports = {
mode:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "<|fim_suffix|>"should create a data url", () => {
expect(url.protocol).toBe("data:");
});
<|fim_middle|>package";
it(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ode: "development",
module: {
rules: [
{
dependency: "url",
type: "asset"
}
]
}
};
<|fim_prefix|>"u<|fim_middle|>se strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle import.meta.url in URL()", () => {
const url = new URL("./index.css?query=yes#fragment", import.meta.url);
expect(url.href).toBe("publ<|fim_suffix|>me).toBe("");
expect(url.port).toBe("");
expect(url.pathname).toBe("public/index.css");
expect(url.search).toBe("?query=yes");
expect... | fim | webpack/webpack | javascript |
<|fim_suffix|>n} */
module.exports = {
mode: "development",
devtool: false,
output: {
assetModuleFilename: "[name][ext][query][fragment]",
publicPath: "public/"
},
module: {
parser: {
javascript: {
url: "relative"
}
}
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configu<|f... | fim | webpack/webpack | javascript |
<|fim_prefix|>const currentDir = require("url").pathToFileURL(__dirname);<|fim_suffix|>ndex.css");
});
<|fim_middle|>
it("should handle import.meta.url in URL()", () => {
const {href} = new URL("./index.css", import.meta.url);
expect(href).toBe(currentDir + "/public/i<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
target: "node",
devtool: false,
output: {
assetModuleFilename: "[name][ext]",
publicPath: "public/"
},
module: {
rules: [
{
test: /\.css$/,
dependency: ["esm", "commonjs"],
loader: "url-... | fim | webpack/webpack | javascript |
<|fim_suffix|>
});
<|fim_prefix|>const currentDir = require("url").pathToFileURL(__dirname);
it("should handle import.meta.url in URL()", () => {
const {href} = new URL("./i<|fim_middle|>ndex.css", import.meta.url);
expect(href).toBe(currentDir + "/index.css");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration}<|fim_suffix|>lse,
output: {
assetModuleFilename: "[name][ext]"
}
};
<|fim_middle|> */
module.exports = {
mode: "development",
target: "node",
devtool: fa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle import.meta.url in URL()", () => {
(<|fim_suffix|>t { href } = new MyURL("./index.css", import.meta.url);
expect(href).toBe("https://example.com/index.css");
})(URL, function () {
throw new Error("should not be called");
});
});
<|fim_middle|>(MyURL, URL) => {
cons<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>odule.exports = {
mode: "development",
target: "node",
devtool: false,
output: {
assetModuleFilename: "[name][ext]",
publicPath: "https://example.com/"
}
};
<|fim_prefix|>"use strict";
<|fim_middle|>/** @type {import("../../../../").Configuration} */
m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle impor<|fim_suffix|>port.meta.url);
expect(href).toBe("https://test.cases/path/index.css");
});
<|fim_middle|>t.meta.url in URL()", () => {
const {href} = new URL("./index.css", im<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ame][ext]"
},
module: {
rules: [
{
test: /\.css$/,
dependency: "url",
loader: "url-loader"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
target: "web",
devtool: false,
output: {
assetModuleFi... | fim | webpack/webpack | javascript |
<|fim_suffix|>nsole.log(1);
<|fim_prefix|>c<|fim_middle|>o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle import.meta.url in URL()",<|fim_suffix|>hs in URL()", () => {
const { href } = new URL("a.js", import.meta.url);
expect(href).toBe("https://test.cases/path2/a.js");
});
<|fim_middle|> () => {
const { href } = new URL("./a.js", import.meta.url);
expect(href).toBe("https://test.cases... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
target: "web",
devtool: false,
output: {
<|fim_suffix|>me][ext]",
publicPath: "/path2/"
}
};
<|fim_middle|> assetModuleFilename: "[na<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>st.cases/custom/inner/a.js");
});
<|fim_prefix|>it("should handle import.meta.url in URL()<|fim_middle|>", () => {
const { href } = new URL("./inner/a.js", import.meta.url);
expect(href).toBe("https://te<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>console.l<|fim_suffix|>);
<|fim_middle|>og(1<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>scope) {
scope.self.location = "https://test.cases/custom/deep/path/main.js";
},
findBundle() {
return "./deep/path/main.js";
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleSco<|fim_middle|>pe(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>""
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
target: "webworker",
devtool: false,
output: {
filename: "deep/path/[name].js",
assetModuleFilename: "[path]<|fim_middle|>[name][ext]",
publicPath: <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should handle import.meta.url in URL()", () => {
const {<|fim_suffix|>;
<|fim_middle|>href} = new URL("./index.css", import.meta.url);
expect(href).toBe("https://test.cases/index.css");
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "[name][ext]",
publicPath: "/"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration}<|fim_middle|> */
module.exports = {
mode: "development",
target: "webworker",
devtool: false,
output: {
assetModuleFilename:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "test";
<|fim_prefix|>export defau<|fim_middle|>lt<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e("body { color: red; }");
const htmlFile = (await import(/* webpackIgnore: true */ "./file.html", { with: { type: "bytes" } })).default;
const htmlFileContent = decoder.decode(htmlFile);
expect(htmlFileContent.trim()).toBe("<div>test</div>");
});
<|fim_prefix|>it("should work", async () => {
const ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsTypeBytes = require("<|fim_suffix|>ports = () => supportsTypeBytes();
<|fim_middle|>../../../helpers/supportsTypeBytes");
module.ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
/** @typedef {import("../../../../lib/util/fs").InputFileSystem} InputFileSystem */
/** @typedef {import("../../../../lib/util/fs").ReadFileSync} ReadFileSync */
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
dev... | fim | webpack/webpack | javascript |
<|fim_suffix|>e"));
<|fim_prefix|>it("shou<|fim_middle|>ld run", () => import("./modul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const Source = require("webpack-sources").Source;
const Compilation = require("../../../../").Compilation;
/** @type {import("../../../../").Configuration} */
module.exports = {
plugins: [
(compiler) => {
/** @type {Record<string, boolean>} */
const files = {};
compiler.hooks.a... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default fun<|fim_suffix|>
} <|fim_middle|>ction add(a, b) {
return a + b;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.toBeDefined();
}); <|fim_prefix|>/**! Main */
it("should handle asset deletion correctly during compression", async () => {
const { defa<|fim_middle|>ult: add } = await import("./chunk.js");
expect(add(1, 2)).toBe(3);
});
it("should not fail when accessing compressed assets", async () => {
await exp... | fim | webpack/webpack | javascript |
<|fim_suffix|>nst manifest = {
"main.js": "/main.js",
"main.js.map": "/main.js.map"
};
compilation.emitAsset(
"asset-manifest.json",
new (require("../../../../").sources.RawSource)(
JSON.stringify(manifest, null, 2)
)
);
}
);
}
);
... | fim | webpack/webpack | javascript |
<|fim_suffix|>*/
console.log("Fail");
<|fim_prefix|>/**! Ch<|fim_middle|>unk <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sole.log("Fail");
<|fim_prefix|><|fim_middle|>/**! Chunk */
con<|endoftext|> | fim | webpack/webpack | javascript |
/**! Main */
it("should fail loading a deleted asset", async () => {
await expect(import("./chunk.js")).rejects.toEqual(
expect.objectContaining({
code: "ENOENT"
})
);
await expect(import("./chunk2.js")).rejects.toEqual(
expect.objectContaining({
code: "ENOENT"
})
);
});
<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = [
// each time sets different assetsInfo object instance in webpack.config.js:54
// this prevents hit in inmemory cache
/^Pack got invalid because of write to: TerserWebpackPlugin|bundle0\.js$/
];
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict"<|fim_suffix|>
compilation.getAsset("chunk_js.bundle0.js.map")
).toBeUndefined();
expect(
compilation.getAsset("chunk2_js.bundle0.js")
).toBeUndefined();
expect(
compilation.getAsset("chunk2_js.bundle0.js.map")
).toBeUndefined();
expect(... | fim | webpack/webpack | javascript |
<|fim_suffix|>module_js.bundle0.js"))).toBe(false);
expect(fs.existsSync(path.join(__STATS__.outputPath, "module_js.bundle0.js.map"))).toBe(true);
});
<|fim_prefix|>const fs = require("fs")
con<|fim_middle|>st path = require("path")
try {
import("./module.js");
} catch (_err) {
// Nothing
}
it("should prevent rela... | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|> "module";
<|fim_middle|>ort default<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> );
compilation.deleteAsset("module_js.bundle0.js");
}
);
});
}
]
};
<|fim_prefix|>"use strict";
const { Compilation } = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
optimization: {
minimize: t<|fim_middle|>ru... | fim | webpack/webpack | javascript |
<|fim_prefix|>mo<|fim_suffix|><|fim_middle|>dule.exports = "a";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>mo<|fim_suffix|> = "b";<|fim_middle|>dule.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.ex<|fim_suffix|> "c";<|fim_middle|>ports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load the full async commons", function(done) {
require.ensure(["./a"], function(require) {
expect(require("./a")).toBe("a");
done();
});
});<|fim_suffix|>(b).toBe("b");
done();
});
});
it("should load a chunk with async commons (require.ensure)", function(done) {
require.ensure([], f... | fim | webpack/webpack | javascript |
<|fim_suffix|>minSize: 1
}
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
optimization: {
spli<|fim_middle|>tChunks: {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.ex<|fim_suffix|> "a";<|fim_middle|>ports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = "<|fim_suffix|>;<|fim_middle|>b"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>xports = "c";<|fim_prefix|>module.<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>module<|fim_middle|>.exports = "d";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;<|fim_prefix|>module.exp<|fim_middle|>orts = "e"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load nested commons chunk", function(done) {
var counter = 0;
require.ensur<|fim_suffix|>expect(require("./d")).toBe("d");
if(++counter == 4) done();
});
require.ensure(["./c", "./e"], function(require) {
expect(require("./c")).toBe("c");
expect(require("./e")).toBe("e");
if(+... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {<|fim_suffix|>n: {
splitChunks: {
minSize: 1
}
}
};
<|fim_middle|>
optimizatio<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e.exports = "a";<|fim_prefix|><|fim_middle|>modul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>orts = "b";<|fim_prefix|>module.ex<|fim_middle|>p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>xports = "c";<|fim_prefix|>mod<|fim_middle|>ule.e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const chunkLoadingSpy = jest.spyOn(__webpack_require__, "e");
it("should not have duplicate chunks in blocks", function (done) {
let i = 0;
const d = () => {
if (i++ >= 3) done();
};
// This split point should contain: a
require.ensure(
[],
function (require) {
expect(require("./a")).toBe(... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").C<|fim_suffix|>{
minSize: 1
},
chunkIds: "named"
}
};
<|fim_middle|>onfiguration} */
module.exports = {
performance: {
hints: false
},
optimization: {
splitChunks: <|endoftext|> | fim | webpack/webpack | javascript |
module.exports = "a";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s = "b";<|fim_prefix|>module.e<|fim_middle|>xport<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"c";<|fim_prefix|>module.exports <|fim_middle|>= <|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.