@serwist/next 9.0.0-preview.8 → 9.0.0

package/dist/chunks/schema.js

@@ -0,0 +1,20 @@
+import { requiredSwDestPartial } from '@serwist/build/schema';
+import { injectManifestOptions as injectManifestOptions$1 } from '@serwist/webpack-plugin/schema';
+import { z } from 'zod';
+
+const injectPartial = z.object({
+    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([
+        "**/*"
+    ])
+}).strict("Do not pass invalid properties to NextInjectManifestPartial!");
+const injectManifestOptions = injectManifestOptions$1.merge(requiredSwDestPartial).merge(injectPartial).omit({
+    disablePrecacheManifest: true
+}).strict("Do not pass invalid properties to NextInjectManifestOptions!");
+
+export { injectManifestOptions as a, injectPartial as i };

package/dist/index.d.ts

@@ -1,6 +1,13 @@
-import type { NextInjectManifestOptions } from "@serwist/build";
 import type { NextConfig } from "next";
-declare const withSerwistInit: (pluginOptions: NextInjectManifestOptions) => (nextConfig?: NextConfig) => NextConfig;
+import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./lib/types.js";
+import { validateInjectManifestOptions } from "./lib/validator.js";
+/**
+ * Integrates Serwist into your Next.js app.
+ * @param userOptions
+ * @returns
+ */
+declare const withSerwistInit: (userOptions: InjectManifestOptions) => ((nextConfig?: NextConfig) => NextConfig);
 export default withSerwistInit;
-export type { NextInjectManifestOptions as PluginOptions };
+export { validateInjectManifestOptions };
+export type { InjectManifestOptions as PluginOptions, InjectManifestOptionsComplete as PluginOptionsComplete };
 //# 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":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAQvC,QAAA,MAAM,eAAe,kBAAmB,yBAAyB,mBAAkB,UAAU,KAAK,UA4NjG,CAAC;AAEF,eAAe,eAAe,CAAC;AAC/B,YAAY,EAAE,yBAAyB,IAAI,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAIvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAInE;;;;GAIG;AACH,QAAA,MAAM,eAAe,gBAAiB,qBAAqB,KAAG,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,KAAK,UAAU,CAoNrG,CAAC;AAEF,eAAe,eAAe,CAAC;AAC/B,OAAO,EAAE,6BAA6B,EAAE,CAAC;AACzC,YAAY,EAAE,qBAAqB,IAAI,aAAa,EAAE,6BAA6B,IAAI,qBAAqB,EAAE,CAAC"}

package/dist/index.js

@@ -1,14 +1,16 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { validateNextInjectManifestOptions } from '@serwist/build/next';
 import { InjectManifest } from '@serwist/webpack-plugin';
 import { ChildCompilationPlugin, relativeToOutputPath } from '@serwist/webpack-plugin/internal';
-import { CleanWebpackPlugin } from 'clean-webpack-plugin';
-import fg from 'fast-glob';
+import { globSync } from 'glob';
 import crypto from 'node:crypto';
-import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import chalk from 'chalk';
+import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
+import { a as injectManifestOptions } from './chunks/schema.js';
+import '@serwist/webpack-plugin/schema';
+import 'zod';
 
 const findFirstTruthy = (arr, fn)=>{
     for (const i of arr){
@@ -83,8 +85,21 @@ const event = (...message)=>{
     prefixedLog("event", ...message);
 };
 
+const validateInjectManifestOptions = (input)=>{
+    const result = injectManifestOptions.safeParse(input, {
+        errorMap: validationErrorMap
+    });
+    if (!result.success) {
+        throw new SerwistConfigError({
+            moduleName: "@serwist/next",
+            message: JSON.stringify(result.error.format(), null, 2)
+        });
+    }
+    return result.data;
+};
+
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const withSerwistInit = (pluginOptions)=>{
+const withSerwistInit = (userOptions)=>{
     return (nextConfig = {})=>({
             ...nextConfig,
             webpack (config, options) {
@@ -92,7 +107,7 @@ const withSerwistInit = (pluginOptions)=>{
                 const { dev } = options;
                 const basePath = options.config.basePath || "/";
                 const tsConfigJson = loadTSConfig(options.dir, nextConfig?.typescript?.tsconfigPath);
-                const { cacheOnNavigation, disable, scope = basePath, swUrl, register, reloadOnOnline, globPublicPatterns, ...buildOptions } = validateNextInjectManifestOptions(pluginOptions);
+                const { cacheOnNavigation, disable, scope = basePath, swUrl, register, reloadOnOnline, globPublicPatterns, ...buildOptions } = validateInjectManifestOptions(userOptions);
                 if (typeof nextConfig.webpack === "function") {
                     config = nextConfig.webpack(config, options);
                 }
@@ -103,7 +118,6 @@ const withSerwistInit = (pluginOptions)=>{
                 if (!config.plugins) {
                     config.plugins = [];
                 }
-                event(`Compiling for ${options.isServer ? "server" : "client (static)"}...`);
                 const _sw = path.posix.join(basePath, swUrl);
                 const _scope = path.posix.join(scope, "/");
                 config.plugins.push(new webpack.DefinePlugin({
@@ -141,10 +155,9 @@ const withSerwistInit = (pluginOptions)=>{
                 };
                 if (!options.isServer) {
                     if (!register) {
-                        info("Service worker won't be automatically registered as per the config, please call the following code in componentDidMount or useEffect:");
-                        info("  window.serwist.register()");
+                        info("The service worker will not be automatically registered, please call 'window.serwist.register()' in 'componentDidMount' or 'useEffect'.");
                         if (!tsConfigJson?.compilerOptions?.types?.includes("@serwist/next/typings")) {
-                            info("You may also want to add @serwist/next/typings to compilerOptions.types in your tsconfig.json/jsconfig.json.");
+                            info("You may also want to add '@serwist/next/typings' to your TypeScript/JavaScript configuration file at 'compilerOptions.types'.");
                         }
                     }
                     const { swSrc: userSwSrc, swDest: userSwDest, additionalPrecacheEntries, exclude, manifestTransforms = [], ...otherBuildOptions } = buildOptions;
@@ -157,7 +170,24 @@ const withSerwistInit = (pluginOptions)=>{
                         swDest = path.join(options.dir, swDest);
                     }
                     const publicDir = path.resolve(options.dir, "public");
-                    const destDir = path.dirname(swDest);
+                    const { dir: destDir, base: destBase } = path.parse(swDest);
+                    const cleanUpList = globSync([
+                        "swe-worker-*.js",
+                        "swe-worker-*.js.map",
+                        destBase,
+                        `${destBase}.map`
+                    ], {
+                        absolute: true,
+                        nodir: true,
+                        cwd: destDir
+                    });
+                    for (const file of cleanUpList){
+                        fs.rm(file, {
+                            force: true
+                        }, (err)=>{
+                            if (err) throw err;
+                        });
+                    }
                     const shouldBuildSWEntryWorker = cacheOnNavigation;
                     let swEntryPublicPath = undefined;
                     let swEntryWorkerDest = undefined;
@@ -174,32 +204,17 @@ const withSerwistInit = (pluginOptions)=>{
                     config.plugins.push(new webpack.DefinePlugin({
                         "self.__SERWIST_SW_ENTRY.swEntryWorker": swEntryPublicPath && `'${swEntryPublicPath}'`
                     }));
-                    info(`Service worker: ${swDest}`);
-                    info(`  URL: ${_sw}`);
-                    info(`  Scope: ${_scope}`);
-                    config.plugins.push(new CleanWebpackPlugin({
-                        cleanOnceBeforeBuildPatterns: [
-                            path.join(destDir, "swe-worker-*.js"),
-                            path.join(destDir, "swe-worker-*.js.map"),
-                            swDest
-                        ]
-                    }));
+                    event(`Bundling the service worker script with the URL '${_sw}' and the scope '${_scope}'...`);
                     let resolvedManifestEntries = additionalPrecacheEntries;
                     if (!resolvedManifestEntries) {
-                        const swDestFileName = path.basename(swDest);
-                        const userPublicGlob = typeof globPublicPatterns === "string" ? [
-                            globPublicPatterns
-                        ] : globPublicPatterns ?? [
-                            "**/*"
-                        ];
-                        const publicScan = fg.sync([
-                            ...userPublicGlob,
-                            "!swe-worker-*.js",
-                            "!swe-worker-*.js.map",
-                            `!${swDestFileName.replace(/^\/+/, "")}`,
-                            `!${swDestFileName.replace(/^\/+/, "")}.map`
-                        ], {
-                            cwd: publicDir
+                        const publicScan = globSync(globPublicPatterns, {
+                            nodir: true,
+                            cwd: publicDir,
+                            ignore: [
+                                "swe-worker-*.js",
+                                destBase,
+                                `${destBase}.map`
+                            ]
                         });
                         resolvedManifestEntries = publicScan.map((f)=>({
                                 url: path.posix.join(basePath, f),
@@ -247,4 +262,4 @@ const withSerwistInit = (pluginOptions)=>{
         });
 };
 
-export { withSerwistInit as default };
+export { withSerwistInit as default, validateInjectManifestOptions };

package/dist/index.schema.d.ts

@@ -0,0 +1,3 @@
+import { injectManifestOptions, injectPartial } from "./lib/schema.js";
+export { injectPartial, 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,MAAM,iBAAiB,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.schema.js

@@ -0,0 +1,4 @@
+export { a as injectManifestOptions, i as injectPartial } from './chunks/schema.js';
+import '@serwist/build/schema';
+import '@serwist/webpack-plugin/schema';
+import 'zod';

package/dist/index.worker.js

@@ -1,6 +1,4 @@
-import { ExpirationPlugin } from '@serwist/expiration';
-import { RangeRequestsPlugin } from '@serwist/range-requests';
-import { CacheFirst, StaleWhileRevalidate, NetworkFirst } from '@serwist/strategies';
+import { CacheFirst, ExpirationPlugin, StaleWhileRevalidate, RangeRequestsPlugin, NetworkFirst } from 'serwist';
 
 const PAGES_CACHE_NAME = {
     rscPrefetch: "pages-rsc-prefetch",
@@ -8,7 +6,7 @@ const PAGES_CACHE_NAME = {
     html: "pages"
 };
 
-const defaultCache = [
+const defaultCache = process.env.NODE_ENV !== "production" ? [] : [
     {
         matcher: /^https:\/\/fonts\.(?:gstatic)\.com\/.*/i,
         handler: new CacheFirst({
@@ -16,7 +14,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 4,
-                    maxAgeSeconds: 365 * 24 * 60 * 60
+                    maxAgeSeconds: 365 * 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -28,7 +27,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 4,
-                    maxAgeSeconds: 7 * 24 * 60 * 60
+                    maxAgeSeconds: 7 * 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -40,7 +40,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 4,
-                    maxAgeSeconds: 7 * 24 * 60 * 60
+                    maxAgeSeconds: 7 * 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -52,7 +53,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 64,
-                    maxAgeSeconds: 30 * 24 * 60 * 60
+                    maxAgeSeconds: 30 * 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -64,7 +66,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 64,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -76,7 +79,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 64,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -88,7 +92,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 32,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 }),
                 new RangeRequestsPlugin()
             ]
@@ -101,7 +106,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 32,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 }),
                 new RangeRequestsPlugin()
             ]
@@ -114,7 +120,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 48,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -126,7 +133,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 32,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -138,7 +146,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 32,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -150,7 +159,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 32,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ]
         })
@@ -171,7 +181,8 @@ const defaultCache = [
             plugins: [
                 new ExpirationPlugin({
                     maxEntries: 16,
-                    maxAgeSeconds: 24 * 60 * 60
+                    maxAgeSeconds: 24 * 60 * 60,
+                    maxAgeFrom: "last-used"
                 })
             ],
             networkTimeoutSeconds: 10

package/dist/lib/find-first-truthy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-first-truthy.d.ts","sourceRoot":"","sources":["../../src/lib/find-first-truthy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,cAAe,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,+BAQhE,CAAC"}

package/dist/lib/get-content-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-content-hash.d.ts","sourceRoot":"","sources":["../../src/lib/get-content-hash.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAI9B,eAAO,MAAM,cAAc,SAAU,GAAG,oBAAoB,SAAS,OAAO,WAK3E,CAAC"}

package/dist/lib/get-file-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-file-hash.d.ts","sourceRoot":"","sources":["../../src/lib/get-file-hash.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,SAAS,CAAC;AAEzB,eAAO,MAAM,WAAW,SAAU,GAAG,oBAAoB,WAAyE,CAAC"}

package/dist/lib/get-package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-package-version.d.ts","sourceRoot":"","sources":["../../src/lib/get-package-version.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,gBAAiB,MAAM,KAAG,MAAM,GAAG,SAMhE,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC"}

package/dist/lib/load-tsconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-tsconfig.d.ts","sourceRoot":"","sources":["../../src/lib/load-tsconfig.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,IAAI,YAAY,EAAE,MAAM,WAAW,CAAC;AAI9D,eAAO,MAAM,YAAY,YAAa,MAAM,wBAAwB,MAAM,GAAG,SAAS,KAAG,YAAY,GAAG,SAmBvG,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,IAAI,eAAgB,GAAG,EAAE,SAErC,CAAC;AAEF,eAAO,MAAM,KAAK,eAAgB,GAAG,EAAE,SAEtC,CAAC;AAEF,eAAO,MAAM,IAAI,eAAgB,GAAG,EAAE,SAErC,CAAC;AAEF,eAAO,MAAM,IAAI,eAAgB,GAAG,EAAE,SAErC,CAAC;AAEF,eAAO,MAAM,KAAK,eAAgB,GAAG,EAAE,SAEtC,CAAC"}

package/dist/lib/schema.d.ts

@@ -0,0 +1,240 @@
+import { z } from "zod";
+export declare const injectPartial: z.ZodObject<{
+    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">>;
+}, "strict", z.ZodTypeAny, {
+    cacheOnNavigation: boolean;
+    disable: boolean;
+    register: boolean;
+    reloadOnOnline: boolean;
+    swUrl: string;
+    globPublicPatterns: string[];
+    scope?: string | undefined;
+}, {
+    cacheOnNavigation?: boolean | undefined;
+    disable?: boolean | undefined;
+    register?: boolean | undefined;
+    reloadOnOnline?: boolean | undefined;
+    scope?: string | undefined;
+    swUrl?: string | undefined;
+    globPublicPatterns?: string[] | undefined;
+}>;
+export declare const injectManifestOptions: z.ZodObject<Omit<{
+    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.ZodString;
+    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    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">>;
+}, "disablePrecacheManifest">, "strict", z.ZodTypeAny, {
+    cacheOnNavigation: boolean;
+    disable: boolean;
+    register: boolean;
+    reloadOnOnline: boolean;
+    swUrl: string;
+    globPublicPatterns: string[];
+    exclude: (string | RegExp | ((args_0: any) => boolean))[];
+    maximumFileSizeToCacheInBytes: number;
+    injectionPoint: string;
+    swSrc: string;
+    compileSrc: boolean;
+    swDest: string;
+    scope?: string | undefined;
+    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;
+    webpackCompilationPlugins?: any[] | undefined;
+}, {
+    swSrc: string;
+    swDest: string;
+    cacheOnNavigation?: boolean | undefined;
+    disable?: boolean | undefined;
+    register?: boolean | undefined;
+    reloadOnOnline?: boolean | undefined;
+    scope?: string | undefined;
+    swUrl?: string | undefined;
+    globPublicPatterns?: string[] | undefined;
+    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;
+    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;
+    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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;EAU+C,CAAC;AAE1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIuC,CAAC"}