@serwist/build 9.0.0-preview.0 → 9.0.0-preview.1

package/dist/chunks/glob.js

@@ -51,8 +51,6 @@ const globPartial = z.object({
 z.object({
     globDirectory: z.string().optional()
 }).strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
-// This needs to be set when using GetManifest or InjectManifest. This is
-// enforced via runtime validation, and needs to be documented.
 const requiredGlobDirectoryPartial = z.object({
     globDirectory: z.string()
 }).strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");

package/dist/chunks/serwist-config-error.js

@@ -1,9 +1,7 @@
 import { z } from 'zod';
 
 const validationErrorMap = (error, ctx)=>{
-    /*
-    This is where you override the various error codes
-    */ switch(error.code){
+    switch(error.code){
         case z.ZodIssueCode.invalid_type:
             {
                 return {
@@ -41,7 +39,6 @@ const validationErrorMap = (error, ctx)=>{
                 };
             }
     }
-    // Fallback to the default message.
     return {
         message: ctx.defaultError
     };

package/dist/index.js

@@ -6,6 +6,7 @@ import crypto from 'crypto';
 import { glob } from 'glob';
 import upath from 'upath';
 import fse from 'fs-extra';
+import prettyBytes from 'pretty-bytes';
 import { v as validationErrorMap, S as SerwistConfigError } from './chunks/serwist-config-error.js';
 import { SourceMapGenerator, SourceMapConsumer } from 'source-map';
 import 'zod';
@@ -195,8 +196,6 @@ const additionalPrecacheEntriesTransform = (additionalPrecacheEntries)=>{
         const warnings = [];
         const stringEntries = new Set();
         for (const additionalEntry of additionalPrecacheEntries){
-            // Warn about either a string or an object that lacks a revision property.
-            // (An object with a revision property set to null is okay.)
             if (typeof additionalEntry === "string") {
                 stringEntries.add(additionalEntry);
                 manifest.push({
@@ -227,110 +226,6 @@ const additionalPrecacheEntriesTransform = (additionalPrecacheEntries)=>{
     };
 };
 
-const BYTE_UNITS = [
-    'B',
-    'kB',
-    'MB',
-    'GB',
-    'TB',
-    'PB',
-    'EB',
-    'ZB',
-    'YB'
-];
-const BIBYTE_UNITS = [
-    'B',
-    'KiB',
-    'MiB',
-    'GiB',
-    'TiB',
-    'PiB',
-    'EiB',
-    'ZiB',
-    'YiB'
-];
-const BIT_UNITS = [
-    'b',
-    'kbit',
-    'Mbit',
-    'Gbit',
-    'Tbit',
-    'Pbit',
-    'Ebit',
-    'Zbit',
-    'Ybit'
-];
-const BIBIT_UNITS = [
-    'b',
-    'kibit',
-    'Mibit',
-    'Gibit',
-    'Tibit',
-    'Pibit',
-    'Eibit',
-    'Zibit',
-    'Yibit'
-];
-/*
-Formats the given number using `Number#toLocaleString`.
-- If locale is a string, the value is expected to be a locale-key (for example: `de`).
-- If locale is true, the system default locale is used for translation.
-- If no value for locale is specified, the number is returned unmodified.
-*/ const toLocaleString = (number, locale, options)=>{
-    let result = number;
-    if (typeof locale === 'string' || Array.isArray(locale)) {
-        result = number.toLocaleString(locale, options);
-    } else if (locale === true || options !== undefined) {
-        result = number.toLocaleString(undefined, options);
-    }
-    return result;
-};
-function prettyBytes(number, options) {
-    if (!Number.isFinite(number)) {
-        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
-    }
-    options = {
-        bits: false,
-        binary: false,
-        space: true,
-        ...options
-    };
-    const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
-    const separator = options.space ? ' ' : '';
-    if (options.signed && number === 0) {
-        return ` 0${separator}${UNITS[0]}`;
-    }
-    const isNegative = number < 0;
-    const prefix = isNegative ? '-' : options.signed ? '+' : '';
-    if (isNegative) {
-        number = -number;
-    }
-    let localeOptions;
-    if (options.minimumFractionDigits !== undefined) {
-        localeOptions = {
-            minimumFractionDigits: options.minimumFractionDigits
-        };
-    }
-    if (options.maximumFractionDigits !== undefined) {
-        localeOptions = {
-            maximumFractionDigits: options.maximumFractionDigits,
-            ...localeOptions
-        };
-    }
-    if (number < 1) {
-        const numberString = toLocaleString(number, options.locale, localeOptions);
-        return prefix + numberString + separator + UNITS[0];
-    }
-    const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
-    number /= (options.binary ? 1024 : 1000) ** exponent;
-    if (!localeOptions) {
-        number = number.toPrecision(3);
-    }
-    const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-    const unit = UNITS[exponent];
-    return prefix + numberString + separator + unit;
-}
-
 function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
     return (originalManifest)=>{
         const warnings = [];
@@ -348,13 +243,6 @@ function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
     };
 }
 
-/*
-  Copyright 2019 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.
-*/ // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
 const escapeRegExp = (str)=>{
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 };
@@ -363,8 +251,6 @@ function modifyURLPrefixTransform(modifyURLPrefix) {
     if (!modifyURLPrefix || typeof modifyURLPrefix !== "object" || Array.isArray(modifyURLPrefix)) {
         throw new Error(errors["modify-url-prefix-bad-prefixes"]);
     }
-    // If there are no entries in modifyURLPrefix, just return an identity
-    // function as a shortcut.
     if (Object.keys(modifyURLPrefix).length === 0) {
         return (manifest)=>{
             return {
@@ -377,12 +263,8 @@ function modifyURLPrefixTransform(modifyURLPrefix) {
             throw new Error(errors["modify-url-prefix-bad-prefixes"]);
         }
     }
-    // Escape the user input so it's safe to use in a regex.
     const safeModifyURLPrefixes = Object.keys(modifyURLPrefix).map(escapeRegExp);
-    // Join all the `modifyURLPrefix` keys so a single regex can be used.
     const prefixMatchesStrings = safeModifyURLPrefixes.join("|");
-    // Add `^` to the front the prefix matches so it only matches the start of
-    // a string.
     const modifyRegex = new RegExp(`^(${prefixMatchesStrings})`);
     return (originalManifest)=>{
         const manifest = originalManifest.map((entry)=>{
@@ -430,8 +312,6 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
         };
     }
     const allWarnings = [];
-    // Take the array of fileDetail objects and convert it into an array of
-    // {url, revision, size} objects, with \ replaced with /.
     const normalizedManifest = fileDetails.map((fileDetails)=>{
         return {
             url: fileDetails.file.replace(/\\/g, "/"),
@@ -449,11 +329,9 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
     if (dontCacheBustURLsMatching) {
         transformsToApply.push(noRevisionForURLsMatchingTransform(dontCacheBustURLsMatching));
     }
-    // Run any manifestTransforms functions second-to-last.
     if (manifestTransforms) {
         transformsToApply.push(...manifestTransforms);
     }
-    // Run additionalPrecacheEntriesTransform last.
     if (additionalPrecacheEntries) {
         transformsToApply.push(additionalPrecacheEntriesTransform(additionalPrecacheEntries));
     }
@@ -466,13 +344,10 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
         transformedManifest = result.manifest;
         allWarnings.push(...result.warnings || []);
     }
-    // Generate some metadata about the manifest before we clear out the size
-    // properties from each entry.
     const count = transformedManifest.length;
     let size = 0;
     for (const manifestEntry of transformedManifest){
         size += manifestEntry.size || 0;
-        // biome-ignore lint/performance/noDelete: I don't understand this part yet.
         delete manifestEntry.size;
     }
     return {
@@ -513,8 +388,6 @@ async function getFileManifestEntries({ additionalPrecacheEntries, dontCacheBust
             }
         }
     } catch (error) {
-        // If there's an exception thrown while globbing, then report
-        // it back as a warning, and don't consider it fatal.
         if (error instanceof Error && error.message) {
             warnings.push(error.message);
         }
@@ -614,34 +487,11 @@ const validateViteInjectManifestOptions = async (input)=>{
     return result.data;
 };
 
-/**
- * This method returns a list of URLs to precache, referred to as a "precache
- * manifest", along with details about the number of entries and their size,
- * based on the options you provide.
- *
- * ```
- * // The following lists some common options; see the rest of the documentation
- * // for the full set of options and defaults.
- * const {count, manifestEntries, size, warnings} = await getManifest({
- *   dontCacheBustURLsMatching: [new RegExp('...')],
- *   globDirectory: '...',
- *   globPatterns: ['...', '...'],
- *   maximumFileSizeToCacheInBytes: ...,
- * });
- * ```
- */ const getManifest = async (config)=>{
+const getManifest = async (config)=>{
     const options = await validateGetManifestOptions(config);
     return await getFileManifestEntries(options);
 };
 
-/*
-  Copyright 2022 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.
-*/ // Adapted from https://github.com/lydell/source-map-url/blob/master/source-map-url.js
-// See https://github.com/GoogleChrome/workbox/issues/3019
 const innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/;
 const regex = RegExp(`(?:/\\*(?:\\s*\r?\n(?://)?)?(?:${innerRegex.source})\\s*\\*/|//(?:${innerRegex.source}))\\s*`);
 function getSourceMapURL(srcContents) {
@@ -650,24 +500,13 @@ function getSourceMapURL(srcContents) {
 }
 
 function rebasePath({ baseDirectory, file }) {
-    // The initial path is relative to the current directory, so make it absolute.
     const absolutePath = upath.resolve(file);
-    // Convert the absolute path so that it's relative to the baseDirectory.
     const relativePath = upath.relative(baseDirectory, absolutePath);
-    // Remove any leading ./ as it won't work in a glob pattern.
     const normalizedPath = upath.normalize(relativePath);
     return normalizedPath;
 }
 
-/**
- * Adapted from https://github.com/nsams/sourcemap-aware-replace, with modern
- * JavaScript updates, along with additional properties copied from originalMap.
- *
- * @param options
- * @returns An object containing both
- * originalSource with the replacement applied, and the modified originalMap.
- * @private
- */ async function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString }) {
+async function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString }) {
     const generator = new SourceMapGenerator({
         file: jsFilename
     });
@@ -717,8 +556,6 @@ function rebasePath({ baseDirectory, file }) {
         return mapping;
     });
     consumer.destroy();
-    // JSON.parse returns any.
-    // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
     const updatedSourceMap = Object.assign(JSON.parse(generator.toString()), {
         names: originalMap.names,
         sourceRoot: originalMap.sourceRoot,
@@ -751,34 +588,8 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
     };
 }
 
-/**
- * This method creates a list of URLs to precache, referred to as a "precache
- * manifest", based on the options you provide.
- *
- * The manifest is injected into the `swSrc` file, and the placeholder string
- * `injectionPoint` determines where in the file the manifest should go.
- *
- * The final service worker file, with the manifest injected, is written to
- * disk at `swDest`.
- *
- * This method will not compile or bundle your `swSrc` file; it just handles
- * injecting the manifest.
- *
- * ```
- * // The following lists some common options; see the rest of the documentation
- * // for the full set of options and defaults.
- * const {count, size, warnings} = await injectManifest({
- *   dontCacheBustURLsMatching: [new RegExp('...')],
- *   globDirectory: '...',
- *   globPatterns: ['...', '...'],
- *   maximumFileSizeToCacheInBytes: ...,
- *   swDest: '...',
- *   swSrc: '...',
- * });
- * ```
- */ const injectManifest = async (config)=>{
+const injectManifest = async (config)=>{
     const options = await validateInjectManifestOptions(config);
-    // Make sure we leave swSrc and swDest out of the precache manifest.
     for (const file of [
         options.swSrc,
         options.swDest
@@ -797,7 +608,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         throw new Error(`${errors["invalid-sw-src"]} ${error instanceof Error && error.message ? error.message : ""}`);
     }
     const injectionResults = swFileContents.match(globalRegexp);
-    // See https://github.com/GoogleChrome/workbox/issues/2230
     const injectionPoint = options.injectionPoint ? options.injectionPoint : "";
     if (!injectionResults) {
         if (upath.resolve(options.swSrc) === upath.resolve(options.swDest)) {
@@ -809,17 +619,10 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
     const manifestString = manifestEntries === undefined ? "undefined" : stringify(manifestEntries);
     const filesToWrite = {};
     const url = getSourceMapURL(swFileContents);
-    // See https://github.com/GoogleChrome/workbox/issues/2957
     const { destPath, srcPath, warning } = translateURLToSourcemapPaths(url, options.swSrc, options.swDest);
     if (warning) {
         warnings.push(warning);
     }
-    // If our swSrc file contains a sourcemap, we would invalidate that
-    // mapping if we just replaced injectionPoint with the stringified manifest.
-    // Instead, we need to update the swDest contents as well as the sourcemap
-    // (assuming it's a real file, not a data: URL) at the same time.
-    // See https://github.com/GoogleChrome/workbox/issues/2235
-    // and https://github.com/GoogleChrome/workbox/issues/2648
     if (srcPath && destPath) {
         const originalMap = await fse.readJSON(srcPath, {
             encoding: "utf8"
@@ -834,8 +637,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         filesToWrite[options.swDest] = source;
         filesToWrite[destPath] = map;
     } else {
-        // If there's no sourcemap associated with swSrc, a simple string
-        // replacement will suffice.
         filesToWrite[options.swDest] = swFileContents.replace(globalRegexp, manifestString);
     }
     for (const [file, contents] of Object.entries(filesToWrite)){
@@ -850,7 +651,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         count,
         size,
         warnings,
-        // Use upath.resolve() to make all the paths absolute.
         filePaths: Object.keys(filesToWrite).map((f)=>upath.resolve(f))
     };
 };

package/dist/index.next.js

@@ -5,13 +5,16 @@ import { v as validationErrorMap, S as SerwistConfigError } from './chunks/serwi
 import './chunks/glob.js';
 
 const nextInjectManifestPartial = z.object({
-    cacheOnFrontEndNav: z.boolean().default(false),
+    cacheOnNavigation: z.boolean().default(false),
     disable: z.boolean().default(false),
     register: z.boolean().default(true),
     reloadOnOnline: z.boolean().default(true),
     scope: z.string().optional(),
     swUrl: z.string().default("/sw.js"),
-    globPublicPatterns: z.array(z.string()).default([
+    globPublicPatterns: z.union([
+        z.string(),
+        z.array(z.string())
+    ]).default([
         "**/*"
     ])
 }).strict("Do not pass invalid properties to NextInjectManifestPartial!");

package/dist/schema/assertType.d.ts

@@ -0,0 +1,3 @@
+export type Equals<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+export declare function assertType<_T extends true>(): void;
+//# sourceMappingURL=assertType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assertType.d.ts","sourceRoot":"","sources":["../../src/schema/assertType.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC;AAEtF,wBAAgB,UAAU,CAAC,EAAE,SAAS,IAAI,UAEzC"}

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASkG,CAAC"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASmC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"getManifest.d.ts","sourceRoot":"","sources":["../../src/schema/getManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC"}
+{"version":3,"file":"getManifest.d.ts","sourceRoot":"","sources":["../../src/schema/getManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGmC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/schema/glob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;EAQkG,CAAC;AAE3H,eAAO,MAAM,4BAA4B;;;;;;EAQxC,CAAC;AAIF,eAAO,MAAM,4BAA4B;;;;;;EAQxC,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/schema/glob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;EAQmC,CAAC;AAE5D,eAAO,MAAM,4BAA4B;;;;;;EAImC,CAAC;AAI7E,eAAO,MAAM,4BAA4B;;;;;;EAImC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"injectManifest.d.ts","sourceRoot":"","sources":["../../src/schema/injectManifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa;;;;;;;;;EAKsG,CAAC;AAEjI,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjC,CAAC"}
+{"version":3,"file":"injectManifest.d.ts","sourceRoot":"","sources":["../../src/schema/injectManifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,aAAa;;;;;;;;;EAKmC,CAAC;AAE9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

package/dist/schema/next.d.ts

@@ -1,28 +1,28 @@
 import { z } from "zod";
 export declare const nextInjectManifestPartial: z.ZodObject<{
-    cacheOnFrontEndNav: z.ZodDefault<z.ZodBoolean>;
+    cacheOnNavigation: z.ZodDefault<z.ZodBoolean>;
     disable: z.ZodDefault<z.ZodBoolean>;
     register: z.ZodDefault<z.ZodBoolean>;
     reloadOnOnline: z.ZodDefault<z.ZodBoolean>;
     scope: z.ZodOptional<z.ZodString>;
     swUrl: z.ZodDefault<z.ZodString>;
-    globPublicPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    globPublicPatterns: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
 }, "strict", z.ZodTypeAny, {
-    cacheOnFrontEndNav: boolean;
+    cacheOnNavigation: boolean;
     disable: boolean;
     register: boolean;
     reloadOnOnline: boolean;
     swUrl: string;
-    globPublicPatterns: string[];
+    globPublicPatterns: (string | string[]) & (string | string[] | undefined);
     scope?: string | undefined;
 }, {
-    cacheOnFrontEndNav?: boolean | undefined;
+    cacheOnNavigation?: boolean | undefined;
     disable?: boolean | undefined;
     register?: boolean | undefined;
     reloadOnOnline?: boolean | undefined;
     scope?: string | undefined;
     swUrl?: string | undefined;
-    globPublicPatterns?: string[] | undefined;
+    globPublicPatterns?: string | string[] | undefined;
 }>;
 export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
@@ -136,25 +136,25 @@ export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     compileSrc: z.ZodDefault<z.ZodBoolean>;
     webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
     swDest: z.ZodString;
-    cacheOnFrontEndNav: z.ZodDefault<z.ZodBoolean>;
+    cacheOnNavigation: z.ZodDefault<z.ZodBoolean>;
     disable: z.ZodDefault<z.ZodBoolean>;
     register: z.ZodDefault<z.ZodBoolean>;
     reloadOnOnline: z.ZodDefault<z.ZodBoolean>;
     scope: z.ZodOptional<z.ZodString>;
     swUrl: z.ZodDefault<z.ZodString>;
-    globPublicPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    globPublicPatterns: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
 }, "disablePrecacheManifest">, "strict", z.ZodTypeAny, {
     maximumFileSizeToCacheInBytes: number;
     injectionPoint: string;
     swSrc: string;
     exclude: (string | RegExp | ((args_0: any) => boolean))[];
     compileSrc: boolean;
-    cacheOnFrontEndNav: boolean;
+    cacheOnNavigation: boolean;
     disable: boolean;
     register: boolean;
     reloadOnOnline: boolean;
     swUrl: string;
-    globPublicPatterns: string[];
+    globPublicPatterns: (string | string[]) & (string | string[] | undefined);
     swDest: string;
     additionalPrecacheEntries?: (string | {
         revision: string | null;
@@ -232,12 +232,12 @@ export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     mode?: string | null | undefined;
     compileSrc?: boolean | undefined;
     webpackCompilationPlugins?: any[] | undefined;
-    cacheOnFrontEndNav?: boolean | undefined;
+    cacheOnNavigation?: boolean | undefined;
     disable?: boolean | undefined;
     register?: boolean | undefined;
     reloadOnOnline?: boolean | undefined;
     swUrl?: string | undefined;
-    globPublicPatterns?: string[] | undefined;
+    globPublicPatterns?: string | string[] | undefined;
     scope?: string | undefined;
 }>;
 //# sourceMappingURL=next.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/schema/next.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EAcrC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQrC,CAAC"}
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/schema/next.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EAUmC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAImC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"swDest.d.ts","sourceRoot":"","sources":["../../src/schema/swDest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;;;;;EAI+G,CAAC;AAElJ,eAAO,MAAM,qBAAqB;;;;;;EAI+G,CAAC"}
+{"version":3,"file":"swDest.d.ts","sourceRoot":"","sources":["../../src/schema/swDest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,qBAAqB;;;;;;EAI4B,CAAC;AAE/D,eAAO,MAAM,qBAAqB;;;;;;EAI4B,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/schema/vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQ7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/schema/vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAS7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/schema/webpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAUwG,CAAC;AAEpI,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAUxC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAC"}
+{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/schema/webpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAUmC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAMmC,CAAC;AAE7E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

package/dist/types.d.ts

@@ -223,7 +223,7 @@ export interface NextInjectManifestPartial {
      * also adds a bit of overhead due to additional network calls.
      * @default false
      */
-    cacheOnFrontEndNav?: boolean;
+    cacheOnNavigation?: boolean;
     /**
      * Whether Serwist should be disabled.
      * @default false
@@ -304,7 +304,7 @@ export interface NextInjectManifestPartial {
      */
     globPublicPatterns?: GlobPattern | GlobPattern[];
 }
-export type NextInjectManifestResolved = Require<NextInjectManifestPartial, "cacheOnFrontEndNav" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns">;
+export type NextInjectManifestResolved = Require<NextInjectManifestPartial, "cacheOnNavigation" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns">;
 export type GetManifestOptions = BasePartial & GlobPartial & RequiredGlobDirectoryPartial;
 export type GetManifestOptionsComplete = BaseResolved & GlobResolved & RequiredGlobDirectoryResolved;
 export type InjectManifestOptions = BasePartial & GlobPartial & InjectPartial & RequiredSwDestPartial & RequiredGlobDirectoryPartial;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/build",
-  "version": "9.0.0-preview.0",
+  "version": "9.0.0-preview.1",
   "type": "module",
   "description": "A module that integrates into your build process, helping you generate a manifest of local files that should be precached.",
   "files": [
@@ -50,29 +50,29 @@
     "fast-json-stable-stringify": "2.1.0",
     "fs-extra": "11.2.0",
     "glob": "10.3.10",
+    "pretty-bytes": "6.1.1",
     "rollup": "4.9.6",
     "source-map": "0.8.0-beta.0",
     "upath": "2.0.1",
     "zod": "3.22.4",
-    "@serwist/background-sync": "9.0.0-preview.0",
-    "@serwist/broadcast-update": "9.0.0-preview.0",
-    "@serwist/cacheable-response": "9.0.0-preview.0",
-    "@serwist/core": "9.0.0-preview.0",
-    "@serwist/expiration": "9.0.0-preview.0",
-    "@serwist/google-analytics": "9.0.0-preview.0",
-    "@serwist/precaching": "9.0.0-preview.0",
-    "@serwist/routing": "9.0.0-preview.0"
+    "@serwist/background-sync": "9.0.0-preview.1",
+    "@serwist/broadcast-update": "9.0.0-preview.1",
+    "@serwist/cacheable-response": "9.0.0-preview.1",
+    "@serwist/core": "9.0.0-preview.1",
+    "@serwist/expiration": "9.0.0-preview.1",
+    "@serwist/google-analytics": "9.0.0-preview.1",
+    "@serwist/precaching": "9.0.0-preview.1",
+    "@serwist/routing": "9.0.0-preview.1"
   },
   "devDependencies": {
     "@types/common-tags": "1.8.4",
     "@types/fs-extra": "11.0.4",
     "@types/node": "20.11.16",
     "@types/stringify-object": "4.0.5",
-    "pretty-bytes": "6.1.1",
     "type-fest": "4.10.2",
     "typescript": "5.4.0-dev.20240203",
-    "@serwist/constants": "9.0.0-preview.0",
-    "@serwist/utils": "9.0.0-preview.0"
+    "@serwist/constants": "9.0.0-preview.1",
+    "@serwist/utils": "9.0.0-preview.1"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/schema/assertType.ts

@@ -0,0 +1,5 @@
+export type Equals<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+
+export function assertType<_T extends true>() {
+  // Do nothing
+}

package/src/schema/base.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import type { BasePartial, BaseResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { manifestEntry } from "./manifestEntry.js";
 import { manifestTransform } from "./manifestTransform.js";
 
@@ -13,4 +14,7 @@ export const basePartial = z
     maximumFileSizeToCacheInBytes: z.number().default(2097152),
     modifyURLPrefix: z.record(z.string(), z.string()).optional(),
   })
-  .strict("Do not pass invalid properties to BasePartial!") satisfies z.ZodType<BaseResolved, z.ZodObjectDef, BasePartial>;
+  .strict("Do not pass invalid properties to BasePartial!");
+
+assertType<Equals<BasePartial, z.input<typeof basePartial>>>();
+assertType<Equals<BaseResolved, z.output<typeof basePartial>>>();

package/src/schema/getManifest.ts

@@ -1,14 +1,13 @@
 import type { z } from "zod";
-
 import type { GetManifestOptions, GetManifestOptionsComplete } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { basePartial } from "./base.js";
 import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
 
 export const getManifestOptions = basePartial
   .merge(globPartial)
   .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to GetManifestOptions!") satisfies z.ZodType<
-  GetManifestOptionsComplete,
-  z.ZodObjectDef,
-  GetManifestOptions
->;
+  .strict("Do not pass invalid properties to GetManifestOptions!");
+
+assertType<Equals<GetManifestOptions, z.input<typeof getManifestOptions>>>();
+assertType<Equals<GetManifestOptionsComplete, z.output<typeof getManifestOptions>>>();

package/src/schema/glob.ts

@@ -7,6 +7,7 @@ import type {
   RequiredGlobDirectoryPartial,
   RequiredGlobDirectoryResolved,
 } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 
 export const globPartial = z
   .object({
@@ -16,17 +17,13 @@ export const globPartial = z
     globStrict: z.boolean().default(true),
     templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
   })
-  .strict("Do not pass invalid properties to GlobPartial!") satisfies z.ZodType<GlobResolved, z.ZodObjectDef, GlobPartial>;
+  .strict("Do not pass invalid properties to GlobPartial!");
 
 export const optionalGlobDirectoryPartial = z
   .object({
     globDirectory: z.string().optional(),
   })
-  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!") satisfies z.ZodType<
-  OptionalGlobDirectoryResolved,
-  z.ZodObjectDef,
-  OptionalGlobDirectoryPartial
->;
+  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
 
 // This needs to be set when using GetManifest or InjectManifest. This is
 // enforced via runtime validation, and needs to be documented.
@@ -34,8 +31,11 @@ export const requiredGlobDirectoryPartial = z
   .object({
     globDirectory: z.string(),
   })
-  .strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!") satisfies z.ZodType<
-  RequiredGlobDirectoryResolved,
-  z.ZodObjectDef,
-  RequiredGlobDirectoryPartial
->;
+  .strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");
+
+assertType<Equals<GlobPartial, z.input<typeof globPartial>>>();
+assertType<Equals<GlobResolved, z.output<typeof globPartial>>>();
+assertType<Equals<OptionalGlobDirectoryPartial, z.input<typeof optionalGlobDirectoryPartial>>>();
+assertType<Equals<OptionalGlobDirectoryResolved, z.output<typeof optionalGlobDirectoryPartial>>>();
+assertType<Equals<RequiredGlobDirectoryPartial, z.input<typeof requiredGlobDirectoryPartial>>>();
+assertType<Equals<RequiredGlobDirectoryResolved, z.output<typeof requiredGlobDirectoryPartial>>>();

package/src/schema/injectManifest.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { InjectManifestOptions, InjectManifestOptionsComplete, InjectPartial, InjectResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { basePartial } from "./base.js";
 import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
 import { requiredSwDestPartial } from "./swDest.js";
@@ -9,15 +10,16 @@ export const injectPartial = z
     injectionPoint: z.string().default("self.__SW_MANIFEST"),
     swSrc: z.string(),
   })
-  .strict("Do not pass invalid properties to InjectPartial!") satisfies z.ZodType<InjectResolved, z.ZodObjectDef, InjectPartial>;
+  .strict("Do not pass invalid properties to InjectPartial!");
 
 export const injectManifestOptions = basePartial
   .merge(globPartial)
   .merge(injectPartial)
   .merge(requiredSwDestPartial)
   .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to InjectManifestOptions!") satisfies z.ZodType<
-  InjectManifestOptionsComplete,
-  z.ZodObjectDef,
-  InjectManifestOptions
->;
+  .strict("Do not pass invalid properties to InjectManifestOptions!");
+
+assertType<Equals<InjectPartial, z.input<typeof injectPartial>>>();
+assertType<Equals<InjectResolved, z.output<typeof injectPartial>>>();
+assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
+assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();

package/src/schema/next.ts

@@ -5,31 +5,29 @@ import type {
   NextInjectManifestPartial,
   NextInjectManifestResolved,
 } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { requiredSwDestPartial } from "./swDest.js";
 import { webpackInjectManifestOptions } from "./webpack.js";
 
 export const nextInjectManifestPartial = z
   .object({
-    cacheOnFrontEndNav: z.boolean().default(false),
+    cacheOnNavigation: z.boolean().default(false),
     disable: z.boolean().default(false),
     register: z.boolean().default(true),
     reloadOnOnline: z.boolean().default(true),
     scope: z.string().optional(),
     swUrl: z.string().default("/sw.js"),
-    globPublicPatterns: z.array(z.string()).default(["**/*"]),
+    globPublicPatterns: z.union([z.string(), z.array(z.string())]).default(["**/*"]),
   })
-  .strict("Do not pass invalid properties to NextInjectManifestPartial!") satisfies z.ZodType<
-  NextInjectManifestResolved,
-  z.ZodObjectDef,
-  NextInjectManifestPartial
->;
+  .strict("Do not pass invalid properties to NextInjectManifestPartial!");
 
 export const nextInjectManifestOptions = webpackInjectManifestOptions
   .merge(requiredSwDestPartial)
   .merge(nextInjectManifestPartial)
   .omit({ disablePrecacheManifest: true })
-  .strict("Do not pass invalid properties to NextInjectManifestOptions!") satisfies z.ZodType<
-  NextInjectManifestOptionsComplete,
-  z.ZodObjectDef,
-  NextInjectManifestOptions
->;
+  .strict("Do not pass invalid properties to NextInjectManifestOptions!");
+
+assertType<Equals<NextInjectManifestPartial, z.input<typeof nextInjectManifestPartial>>>();
+assertType<Equals<NextInjectManifestResolved, z.output<typeof nextInjectManifestPartial>>>();
+assertType<Equals<NextInjectManifestOptions, z.input<typeof nextInjectManifestOptions>>>();
+assertType<Equals<NextInjectManifestOptionsComplete, z.output<typeof nextInjectManifestOptions>>>();

package/src/schema/swDest.ts

@@ -1,14 +1,20 @@
 import { z } from "zod";
 import type { OptionalSwDestPartial, OptionalSwDestResolved, RequiredSwDestPartial, RequiredSwDestResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 
 export const optionalSwDestPartial = z
   .object({
     swDest: z.string().optional(),
   })
-  .strict("Do not pass invalid properties to OptionalSwDest!") satisfies z.ZodType<OptionalSwDestResolved, z.ZodObjectDef, OptionalSwDestPartial>;
+  .strict("Do not pass invalid properties to OptionalSwDest!");
 
 export const requiredSwDestPartial = z
   .object({
     swDest: z.string(),
   })
-  .strict("Do not pass invalid properties to RequiredSwDest!") satisfies z.ZodType<RequiredSwDestResolved, z.ZodObjectDef, RequiredSwDestPartial>;
+  .strict("Do not pass invalid properties to RequiredSwDest!");
+
+assertType<Equals<OptionalSwDestPartial, z.input<typeof optionalSwDestPartial>>>();
+assertType<Equals<OptionalSwDestResolved, z.output<typeof optionalSwDestPartial>>>();
+assertType<Equals<RequiredSwDestPartial, z.input<typeof requiredSwDestPartial>>>();
+assertType<Equals<RequiredSwDestResolved, z.output<typeof requiredSwDestPartial>>>();

package/src/schema/vite.ts

@@ -1,5 +1,6 @@
 import type { z } from "zod";
 import type { ViteInjectManifestOptions, ViteInjectManifestOptionsComplete } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { basePartial } from "./base.js";
 import { globPartial } from "./glob.js";
 import { requiredGlobDirectoryPartial } from "./glob.js";
@@ -11,8 +12,7 @@ export const viteInjectManifestOptions = basePartial
   .merge(injectPartial)
   .merge(requiredSwDestPartial)
   .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to ViteInjectManifestPartial!") satisfies z.ZodType<
-  ViteInjectManifestOptionsComplete,
-  z.ZodObjectDef,
-  ViteInjectManifestOptions
->;
+  .strict("Do not pass invalid properties to ViteInjectManifestPartial!");
+
+assertType<Equals<ViteInjectManifestOptions, z.input<typeof viteInjectManifestOptions>>>();
+assertType<Equals<ViteInjectManifestOptionsComplete, z.output<typeof viteInjectManifestOptions>>>();

package/src/schema/webpack.ts

@@ -7,6 +7,7 @@ import type {
   WebpackPartial,
   WebpackResolved,
 } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
 import { basePartial } from "./base.js";
 import { injectPartial } from "./injectManifest.js";
 import { optionalSwDestPartial } from "./swDest.js";
@@ -21,7 +22,7 @@ export const webpackPartial = z
     include: z.array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())])).optional(),
     mode: z.string().nullable().optional(),
   })
-  .strict("Do not pass invalid properties to WebpackPartial!") satisfies z.ZodType<WebpackResolved, z.ZodObjectDef, WebpackPartial>;
+  .strict("Do not pass invalid properties to WebpackPartial!");
 
 export const webpackInjectManifestPartial = z
   .object({
@@ -29,19 +30,18 @@ export const webpackInjectManifestPartial = z
     swDest: z.string().optional(),
     webpackCompilationPlugins: z.array(z.any()).optional(),
   })
-  .strict("Do not pass invalid properties to WebpackInjectManifestPartial!") satisfies z.ZodType<
-  WebpackInjectManifestResolved,
-  z.ZodObjectDef,
-  WebpackInjectManifestPartial
->;
+  .strict("Do not pass invalid properties to WebpackInjectManifestPartial!");
 
 export const webpackInjectManifestOptions = basePartial
   .merge(webpackPartial)
   .merge(injectPartial)
   .merge(optionalSwDestPartial)
   .merge(webpackInjectManifestPartial)
-  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!") satisfies z.ZodType<
-  WebpackInjectManifestOptionsComplete,
-  z.ZodObjectDef,
-  WebpackInjectManifestOptions
->;
+  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!");
+
+assertType<Equals<WebpackPartial, z.input<typeof webpackPartial>>>();
+assertType<Equals<WebpackResolved, z.output<typeof webpackPartial>>>();
+assertType<Equals<WebpackInjectManifestPartial, z.input<typeof webpackInjectManifestPartial>>>();
+assertType<Equals<WebpackInjectManifestResolved, z.output<typeof webpackInjectManifestPartial>>>();
+assertType<Equals<WebpackInjectManifestOptions, z.input<typeof webpackInjectManifestOptions>>>();
+assertType<Equals<WebpackInjectManifestOptionsComplete, z.output<typeof webpackInjectManifestOptions>>>();

package/src/types.ts

@@ -254,7 +254,7 @@ export interface NextInjectManifestPartial {
    * also adds a bit of overhead due to additional network calls.
    * @default false
    */
-  cacheOnFrontEndNav?: boolean;
+  cacheOnNavigation?: boolean;
   /**
    * Whether Serwist should be disabled.
    * @default false
@@ -338,7 +338,7 @@ export interface NextInjectManifestPartial {
 
 export type NextInjectManifestResolved = Require<
   NextInjectManifestPartial,
-  "cacheOnFrontEndNav" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns"
+  "cacheOnNavigation" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns"
 >;
 
 export type GetManifestOptions = BasePartial & GlobPartial & RequiredGlobDirectoryPartial;