text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>eElement("link");
link.rel = "stylesheet";
link.href = HREF;
document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
const HREF = "bundle0.<|fim_middle|>css";
module.exports = {
moduleScope(scope) {
const { document } = scope.window;
const existing = document
.getElementsByTagNa... | fim | webpack/webpack | javascript |
<|fim_suffix|>development",
experiments: {
css: true
}
};
<|fim_prefix|>"use st<|fim_middle|>rict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as f1 from "./f1/style.module.css";
import * as f2 from "./f2/style.module.css";
it("shoul<|fim_suffix|>(f1.xxx).toBeDefined();
expect(f2.xxx).toBeDefined();
expect(f1.xxx).not.toBe(f2.xxx);
});
<|fim_middle|>d generate unique hashed class names for same-named classes in different directories"... | fim | webpack/webpack | javascript |
<|fim_suffix|> {
test: /\.module\.css$/i,
type: "css/module"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
modu<|fim_middle|>le.exports = {
experiments: {
css: true
},
module: {
rules: [
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { expectCssOrder } from "./helpers<|fim_suffix|>ack to the default import-order sort", done => {
expectCssOrder("fallback", 2, "bcdea123", done);
});
<|fim_middle|>";
it("orderModules: returning undefined falls b<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>: ([a-z0-9])/g)
.map(match => match[7]);
expect(matches).toEqual(expected.split(""));
done();
} catch (e) {
done(e);
}
}, done);
}
<|fim_prefix|>import fs from "fs";
import path from "path";
export function expectCssOrder(variant, idx, expected, done) {
__non_webpack_require__(`./${var... | fim | webpack/webpack | javascript |
import "./e.css";
import "./a.css";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ectCssOrder("multi-tap", 3, "abcde123", done);
});
<|fim_prefix|>import { expectCssOrder } from "./helpers";
it("orderModules<|fim_middle|>: SyncBailHook short-circuits at the first tap that returns a value", done => {
exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ules: returning modules as-is yields name-sorted CSS without warnings", done => {
expectCssOrder("name", 0, "abcde123", done);
});
<|fim_prefix|>import { expectCs<|fim_middle|>sOrder } from "./helpers";
it("orderMod<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>one);
});
<|fim_prefix|>import { expectCssOrder } from "./helpers";
it("orderModules: a tap can pin a specific file (e.css) to the front", done => {
expectCssOrder("pr<|fim_middle|>iority", 1, "eabcd123", d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const variants <|fim_suffix|>}.js`,
`${variant}-lazy4_js.bundle${i}.js`,
`bundle${i}.js`
];
}
};
<|fim_middle|>= ["name", "priority", "fallback", "multi-tap"];
module.exports = {
findBundle(i) {
const variant = variants[i];
return [
`${variant}-css.bundle${i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = [
[
// Only the "fallback" config (which returns undefined from orderModules)
<|fim_suffix|>modules are imported in:\n {2}- css \.\/lazy1\.css\n {2}- css \.\/lazy2\.css/
]
];
<|fim_middle|>// keeps the default topological merge and therefore emits this warning.
/Con... | fim | webpack/webpack | javascript |
"use strict";
/** @typedef {import("../../../../").Compiler} Compiler */
/** @typedef {ReturnType<typeof import("../../../../").css.CssModulesPlugin.getCompilationHooks>} CssCompilationHooks */
/**
* @typedef {object} Variant
* @property {string} name scenario name
* @property {(hooks: CssCompilationHooks) => void... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as style from "./style.module.css";
const fs = __non_webpack_require__("fs");
const path = __non_webpack_require__("path");
const readBundle = () =>
fs.readFileSync(path.join(__dirname, "bundle0.css"), "utf-8");
const matchC<|fim_suffix|>oMatch(/import-shared-a$/);
expect(style["import-share... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../<|fim_suffix|>Name: "value-overriding"
},
node: {
__dirname: false,
__filename: false
},
module: {
rules: [
{
test: /\.module\.css$/i,
type: "css/module"
}
]
}
};
<|fim_middle|>../../../").Configuration} */
module.exports = {
target: "web",
... | fim | webpack/webpack | javascript |
<|fim_suffix|>The url() references should have been resolved against the @value paths
// — not left as the literal identifier.
expect(cssContent).not.toMatch(/url\(\s*bgPath\s*\)/);
expect(cssContent).not.toMatch(/url\(\s*bareBgPath\s*\)/);
expect(cssContent).not.toMatch(/url\(\s*singleQuotedBgPath\s*\)/);
// The... | fim | webpack/webpack | javascript |
<|fim_suffix|>output: {
uniqueName: "value-url-import"
},
node: {
__dirname: false,
__filename: false
},
module: {
rules: [
{
test: /\.module\.css$/i,
type: "css/module"
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "we... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { Teaser } from "./liba";
document.body.innerHTML = Teaser();
// https://github.com/webpack/webpack/issues/18961
// https://github.com/jantimon/reproduction-webpack-css-order
it("keep consistent css order", function() {
const fs = __non_webpack_require__("fs");
let source = fs.re<|fim_suffix|>a... | fim | webpack/webpack | javascript |
<|fim_suffix|>
${CarouselButton({
className: styles.teaserCarouselButton,
})}
</div>
`;
};
<|fim_prefix|>import { CarouselButton } from '../libb';
import styles from './teaser.module.css';
export const Teaser = () => {
return `
<div class="${styles.te<|fim_middle|>aser}">
<h2>Teas... | fim | webpack/webpack | javascript |
<|fim_prefix|>export * fr<|fim_suffix|>
<|fim_middle|>om './common';<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import styles f<|fim_suffix|>}">Carousel Button</button>`;
};
<|fim_middle|>rom './button.module.css';
export const CarouselButton = ({
className = '',
}) => {
return `<button class="${styles.button + (
className ? ` ${className}` : ''
)<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export * from './comm<|fim_middle|>on'<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> esModule: true,
modules: {
namedExport: false,
localIdentName: "[name]"
}
}
}
]
}
]
},
plugins: [
new MiniCssExtractPlugin({
filename: "[name].css"
})
],
node: {
__dirname: false,
__filename: false
}
};
<|fim_prefix|>"use strict";
cons... | fim | webpack/webpack | javascript |
<|fim_suffix|>utf-8");
expect(removeComments(source)).toMatchSnapshot()
});
function removeComments(source) {
return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\n/g, "");
}
<|fim_prefix|>import { c, b, a } from "dep";
c()
b()
a()
it("keep consistent css order", function() {
const fs = __non_webpack_require_... | fim | webpack/webpack | javascript |
<|fim_suffix|>n: {
concatenateModules: true
},
module: {
rules: [
{
test: /\.css$/,
use: [
{
loader: MiniCssExtractPlugin.loader
},
{
loader: "css-loader",
options: {
esModule: true,
modules: {
namedExport: false,
localIdentName: "[name]"
... | fim | webpack/webpack | javascript |
<|fim_suffix|>y2 } from "./dependency";
export function component(...args) {
return args;
}
<|fim_prefix|>export { dependency<|fim_middle|>, dependenc<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import styles from "./dependency.css";
export f<|fim_suffix|>== undefined;
}<|fim_middle|>unction dependency() {
return styles !<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import styles from "./dependency2.css";
export <|fim_suffix|>ndency2() {
return styles !== undefined;
}<|fim_middle|>function depe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>y";
<|fim_prefix|>export * from "./depend<|fim_middle|>ency2";
export * from "./dependenc<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { comp<|fim_suffix|>fs = __non_webpack_require__("fs");
let source = fs.readFileSync(__dirname + "/main.css", "utf-8");
expect(removeComments(source)).toMatchSnapshot()
});
function removeComments(source) {
return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\n/g, "");
}<|fim_middle|>onent,... | fim | webpack/webpack | javascript |
<|fim_suffix|>css"
})
],
node: {
__dirname: false,
__filename: false
}
};
<|fim_prefix|>"use strict";
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
/** @type {import("../../../../types").Configuration} */
module.exports = {
devtool: false,
target: "web",
entry: "./index.js",
mode: "dev... | fim | webpack/webpack | javascript |
<|fim_suffix|>ndency";
export function component() {
dependency();
dependency2();
}<|fim_prefix|>import { dependency, dependency2 }<|fim_middle|> from "./depe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>ss";
export function dependency() {
return styles !== undefined;
}<|fim_middle|>rt styles from "./dependency.c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ency2() {
return styles !== undefined;
}<|fim_prefix|>import styles from "./dependency2.css<|fim_middle|>";
export function depend<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>./dependency";
<|fim_prefix|>exp<|fim_middle|>ort * from "./dependency2";
export * from "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/\n/g, "");
}<|fim_prefix|>const { component } = require("./component");
component()
// https://github.com/webpack/webpack/issues/18961
// https://github.com/jantimon/reproduction-webpack-css-order
it("keep consistent css order", function() {
const fs = __non_webpack_require__("fs");
let s<|fim_middle|... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
/** @type {import("../../../../").Configuration} */
module.exports = {
devt<|fim_suffix|>e].css"
})
],
node: {
__dirname: false,
__filename: false
}
};
<|fim_middle|>ool: false,
target: "web",
entry: "./index.js",... | fim | webpack/webpack | javascript |
<|fim_suffix|>on component() {
dependency();
dependency2();
dependency3();
}<|fim_prefix|>const { dependency3 } = require("./dependency/dependency3");
import { dependency, dependency2<|fim_middle|> } from "./dependency";
export functi<|endoftext|> | fim | webpack/webpack | javascript |
import styles from "./dependency.css";
export function dependency() {
return styles !== undefined;
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>les from "./dependency2.css";
export function dependency2() {
return styles !== undefined;
}<|fim_middle|>rt sty<|endoftext|> | fim | webpack/webpack | javascript |
import styles from "./dependency3.css";
export function dependency3() {
return styles !== undefined;
}<|endoftext|> | fim | webpack/webpack | javascript |
export * from "./dependency2";
export * from "./dependency";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const { component } = require("./component");
component()
// https://github.com/webpack/webpack/issues/18961
// https://github.co<|fim_suffix|> order", function() {
const fs = __non_webpack_require__("fs");
let source = fs.readFileSync(__dirname + "/main.css", "utf-8");
expect(removeComments(source)).... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
/** @type {import("../../../../").Configuration} */
module.exports = {
devtool: false,
target: "web",
entry: "./index.js",
mode: "development",
optimization: {
concatenateModules: false<|fim_suffix|> options: {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import './style.css';
import * as style1 from './style1.local.css'
import * as style2 from './style2.global.css'
import './style3.auto.css';
import * as style3 from './style4.modules.css'
it("should not parse css modules in type: css", () => {
const style = getComputedStyle(document.body);
expect... | fim | webpack/webpack | javascript |
<|fim_suffix|>.window.document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link<|fim_middle|> = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
scope<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",<|fim_suffix|>/i,
type: "css/global"
},
{
test: /\.auto\.css$/i,
type: "css/auto"
},
{
test: /\.modules\.css$/i,
type: "css/auto"
}
]
},
experiments: {
css: true
}... | fim | webpack/webpack | javascript |
<|fim_suffix|> findBundle() {
return ["./test.js"];
}
};
<|fim_prefix|>"use strict";
// Assertions live in the emitted `t<|fim_middle|>est.js` asset; the css entry's JS chunk
// has no `it(...)` body of its own.
module.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>y");
});
<|fim_prefix|>const fs = require("fs");
const path = require("path");
it("sho<|fim_middle|>uld resolve the extensionless `./src` entry to src/index.css", () => {
const css = fs.readFileSync(path.resolve(__dirname, "main.css"), "utf-8");
expect(css).toContain(".default-entr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
// `./src` with no extension must resolve `./src/index.css` when the css
// experiment is on — the same way `./src` resolves `./src/index.js` by default.
const fs = require("fs");
const path = require("path");
const webpack = require("../../../../");
/** @type {import("../..<|fim_suffix|>"... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as style1 from "./style.module.css?namespace";
import style2 from "./style.module.css?default";
import { foo } from "./style.module.css?named";
it("should able to import with default and named exports", () => {
expect(style1.default).toEqual(nsObj({ foo: 'style_module_css_namespace-foo' }));
/... | fim | webpack/webpack | javascript |
<|fim_suffix|> },
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").C<|fim_middle|>onfiguration} */
module.exports = {
target: "node",
mode: "development",
devtool: false,
module: {
rules: [
{
test: /\.css/,
parser: {
namedExports: false
},
ty... | fim | webpack/webpack | javascript |
<|fim_suffix|>t link of links.slice(1)) {
css.push(link.sheet.css);
}
expect(css).toMatchSnapshot('css');
expect(styles).toMatchSnapshot('classes');
done();
});
<|fim_prefix|>import * as styles from "./style.modules.css";
it(`should work with URLs in CSS`, done => {
const links = document.getElementsByTagName(... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["bundle0.js"];
},
moduleScope(scope) {
const link = scope.window.document.createElement("link");
link.rel = "stylesheet";
link.href = "bundle0.css";
<|fim_suffix|> }
};
<|fim_middle|> scope.window.document.head.appendChild(link);
<|endof... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
target: "web",
mode: "development",
experiments: {
css: true
}
},
{
target: "web",
mode: "production",
experiments: {
css: true
}
}
];
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import moduleText, { class as moduleTextClass } from "./module-text.css";
import autoText from "./auto-text.css";
import * as moduleTextNoEsm from "./module-text-no-esm.css";
import autoTextNoEsm from "./auto-text-no-esm.css";
import moduleWithImports from "./module-with-imports.css";
import parentModuleW... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
/** @type {import("../../../../").Configuration} */
/**
* @param {object} options Configuration options
* @param {boolean=} options.concatenateModules Whether to concatenate modu... | fim | webpack/webpack | javascript |
<|fim_suffix|>r(m => m.modules);
expect(concatModules.length).toBe(1);
// index.js + 2 text + 1 text-dep + 2 sheet + 1 sheet-dep + 1 link + 1 link-dep
// + 2 style + 1 style-dep = 12
expect(concatModules[0].modules.length).toBeGreaterThanOrEqual(12);
});
<|fim_prefix|>import textA from "./text-a.css";
import textB ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle(i, options) {
return ["link-b.bundle0.js", "bundle0.js"];
},
moduleScope(scope) <|fim_suffix|>;
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_middle|>{
const link = scope.window.document.createElement("link");
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Con<|fim_suffix|> exportType: "css-style-sheet"
}
},
{
test: /link-.*\.css$/,
type: "css/module",
parser: {
exportType: "link"
}
},
{
test: /style-.*\.css$/,
type: "css/module",
parser: {
exportType:... | fim | webpack/webpack | javascript |
<|fim_suffix|>Type", () => {
expect(sheet).toBeInstanceOf(CSSStyleSheet);
const cssText = Array.from(sheet.cssRules)
.map(r => r.cssText)
.join("\n");
expect(cssText).toContain("https://example.com/");
expect(cssText).not.toContain(PLACEHOLDER);
});
it("should substitute [fullhash] in url() for style exportTyp... | fim | webpack/webpack | javascript |
<|fim_suffix|>findBundle(i) {
return i === 0 ? "./bundle0.js" : "./bundle1.js";
}
};
<|fim_prefix|>"use stri<|fim_middle|>ct";
module.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const rules = [
{
test: /text\.css$/,
type: "css/auto",
parser: { exportType: "text" }
},
{
test: /sheet\.css$/,
<|fim_suffix|>",
publicPath: "https://example.com/[fullhash:8]/",
assetModuleFilename: "images/[name][ext]"
},
module: { rules },
experiments: { css: true... | fim | webpack/webpack | javascript |
<|fim_suffix|>wn content
expect(allCSS.some(c => c.includes("overflow: hidden"))).toBe(true);
// e.css own content
expect(allCSS.some(c => c.includes("position: relative"))).toBe(true);
// shared.css should appear exactly once (module cache prevents duplicate execution)
const sharedCount = allCSS.filter(c => c.inc... | fim | webpack/webpack | javascript |
<|fim_suffix|>st: /\.css$/,
type: "css/module",
parser: {
exportType: "style"
}
}
]
},
experiments: {
css: true
},
plugins: [
new webpack.DefinePlugin({
"process.env.BROWSER": JSON.stringify(target === "web"),
"process.env.CONCAT": JSON.stringify(concatenateModules)
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ntain("color: red");
});
it("should create a style tag for wrapper-style.css own content", () => {
const allCSS = Array.from(
window.document.getElementsByTagName("style")
).map(s => s.textContent);
expect(allCSS.some(c => c.includes("padding: 10px"))).toBe(true);
});
it("should create a style tag... | fim | webpack/webpack | javascript |
<|fim_suffix|>
type: "css/module",
parser: {
exportType: "text"
}
}
]
},
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
devtool: false,
module: {
rules: [
{
test... | fim | webpack/webpack | javascript |
import textCss from "./style.css";
import sheet from "./style-for-sheet.css";
import "./style-for-inject.css";
it("should resolve url() relative to output root for text exportType", () => {
// url() in non-link CSS is resolved relative to the document, not any output file.
// undoPath should be "" regardless of cssF... | fim | webpack/webpack | javascript |
<|fim_suffix|>module.exports = {
findBundle(i, options) {
if (i === 0) return "./bundle0.js";
return "./js/bundle1.js";
}
};
<|fim_prefix|>"us<|fim_middle|>e strict";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>r",
devtool: false,
target: "web",
mode: "development",
output: {
// JS in "js/" subdirectory — undoPath from JS path would be "../"
// but non-link url() resolves relative to document, so still ""
filename: "js/bundle1.js",
cssFilename: "css/[name].css",
cssChunkFilename: "css/[nam... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as styles1 from "./style.module.css?camel-case#1";
import * as styles2 from "./style.module.css?camel-case#2";
const prod = process.env.NODE_ENV === "production";
const target = process.env.TARGET;
it("concatenation and mangling should work", () => {
expect(styles1.class).toBe(prod ? "w3DuhZ" ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle(i) {
return [
`style_module_css_as-is.bundle${i}.js`,
`style_module_css_camel-case.bundle${i}.js`,
`style_module_css_camel-case-only.bund<|fim_suffix|>${i}.js`,
`style_module_css_dashes.bundle${i}.js`,
`style_module_css_dashes-only.bundle${i}.... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @typedef {import("../../../../").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
/** @typedef {import("../../../../").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
const common = {
optimization: {
... | fim | webpack/webpack | javascript |
import * as styles from "./style.module.css";
it("should export both the original and the uppercase form when exportsConvention returns an array", () => {
expect(styles).toMatchSnapshot();
// Original-name form
expect(styles["btn-info_is-disabled"]).toBe(
"style_module_css-btn-info_is-disabled"
);
expect(styles... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "development",
module: {
rules: [
{
test: /\.module\.css$/,
type: "css/mo... | fim | webpack/webpack | javascript |
import * as style from "../pseudo-export/style.module.css?ns";
import { a, abc } from "../pseudo-export/style.module.css?picked";
import def from "../pseudo-export/style.module.css?default";
it("should allow to import a css module", () => {
expect(style).toEqual(
nsObj({
a: "a",
abc: "a b c",
comments: "ab... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports <|fim_suffix|>elopment",
experiments: {
css: true
}
};
<|fim_middle|>= {
target: "node",
mode: "dev<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should not have .css file", (done) => {
__non_webpack_require__("./pseudo-export_style_module_css.bundle0.js");
__non_webpa<|fim_suffix|>-export/style.module.css"),
import("../pseudo-export/style.module.css?module"),
import("../pseudo-export/style.module.css?exportsOnly"),
]).then(([style1, sty... | fim | webpack/webpack | javascript |
<|fim_suffix|> ];
}
};
<|fim_prefix|>"use strict";
module.exports = {
f<|fim_middle|>indBundle() {
return [
"pseudo-export_style_module_css.bundle0.js",
"pseudo-export_style_module_css_module.bundle0.js",
"pseudo-export_style_module_css_exportsOnly.bundle0.js",
"bundle0.js"
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/,
type: "css/module"
},
{
resourceQuery: /\?exportsOnly/,
generator: {
exportsOnly: true
},
type: "css/global"
}
]
},
experiments: {
css: true
},
node: {
__dirname: false
}
}
];
<|fim_prefix|>"use strict";<|fim_middle|>
/** @type {import("..... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as style from "./style.module.css";
import * as style1 from "https://test.<|fim_suffix|> new URL("https://test.cases/url-external.css", import.meta.url);
expect(url.toString().endsWith("url-external.css")).toBe(true);
});
it("should import an external css dynamically", done => {
import("./dyn... | fim | webpack/webpack | javascript |
<|fim_suffix|>of write to/
];
}
return [];
};
<|fim_prefix|>"use strict";
module.exports = (options) => {
if (options[0].cache && options[0].cache.type === "filesystem") {
return [
/Pack got invalid because of write to/,
/Pac<|fim_middle|>k got invalid because <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ndex.js",
target: "node",
optimization: {
chunkIds: "named",
moduleIds: "named"
},
experiments: {
css: true,
outputModule: true
}
}
];
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {import("../../../../").Configuration} */
module.exports = [
{
cont<|fim_mi... | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as style from "./style.css";
it("should import an external CSS inside CSS", () => {
const bodyStyle = getComputedStyle(document.body);
expect(bodyStyle.getPropertyValue("color")).toBe(" green");
expect(bodyStyle.getPropertyValue("padding")).toBe(" 10px");
});
// import * as style1 from "htt... | fim | webpack/webpack | javascript |
<|fim_suffix|>eet";
link.href = stats.experiments.outputModule ? "bundle1.css" : "bundle0.css";
scope.window.document.head.appendChild(link);
},
findBundle(i) {
return i === 0 ? ["dynamic_css.bundle0.js", "bundle0.js"] : ["bundle1.mjs"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope, ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use st<|fim_suffix|>
},
experiments: {
css: true,
outputModule: true
}
}
];
<|fim_middle|>rict";
/** @type {import("../../../../").Configuration} */
module.exports = [
{
target: "web",
optimization: {
chunkIds: "named"
},
experiments: {
css: true
}
},
{
target: "web",
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should silence the confli<|fim_suffix|>lazy2.css")]);
});
<|fim_middle|>cting order warning when matched by ignoreWarnings", async () => {
await Promise.all([import("./lazy1.css"), import("./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stric<|fim_suffix|>undle() {
return ["css.bundle0.js", "bundle0.js"];
}
};
<|fim_middle|>t";
module.exports = {
findB<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
target: "web",
mode: "development",
experiments: {
css: true
},
optimization: {
splitChunks: {
cacheGroups: {
css: {
type: "css/auto",
enforce: true,
name: "css"
}
}
}
},
ignoreWarnings: [/Conflicting order/]
};
<|fim_prefix|>"use strict";
/** @type {import("../... | fim | webpack/webpack | javascript |
"use strict";
module.exports = () => [
/Can't resolve 'non-exported-css'/,
/Can't resolve '\.\/directory'/,
/Package path \.\/non-valid\.css is exported from package (.+), but no valid target file was found/,
/Can't resolve '\.\/no-extension-in-request'/
];
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./style.css";
it("should compile", done => {
const links = document.getElementsByTagName("link");
const css =<|fim_suffix|>ect(css).toMatchSnapshot();
done();
});
<|fim_middle|> [];
// Skip first because import it by default
for (const link of links.slice(1)) {
css.push(link.sheet.css);
... | fim | webpack/webpack | javascript |
<|fim_suffix|>= function loader(content) {
return content.replace(/\/[*/][#]?\s*sourceMappingURL=.+(\*\/)?/g, "");
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module<|fim_middle|>.exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>) {
return 'doNotImportCss';
}<|fim_middle|>function doNotImportCss(<|endoftext|> | fim | webpack/webpack | javascript |
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function loader(content) {
return content + `.using-loader { color: red; }`;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = scope.window.document.createElement("l<|fim_suffix|> scope.window.document.head.appendChild(link);
}
};
<|fim_middle|>ink");
link.rel = "stylesheet";
link.href = `bundle${scope.__STATS_I__}.css`;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t external-14.css"
},
plugins: [new webpack.IgnorePlugin({ resourceRegExp: /ignore\.css/ })]
},
{
target: "web",
mode: "development",
experiments: {
css: true
},
module: {
parser: {
css: {
import: false
}
}
}
}
];
<|fim_prefix|>"use strict";
const webpack = requir... | fim | webpack/webpack | javascript |
<|fim_suffix|>ComputedStyle(document.body);
expect(style.getPropertyValue("background")).toBe(" blue");
expect(style.getPropertyValue("color")).toBe(" green");
done();
});
<|fim_prefix|>import "./style.css";
it("should compile with warnings", done => {
const<|fim_middle|> style = get<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
link.href = "bundle0.css";
scope.window.document.head.appendChild(link);
}
};
<|fim_prefix|>"use strict";
module.exports = {
moduleScope(scope) {
const link = sc<|fim_middle|>ope.window.document.createElement("link");
link.rel = "stylesheet"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>opment",
experiments: {
css: true
}
};
<|fim_prefix|>"use strict";
/** @ty<|fim_middle|>pe {import("../../../../").Configuration} */
module.exports = {
target: "web",
mode: "devel<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>green");
expect(importedRule.style["font-style"]).toBe("italic");
});
it("should handle url() for images in CSSStyleSheet", () => {
const rules = Array.from(sheet.cssRules);
// Check that the rule with background-image exists
const imageRule = rules.find(rule => rule.selectorText === ".with-image")... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.