@serwist/webpack-plugin 9.0.0-preview.9 → 9.0.1

package/dist/chunks/schema.js

@@ -0,0 +1,32 @@
+import { basePartial, injectPartial as injectPartial$1, optionalSwDestPartial } from '@serwist/build/schema';
+import { z } from 'zod';
+
+const webpackPartial = z.object({
+    chunks: z.array(z.string()).optional(),
+    exclude: z.array(z.union([
+        z.string(),
+        z.instanceof(RegExp),
+        z.function(z.tuple([
+            z.any()
+        ]), z.boolean())
+    ])).default([
+        /\.map$/,
+        /^manifest.*\.js$/
+    ]),
+    excludeChunks: z.array(z.string()).optional(),
+    include: z.array(z.union([
+        z.string(),
+        z.instanceof(RegExp),
+        z.function(z.tuple([
+            z.any()
+        ]), z.boolean())
+    ])).optional()
+}).strict("Do not pass invalid properties to WebpackPartial!");
+const injectPartial = z.object({
+    compileSrc: z.boolean().default(true),
+    swDest: z.string().optional(),
+    webpackCompilationPlugins: z.array(z.any()).optional()
+}).strict("Do not pass invalid properties to WebpackInjectManifestPartial!");
+const injectManifestOptions = basePartial.merge(webpackPartial).merge(injectPartial$1).merge(optionalSwDestPartial).merge(injectPartial).strict("Do not pass invalid properties to WebpackInjectManifestOptions!");
+
+export { injectManifestOptions, injectPartial, webpackPartial };

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 import { InjectManifest } from "./inject-manifest.js";
-export { InjectManifest };
+import type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved } from "./lib/types.js";
+import { validateInjectManifestOptions } from "./lib/validator.js";
+export { InjectManifest, validateInjectManifestOptions };
+export type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,EAAE,cAAc,EAAE,6BAA6B,EAAE,CAAC;AACzD,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}

package/dist/index.internal.js

@@ -1,4 +1,3 @@
-import webpack from 'webpack';
 import { r as relativeToOutputPath } from './chunks/relative-to-output-path.js';
 import 'upath';
 
@@ -6,12 +5,18 @@ class ChildCompilationPlugin {
     src;
     dest;
     plugins;
+    webpack;
     constructor({ src, dest, plugins }){
         this.src = src;
         this.dest = dest;
         this.plugins = plugins;
+        this.webpack = null;
+    }
+    propagateWebpackConfig(compiler) {
+        this.webpack = compiler.webpack;
     }
     apply(compiler) {
+        this.propagateWebpackConfig(compiler);
         compiler.hooks.make.tapPromise(this.constructor.name, (compilation)=>this.performChildCompilation(compilation, compiler).catch((error)=>{
                 compilation.errors.push(error);
             }));
@@ -30,7 +35,7 @@ class ChildCompilationPlugin {
                 plugin?.apply(childCompiler);
             }
         }
-        new webpack.EntryPlugin(parentCompiler.context, this.src, this.constructor.name).apply(childCompiler);
+        new this.webpack.EntryPlugin(parentCompiler.context, this.src, this.constructor.name).apply(childCompiler);
         await new Promise((resolve, reject)=>{
             childCompiler.runAsChild((error, _entries, childCompilation)=>{
                 if (error) {

package/dist/index.js

@@ -1,11 +1,23 @@
-import { transformManifest, getSourceMapURL, validateWebpackInjectManifestOptions, escapeRegExp, replaceAndUpdateSourceMap } from '@serwist/build';
-import stringify from 'fast-json-stable-stringify';
+import { transformManifest, getSourceMapURL, stringify, escapeRegExp, replaceAndUpdateSourceMap } from '@serwist/build';
 import prettyBytes from 'pretty-bytes';
 import upath from 'upath';
-import webpack from 'webpack';
-import crypto from 'crypto';
+import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
+import crypto from 'node:crypto';
 import { r as relativeToOutputPath } from './chunks/relative-to-output-path.js';
 
+const validateInjectManifestOptions = async (input)=>{
+    const result = await (await import('./chunks/schema.js')).injectManifestOptions.spa(input, {
+        errorMap: validationErrorMap
+    });
+    if (!result.success) {
+        throw new SerwistConfigError({
+            moduleName: "@serwist/webpack-plugin",
+            message: JSON.stringify(result.error.format(), null, 2)
+        });
+    }
+    return result.data;
+};
+
 const getAssetHash = (asset)=>{
     if (asset.info?.immutable) {
         return null;
@@ -31,7 +43,7 @@ const checkConditions = (asset, compilation, conditions = [])=>{
                 compilation
             });
         }
-        if (webpack.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
+        if (compilation.compiler.webpack.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
             return true;
         }
     }
@@ -123,7 +135,8 @@ const getManifestEntriesFromCompilation = async (compilation, config)=>{
         manifestTransforms: config.manifestTransforms,
         maximumFileSizeToCacheInBytes: config.maximumFileSizeToCacheInBytes,
         modifyURLPrefix: config.modifyURLPrefix,
-        transformParam: compilation
+        transformParam: compilation,
+        disablePrecacheManifest: config.disablePrecacheManifest
     });
     for (const warning of warnings){
         compilation.warnings.push(new Error(warning));
@@ -151,15 +164,19 @@ const _generatedAssetNames = new Set();
 class InjectManifest {
     config;
     alreadyCalled;
+    webpack;
     constructor(config){
         this.config = config;
         this.alreadyCalled = false;
+        this.webpack = null;
     }
-    propagateWebpackConfig() {
+    propagateWebpackConfig(compiler) {
+        this.webpack = compiler.webpack;
         const parsedSwSrc = upath.parse(this.config.swSrc);
-        this.config = Object.assign({
-            swDest: `${parsedSwSrc.name}.js`
-        }, this.config);
+        this.config = {
+            swDest: `${parsedSwSrc.name}.js`,
+            ...this.config
+        };
     }
     async getManifestEntries(compilation, config) {
         if (config.disablePrecacheManifest) {
@@ -190,11 +207,11 @@ class InjectManifest {
         };
     }
     apply(compiler) {
-        this.propagateWebpackConfig();
+        this.propagateWebpackConfig(compiler);
         compiler.hooks.make.tapPromise(this.constructor.name, (compilation)=>this.handleMake(compilation, compiler).catch((error)=>{
                 compilation.errors.push(error);
             }));
-        const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = webpack.Compilation;
+        const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = this.webpack.Compilation;
         compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation)=>{
             compilation.hooks.processAssets.tapPromise({
                 name: this.constructor.name,
@@ -217,7 +234,7 @@ class InjectManifest {
                 plugin.apply(childCompiler);
             }
         }
-        new webpack.EntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
+        new this.webpack.EntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
         await new Promise((resolve, reject)=>{
             childCompiler.runAsChild((error, _entries, childCompilation)=>{
                 if (error) {
@@ -232,10 +249,10 @@ class InjectManifest {
     }
     addSrcToAssets(compilation, parentCompiler) {
         const source = parentCompiler.inputFileSystem.readFileSync(this.config.swSrc);
-        compilation.emitAsset(this.config.swDest, new webpack.sources.RawSource(source));
+        compilation.emitAsset(this.config.swDest, new this.webpack.sources.RawSource(source));
     }
     async handleMake(compilation, parentCompiler) {
-        this.config = await validateWebpackInjectManifestOptions(this.config);
+        this.config = await validateInjectManifestOptions(this.config);
         this.config.swDest = relativeToOutputPath(compilation, this.config.swDest);
         _generatedAssetNames.add(this.config.swDest);
         if (this.config.compileSrc) {
@@ -243,7 +260,7 @@ class InjectManifest {
         } else {
             this.addSrcToAssets(compilation, parentCompiler);
             if (Array.isArray(this.config.webpackCompilationPlugins) && this.config.webpackCompilationPlugins.length > 0) {
-                compilation.warnings.push(new Error("compileSrc is false, so the " + "webpackCompilationPlugins option will be ignored."));
+                compilation.warnings.push(new Error("'compileSrc' is 'false', so the 'webpackCompilationPlugins' option will be ignored."));
             }
         }
     }
@@ -273,10 +290,10 @@ class InjectManifest {
                 replaceString: manifestString,
                 searchString: config.injectionPoint
             });
-            compilation.updateAsset(sourcemapAssetName, new webpack.sources.RawSource(map));
-            compilation.updateAsset(config.swDest, new webpack.sources.RawSource(source));
+            compilation.updateAsset(sourcemapAssetName, new this.webpack.sources.RawSource(map));
+            compilation.updateAsset(config.swDest, new this.webpack.sources.RawSource(source));
         } else {
-            compilation.updateAsset(config.swDest, new webpack.sources.RawSource(swAssetString.replace(config.injectionPoint, manifestString)));
+            compilation.updateAsset(config.swDest, new this.webpack.sources.RawSource(swAssetString.replace(config.injectionPoint, manifestString)));
         }
         if (compilation.getLogger) {
             const logger = compilation.getLogger(this.constructor.name);
@@ -285,4 +302,4 @@ class InjectManifest {
     }
 }
 
-export { InjectManifest };
+export { InjectManifest, validateInjectManifestOptions };

package/dist/index.schema.d.ts

@@ -0,0 +1,3 @@
+import { injectManifestOptions, injectPartial, webpackPartial } from "./lib/schema.js";
+export { webpackPartial, injectPartial as injectManifestPartial, injectManifestOptions };
+//# sourceMappingURL=index.schema.d.ts.map

package/dist/index.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,aAAa,IAAI,qBAAqB,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.schema.js

@@ -0,0 +1,3 @@
+export { injectManifestOptions, injectPartial as injectManifestPartial, webpackPartial } from './chunks/schema.js';
+import '@serwist/build/schema';
+import 'zod';

package/dist/inject-manifest.d.ts

@@ -1,5 +1,5 @@
-import type { WebpackInjectManifestOptions } from "@serwist/build";
-import webpack from "webpack";
+import type { Compiler } from "webpack";
+import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./lib/types.js";
 /**
  * This class supports compiling a service worker file provided via `swSrc`,
  * and injecting into that service worker a list of URLs and revision
@@ -23,64 +23,57 @@ import webpack from "webpack";
  * ```
  */
 export declare class InjectManifest {
-    protected config: WebpackInjectManifestOptions;
+    protected config: InjectManifestOptionsComplete;
     private alreadyCalled;
+    private webpack;
     /**
      * Creates an instance of InjectManifest.
      */
-    constructor(config: WebpackInjectManifestOptions);
+    constructor(config: InjectManifestOptions);
     /**
      * @param compiler default compiler object passed from webpack
      *
      * @private
      */
-    propagateWebpackConfig(): void;
+    private propagateWebpackConfig;
     /**
      * `getManifestEntriesFromCompilation` with a few additional checks.
      *
      * @private
      */
-    getManifestEntries(compilation: webpack.Compilation, config: WebpackInjectManifestOptions): Promise<{
-        size: number;
-        sortedEntries: {
-            revision: string | null;
-            url: string;
-            integrity?: string | undefined;
-        }[] | undefined;
-        manifestString: string;
-    }>;
+    private getManifestEntries;
     /**
      * @param compiler default compiler object passed from webpack
      *
      * @private
      */
-    apply(compiler: webpack.Compiler): void;
+    apply(compiler: Compiler): void;
     /**
      * @param compilation The webpack compilation.
      * @param parentCompiler The webpack parent compiler.
      *
      * @private
      */
-    performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+    private performChildCompilation;
     /**
      * @param compilation The webpack compilation.
      * @param parentCompiler The webpack parent compiler.
      *
      * @private
      */
-    addSrcToAssets(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): void;
+    private addSrcToAssets;
     /**
      * @param compilation The webpack compilation.
      * @param parentCompiler The webpack parent compiler.
      *
      * @private
      */
-    handleMake(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+    private handleMake;
     /**
      * @param compilation The webpack compilation.
      *
      * @private
      */
-    addAssets(compilation: webpack.Compilation): Promise<void>;
+    private addAssets;
 }
 //# sourceMappingURL=inject-manifest.d.ts.map

package/dist/inject-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-manifest.d.ts","sourceRoot":"","sources":["../src/inject-manifest.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAMnE,OAAO,OAAO,MAAM,SAAS,CAAC;AAU9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,MAAM,EAAE,4BAA4B,CAAC;IAC/C,OAAO,CAAC,aAAa,CAAU;IAE/B;;OAEG;gBACS,MAAM,EAAE,4BAA4B;IAKhD;;;;OAIG;IACH,sBAAsB,IAAI,IAAI;IAa9B;;;;OAIG;IACG,kBAAkB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,4BAA4B;;;;;;;;;IAwC/F;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;IA4BvC;;;;;OAKG;IACG,uBAAuB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAiChH;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;IAMxF;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBnG;;;;OAIG;IACG,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAmDjE"}
+{"version":3,"file":"inject-manifest.d.ts","sourceRoot":"","sources":["../src/inject-manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,QAAQ,EAAoC,MAAM,SAAS,CAAC;AACvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAW3F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,MAAM,EAAE,6BAA6B,CAAC;IAChD,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAEhC;;OAEG;gBACS,MAAM,EAAE,qBAAqB;IAOzC;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAa9B;;;;OAIG;YACW,kBAAkB;IAwChC;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IA6B/B;;;;;OAKG;YACW,uBAAuB;IAiCrC;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAKtB;;;;;OAKG;YACW,UAAU;IAiBxB;;;;OAIG;YACW,SAAS;CAmDxB"}

package/dist/lib/child-compilation-plugin.d.ts

@@ -1,5 +1,4 @@
-import type { WebpackPluginInstance } from "webpack";
-import webpack from "webpack";
+import type { Compiler, WebpackPluginInstance, default as Webpack } from "webpack";
 export interface ChildCompilationPluginOptions {
     src: string;
     dest: string;
@@ -14,8 +13,26 @@ export declare class ChildCompilationPlugin implements WebpackPluginInstance {
     src: string;
     dest: string;
     plugins: WebpackPluginInstance[] | undefined;
+    webpack: typeof Webpack;
     constructor({ src, dest, plugins }: ChildCompilationPluginOptions);
-    apply(compiler: webpack.Compiler): void;
-    performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void>;
+    /**
+     * @param compiler default compiler object passed from webpack
+     *
+     * @private
+     */
+    private propagateWebpackConfig;
+    /**
+     * @param compiler default compiler object passed from webpack
+     *
+     * @private
+     */
+    apply(compiler: Compiler): void;
+    /**
+     * @param compilation The webpack compilation.
+     * @param parentCompiler The webpack parent compiler.
+     *
+     * @private
+     */
+    private performChildCompilation;
 }
 //# sourceMappingURL=child-compilation-plugin.d.ts.map

package/dist/lib/child-compilation-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"child-compilation-plugin.d.ts","sourceRoot":"","sources":["../../src/lib/child-compilation-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,OAAO,MAAM,SAAS,CAAC;AAI9B,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,qBAAqB;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAC;gBACjC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKjE,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ;IAO1B,uBAAuB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAiCjH"}
+{"version":3,"file":"child-compilation-plugin.d.ts","sourceRoot":"","sources":["../../src/lib/child-compilation-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,QAAQ,EAAgB,qBAAqB,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC;AAI9G,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,qBAAqB;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAC;IAC7C,OAAO,EAAE,OAAO,OAAO,CAAC;gBACZ,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAMjE;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAG9B;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ;IASxB;;;;;OAKG;YACW,uBAAuB;CAiCtC"}

package/dist/lib/get-manifest-entries-from-compilation.d.ts

@@ -1,6 +1,7 @@
-import type { ManifestEntry, WebpackInjectManifestOptions } from "@serwist/build";
+import type { ManifestEntry } from "@serwist/build";
 import type { Compilation } from "webpack";
-export declare const getManifestEntriesFromCompilation: (compilation: Compilation, config: WebpackInjectManifestOptions) => Promise<{
+import type { InjectManifestOptionsComplete } from "./types.js";
+export declare const getManifestEntriesFromCompilation: (compilation: Compilation, config: InjectManifestOptionsComplete) => Promise<{
     size: number;
     sortedEntries: ManifestEntry[] | undefined;
 }>;

package/dist/lib/get-manifest-entries-from-compilation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-manifest-entries-from-compilation.d.ts","sourceRoot":"","sources":["../../src/lib/get-manifest-entries-from-compilation.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAe,aAAa,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAE/F,OAAO,KAAK,EAAgB,WAAW,EAAgB,MAAM,SAAS,CAAC;AAwKvE,eAAO,MAAM,iCAAiC,gBAC/B,WAAW,UAChB,4BAA4B;UACnB,MAAM;mBAAiB,aAAa,EAAE,GAAG,SAAS;EAgCpE,CAAC"}
+{"version":3,"file":"get-manifest-entries-from-compilation.d.ts","sourceRoot":"","sources":["../../src/lib/get-manifest-entries-from-compilation.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAO,KAAK,EAAgB,WAAW,EAAgB,MAAM,SAAS,CAAC;AAIvE,OAAO,KAAK,EAAyB,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAoKvF,eAAO,MAAM,iCAAiC,gBAC/B,WAAW,UAChB,6BAA6B,KACpC,QAAQ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,aAAa,EAAE,GAAG,SAAS,CAAA;CAAE,CAiCtE,CAAC"}

package/dist/lib/schema.d.ts

@@ -0,0 +1,225 @@
+import { z } from "zod";
+export declare const webpackPartial: z.ZodObject<{
+    chunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
+    excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    exclude: (string | RegExp | ((args_0: any) => boolean))[];
+    chunks?: string[] | undefined;
+    excludeChunks?: string[] | undefined;
+    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+}, {
+    chunks?: string[] | undefined;
+    exclude?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+    excludeChunks?: string[] | undefined;
+    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+}>;
+export declare const injectPartial: z.ZodObject<{
+    compileSrc: z.ZodDefault<z.ZodBoolean>;
+    swDest: z.ZodOptional<z.ZodString>;
+    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strict", z.ZodTypeAny, {
+    compileSrc: boolean;
+    swDest?: string | undefined;
+    webpackCompilationPlugins?: any[] | undefined;
+}, {
+    compileSrc?: boolean | undefined;
+    swDest?: string | undefined;
+    webpackCompilationPlugins?: any[] | undefined;
+}>;
+export declare const injectManifestOptions: z.ZodObject<{
+    chunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
+    excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
+    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }, {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }>]>, "many">>;
+    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
+    dontCacheBustURLsMatching: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }, {
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }>, "many">, z.ZodOptional<z.ZodUnknown>], null>, z.ZodUnion<[z.ZodPromise<z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+            size: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }, {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }>, "many">;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }, {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }>>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+            size: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }, {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }>, "many">;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }, {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }>]>>, "many">>;
+    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
+    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    injectionPoint: z.ZodDefault<z.ZodString>;
+    swSrc: z.ZodString;
+    compileSrc: z.ZodDefault<z.ZodBoolean>;
+    swDest: z.ZodOptional<z.ZodString>;
+    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strict", z.ZodTypeAny, {
+    exclude: (string | RegExp | ((args_0: any) => boolean))[];
+    compileSrc: boolean;
+    disablePrecacheManifest: boolean;
+    maximumFileSizeToCacheInBytes: number;
+    injectionPoint: string;
+    swSrc: string;
+    chunks?: string[] | undefined;
+    excludeChunks?: string[] | undefined;
+    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+    additionalPrecacheEntries?: (string | {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    })[] | undefined;
+    dontCacheBustURLsMatching?: RegExp | undefined;
+    manifestTransforms?: ((args_0: {
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }[], args_1: unknown) => {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    } | Promise<{
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }>)[] | undefined;
+    modifyURLPrefix?: Record<string, string> | undefined;
+    swDest?: string | undefined;
+    webpackCompilationPlugins?: any[] | undefined;
+}, {
+    swSrc: string;
+    chunks?: string[] | undefined;
+    exclude?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+    excludeChunks?: string[] | undefined;
+    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
+    additionalPrecacheEntries?: (string | {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    })[] | undefined;
+    disablePrecacheManifest?: boolean | undefined;
+    dontCacheBustURLsMatching?: RegExp | undefined;
+    manifestTransforms?: ((args_0: {
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    }[], args_1: unknown) => {
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    } | Promise<{
+        manifest: {
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+            revision?: string | null | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }>)[] | undefined;
+    maximumFileSizeToCacheInBytes?: number | undefined;
+    modifyURLPrefix?: Record<string, string> | undefined;
+    injectionPoint?: string | undefined;
+    compileSrc?: boolean | undefined;
+    swDest?: string | undefined;
+    webpackCompilationPlugins?: any[] | undefined;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/lib/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lib/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EASmC,CAAC;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;EAMkD,CAAC;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK0C,CAAC"}

package/dist/lib/types.d.ts

@@ -0,0 +1,54 @@
+import type { BasePartial, BaseResolved, InjectPartial as BaseInjectPartial, InjectResolved as BaseInjectResolved, OptionalSwDestPartial, OptionalSwDestResolved } from "@serwist/build";
+import type { Require } from "@serwist/utils";
+export 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 | ((arg0: any) => boolean))[];
+    /**
+     * 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 | ((arg0: any) => boolean))[];
+}
+export type WebpackResolved = Require<WebpackPartial, "exclude">;
+export interface InjectPartial {
+    /**
+     * 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?: any[];
+}
+export type InjectResolved = Require<InjectPartial, "compileSrc">;
+export interface InjectManifestOptions extends BasePartial, WebpackPartial, BaseInjectPartial, OptionalSwDestPartial, InjectPartial {
+}
+export interface InjectManifestOptionsComplete extends BaseResolved, WebpackResolved, BaseInjectResolved, OptionalSwDestResolved, InjectResolved {
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,aAAa,IAAI,iBAAiB,EAClC,cAAc,IAAI,kBAAkB,EACpC,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;IACzD;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;CAC1D;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;AAEjE,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAIrB;;;OAGG;IACH,yBAAyB,CAAC,EAAE,GAAG,EAAE,CAAC;CACnC;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;AAElE,MAAM,WAAW,qBAAsB,SAAQ,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,aAAa;CAAG;AAEtI,MAAM,WAAW,6BAA8B,SAAQ,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,cAAc;CAAG"}

package/dist/lib/validator.d.ts

@@ -0,0 +1,3 @@
+import type { InjectManifestOptionsComplete } from "./types.js";
+export declare const validateInjectManifestOptions: (input: unknown) => Promise<InjectManifestOptionsComplete>;
+//# sourceMappingURL=validator.d.ts.map

package/dist/lib/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/lib/validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEhE,eAAO,MAAM,6BAA6B,UAAiB,OAAO,KAAG,QAAQ,6BAA6B,CAMzG,CAAC"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@serwist/webpack-plugin",
-  "version": "9.0.0-preview.9",
+  "version": "9.0.1",
   "type": "module",
-  "description": "A plugin for your Webpack build process, helping you generate a manifest of local files that should be precached.",
+  "description": "A plugin for your webpack build process, helping you generate a manifest of local files that should be precached.",
   "files": [
     "src",
     "dist"
@@ -22,7 +22,7 @@
   },
   "author": "Google's Web DevRel Team, Serwist's Team",
   "license": "MIT",
-  "repository": "serwist/serwist",
+  "repository": "https://github.com/serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
   "main": "./dist/index.js",
@@ -31,6 +31,9 @@
     "*": {
       "internal": [
         "./dist/index.internal.d.ts"
+      ],
+      "schema": [
+        "./dist/index.schema.d.ts"
       ]
     }
   },
@@ -43,21 +46,26 @@
       "types": "./dist/index.internal.d.ts",
       "default": "./dist/index.internal.js"
     },
+    "./schema": {
+      "types": "./dist/index.schema.d.ts",
+      "default": "./dist/index.schema.js"
+    },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "fast-json-stable-stringify": "2.1.0",
     "pretty-bytes": "6.1.1",
     "upath": "2.0.1",
-    "@serwist/build": "9.0.0-preview.9"
+    "zod": "3.22.4",
+    "@serwist/build": "9.0.1"
   },
   "devDependencies": {
-    "@types/node": "20.11.16",
+    "@types/node": "20.12.7",
     "@types/webpack": "5.28.5",
-    "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240206",
-    "webpack": "5.90.1",
-    "@serwist/constants": "9.0.0-preview.9"
+    "rollup": "4.14.3",
+    "typescript": "5.5.0-dev.20240415",
+    "webpack": "5.91.0",
+    "@serwist/configs": "9.0.1",
+    "@serwist/utils": "9.0.1"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0",
@@ -66,6 +74,9 @@
   "peerDependenciesMeta": {
     "typescript": {
       "optional": true
+    },
+    "webpack": {
+      "optional": true
     }
   },
   "scripts": {

package/src/index.schema.ts

@@ -0,0 +1,3 @@
+import { injectManifestOptions, injectPartial, webpackPartial } from "./lib/schema.js";
+
+export { webpackPartial, injectPartial as injectManifestPartial, injectManifestOptions };

package/src/index.ts

@@ -7,5 +7,8 @@
 */
 
 import { InjectManifest } from "./inject-manifest.js";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved } from "./lib/types.js";
+import { validateInjectManifestOptions } from "./lib/validator.js";
 
-export { InjectManifest };
+export { InjectManifest, validateInjectManifestOptions };
+export type { InjectManifestOptions, InjectManifestOptionsComplete, WebpackPartial, WebpackResolved };

package/src/inject-manifest.ts

@@ -1,17 +1,9 @@
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-import type { WebpackInjectManifestOptions } from "@serwist/build";
-import { escapeRegExp, replaceAndUpdateSourceMap, validateWebpackInjectManifestOptions } from "@serwist/build";
-import stringify from "fast-json-stable-stringify";
+import { escapeRegExp, replaceAndUpdateSourceMap, stringify } from "@serwist/build";
 import prettyBytes from "pretty-bytes";
 import upath from "upath";
-import type { Compilation } from "webpack";
-import webpack from "webpack";
+import type { Compilation, Compiler, WebpackError, default as Webpack } from "webpack";
+import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./lib/types.js";
+import { validateInjectManifestOptions } from "./lib/validator.js";
 
 import { getManifestEntriesFromCompilation } from "./lib/get-manifest-entries-from-compilation.js";
 import { getSourcemapAssetName } from "./lib/get-sourcemap-asset-name.js";
@@ -44,15 +36,18 @@ const _generatedAssetNames = new Set<string>();
  * ```
  */
 export class InjectManifest {
-  protected config: WebpackInjectManifestOptions;
+  protected config: InjectManifestOptionsComplete;
   private alreadyCalled: boolean;
+  private webpack: typeof Webpack;
 
   /**
    * Creates an instance of InjectManifest.
    */
-  constructor(config: WebpackInjectManifestOptions) {
-    this.config = config;
+  constructor(config: InjectManifestOptions) {
+    // We are essentially lying to TypeScript.
+    this.config = config as InjectManifestOptionsComplete;
     this.alreadyCalled = false;
+    this.webpack = null!;
   }
 
   /**
@@ -60,17 +55,17 @@ export class InjectManifest {
    *
    * @private
    */
-  propagateWebpackConfig(): void {
+  private propagateWebpackConfig(compiler: Compiler): void {
+    this.webpack = compiler.webpack;
+
     const parsedSwSrc = upath.parse(this.config.swSrc);
     // Because this.config is listed last, properties that are already set
     // there take precedence over derived properties from the compiler.
-    this.config = Object.assign(
-      {
-        // Use swSrc with a hardcoded .js extension, in case swSrc is a .ts file.
-        swDest: `${parsedSwSrc.name}.js`,
-      },
-      this.config,
-    );
+    this.config = {
+      // Use swSrc with a hardcoded .js extension, in case swSrc is a .ts file.
+      swDest: `${parsedSwSrc.name}.js`,
+      ...this.config,
+    };
   }
 
   /**
@@ -78,7 +73,7 @@ export class InjectManifest {
    *
    * @private
    */
-  async getManifestEntries(compilation: webpack.Compilation, config: WebpackInjectManifestOptions) {
+  private async getManifestEntries(compilation: Compilation, config: InjectManifestOptionsComplete) {
     if (config.disablePrecacheManifest) {
       return {
         size: 0,
@@ -92,7 +87,7 @@ export class InjectManifest {
       const warningMessage = `${this.constructor.name} has been called multiple times, perhaps due to running webpack in --watch mode. The precache manifest generated after the first call may be inaccurate! Please see https://github.com/GoogleChrome/workbox/issues/1790 for more information.`;
 
       if (!compilation.warnings.some((warning) => warning instanceof Error && warning.message === warningMessage)) {
-        compilation.warnings.push(new Error(warningMessage) as webpack.WebpackError);
+        compilation.warnings.push(new Error(warningMessage) as WebpackError);
       }
     } else {
       this.alreadyCalled = true;
@@ -123,16 +118,17 @@ export class InjectManifest {
    *
    * @private
    */
-  apply(compiler: webpack.Compiler): void {
-    this.propagateWebpackConfig();
+  apply(compiler: Compiler): void {
+    this.propagateWebpackConfig(compiler);
 
     compiler.hooks.make.tapPromise(this.constructor.name, (compilation) =>
-      this.handleMake(compilation, compiler).catch((error: webpack.WebpackError) => {
+      this.handleMake(compilation, compiler).catch((error: WebpackError) => {
         compilation.errors.push(error);
       }),
     );
 
-    const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = webpack.Compilation;
+    // webpack should not be null at this point.
+    const { PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER } = this.webpack.Compilation;
     // Specifically hook into thisCompilation, as per
     // https://github.com/webpack/webpack/issues/11425#issuecomment-690547848
     compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation) => {
@@ -144,7 +140,7 @@ export class InjectManifest {
           stage: PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER - 10,
         },
         () =>
-          this.addAssets(compilation).catch((error: webpack.WebpackError) => {
+          this.addAssets(compilation).catch((error: WebpackError) => {
             compilation.errors.push(error);
           }),
       );
@@ -157,7 +153,7 @@ export class InjectManifest {
    *
    * @private
    */
-  async performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void> {
+  private async performChildCompilation(compilation: Compilation, parentCompiler: Compiler): Promise<void> {
     const outputOptions: Parameters<Compilation["createChildCompiler"]>["1"] = {
       filename: this.config.swDest,
     };
@@ -174,7 +170,7 @@ export class InjectManifest {
       }
     }
 
-    new webpack.EntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
+    new this.webpack.EntryPlugin(parentCompiler.context, this.config.swSrc, this.constructor.name).apply(childCompiler);
 
     await new Promise<void>((resolve, reject) => {
       childCompiler.runAsChild((error, _entries, childCompilation) => {
@@ -196,10 +192,9 @@ export class InjectManifest {
    *
    * @private
    */
-  addSrcToAssets(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): void {
-    // eslint-disable-next-line
+  private addSrcToAssets(compilation: Compilation, parentCompiler: Compiler): void {
     const source = (parentCompiler.inputFileSystem as any).readFileSync(this.config.swSrc);
-    compilation.emitAsset(this.config.swDest!, new webpack.sources.RawSource(source));
+    compilation.emitAsset(this.config.swDest!, new this.webpack.sources.RawSource(source));
   }
 
   /**
@@ -208,8 +203,8 @@ export class InjectManifest {
    *
    * @private
    */
-  async handleMake(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void> {
-    this.config = await validateWebpackInjectManifestOptions(this.config);
+  private async handleMake(compilation: Compilation, parentCompiler: Compiler): Promise<void> {
+    this.config = await validateInjectManifestOptions(this.config);
     this.config.swDest = relativeToOutputPath(compilation, this.config.swDest!);
     _generatedAssetNames.add(this.config.swDest);
 
@@ -220,9 +215,7 @@ export class InjectManifest {
       // This used to be a fatal error, but just warn at runtime because we
       // can't validate it easily.
       if (Array.isArray(this.config.webpackCompilationPlugins) && this.config.webpackCompilationPlugins.length > 0) {
-        compilation.warnings.push(
-          new Error("compileSrc is false, so the " + "webpackCompilationPlugins option will be ignored.") as webpack.WebpackError,
-        );
+        compilation.warnings.push(new Error("'compileSrc' is 'false', so the 'webpackCompilationPlugins' option will be ignored.") as WebpackError);
       }
     }
   }
@@ -232,7 +225,7 @@ export class InjectManifest {
    *
    * @private
    */
-  async addAssets(compilation: webpack.Compilation): Promise<void> {
+  private async addAssets(compilation: Compilation): Promise<void> {
     const config = Object.assign({}, this.config);
 
     const { size, sortedEntries, manifestString } = await this.getManifestEntries(compilation, config);
@@ -244,7 +237,7 @@ export class InjectManifest {
     const swAsset = compilation.getAsset(config.swDest!);
     const swAssetString = swAsset!.source.source().toString();
 
-    const globalRegexp = new RegExp(escapeRegExp(config.injectionPoint!), "g");
+    const globalRegexp = new RegExp(escapeRegExp(config.injectionPoint), "g");
     const injectionResults = swAssetString.match(globalRegexp);
 
     if (!injectionResults) {
@@ -270,12 +263,12 @@ export class InjectManifest {
         searchString: config.injectionPoint!,
       });
 
-      compilation.updateAsset(sourcemapAssetName, new webpack.sources.RawSource(map));
-      compilation.updateAsset(config.swDest!, new webpack.sources.RawSource(source));
+      compilation.updateAsset(sourcemapAssetName, new this.webpack.sources.RawSource(map));
+      compilation.updateAsset(config.swDest!, new this.webpack.sources.RawSource(source));
     } else {
       // If there's no sourcemap associated with swDest, a simple string
       // replacement will suffice.
-      compilation.updateAsset(config.swDest!, new webpack.sources.RawSource(swAssetString.replace(config.injectionPoint!, manifestString)));
+      compilation.updateAsset(config.swDest!, new this.webpack.sources.RawSource(swAssetString.replace(config.injectionPoint!, manifestString)));
     }
 
     if (compilation.getLogger) {

package/src/lib/child-compilation-plugin.ts

@@ -1,5 +1,4 @@
-import type { Compilation, WebpackPluginInstance } from "webpack";
-import webpack from "webpack";
+import type { Compilation, Compiler, WebpackError, WebpackPluginInstance, default as Webpack } from "webpack";
 
 import { relativeToOutputPath } from "./relative-to-output-path.js";
 
@@ -18,19 +17,42 @@ export class ChildCompilationPlugin implements WebpackPluginInstance {
   src: string;
   dest: string;
   plugins: WebpackPluginInstance[] | undefined;
+  webpack: typeof Webpack;
   constructor({ src, dest, plugins }: ChildCompilationPluginOptions) {
     this.src = src;
     this.dest = dest;
     this.plugins = plugins;
+    this.webpack = null!;
   }
-  apply(compiler: webpack.Compiler) {
+  /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */
+  private propagateWebpackConfig(compiler: Compiler): void {
+    this.webpack = compiler.webpack;
+  }
+  /**
+   * @param compiler default compiler object passed from webpack
+   *
+   * @private
+   */
+  apply(compiler: Compiler) {
+    this.propagateWebpackConfig(compiler);
+
     compiler.hooks.make.tapPromise(this.constructor.name, (compilation) =>
-      this.performChildCompilation(compilation, compiler).catch((error: webpack.WebpackError) => {
+      this.performChildCompilation(compilation, compiler).catch((error: WebpackError) => {
         compilation.errors.push(error);
       }),
     );
   }
-  async performChildCompilation(compilation: webpack.Compilation, parentCompiler: webpack.Compiler): Promise<void> {
+  /**
+   * @param compilation The webpack compilation.
+   * @param parentCompiler The webpack parent compiler.
+   *
+   * @private
+   */
+  private async performChildCompilation(compilation: Compilation, parentCompiler: Compiler): Promise<void> {
     const resolvedDest = relativeToOutputPath(compilation, this.dest);
     const outputOptions: Parameters<Compilation["createChildCompiler"]>["1"] = {
       filename: resolvedDest,
@@ -48,7 +70,7 @@ export class ChildCompilationPlugin implements WebpackPluginInstance {
       }
     }
 
-    new webpack.EntryPlugin(parentCompiler.context, this.src, this.constructor.name).apply(childCompiler);
+    new this.webpack.EntryPlugin(parentCompiler.context, this.src, this.constructor.name).apply(childCompiler);
 
     await new Promise<void>((resolve, reject) => {
       childCompiler.runAsChild((error, _entries, childCompilation) => {

package/src/lib/get-asset-hash.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import crypto from "crypto";
+import crypto from "node:crypto";
 import type { Asset } from "webpack";
 
 /**

package/src/lib/get-manifest-entries-from-compilation.ts

@@ -6,13 +6,13 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { FileDetails, ManifestEntry, WebpackInjectManifestOptions } from "@serwist/build";
+import type { FileDetails, ManifestEntry } from "@serwist/build";
 import { transformManifest } from "@serwist/build";
 import type { Asset, Chunk, Compilation, WebpackError } from "webpack";
-import webpack from "webpack";
 
 import { getAssetHash } from "./get-asset-hash.js";
 import { resolveWebpackURL } from "./resolve-webpack-url.js";
+import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./types.js";
 
 /**
  * For a given asset, checks whether at least one of the conditions matches.
@@ -36,7 +36,7 @@ const checkConditions = (
       return condition({ asset, compilation });
       //return compilation !== null;
     }
-    if (webpack.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
+    if (compilation.compiler.webpack.ModuleFilenameHelpers.matchPart(asset.name, condition)) {
       return true;
     }
   }
@@ -105,7 +105,7 @@ const getNamesOfAssetsInChunk = (chunk: Chunk): string[] => {
  * based on the criteria provided.
  * @private
  */
-const filterAssets = (compilation: Compilation, config: WebpackInjectManifestOptions): Set<Asset> => {
+const filterAssets = (compilation: Compilation, config: InjectManifestOptions): Set<Asset> => {
   const filteredAssets = new Set<Asset>();
   const assets = compilation.getAssets();
 
@@ -178,7 +178,7 @@ const filterAssets = (compilation: Compilation, config: WebpackInjectManifestOpt
 
 export const getManifestEntriesFromCompilation = async (
   compilation: Compilation,
-  config: WebpackInjectManifestOptions,
+  config: InjectManifestOptionsComplete,
 ): Promise<{ size: number; sortedEntries: ManifestEntry[] | undefined }> => {
   const filteredAssets = filterAssets(compilation, config);
 
@@ -189,7 +189,7 @@ export const getManifestEntriesFromCompilation = async (
       file: resolveWebpackURL(publicPath as string, asset.name),
       hash: getAssetHash(asset),
       size: asset.source.size() || 0,
-    } as FileDetails;
+    } satisfies FileDetails;
   });
 
   const { manifestEntries, size, warnings } = await transformManifest({
@@ -200,6 +200,7 @@ export const getManifestEntriesFromCompilation = async (
     maximumFileSizeToCacheInBytes: config.maximumFileSizeToCacheInBytes,
     modifyURLPrefix: config.modifyURLPrefix,
     transformParam: compilation,
+    disablePrecacheManifest: config.disablePrecacheManifest,
   });
 
   // See https://github.com/GoogleChrome/workbox/issues/2790

package/src/lib/schema.ts

@@ -0,0 +1,28 @@
+import { basePartial, injectPartial as baseInjectPartial, optionalSwDestPartial } from "@serwist/build/schema";
+import { z } from "zod";
+
+export const webpackPartial = z
+  .object({
+    chunks: z.array(z.string()).optional(),
+    exclude: z
+      .array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())]))
+      .default([/\.map$/, /^manifest.*\.js$/]),
+    excludeChunks: z.array(z.string()).optional(),
+    include: z.array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())])).optional(),
+  })
+  .strict("Do not pass invalid properties to WebpackPartial!");
+
+export const injectPartial = z
+  .object({
+    compileSrc: z.boolean().default(true),
+    swDest: z.string().optional(),
+    webpackCompilationPlugins: z.array(z.any()).optional(),
+  })
+  .strict("Do not pass invalid properties to WebpackInjectManifestPartial!");
+
+export const injectManifestOptions = basePartial
+  .merge(webpackPartial)
+  .merge(baseInjectPartial)
+  .merge(optionalSwDestPartial)
+  .merge(injectPartial)
+  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!");

package/src/lib/types.ts

@@ -0,0 +1,67 @@
+import type {
+  BasePartial,
+  BaseResolved,
+  InjectPartial as BaseInjectPartial,
+  InjectResolved as BaseInjectResolved,
+  OptionalSwDestPartial,
+  OptionalSwDestResolved,
+} from "@serwist/build";
+import type { Require } from "@serwist/utils";
+
+export 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 | ((arg0: any) => boolean))[];
+  /**
+   * 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 | ((arg0: any) => boolean))[];
+}
+
+export type WebpackResolved = Require<WebpackPartial, "exclude">;
+
+export interface InjectPartial {
+  /**
+   * 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;
+  // This can only be set if `compileSrc` is true, but that restriction can't be
+  // represented in TypeScript. It's enforced via custom runtime validation
+  // logic and needs to be documented.
+  /**
+   * Optional webpack plugins that will be used when compiling the `swSrc`
+   * file. Only valid if `compileSrc` is `true`.
+   */
+  webpackCompilationPlugins?: any[];
+}
+
+export type InjectResolved = Require<InjectPartial, "compileSrc">;
+
+export interface InjectManifestOptions extends BasePartial, WebpackPartial, BaseInjectPartial, OptionalSwDestPartial, InjectPartial {}
+
+export interface InjectManifestOptionsComplete extends BaseResolved, WebpackResolved, BaseInjectResolved, OptionalSwDestResolved, InjectResolved {}

package/src/lib/validator.ts

@@ -0,0 +1,10 @@
+import { SerwistConfigError, validationErrorMap } from "@serwist/build/schema";
+import type { InjectManifestOptionsComplete } from "./types.js";
+
+export const validateInjectManifestOptions = async (input: unknown): Promise<InjectManifestOptionsComplete> => {
+  const result = await (await import("./schema.js")).injectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  if (!result.success) {
+    throw new SerwistConfigError({ moduleName: "@serwist/webpack-plugin", message: JSON.stringify(result.error.format(), null, 2) });
+  }
+  return result.data;
+};