@serwist/build 9.0.0-preview.11 → 9.0.0-preview.13

package/src/types.ts

@@ -1,5 +1,4 @@
 import type { Require } from "@serwist/utils";
-import type { Pattern as GlobPattern } from "fast-glob";
 import type { PackageJson } from "type-fest";
 import type { z } from "zod";
 import type { manifestEntry } from "./schema/manifestEntry.js";
@@ -161,43 +160,6 @@ export interface InjectPartial {
 
 export type InjectResolved = Require<InjectPartial, "injectionPoint">;
 
-export interface WebpackPartial {
-  /**
-   * One or more chunk names whose corresponding output files should be included
-   * in the precache manifest.
-   */
-  chunks?: string[];
-  // We can't use the @default annotation here to assign the value via AJV, as
-  // an (RegExp)[] can't be serialized into JSON.
-  // The default value of [/\.map$/, /^manifest.*\.js$/] will be assigned by
-  // the validation function, and we need to reflect that in the docs.
-  /**
-   * One or more specifiers used to exclude assets from the precache manifest.
-   * This is interpreted following
-   * [the same rules](https://webpack.js.org/configuration/module/#condition)
-   * as `webpack`'s standard `exclude` option.
-   * @default
-   * ```
-   * [/\.map$/, /^manifest.*\.js$]
-   * ```
-   */
-  exclude?: (string | RegExp | ((arg0: any) => boolean))[];
-  /**
-   * One or more chunk names whose corresponding output files should be excluded
-   * from the precache manifest.
-   */
-  excludeChunks?: string[];
-  /**
-   * One or more specifiers used to include assets in the precache manifest.
-   * This is interpreted following
-   * [the same rules](https://webpack.js.org/configuration/module/#condition)
-   * as `webpack`'s standard `include` option.
-   */
-  include?: (string | RegExp | ((arg0: any) => boolean))[];
-}
-
-export type WebpackResolved = Require<WebpackPartial, "exclude">;
-
 export interface RequiredSwDestPartial {
   /**
    * The path and filename of the service worker file that will be created by
@@ -219,121 +181,6 @@ export interface OptionalSwDestPartial {
 
 export type OptionalSwDestResolved = OptionalSwDestPartial;
 
-export interface WebpackInjectManifestPartial {
-  /**
-   * When `true` (the default), the `swSrc` file will be compiled by `webpack`.
-   * When `false`, compilation will not occur (and `webpackCompilationPlugins`
-   * can't be used.) Set to `false` if you want to inject the manifest into,
-   * e.g., a JSON file.
-   * @default true
-   */
-  compileSrc?: boolean;
-  // This can only be set if `compileSrc` is true, but that restriction can't be
-  // represented in TypeScript. It's enforced via custom runtime validation
-  // logic and needs to be documented.
-  /**
-   * Optional `webpack` plugins that will be used when compiling the `swSrc`
-   * input file. Only valid if `compileSrc` is `true`.
-   */
-  webpackCompilationPlugins?: any[];
-}
-
-export type WebpackInjectManifestResolved = Require<WebpackInjectManifestPartial, "compileSrc">;
-
-export interface NextInjectManifestPartial {
-  /**
-   * 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?: GlobPattern | GlobPattern[];
-}
-
-export type NextInjectManifestResolved = Require<
-  NextInjectManifestPartial,
-  "cacheOnNavigation" | "disable" | "register" | "reloadOnOnline" | "swUrl" | "globPublicPatterns"
->;
-
 export type GetManifestOptions = BasePartial & GlobPartial & RequiredGlobDirectoryPartial;
 
 export type GetManifestOptionsComplete = BaseResolved & GlobResolved & RequiredGlobDirectoryResolved;
@@ -342,28 +189,6 @@ export type InjectManifestOptions = BasePartial & GlobPartial & InjectPartial &
 
 export type InjectManifestOptionsComplete = BaseResolved & GlobResolved & InjectResolved & RequiredSwDestResolved & RequiredGlobDirectoryResolved;
 
-export type WebpackInjectManifestOptions = BasePartial & WebpackPartial & InjectPartial & OptionalSwDestPartial & WebpackInjectManifestPartial;
-
-export type WebpackInjectManifestOptionsComplete = BaseResolved &
-  WebpackResolved &
-  InjectResolved &
-  OptionalSwDestResolved &
-  WebpackInjectManifestResolved;
-
-export type ViteInjectManifestOptions = BasePartial & GlobPartial & InjectPartial & RequiredSwDestPartial & RequiredGlobDirectoryPartial;
-
-export type ViteInjectManifestOptionsComplete = BaseResolved & GlobResolved & InjectResolved & RequiredSwDestResolved & RequiredGlobDirectoryResolved;
-
-export type NextInjectManifestOptions = Omit<
-  WebpackInjectManifestOptions & RequiredSwDestPartial & NextInjectManifestPartial,
-  "disablePrecacheManifest"
->;
-
-export type NextInjectManifestOptionsComplete = Omit<
-  WebpackInjectManifestOptionsComplete & RequiredSwDestResolved & NextInjectManifestResolved,
-  "disablePrecacheManifest"
->;
-
 export interface GetManifestResult {
   count: number;
   manifestEntries: ManifestEntry[] | undefined;

package/dist/chunks/vite.js

@@ -1,7 +0,0 @@
-import { b as basePartial, g as globPartial, r as requiredGlobDirectoryPartial } from './glob.js';
-import { i as injectPartial, r as requiredSwDestPartial } from './injectManifest.js';
-import 'zod';
-
-const viteInjectManifestOptions = basePartial.merge(globPartial).merge(injectPartial).merge(requiredSwDestPartial).merge(requiredGlobDirectoryPartial).strict("Do not pass invalid properties to ViteInjectManifestPartial!");
-
-export { viteInjectManifestOptions };

package/dist/chunks/webpack.js

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

package/dist/index.next.d.ts

@@ -1,3 +0,0 @@
-import { validateNextInjectManifestOptions } from "./lib/validate-next-options.js";
-export { validateNextInjectManifestOptions };
-//# sourceMappingURL=index.next.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.next.d.ts","sourceRoot":"","sources":["../src/index.next.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,gCAAgC,CAAC;AAEnF,OAAO,EAAE,iCAAiC,EAAE,CAAC"}

package/dist/index.next.js

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-import { r as requiredSwDestPartial } from './chunks/injectManifest.js';
-import { webpackInjectManifestOptions } from './chunks/webpack.js';
-import { v as validationErrorMap, S as SerwistConfigError } from './chunks/serwist-config-error.js';
-import './chunks/glob.js';
-
-const nextInjectManifestPartial = 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.union([
-        z.string(),
-        z.array(z.string())
-    ]).default([
-        "**/*"
-    ])
-}).strict("Do not pass invalid properties to NextInjectManifestPartial!");
-const nextInjectManifestOptions = webpackInjectManifestOptions.merge(requiredSwDestPartial).merge(nextInjectManifestPartial).omit({
-    disablePrecacheManifest: true
-}).strict("Do not pass invalid properties to NextInjectManifestOptions!");
-
-const validateNextInjectManifestOptions = (input)=>{
-    const result = nextInjectManifestOptions.safeParse(input, {
-        errorMap: validationErrorMap
-    });
-    if (!result.success) {
-        throw new SerwistConfigError({
-            moduleName: "@serwist/next",
-            message: JSON.stringify(result.error.format(), null, 2)
-        });
-    }
-    return result.data;
-};
-
-export { validateNextInjectManifestOptions };

package/dist/lib/serwist-config-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serwist-config-error.d.ts","sourceRoot":"","sources":["../../src/lib/serwist-config-error.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;CAI/E"}

package/dist/lib/validate-next-options.d.ts

@@ -1,3 +0,0 @@
-import type { NextInjectManifestOptionsComplete } from "../types.js";
-export declare const validateNextInjectManifestOptions: (input: unknown) => NextInjectManifestOptionsComplete;
-//# sourceMappingURL=validate-next-options.d.ts.map

package/dist/lib/validate-next-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate-next-options.d.ts","sourceRoot":"","sources":["../../src/lib/validate-next-options.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAGrE,eAAO,MAAM,iCAAiC,UAAW,OAAO,KAAG,iCAQlE,CAAC"}

package/dist/schema/next.d.ts

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

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

@@ -1 +0,0 @@
-{"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"}