@serwist/webpack-plugin 9.0.0-preview.12 → 9.0.0-preview.13

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.js

@@ -1,10 +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 { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
 import crypto from '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;
@@ -238,7 +251,7 @@ class InjectManifest {
         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) {
@@ -288,4 +301,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 type { Compiler } from "webpack";
+import type { InjectManifestOptions } 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,13 +23,13 @@ import type { Compiler } from "webpack";
  * ```
  */
 export declare class InjectManifest {
-    protected config: WebpackInjectManifestOptions;
+    protected config: InjectManifestOptions;
     private alreadyCalled;
     private webpack;
     /**
      * Creates an instance of InjectManifest.
      */
-    constructor(config: WebpackInjectManifestOptions);
+    constructor(config: InjectManifestOptions);
     /**
      * @param compiler default compiler object passed from webpack
      *

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;AAKnE,OAAO,KAAK,EAAe,QAAQ,EAAoC,MAAM,SAAS,CAAC;AAUvF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,MAAM,EAAE,4BAA4B,CAAC;IAC/C,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAEhC;;OAEG;gBACS,MAAM,EAAE,4BAA4B;IAMhD;;;;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"}
+{"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,MAAM,gBAAgB,CAAC;AAW5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACxC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAEhC;;OAEG;gBACS,MAAM,EAAE,qBAAqB;IAMzC;;;;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/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 { InjectManifestOptions } from "./types.js";
+export declare const getManifestEntriesFromCompilation: (compilation: Compilation, config: InjectManifestOptions) => 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;AAuKvE,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,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAoKxD,eAAO,MAAM,iCAAiC,gBAC/B,WAAW,UAChB,qBAAqB;UACZ,MAAM;mBAAiB,aAAa,EAAE,GAAG,SAAS;EAgCpE,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.ZodNullable<z.ZodString>;
+        url: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        revision: string | null;
+        url: string;
+        integrity?: string | undefined;
+    }, {
+        revision: string | null;
+        url: string;
+        integrity?: string | 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.ZodNullable<z.ZodString>;
+        url: z.ZodString;
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        revision: string | null;
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+    }, {
+        revision: string | null;
+        url: string;
+        size: number;
+        integrity?: string | 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.ZodNullable<z.ZodString>;
+            url: z.ZodString;
+            size: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }, {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }>, "many">;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }, {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }>>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodNullable<z.ZodString>;
+            url: z.ZodString;
+            size: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }, {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }>, "many">;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    }, {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | 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 | {
+        revision: string | null;
+        url: string;
+        integrity?: string | undefined;
+    })[] | undefined;
+    dontCacheBustURLsMatching?: RegExp | undefined;
+    manifestTransforms?: ((args_0: {
+        revision: string | null;
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+    }[], args_1: unknown) => {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    } | Promise<{
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | 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 | {
+        revision: string | null;
+        url: string;
+        integrity?: string | undefined;
+    })[] | undefined;
+    disablePrecacheManifest?: boolean | undefined;
+    dontCacheBustURLsMatching?: RegExp | undefined;
+    manifestTransforms?: ((args_0: {
+        revision: string | null;
+        url: string;
+        size: number;
+        integrity?: string | undefined;
+    }[], args_1: unknown) => {
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | undefined;
+        }[];
+        warnings?: string[] | undefined;
+    } | Promise<{
+        manifest: {
+            revision: string | null;
+            url: string;
+            size: number;
+            integrity?: string | 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`
+     * input 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;IAKlB;;;;;;;;;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.12",
+  "version": "9.0.0-preview.13",
   "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"
@@ -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.12"
+    "zod": "3.22.4",
+    "@serwist/build": "9.0.0-preview.13"
   },
   "devDependencies": {
-    "@types/node": "20.11.16",
+    "@types/node": "20.11.24",
     "@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.12"
+    "rollup": "4.12.0",
+    "typescript": "5.5.0-dev.20240304",
+    "webpack": "5.90.3",
+    "@serwist/utils": "9.0.0-preview.13",
+    "@serwist/constants": "9.0.0-preview.13"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0",

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,16 +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, Compiler, WebpackError, default as Webpack } from "webpack";
+import type { InjectManifestOptions } 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";
@@ -43,14 +36,14 @@ const _generatedAssetNames = new Set<string>();
  * ```
  */
 export class InjectManifest {
-  protected config: WebpackInjectManifestOptions;
+  protected config: InjectManifestOptions;
   private alreadyCalled: boolean;
   private webpack: typeof Webpack;
 
   /**
    * Creates an instance of InjectManifest.
    */
-  constructor(config: WebpackInjectManifestOptions) {
+  constructor(config: InjectManifestOptions) {
     this.config = config;
     this.alreadyCalled = false;
     this.webpack = null!;
@@ -79,7 +72,7 @@ export class InjectManifest {
    *
    * @private
    */
-  private async getManifestEntries(compilation: Compilation, config: WebpackInjectManifestOptions) {
+  private async getManifestEntries(compilation: Compilation, config: InjectManifestOptions) {
     if (config.disablePrecacheManifest) {
       return {
         size: 0,
@@ -210,7 +203,7 @@ export class InjectManifest {
    * @private
    */
   private async handleMake(compilation: Compilation, parentCompiler: Compiler): Promise<void> {
-    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);
 

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

@@ -6,12 +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 { getAssetHash } from "./get-asset-hash.js";
 import { resolveWebpackURL } from "./resolve-webpack-url.js";
+import type { InjectManifestOptions } from "./types.js";
 
 /**
  * For a given asset, checks whether at least one of the conditions matches.
@@ -104,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();
 
@@ -177,7 +178,7 @@ const filterAssets = (compilation: Compilation, config: WebpackInjectManifestOpt
 
 export const getManifestEntriesFromCompilation = async (
   compilation: Compilation,
-  config: WebpackInjectManifestOptions,
+  config: InjectManifestOptions,
 ): Promise<{ size: number; sortedEntries: ManifestEntry[] | undefined }> => {
   const filteredAssets = filterAssets(compilation, config);
 

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,71 @@
+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[];
+  // We can't use the @default annotation here to assign the value via AJV, as
+  // an (RegExp)[] can't be serialized into JSON.
+  // The default value of [/\.map$/, /^manifest.*\.js$/] will be assigned by
+  // the validation function, and we need to reflect that in the docs.
+  /**
+   * 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`
+   * input 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;
+};