@serwist/webpack-plugin 9.5.6 → 9.5.8

package/dist/chunks/relative-to-output-path-Gvhd54pA.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { toUnix } from "@serwist/utils";
+//#region src/lib/perform-child-compilation.ts
+/**
+* Perform a child compilation.
+*
+* @param compiler The parent webpack compiler.
+* @param compilation The webpack compilation.
+* @param name The name of the child compiler.
+* @param src The source file. Should be absolute.
+* @param dest The destination file. Should be relative to the compilation.
+* @param plugins Additional webpack plugins.
+*
+* @private
+*/
+const performChildCompilation = async (compiler, compilation, name, src, dest, plugins) => {
+	const childCompiler = compilation.createChildCompiler(name, { filename: dest }, plugins);
+	new compiler.webpack.webworker.WebWorkerTemplatePlugin().apply(childCompiler);
+	new compiler.webpack.EntryPlugin(compiler.context, src, name).apply(childCompiler);
+	await new Promise((resolve, reject) => {
+		childCompiler.runAsChild((error, _entries, childCompilation) => {
+			if (error) reject(error);
+			else {
+				if (childCompilation?.warnings) compilation.warnings.push(...childCompilation.warnings);
+				if (childCompilation?.errors) compilation.errors.push(...childCompilation.errors);
+				resolve();
+			}
+		});
+	});
+};
+//#endregion
+//#region src/lib/relative-to-output-path.ts
+/**
+* @param compilation The webpack compilation.
+* @param originalPath The original path value.
+*
+* @returns If path was not absolute, the returns path as-is.
+* Otherwise, returns path relative to the compilation's output path.
+*
+* @private
+*/
+const relativeToOutputPath = (compilation, originalPath) => {
+	if (path.resolve(originalPath) === path.normalize(originalPath)) return toUnix(path.relative(compilation.options.output.path, originalPath));
+	return originalPath;
+};
+//#endregion
+export { performChildCompilation as n, relativeToOutputPath as t };
+
+//# sourceMappingURL=relative-to-output-path-Gvhd54pA.js.map

package/dist/chunks/relative-to-output-path-Gvhd54pA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative-to-output-path-Gvhd54pA.js","names":[],"sources":["../../src/lib/perform-child-compilation.ts","../../src/lib/relative-to-output-path.ts"],"sourcesContent":["import type { Compilation, Compiler } from \"webpack\";\nimport type { WebpackPlugin } from \"./types.js\";\n\n/**\n * Perform a child compilation.\n *\n * @param compiler The parent webpack compiler.\n * @param compilation The webpack compilation.\n * @param name The name of the child compiler.\n * @param src The source file. Should be absolute.\n * @param dest The destination file. Should be relative to the compilation.\n * @param plugins Additional webpack plugins.\n *\n * @private\n */\nexport const performChildCompilation = async (\n  compiler: Compiler,\n  compilation: Compilation,\n  name: string,\n  src: string,\n  dest: string,\n  plugins: WebpackPlugin[] | undefined,\n) => {\n  const childCompiler = compilation.createChildCompiler(name, { filename: dest }, plugins);\n\n  new compiler.webpack.webworker.WebWorkerTemplatePlugin().apply(childCompiler);\n\n  new compiler.webpack.EntryPlugin(compiler.context, src, name).apply(childCompiler);\n\n  await new Promise<void>((resolve, reject) => {\n    childCompiler.runAsChild((error, _entries, childCompilation) => {\n      if (error) {\n        reject(error);\n      } else {\n        if (childCompilation?.warnings) {\n          compilation.warnings.push(...childCompilation.warnings);\n        }\n        if (childCompilation?.errors) {\n          compilation.errors.push(...childCompilation.errors);\n        }\n        resolve();\n      }\n    });\n  });\n};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport path from \"node:path\";\nimport { toUnix } from \"@serwist/utils\";\nimport type { Compilation } from \"webpack\";\n\n/**\n * @param compilation The webpack compilation.\n * @param originalPath The original path value.\n *\n * @returns If path was not absolute, the returns path as-is.\n * Otherwise, returns path relative to the compilation's output path.\n *\n * @private\n */\nexport const relativeToOutputPath = (compilation: Compilation, originalPath: string): string => {\n  // See https://github.com/jantimon/html-webpack-plugin/pull/266/files#diff-168726dbe96b3ce427e7fedce31bb0bcR38\n  if (path.resolve(originalPath) === path.normalize(originalPath)) {\n    return toUnix(path.relative(compilation.options.output.path!, originalPath));\n  }\n\n  // Otherwise, return swDest as-is.\n  return originalPath;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,0BAA0B,OACrC,UACA,aACA,MACA,KACA,MACA,YACG;CACH,MAAM,gBAAgB,YAAY,oBAAoB,MAAM,EAAE,UAAU,MAAM,EAAE,QAAQ;AAExF,KAAI,SAAS,QAAQ,UAAU,yBAAyB,CAAC,MAAM,cAAc;AAE7E,KAAI,SAAS,QAAQ,YAAY,SAAS,SAAS,KAAK,KAAK,CAAC,MAAM,cAAc;AAElF,OAAM,IAAI,SAAe,SAAS,WAAW;AAC3C,gBAAc,YAAY,OAAO,UAAU,qBAAqB;AAC9D,OAAI,MACF,QAAO,MAAM;QACR;AACL,QAAI,kBAAkB,SACpB,aAAY,SAAS,KAAK,GAAG,iBAAiB,SAAS;AAEzD,QAAI,kBAAkB,OACpB,aAAY,OAAO,KAAK,GAAG,iBAAiB,OAAO;AAErD,aAAS;;IAEX;GACF;;;;;;;;;;;;;ACtBJ,MAAa,wBAAwB,aAA0B,iBAAiC;AAE9F,KAAI,KAAK,QAAQ,aAAa,KAAK,KAAK,UAAU,aAAa,CAC7D,QAAO,OAAO,KAAK,SAAS,YAAY,QAAQ,OAAO,MAAO,aAAa,CAAC;AAI9E,QAAO"}

package/dist/chunks/schema-CpgCa1bB.js

@@ -0,0 +1,51 @@
+import { basePartial, fn, injectPartial, optionalSwDestPartial } from "@serwist/build/schema";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/lib/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	injectManifestOptions: () => injectManifestOptions,
+	injectPartial: () => injectPartial$1,
+	webpackPartial: () => webpackPartial
+});
+const webpackConditionCallback = fn({
+	input: [z.any()],
+	output: z.boolean()
+});
+const webpackCondition = z.union([
+	z.string(),
+	z.instanceof(RegExp),
+	webpackConditionCallback
+]);
+const webpackPartial = z.strictObject({
+	chunks: z.array(z.string()).optional(),
+	exclude: z.array(webpackCondition).default([/\.map$/, /^manifest.*\.js$/]),
+	excludeChunks: z.array(z.string()).optional(),
+	include: z.array(webpackCondition).optional()
+});
+const injectPartial$1 = z.strictObject({
+	compileSrc: z.boolean().default(true),
+	swDest: z.string().optional(),
+	webpackCompilationPlugins: z.array(z.any()).optional()
+});
+const injectManifestOptions = z.strictObject({
+	...basePartial.shape,
+	...webpackPartial.shape,
+	...injectPartial.shape,
+	...optionalSwDestPartial.shape,
+	...injectPartial$1.shape
+});
+//#endregion
+export { webpackPartial as i, injectPartial$1 as n, schema_exports as r, injectManifestOptions as t };
+
+//# sourceMappingURL=schema-CpgCa1bB.js.map

package/dist/chunks/schema-CpgCa1bB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-CpgCa1bB.js","names":["injectPartial","baseInjectPartial"],"sources":["../../src/lib/schema.ts"],"sourcesContent":["import { injectPartial as baseInjectPartial, basePartial, fn, optionalSwDestPartial } from \"@serwist/build/schema\";\nimport { z } from \"zod\";\n\nconst webpackConditionCallback = fn({\n  input: [z.any()],\n  output: z.boolean(),\n});\n\nconst webpackCondition = z.union([z.string(), z.instanceof(RegExp), webpackConditionCallback]);\n\nexport const webpackPartial = z.strictObject({\n  chunks: z.array(z.string()).optional(),\n  exclude: z.array(webpackCondition).default([/\\.map$/, /^manifest.*\\.js$/]),\n  excludeChunks: z.array(z.string()).optional(),\n  include: z.array(webpackCondition).optional(),\n});\n\nexport const injectPartial = z.strictObject({\n  compileSrc: z.boolean().default(true),\n  swDest: z.string().optional(),\n  webpackCompilationPlugins: z.array(z.any()).optional(),\n});\n\nexport const injectManifestOptions = z.strictObject({\n  ...basePartial.shape,\n  ...webpackPartial.shape,\n  ...baseInjectPartial.shape,\n  ...optionalSwDestPartial.shape,\n  ...injectPartial.shape,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,MAAM,2BAA2B,GAAG;CAClC,OAAO,CAAC,EAAE,KAAK,CAAC;CAChB,QAAQ,EAAE,SAAS;CACpB,CAAC;AAEF,MAAM,mBAAmB,EAAE,MAAM;CAAC,EAAE,QAAQ;CAAE,EAAE,WAAW,OAAO;CAAE;CAAyB,CAAC;AAE9F,MAAa,iBAAiB,EAAE,aAAa;CAC3C,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CACtC,SAAS,EAAE,MAAM,iBAAiB,CAAC,QAAQ,CAAC,UAAU,mBAAmB,CAAC;CAC1E,eAAe,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CAC7C,SAAS,EAAE,MAAM,iBAAiB,CAAC,UAAU;CAC9C,CAAC;AAEF,MAAaA,kBAAgB,EAAE,aAAa;CAC1C,YAAY,EAAE,SAAS,CAAC,QAAQ,KAAK;CACrC,QAAQ,EAAE,QAAQ,CAAC,UAAU;CAC7B,2BAA2B,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,UAAU;CACvD,CAAC;AAEF,MAAa,wBAAwB,EAAE,aAAa;CAClD,GAAG,YAAY;CACf,GAAG,eAAe;CAClB,GAAGC,cAAkB;CACrB,GAAG,sBAAsB;CACzB,GAAGD,gBAAc;CAClB,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,137 @@
+import { BasePartial, BaseResolved, InjectPartial, InjectResolved, OptionalSwDestPartial, OptionalSwDestResolved } from "@serwist/build";
+import { Require } from "@serwist/utils";
+import { Asset, Compilation, Compiler, WebpackPluginFunction, WebpackPluginInstance } from "webpack";
+
+//#region src/lib/types.d.ts
+interface ConditionCallbackOptions {
+  asset: Asset;
+  compilation: Compilation;
+}
+type ConditionCallback = (options: ConditionCallbackOptions) => boolean;
+interface WebpackPartial {
+  /**
+   * One or more chunk names whose corresponding output files should be included
+   * in the precache manifest.
+   */
+  chunks?: string[];
+  /**
+   * One or more specifiers used to exclude assets from the precache manifest.
+   * This is interpreted following
+   * [the same rules](https://webpack.js.org/configuration/module/#condition)
+   * as webpack's standard `exclude` option.
+   * @default
+   * ```
+   * [/\.map$/, /^manifest.*\.js$/]
+   * ```
+   */
+  exclude?: (string | RegExp | ConditionCallback)[];
+  /**
+   * One or more chunk names whose corresponding output files should be excluded
+   * from the precache manifest.
+   */
+  excludeChunks?: string[];
+  /**
+   * One or more specifiers used to include assets in the precache manifest.
+   * This is interpreted following
+   * [the same rules](https://webpack.js.org/configuration/module/#condition)
+   * as webpack's standard `include` option.
+   */
+  include?: (string | RegExp | ConditionCallback)[];
+}
+type WebpackResolved = Require<WebpackPartial, "exclude">;
+interface InjectPartial$1 {
+  /**
+   * When `true` (the default), the `swSrc` file will be compiled by webpack.
+   * When `false`, compilation will not occur (and `webpackCompilationPlugins`
+   * can't be used.) Set to `false` if you want to inject the manifest into,
+   * e.g., a JSON file.
+   * @default true
+   */
+  compileSrc?: boolean;
+  /**
+   * Optional webpack plugins that will be used when compiling the `swSrc`
+   * file. Only valid if `compileSrc` is `true`.
+   */
+  webpackCompilationPlugins?: WebpackPlugin[];
+}
+type InjectResolved$1 = Require<InjectPartial$1, "compileSrc">;
+interface InjectManifestOptions extends BasePartial, WebpackPartial, InjectPartial, OptionalSwDestPartial, InjectPartial$1 {}
+interface InjectManifestOptionsComplete extends BaseResolved, WebpackResolved, InjectResolved, OptionalSwDestResolved, InjectResolved$1 {}
+type WebpackPlugin = WebpackPluginFunction | WebpackPluginInstance;
+//#endregion
+//#region src/inject-manifest.d.ts
+/**
+ * This class supports compiling a service worker file provided via `swSrc`,
+ * and injecting into that service worker a list of URLs and revision
+ * information for precaching based on the webpack asset pipeline.
+ *
+ * Use an instance of `InjectManifest` in the
+ * [`plugins` array](https://webpack.js.org/concepts/plugins/#usage) of a
+ * webpack config.
+ *
+ * In addition to injecting the manifest, this plugin will perform a compilation
+ * of the `swSrc` file, using the options from the main webpack configuration.
+ *
+ * ```
+ * // The following lists some common options; see the rest of the documentation
+ * // for the full set of options and defaults.
+ * new InjectManifest({
+ *   exclude: [/.../, '...'],
+ *   maximumFileSizeToCacheInBytes: ...,
+ *   swSrc: '...',
+ * });
+ * ```
+ */
+declare class InjectManifest {
+  protected config: InjectManifestOptionsComplete;
+  private alreadyCalled;
+  private webpack;
+  /**
+   * Creates an instance of InjectManifest.
+   */
+  constructor(config: InjectManifestOptions);
+  /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */
+  private propagateWebpackConfig;
+  /**
+   * `getManifestEntriesFromCompilation` with a few additional checks.
+   *
+   * @private
+   */
+  private getManifestEntries;
+  /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */
+  apply(compiler: Compiler): void;
+  /**
+   * @param compiler The webpack parent compiler.
+   * @param compilation The webpack compilation.
+   *
+   * @private
+   */
+  private addSrcToAssets;
+  /**
+   * @param compiler The webpack parent compiler.
+   * @param compilation The webpack compilation.
+   *
+   * @private
+   */
+  private handleMake;
+  /**
+   * @param compilation The webpack compilation.
+   *
+   * @private
+   */
+  private addAssets;
+}
+//#endregion
+//#region src/lib/validator.d.ts
+declare const validateInjectManifestOptions: (input: unknown) => Promise<InjectManifestOptionsComplete>;
+//#endregion
+export { InjectManifest, type InjectManifestOptions, type InjectManifestOptionsComplete, type WebpackPartial, type WebpackResolved, validateInjectManifestOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/types.ts","../src/inject-manifest.ts","../src/lib/validator.ts"],"mappings":";;;;;UAWiB,wBAAA;EACf,KAAA,EAAO,KAAA;EACP,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,iBAAA,IAAqB,OAAA,EAAS,wBAAA;AAAA,UAEzB,cAAA;EANf;;;;EAWA,MAAA;EAVwB;AAG1B;;;;;AAEA;;;;EAgBE,OAAA,aAAoB,MAAA,GAAS,iBAAA;EAYT;;;;EAPpB,aAAA;EALA;;;;;;EAYA,OAAA,aAAoB,MAAA,GAAS,iBAAA;AAAA;AAAA,KAGnB,eAAA,GAAkB,OAAA,CAAQ,cAAA;AAAA,UAErB,eAAA;EAFU;;;;AAE3B;;;EAQE,UAAA;EAAA;;;;EAQA,yBAAA,GAA4B,aAAA;AAAA;AAAA,KAGlB,gBAAA,GAAiB,OAAA,CAAQ,eAAA;AAAA,UAEpB,qBAAA,SAA8B,WAAA,EAAa,cAAA,EAAgB,aAAA,EAAmB,qBAAA,EAAuB,eAAA;AAAA,UAErG,6BAAA,SAAsC,YAAA,EAAc,eAAA,EAAiB,cAAA,EAAoB,sBAAA,EAAwB,gBAAA;AAAA,KAEtH,aAAA,GAAgB,qBAAA,GAAwB,qBAAA;;;;;;AAjEpD;;;;;;;;;;AAKA;;;;;AAEA;;;;cCoBa,cAAA;EAAA,UACD,MAAA,EAAQ,6BAAA;EAAA,QACV,aAAA;EAAA,QACA,OAAA;EDKsC;;;cCAlC,MAAA,EAAQ,qBAAA;EDZS;;;;;EAAA,QCyBrB,sBAAA;EDbsC;AAGhD;;;;EAHgD,QC+BhC,kBAAA;ED1BC;;;;;ECsEf,KAAA,CAAM,QAAA,EAAU,QAAA;EDtDY;;;AAG9B;;;EAH8B,QCyFpB,cAAA;EDtFwC;AAElD;;;;;EAFkD,QCiGlC,UAAA;ED/F+E;;;;;EAAA,QC4H/E,SAAA;AAAA;;;cCjMH,6BAAA,GAAuC,KAAA,cAAiB,OAAA,CAAQ,6BAAA"}

package/dist/index.internal.d.mts

@@ -0,0 +1,44 @@
+import { Compilation, Compiler, WebpackPluginInstance } from "webpack";
+
+//#region src/lib/child-compilation-plugin.d.ts
+interface ChildCompilationPluginOptions {
+  src: string;
+  dest: string;
+  plugins?: WebpackPluginInstance[];
+}
+/**
+ * Compile a file by creating a child of the hooked compiler.
+ *
+ * @private
+ */
+declare class ChildCompilationPlugin implements WebpackPluginInstance {
+  src: string;
+  dest: string;
+  plugins: WebpackPluginInstance[] | undefined;
+  constructor({
+    src,
+    dest,
+    plugins
+  }: ChildCompilationPluginOptions);
+  /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */
+  apply(compiler: Compiler): void;
+}
+//#endregion
+//#region src/lib/relative-to-output-path.d.ts
+/**
+ * @param compilation The webpack compilation.
+ * @param originalPath The original path value.
+ *
+ * @returns If path was not absolute, the returns path as-is.
+ * Otherwise, returns path relative to the compilation's output path.
+ *
+ * @private
+ */
+declare const relativeToOutputPath: (compilation: Compilation, originalPath: string) => string;
+//#endregion
+export { ChildCompilationPlugin, relativeToOutputPath };
+//# sourceMappingURL=index.internal.d.mts.map

package/dist/index.internal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.internal.d.mts","names":[],"sources":["../src/lib/child-compilation-plugin.ts","../src/lib/relative-to-output-path.ts"],"mappings":";;;UAIiB,6BAAA;EACf,GAAA;EACA,IAAA;EACA,OAAA,GAAU,qBAAA;AAAA;;;;;;cAQC,sBAAA,YAAkC,qBAAA;EAC7C,GAAA;EACA,IAAA;EACA,OAAA,EAAS,qBAAA;;IACK,GAAA;IAAK,IAAA;IAAM;EAAA,GAAW,6BAAA;EAD3B;;;;;EAWT,KAAA,CAAM,QAAA,EAAU,QAAA;AAAA;;;;;AAzBlB;;;;;;;cCiBa,oBAAA,GAAwB,WAAA,EAAa,WAAA,EAAa,YAAA"}

package/dist/index.internal.mjs

@@ -0,0 +1,31 @@
+import { n as performChildCompilation, t as relativeToOutputPath } from "./chunks/relative-to-output-path-Gvhd54pA.js";
+//#region src/lib/child-compilation-plugin.ts
+/**
+* Compile a file by creating a child of the hooked compiler.
+*
+* @private
+*/
+var ChildCompilationPlugin = class {
+	src;
+	dest;
+	plugins;
+	constructor({ src, dest, plugins }) {
+		this.src = src;
+		this.dest = dest;
+		this.plugins = plugins;
+	}
+	/**
+	* @param compiler default compiler object passed from webpack
+	*
+	* @private
+	*/
+	apply(compiler) {
+		compiler.hooks.make.tapPromise(this.constructor.name, (compilation) => performChildCompilation(compiler, compilation, this.constructor.name, this.src, relativeToOutputPath(compilation, this.dest), this.plugins).catch((error) => {
+			compilation.errors.push(error);
+		}));
+	}
+};
+//#endregion
+export { ChildCompilationPlugin, relativeToOutputPath };
+
+//# sourceMappingURL=index.internal.mjs.map

package/dist/index.internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.internal.mjs","names":[],"sources":["../src/lib/child-compilation-plugin.ts"],"sourcesContent":["import type { Compiler, WebpackError, WebpackPluginInstance } from \"webpack\";\nimport { performChildCompilation } from \"./perform-child-compilation.js\";\nimport { relativeToOutputPath } from \"./relative-to-output-path.js\";\n\nexport interface ChildCompilationPluginOptions {\n  src: string;\n  dest: string;\n  plugins?: WebpackPluginInstance[];\n}\n\n/**\n * Compile a file by creating a child of the hooked compiler.\n *\n * @private\n */\nexport class ChildCompilationPlugin implements WebpackPluginInstance {\n  src: string;\n  dest: string;\n  plugins: WebpackPluginInstance[] | undefined;\n  constructor({ src, dest, plugins }: ChildCompilationPluginOptions) {\n    this.src = src;\n    this.dest = dest;\n    this.plugins = plugins;\n  }\n  /**\n   * @param compiler default compiler object passed from webpack\n   *\n   * @private\n   */\n  apply(compiler: Compiler) {\n    compiler.hooks.make.tapPromise(this.constructor.name, (compilation) =>\n      performChildCompilation(\n        compiler,\n        compilation,\n        this.constructor.name,\n        this.src,\n        relativeToOutputPath(compilation, this.dest),\n        this.plugins,\n      ).catch((error: WebpackError) => {\n        compilation.errors.push(error);\n      }),\n    );\n  }\n}\n"],"mappings":";;;;;;;AAeA,IAAa,yBAAb,MAAqE;CACnE;CACA;CACA;CACA,YAAY,EAAE,KAAK,MAAM,WAA0C;AACjE,OAAK,MAAM;AACX,OAAK,OAAO;AACZ,OAAK,UAAU;;;;;;;CAOjB,MAAM,UAAoB;AACxB,WAAS,MAAM,KAAK,WAAW,KAAK,YAAY,OAAO,gBACrD,wBACE,UACA,aACA,KAAK,YAAY,MACjB,KAAK,KACL,qBAAqB,aAAa,KAAK,KAAK,EAC5C,KAAK,QACN,CAAC,OAAO,UAAwB;AAC/B,eAAY,OAAO,KAAK,MAAM;IAC9B,CACH"}