text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configurati<|fim_suffix|>ent",
experiments: {
css: true
}
};
<|fim_middle|>on} */
module.exports = {
devtool: false,
target: "web",
mode: "developm<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>al({});
const computedStyle = getComputedStyle(document.body);
expect(computedStyle.getPropertyValue("background")).toBe(" red");
expect(computedStyle.getPropertyValue("margin")).toBe(" 10px");
});
<|fim_prefix|>import * as style from "<|fim_middle|>./style.css";
it("should compile and load style on d... | fim | webpack/webpack | javascript |
<|fim_suffix|>e.window.document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = scope.window.document.c<|fim_middle|>reateElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scop<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
experiments: {
css: true
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
exports.pitch = async function (remaining) {
const result = await this.importModule(
this.resourcePat<|fim_suffix|>turn result.default || result;
};
<|fim_middle|>h + '.webpack[javascript/auto]' + '!=!' + remaining, {
publicPath:... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const re<|fim_suffix|><|fim_middle|>d = '#f00';
export const green = '#0f0';<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
});
<|fim_prefix|>import stylesheet from './stylesheet.js';
it(<|fim_middle|>"should compile", () => {
expect(stylesheet).toBe("body { background: #f00; color: #0f0; }")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>y { background: ${red}; color: ${green}; }`;
<|fim_prefix|>import { green, red } from './colors.js';<|fim_middle|>
export default `bod<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>riments: {
css: true
}
};
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {i<|fim_middle|>mport("../../../../").Configuration} */
module.exports = {
plugins: [new webpack.HotModuleReplacementPlugin()],
target: "web",
mode: "development",
module: {
rules: [
{
... | fim | webpack/webpack | javascript |
it("should call the createStylesheet hook for each stylesheet link", async () => {
await import("./style.css");
const links = [...document.getElementsByTagName("link")];
const styleLink = links.find((link) => /style_css/.test(link.href));
expect(styleLink).toBeDefined();
expect(styleLink.getAttribute("data-inser... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict<|fim_suffix|>xports = {
findBundle() {
return ["style_css.chunk.js", "bundle0.js"];
}
};
<|fim_middle|>";
module.e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpac<|fim_suffix|>ce}\nlink.setAttribute("data-insert-marker", "via-create-stylesheet");`
);
});
}
],
experiments: {
css: true
}
};
<|fim_middle|>k = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
outpu... | fim | webpack/webpack | javascript |
<|fim_suffix|>
return done(e);
}
done();
}, done);
});
it("should allow to process tailwind as global css", done => {
prod
? __non_webpack_require__("./382.bundle1.js")
: __non_webpack_require__("./tailwind_min_css.bundle0.js");
import("./tailwind.min.css").then(() => done(), done);
});
<|fim_prefix|>co... | fim | webpack/webpack | javascript |
<|fim_suffix|>00"]
};
<|fim_prefix|>impor<|fim_middle|>t * as style from "./tailwind.module.css";
export default {
placeholder: style["placeholder-gray-7<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> css: true
}
},
{
target: "web",
mode: "production",
performance: false,
experiments: {
css: true
}
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
target: "web",
mode: "development"<|fim_middle|>,
output: {
uniqueNam... | fim | webpack/webpack | javascript |
<|fim_suffix|>.parentNode).toBe(document.body);
});
<|fim_prefix|>it("shoul<|fim_middle|>d call the linkInsert hook to control where the link is inserted", async () => {
await import("./style.css");
const links = [...document.getElementsByTagName("link")];
const styleLink = links.find((link) => /style_css/.test(lin... | fim | webpack/webpack | javascript |
<|fim_suffix|>.js"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["style_css.chunk.js", "<|fim_middle|>bundle0<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
ou<|fim_suffix|>rride insertion: place link into <body> instead of
// the default `document.head.appendChild(link);`.
hooks.linkInsert.tap(
"Link... | fim | webpack/webpack | javascript |
<|fim_suffix|>hNameLocal).toMatchSnapshot();
expect(fileLocal).toMatchSnapshot();
expect(queryFragment).toMatchSnapshot();
expect(uniqueNameIdContenthash).toMatchSnapshot();
expect(hashLocalCustom).toMatchSnapshot();
expect(uniquenameLocal).toMatchSnapshot();
done()
}).catch(done)
});
<|fim_prefix|>it("sho... | fim | webpack/webpack | javascript |
<|fim_suffix|>s_file-local.bundle${i}.js`,
`style_module_css_q_f.bundle${i}.js`,
`style_module_css_uniqueName-id-contenthash.bundle${i}.js`,
`style_module_css_hash-local-custom.bundle${i}.js`,
`style_module_css_uniquename-local.bundle${i}.js`,
`style_module_less.bundle${i}.js`,
`bundle${i}.js`
];
}... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const common = {
mode: "development",
devtool: false,
module: {
<|fim_suffix|>ocalIdentHashSalt: "salt",
localIdentHashDigest: "base26",
localIdentHashDigestLength: 16,
localIdentName: "[hash]-[local]"
}
}
]
}
]
},
experiments: {
css: true
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import <|fim_suffix|>order-1.css";
import "./async-different-order-2.css";
<|fim_middle|>"./async-different-<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./async-different-order-2.css";
import "./as<|fim_suffix|>c-different-order-1.css";
<|fim_middle|>yn<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function load1() {
return import("./async-different-or<|fim_suffix|> load2()]).catch(() => {});
<|fim_middle|>der-one.js");
}
function load2() {
return import("./async-different-order-two.js");
}
Promise.all([load1(),<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>in-b.css";
<|fim_prefix|>import<|fim_middle|> "./at-import-chain-a.css";
import "./at-import-cha<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>-entry-b.css";
<|fim_prefix|>import "./at-import-in-the-entry-a.css";
import "./at-import-in-th<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it<|fim_suffix|>tem.href)).map((item) => item.sheet.css)).toMatchSnapshot();
});
<|fim_middle|>("should work css modules and composes", async () => {
const styles = await import(/* webpackChunkName: "composes-async-1" */ "./composes-async-1.modules.css");
const styles1 = await import(/* webpackChunkNam... | fim | webpack/webpack | javascript |
<|fim_suffix|>nt-entries-style2.css";
export default "one";
<|fim_prefix|>import "<|fim_middle|>./content-entries-style1.css";
import "./conte<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>-style1.css";
export default "two";
<|fim_prefix|>import "./content-entries-style2.css<|fim_middle|>";
import "./content-entries<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should work with asset modules", async () => {
await import("./asset-modules.css");
const links = [...document.getElementsByTagName("link")];
expect(links.find((item) => /asset-modules/.test(item.href)).sheet.css).toMatchSnapshot();
});
// TODO fix me
it("should work with multiple @charset at-ru... | fim | webpack/webpack | javascript |
import "./layer-at-rule.css";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.txt";
<|fim_prefix|>import ".<|fim_middle|>/virtual.css!=!./source<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>css";
<|fim_prefix|><|fim_middle|>import "./multiple-at-charset-a.css";
import "./multiple-at-charset-b.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>i<|fim_suffix|>"./nested-component.css";
<|fim_middle|>mport <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./nested-a.css";
i<|fim_suffix|>nested-b.css";
<|fim_middle|>mport "./nested-component.js";
import "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("./shared-import-c.css");
<|fim_prefix|>import "./shared-import-a.css";
import "./shared-<|fim_middle|>import-b.css";
await import<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import ".<|fim_suffix|>rule.css";
<|fim_middle|>/supports-at-<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ort-chain-b_css.chunk.js",
"content-entries-one_js.chunk.js",
"content-entries-two_js.chunk.js",
"bundle0.js"
];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return [
"asset-modules_css.chunk.js",
"multiple-at-charset_js-multiple-at-charset-a_css-multiple-at-cha... | fim | webpack/webpack | javascript |
<|fim_suffix|>d"
},
module: {
rules: []
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exp<|fim_middle|>orts = {
target: "web",
output: {
chunkFilename: "[name].chunk.js"
},
optimization: {
chunkIds: "name<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it(<|fim_suffix|>y one module", () => {
expect(Object.keys(__webpack_modules__).length).toBe(1);
});
<|fim_middle|>"should contain onl<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|> "./common.css";
<|fim_middle|>import<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./si<|fim_suffix|>ss";
<|fim_middle|>x-b.c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const fs = require("fs");
const path = require("path");
module.exports = {
findBundle<|fim_suffix|>oMatchSnapshot(file);
}
}
};
<|fim_middle|>() {
return ["basic.js"];
},
afterExecute(options) {
const files = fs
.readdirSync(options.output.path)
.filter((item) => !/stats/.t... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
entry: {
basic: "./basic.js",
one: "./one.css",
two: "./two.css<|fim_suffix|>e: "./five.css",
common: "./commonjs.js",
six: { import: "./six.js", dependOn: "common" }
},
output: {
filename:... | fim | webpack/webpack | javascript |
<|fim_suffix|>.css";
<|fim_prefix|>import "./c.css";
import<|fim_middle|> "./d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impor<|fim_suffix|> "./d.css";
import "./c.css";
<|fim_middle|>t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>oMatchSnapshot("async");
});
<|fim_prefix|>import "./a.css";
import "./b.css";
it("should work", async () => {
await import("./async-one.js");
const links = document.getElementsByTagName("link");
expect(links.find((item) => /one\.css/.test(item.href)).sheet.css).toMatchSnapshot("initial");
expect(l... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|>
if (once) {
return;
}
const link1 = scope.window.document.createElement("link");
link1.rel = "stylesheet";
link1.href = "one.css";
scope.window.document.head.appendChild(link1);
const link2 = scope.window.document.createElement("link");
link2.rel = "styles... | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./b.css";
import "./a.css";
it("should work", async () => {
await import("./async-two.js");
const links = document.getElementsByTagName("link");
expect(links.find((item) => /two\.css/.test(item<|fim_suffix|>pshot("initial");
expect(links.find((item) => /async-two_js-c_css-d_css\.chunk\.css/... | fim | webpack/webpack | javascript |
<|fim_suffix|>].chunk.js"
},
optimization: {
chunkIds: "named"
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
entry: {<|fim_middle|>
one: "./one.js",
two: "./two.js"
},
output: {
filename: "[name].js"... | fim | webpack/webpack | javascript |
<|fim_prefix|>// Entry for `parser.namedExports: false` configs. The CSS modules
// expose only `default`, so a default import is the only valid form.
// Mangling does not apply here — there are no JS named exports for
// CSS classes — but concatenation still does.
import asIsDefault from "./style.module.css?as-is";
i... | fim | webpack/webpack | javascript |
// Entry for `parser.namedExports: true` configs. Pure named imports
// keep every CSS export mangleable — a namespace import would mark
// them all as observed-by-name and disable mangling.
import {
simple as asIsSimple,
foo_bar as asIsFooBar,
foo as asIsFoo
} from "./style.module.css?as-is";
import {
simple as c... | fim | webpack/webpack | javascript |
<|fim_suffix|>ile exists.
return [`bundle${i}.${ext}`];
}
};
<|fim_prefix|>"use strict"<|fim_middle|>;
module.exports = {
findBundle(i, options) {
const ext =
options.experiments && options.experiments.outputModule ? "mjs" : "js";
// With concatenateModules: true the CSS variants are concatenated
// into ... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>"use strict";
module.<|fim_middle|>exports = () => process.version.slice(0, 4) !== "v10."<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>output = { module: true, chunkFormat: "module" };
/** @type {NonNullable<Configuration["experiments"]>} */
(config.experiments).outputModule = true;
}
return config;
};
module.exports = [
makeConfig({ namedExports: true, outputModule: false }),
makeConfig({ namedExports: false, outputModule: fals... | fim | webpack/webpack | javascript |
<|fim_suffix|>lass' }));
expect(style2).toEqual(nsObj({ class: 'style_module_css_default-class' }));
expect(style3).toEqual(nsObj({ class: 'style_module_css_named-class' }));
});
it("should able to import with different namedExports (async)", (done) => {
Promise.all([
import("./style.module.css"),
import("./sty... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {i<|fim_suffix|>dExports: false
},
type: "css/module"
},
{
resourceQuery: /\?named/,
parser: {
namedExports: true
},
type: "css/module"
}
]
},
experiments: {
css: true
}
};
<|fim_middle|>mport("../../../../").Configuration} */
module.ex... | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>import "./style.css";
it("should compile with warnin<|fim_middle|>g", done => {
const style = getComputedStyle(document.body);
expect(style.getPropertyValue("background")).toBe(" red");
done();
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use str<|fim_suffix|>ope(scope) {
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_middle|>ict";
module.exports = {
moduleSc<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
experiments: {
css: true
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import './style.css'<|fim_suffix|>s(__webpack_modules__).length).toBe(1)
})
<|fim_middle|> // doesn't has js output
it('should contain no js outupt', () => {
// only has index.js
expect(Reflect.ownKey<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
experimen<|fim_suffix|>}
};
<|fim_middle|>ts: {
css: true
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>=> {})
<|fim_middle|>import "./main.css"
require("./a2.css")
import("./a2.css").then(() <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> => {})
<|fim_prefix|>import a1 from "./a1.module.css"
const a2 = require<|fim_middle|>("./a2.module.css")
import("./a3.module.css").then(()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>"use strict";
module.exports<|fim_middle|> = {
findBundle(i) {
switch (i) {
case 0:
return ["test.js"];
case 1:
return ["test.js", "1/main.js"];
case 2:
return ["test.js", "2/main.js"];
}
}
};<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
} else if (__STATS_I__ === 2) {
stats.modules
.filter(module => module.moduleType === "css/auto")
.forEach(module => {
expect(module.sizes["javascript"] === 1).toBe(false);
});
}
});
<|fim_prefix|>it("should work"<|fim_middle|>, () => {
const stats = __STATS__.children[__STATS_I__];
... | fim | webpack/webpack | javascript |
<|fim_suffix|> );
}
);
});
}
}
]
});
/** @type {import("../../../../").Configuration[]} */
module.exports = /** @type {(0 | 1 | 2)[]} */ ([0, 1]).map((i) => common(i));
<|fim_prefix|>"use strict";
const fs = require("fs");
const path = require("path");
const webpack = require("../../../../");
/... | fim | webpack/webpack | javascript |
<|fim_suffix|>1);
expect(__STATS__.modules.length).toBe(5);
});
<|fim_prefix|>import { exportName } from "./style.modules.css";
im<|fim_middle|>port { div } from "./module.js";
it("should don't generate extra runtime modules", () => {
expect(exportName).toBeDefined();
expect(div(2, 2)).toBe(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export function div(a, b) {
<|fim_suffix|>}
<|fim_middle|> return a / b;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rget: "web",
optimization: {
minimize: false
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {i<|fim_middle|>mport("../../../../").Configuration} */
module.exports = {
devtool: false,
mode: "production",
ta<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./style.css";
it("should compile", () => {
const links = document.getElementsByTagName("link");
const css = [];
// Skip first because import it by default
for (const link of links.slice(1)) {
css.push(link.sheet.css);
}
expect(css).toMatchSnapshot();
expect(Object.keys(__webpack_module... | fim | webpack/webpack | javascript |
<|fim_suffix|>ead.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.<|fim_middle|>css";
scope.window.document.h<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> css: true
},
module: {
rules: [
{
test: /resource\.png$/,
type: "asset/resource"
},
{
test: /inline\.png$/,
type: "asset/inline"
},
{
test: /source\.text$/,
type: "asset/source"
},
{
mimetype: "text/html",
type: "asset/resource"
},
{
mim... | fim | webpack/webpack | javascript |
<|fim_suffix|>k_modules__["./i.modules.css"]).toBeDefined();
expect(__webpack_modules__["./e.modules.css"]).toBeUndefined();
})<|fim_prefix|>import { i } from "./i.modules.css"
it("sh<|fim_middle|>ould work", () => {
expect(typeof i).toBe("string")
expect(__webpac<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>}
};
<|fim_prefix|>"use strict<|fim_middle|>";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node",
mode: "development",
devtool: false,
experiments: {
css: true
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>in
// sourcesContent (and that wrapper embeds the CSS body) — under
// `nosources` it must be gone.
expect(jsMapRaw).not.toContain(".nosources-test-class");
// And — the actual regression — the inline data URI map embedded in
// the CSS string must also have its sourcesContent stripped.
const bundl... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use<|fim_suffix|> scope.__NodeBuffer = Buffer;
}
};
<|fim_middle|> strict";
const fs = require("fs");
const path = require("path");
module.exports = {
moduleScope(scope) {
scope.__nodeFs = fs;
scope.__nodePath = path;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ersion.startsWith("v10.") && !process.version.startsWith("v12.");
<|fim_prefix|>"use st<|fim_middle|>rict";
module.exports = () =>
!process.v<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/**
* @param {string} exportType the CSS parser exportType under test
* @returns {import("../../../../").Configuration} webpack configuration
*/
const makeConfig = (exportType) => ({
name: exportType,
target: "web",
mode: "development",
devtool<|fim_suffix|>..(exportType !== "link" &... | fim | webpack/webpack | javascript |
<|fim_suffix|>(document.body);
expect(style.getPropertyValue("background")).toBe(" red");
done();
});
<|fim_prefix|>import "./style.css";
it("should co<|fim_middle|>mpile and load style on demand", done => {
const style = getComputedStyle<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_prefix|>"use str<|fim_middle|>ict";
module.exports = {
moduleScope(scope) {
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "deve<|fim_middle|>lopment",
experiments: {
css: <|endoftext|> | fim | webpack/webpack | javascript |
import * as style from "./style.css";
it("should compile and load style on demand", done => {
expect(style).toEqual({});
import("./style2.css").then(x => {
expect(x).toEqual({});
const style = getComputedStyle(document.body);
expect(style.getPropertyValue("background")).toBe(" red");
expect(style.getProperty... | fim | webpack/webpack | javascript |
"use strict";
const fs = require("fs");
const path = require("path");
module.exports = {
moduleScope(scope) {
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
},
findBundle(i, options) {
const sourc... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|>experiments: {
css: true
}
};
<|fim_middle|>/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
devtool: false,
output: {
pathinfo: true,
cssChunkFilename: "[name].[chunkhash].css"
},
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ect(local).toMatchSnapshot();
expect(global).toMatchSnapshot();
expect(pure).toMatchSnapshot();
expect(scope).toMatchSnapshot();
expect(values).toMatchSnapshot();
expect(css).toMatchSnapshot();
});
<|fim_prefix|>import * as composes from "./postcss-modules-extract-imports.modules.css";
import * as lo... | fim | webpack/webpack | javascript |
<|fim_suffix|>ow.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
module<|fim_middle|>Scope(scope) {
const link = scope.wind<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
experiments: {
css: true
},
module: {
rules: [
{
test: /postcss-modules-local-by-default\.global\.modules\.css$/,
type: "css/global"
},
{
test: /postcss-modules-local-b... | fim | webpack/webpack | javascript |
import * as styles1 from "./style.css";
import * as styles2 from "./style.modules.css";
it("should prefer relative", () => {
expect(styles1).toEqual({});
expect(styles2).toEqual(nsObj({
"style-module": "style_modules_css-style-module",
}));
const style = getComputedStyle(document.body);
expect(style.getProper... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope<|fim_suffix|>nst link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_middle|>) {
co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/*<|fim_suffix|>{
css: true
}
};
<|fim_middle|>* @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
experiments: <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"style-module": "style_modules_less-style-module",
}));
const style = getComputedStyle(document.body);
expect(style.getPropertyValue("background")).toBe(" red");
expect(style.getPropertyValue("color")).toBe(" red");
});
<|fim_prefix|>import * as styles1 from "./style.less";
import * as styles2 from ... | fim | webpack/webpack | javascript |
<|fim_suffix|>ow.document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = scope.window.docume<|fim_middle|>nt.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope.wind<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>st: /\.less$/,
use: "less-loader",
type: "css/auto"
}
]
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.e<|fim_middle|>xports = {
target: "web",
mode: "development",
module: {
rules: [
{
te<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function() {
import(/* webpackPrefetch: true, webpackChunkName: "chunk1-a" */ "./chunk1-a.mjs");
import(/* webpackPreload: true, webpackChunkName: "chunk1-b" */ "./chunk1-b.mjs");
import(/* webpackPreload: true, <|fim_suffix|>css");
import(/* webpackPrefetch: 10, webpackChunkName: "chun... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function() {
import(/*<|fim_suffix|>fetch: true, webpackChunkName: "chunk1-a" */ "./chunk1-a.mjs");
import(/* webpackPreload: true, webpackChunkName: "chunk1-b" */ "./chunk1-b.mjs");
}
<|fim_middle|> webpackPre<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>, () => {
let link, script;
expect(document.head._children).toHaveLength(3);
// Test preload
link = document.head._children[0];
expect(link._type).toBe("link");
expect(link.rel).toBe("prefetch");
expect(link.as).toBe("script");
expect(link.href).toBe("https://example.com/public/path/chunk1.mjs")... | fim | webpack/webpack | javascript |
<|fim_suffix|>ename: "[name].mjs",
crossOriginLoading: "anonymous",
chunkFormat: "module"
},
performance: {
hints: false
},
optimization: {
minimize: false
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
entry: "./index.mjs",
experiments: {
outpu... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function() {
import(/* webpackChunkName: "chunk1-a"<|fim_suffix|>./chunk1-a.css");
import(/* webpackChunkName: "chunk1-c" */ "./chunk1-c.mjs");
}
<|fim_middle|> */ "./chunk1-a.mjs");
import(/* webpackChunkName: "chunk1-b" */ "./chunk1-b.mjs");
import(/* webpackPreload: true, webpackChun... | fim | webpack/webpack | javascript |
<|fim_suffix|>port(/* webpackChunkName: "chunk1-b" */ "./chunk1-b.mjs");
}
<|fim_prefix|>export default function() {
import(/* webpackChunk<|fim_middle|>Name: "chunk1-a" */ "./chunk1-a.mjs");
im<|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.