@serwist/next 9.0.0-preview.2 → 9.0.0-preview.20

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"}

package/dist/lib/types.d.ts

@@ -0,0 +1,95 @@
+import type { RequiredSwDestPartial, RequiredSwDestResolved } from "@serwist/build";
+import type { Require } from "@serwist/utils";
+import type { InjectManifestOptions as WebpackInjectManifestOptions, InjectManifestOptionsComplete as WebpackInjectManifestOptionsComplete } from "@serwist/webpack-plugin";
+export interface InjectPartial {
+    /**
+     * Enables additional route caching when users navigate through pages with
+     * `next/link`. This improves the user experience in some cases but it
+     * also adds a bit of overhead due to additional network calls.
+     * @default false
+     */
+    cacheOnNavigation?: boolean;
+    /**
+     * Whether Serwist should be disabled.
+     * @default false
+     */
+    disable?: boolean;
+    /**
+     * Whether `@serwist/next` should automatically register the service worker for you. If
+     * you want to register the service worker yourself, set this to `false` and run
+     * `window.serwist.register()` in `componentDidMount` or `useEffect`.
+     * @example
+     *   ```tsx
+     *   // app/register-pwa.tsx
+     *   "use client";
+     *   import { useEffect } from "react";
+     *   import type { Serwist } from "@serwist/window";
+     *
+     *   declare global {
+     *     interface Window {
+     *       serwist: Serwist;
+     *     }
+     *   }
+     *
+     *   export default function RegisterPWA() {
+     *     useEffect(() => {
+     *       if ("serviceWorker" in navigator && window.serwist !== undefined) {
+     *         window.serwist.register();
+     *       }
+     *     }, []);
+     *     return <></>;
+     *   }
+     *
+     *   // app/layout.tsx
+     *   import RegisterPWA from "./register-pwa";
+     *
+     *   export default function RootLayout({
+     *     children,
+     *   }: {
+     *     children: React.ReactNode;
+     *   }) {
+     *     return (
+     *       <html lang="en">
+     *         <head />
+     *         <body>
+     *           <RegisterPWA />
+     *           {children}
+     *         </body>
+     *       </html>
+     *     );
+     *   }
+     *   ```
+     * @default true
+     */
+    register?: boolean;
+    /**
+     * Whether Serwist should reload the app when it goes online.
+     * @default true
+     */
+    reloadOnOnline?: boolean;
+    /**
+     * The service worker's URL scope. Set to `/foo/` so that paths under `/foo/` are under the service
+     * worker's control while others are not.
+     * @default nextConfig.basePath
+     */
+    scope?: string;
+    /**
+     * The URL to the service worker.
+     * @default "/sw.js"
+     */
+    swUrl?: string;
+    /**
+     * Files in the public directory matching any of these patterns
+     * will be included in the precache manifest. For more information,
+     * see [`node-glob`'s Glob Primer](https://github.com/isaacs/node-glob#glob-primer).
+     * @default
+     * ```
+     * ["**\/*"]
+     * ```
+     */
+    globPublicPatterns?: string[];
+}
+export type InjectResolved = Require<InjectPartial, "cacheOnNavigation" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns">;
+export type InjectManifestOptions = Omit<WebpackInjectManifestOptions & RequiredSwDestPartial & InjectPartial, "disablePrecacheManifest">;
+export type InjectManifestOptionsComplete = Omit<WebpackInjectManifestOptionsComplete & RequiredSwDestResolved & InjectResolved, "disablePrecacheManifest">;
+//# 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,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EACV,qBAAqB,IAAI,4BAA4B,EACrD,6BAA6B,IAAI,oCAAoC,EACtE,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE,mBAAmB,GAAG,SAAS,GAAG,UAAU,GAAG,gBAAgB,GAAG,OAAO,GAAG,oBAAoB,CAAC,CAAC;AAEtJ,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,4BAA4B,GAAG,qBAAqB,GAAG,aAAa,EAAE,yBAAyB,CAAC,CAAC;AAE1I,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,oCAAoC,GAAG,sBAAsB,GAAG,cAAc,EAC9E,yBAAyB,CAC1B,CAAC"}

package/dist/lib/validator.d.ts

@@ -0,0 +1,3 @@
+import type { InjectManifestOptionsComplete } from "./types.js";
+export declare const validateInjectManifestOptions: (input: unknown) => 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":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEhE,eAAO,MAAM,6BAA6B,UAAW,OAAO,KAAG,6BAQ9D,CAAC"}

package/dist/worker/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const PAGES_CACHE_NAME: {
+    readonly rscPrefetch: "pages-rsc-prefetch";
+    readonly rsc: "pages-rsc";
+    readonly html: "pages";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/worker/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/worker/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC"}

package/dist/worker/defaultCache.d.ts

@@ -1,3 +1,9 @@
 import type { RuntimeCaching } from "@serwist/sw";
+/**
+ * The default, recommended list of caching strategies for applications
+ * built with Next.js.
+ *
+ * @see https://serwist.pages.dev/docs/next/worker-exports#default-cache
+ */
 export declare const defaultCache: RuntimeCaching[];
 //# sourceMappingURL=defaultCache.d.ts.map

package/dist/worker/defaultCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultCache.d.ts","sourceRoot":"","sources":["../../src/worker/defaultCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,eAAO,MAAM,YAAY,kBA0NG,CAAC"}
+{"version":3,"file":"defaultCache.d.ts","sourceRoot":"","sources":["../../src/worker/defaultCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,EAiQlC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/next",
-  "version": "9.0.0-preview.2",
+  "version": "9.0.0-preview.20",
   "type": "module",
   "description": "A module that integrates Serwist into your Next.js application.",
   "files": [
@@ -12,16 +12,21 @@
     "serwistjs",
     "sw",
     "service worker",
+    "progressive web apps",
     "web",
-    "service-worker"
+    "service-worker",
+    "progressive-web-apps",
+    "next",
+    "next.js",
+    "pwa"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
   "author": "Serwist's Team",
   "license": "MIT",
-  "repository": "serwist/serwist",
-  "bugs": "https://github.com/serwist/serwist/issues",
+  "repository": "https://gitlab.com/serwist/serwist",
+  "bugs": "https://gitlab.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -32,6 +37,9 @@
       ],
       "typings": [
         "./dist/sw-entry.d.ts"
+      ],
+      "schema": [
+        "./dist/index.schema.d.ts"
       ]
     }
   },
@@ -47,40 +55,39 @@
     "./typings": {
       "types": "./dist/sw-entry.d.ts"
     },
+    "./schema": {
+      "types": "./dist/index.schema.d.ts",
+      "default": "./dist/index.schema.js"
+    },
     "./package.json": "./package.json"
   },
   "dependencies": {
     "chalk": "5.3.0",
-    "clean-webpack-plugin": "4.0.0",
-    "fast-glob": "3.3.2",
-    "@serwist/build": "9.0.0-preview.2",
-    "@serwist/core": "9.0.0-preview.2",
-    "@serwist/webpack-plugin": "9.0.0-preview.2",
-    "@serwist/window": "9.0.0-preview.2"
+    "glob": "10.3.10",
+    "zod": "3.22.4",
+    "@serwist/build": "9.0.0-preview.20",
+    "@serwist/core": "9.0.0-preview.20",
+    "@serwist/sw": "9.0.0-preview.20",
+    "@serwist/webpack-plugin": "9.0.0-preview.20",
+    "@serwist/window": "9.0.0-preview.20"
   },
   "devDependencies": {
-    "@types/node": "20.11.16",
-    "next": "14.1.0",
+    "@types/node": "20.11.30",
+    "next": "14.1.4",
     "react": "18.2.0",
     "react-dom": "18.2.0",
-    "rollup": "4.9.6",
-    "type-fest": "4.10.2",
-    "typescript": "5.4.0-dev.20240206",
-    "webpack": "5.90.1",
-    "@serwist/constants": "9.0.0-preview.2",
-    "@serwist/sw": "9.0.0-preview.2",
-    "@serwist/utils": "9.0.0-preview.2"
+    "rollup": "4.13.0",
+    "type-fest": "4.13.1",
+    "typescript": "5.5.0-dev.20240323",
+    "webpack": "5.91.0",
+    "@serwist/constants": "9.0.0-preview.20",
+    "@serwist/utils": "9.0.0-preview.20"
   },
   "peerDependencies": {
     "next": ">=14.0.0",
-    "typescript": ">=5.0.0",
-    "webpack": ">=5.9.0",
-    "@serwist/sw": "9.0.0-preview.2"
+    "typescript": ">=5.0.0"
   },
   "peerDependenciesMeta": {
-    "@serwist/sw": {
-      "optional": true
-    },
     "typescript": {
       "optional": true
     }

package/src/index.schema.ts

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

package/src/index.ts

@@ -1,21 +1,24 @@
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-
-import type { NextInjectManifestOptions } from "@serwist/build";
-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 type { NextConfig } from "next";
 import type { Compilation, Configuration, default as Webpack } from "webpack";
-
 import type { ExcludeParams, SerwistNextOptions, SerwistNextOptionsKey } from "./internal-types.js";
-import { getContentHash, getFileHash, loadTSConfig, logger } from "./utils/index.js";
+import { getContentHash, getFileHash, loadTSConfig, logger } from "./lib/index.js";
+import type { InjectManifestOptions, InjectManifestOptionsComplete } from "./lib/types.js";
+import { validateInjectManifestOptions } from "./lib/validator.js";
 
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 
-const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig?: NextConfig) => NextConfig) => {
+/**
+ * Integrates Serwist into your Next.js app.
+ * @param userOptions
+ * @returns
+ */
+const withSerwistInit = (userOptions: InjectManifestOptions): ((nextConfig?: NextConfig) => NextConfig) => {
   return (nextConfig = {}) => ({
     ...nextConfig,
     webpack(config: Configuration, options) {
@@ -35,7 +38,7 @@ const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig
         reloadOnOnline,
         globPublicPatterns,
         ...buildOptions
-      } = validateNextInjectManifestOptions(pluginOptions);
+      } = validateInjectManifestOptions(userOptions);
 
       if (typeof nextConfig.webpack === "function") {
         config = nextConfig.webpack(config, options);
@@ -95,7 +98,7 @@ const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig
           logger.info("  window.serwist.register()");
 
           if (!tsConfigJson?.compilerOptions?.types?.includes("@serwist/next/typings")) {
-            logger.info("You may also want to add @serwist/next/typings to compilerOptions.types in your tsconfig.json/jsconfig.json.");
+            logger.info("You may also want to add '@serwist/next/typings' to compilerOptions.types in your tsconfig.json/jsconfig.json.");
           }
         }
 
@@ -122,7 +125,19 @@ const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig
         }
 
         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: string | undefined = undefined;
@@ -150,31 +165,15 @@ const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig
         logger.info(`  URL: ${_sw}`);
         logger.info(`  Scope: ${_scope}`);
 
-        config.plugins.push(
-          new CleanWebpackPlugin({
-            cleanOnceBeforeBuildPatterns: [path.join(destDir, "swe-worker-*.js"), path.join(destDir, "swe-worker-*.js.map"), swDest],
-          }),
-        );
-
         // Precache files in public folder
         let resolvedManifestEntries = additionalPrecacheEntries;
 
         if (!resolvedManifestEntries) {
-          const swDestFileName = path.basename(swDest);
-          const userPublicGlob = typeof globPublicPatterns === "string" ? [globPublicPatterns] : globPublicPatterns ?? ["**/*"];
-          const publicScan = fg.sync(
-            [
-              ...userPublicGlob,
-              // Forcibly include these in case the user outputs these files to `public`.
-              "!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),
             revision: getFileHash(path.join(publicDir, f)),
@@ -238,4 +237,5 @@ const withSerwistInit = (pluginOptions: NextInjectManifestOptions): ((nextConfig
 };
 
 export default withSerwistInit;
-export type { NextInjectManifestOptions as PluginOptions };
+export { validateInjectManifestOptions };
+export type { InjectManifestOptions as PluginOptions, InjectManifestOptionsComplete as PluginOptionsComplete };

package/src/index.worker.ts

@@ -1,5 +1,4 @@
+import { PAGES_CACHE_NAME } from "./worker/constants.js";
 import { defaultCache } from "./worker/defaultCache.js";
-import { type DefinePageRuntimeCachingOptions, type PageRuntimeCaching, definePageRuntimeCaching } from "./worker/definePageRuntimeCaching.js";
 
-export { defaultCache, definePageRuntimeCaching };
-export type { DefinePageRuntimeCachingOptions, PageRuntimeCaching };
+export { defaultCache, PAGES_CACHE_NAME };

package/src/lib/schema.ts

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