@serwist/turbopack 9.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2023 Google LLC, 2019-2023 ShadowWalker w@weiw.io https://weiw.io, 2020-2023 Anthony Fu <https://github.com/antfu>, 2023-PRESENT Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://serwist.pages.dev/docs/next/turbo.

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server.js";
+import type { InjectManifestOptions } from "./types.js";
+/**
+ * Creates a Route Handler for Serwist files.
+ * @param options Options for {@linkcode getFileManifestEntries}.
+ */
+export declare const createSerwistRoute: (options: InjectManifestOptions) => {
+    dynamic: "force-static";
+    dynamicParams: false;
+    revalidate: false;
+    generateStaticParams: () => Promise<{
+        path: string;
+    }[]>;
+    GET: (_: Request, { params }: {
+        params: Promise<{
+            path: string;
+        }>;
+    }) => Promise<NextResponse<unknown>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,OAAO,KAAK,EAAE,qBAAqB,EAAiC,MAAM,YAAY,CAAC;AAuCvF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,qBAAqB;;;;;;;aAoFzC,OAAO,cAAc;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE;CAajF,CAAC"}

package/dist/index.js

@@ -0,0 +1,210 @@
+import path from 'node:path';
+import { rebasePath, getFileManifestEntries } from '@serwist/build';
+import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
+import { green, bold, white, yellow, red, cyan, dim } from 'kolorist';
+import { NextResponse } from 'next/server.js';
+import { z } from 'zod';
+import { injectManifestOptions } from './index.schema.js';
+import { createRequire } from 'node:module';
+import semver from 'semver';
+
+const require$1 = createRequire(import.meta.url);
+const LOGGING_SPACE_PREFIX = semver.gte(require$1("next/package.json").version, "16.0.0") ? "" : " ";
+const prefixedLog = (prefixType, ...message)=>{
+    let prefix;
+    let consoleMethod;
+    switch(prefixType){
+        case "wait":
+            prefix = `${white(bold("○"))} (serwist)`;
+            consoleMethod = "log";
+            break;
+        case "error":
+            prefix = `${red(bold("X"))} (serwist)`;
+            consoleMethod = "error";
+            break;
+        case "warn":
+            prefix = `${yellow(bold("⚠"))} (serwist)`;
+            consoleMethod = "warn";
+            break;
+        case "info":
+            prefix = `${white(bold("○"))} (serwist)`;
+            consoleMethod = "log";
+            break;
+        case "event":
+            prefix = `${green(bold("✓"))} (serwist)`;
+            consoleMethod = "log";
+            break;
+    }
+    if ((message[0] === "" || message[0] === undefined) && message.length === 1) {
+        message.shift();
+    }
+    if (message.length === 0) {
+        console[consoleMethod]("");
+    } else {
+        console[consoleMethod](`${LOGGING_SPACE_PREFIX}${prefix}`, ...message);
+    }
+};
+const wait = (...message)=>prefixedLog("wait", ...message);
+const error = (...message)=>prefixedLog("error", ...message);
+const warn = (...message)=>prefixedLog("warn", ...message);
+const info = (...message)=>prefixedLog("info", ...message);
+const event = (...message)=>prefixedLog("event", ...message);
+
+var logger = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  error: error,
+  event: event,
+  info: info,
+  wait: wait,
+  warn: warn
+});
+
+const esbuild = import('esbuild-wasm');
+const logSerwistResult = (filePath, buildResult)=>{
+    const { count, size, warnings } = buildResult;
+    const hasWarnings = warnings && warnings.length > 0;
+    if (filePath === "sw.js" && (hasWarnings || count > 0)) {
+        logger[hasWarnings ? "warn" : "event"](`${cyan(count)} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}${hasWarnings ? `\n${yellow([
+            "⚠ warnings",
+            ...warnings.map((w)=>`  ${w}`),
+            ""
+        ].join("\n"))}` : ""}`);
+    }
+};
+const validateGetManifestOptions = async (input)=>{
+    const result = await injectManifestOptions.spa(input, {
+        error: validationErrorMap
+    });
+    if (!result.success) {
+        throw new SerwistConfigError({
+            moduleName: "@serwist/turbopack",
+            message: z.prettifyError(result.error)
+        });
+    }
+    return result.data;
+};
+const isDev = process.env.NODE_ENV === "development";
+const contentTypeMap = {
+    ".js": "application/javascript",
+    ".map": "application/json; charset=UTF-8"
+};
+const createSerwistRoute = (options)=>{
+    const dynamic = "force-static", dynamicParams = false, revalidate = false;
+    const validation = validateGetManifestOptions(options).then((config)=>{
+        return {
+            ...config,
+            disablePrecacheManifest: isDev,
+            additionalPrecacheEntries: isDev ? [] : config.additionalPrecacheEntries,
+            globIgnores: [
+                ...config.globIgnores,
+                rebasePath({
+                    file: config.swSrc,
+                    baseDirectory: config.globDirectory
+                })
+            ],
+            manifestTransforms: [
+                ...config.manifestTransforms ?? [],
+                (manifestEntries)=>{
+                    const manifest = manifestEntries.map((m)=>{
+                        if (m.url.startsWith(config.nextConfig.distDir)) {
+                            m.url = `${config.nextConfig.assetPrefix ?? ""}/_next/${m.url.slice(config.nextConfig.distDir.length)}`;
+                        }
+                        if (m.url.startsWith("public/")) {
+                            m.url = path.posix.join(config.nextConfig.basePath, m.url.slice(7));
+                        }
+                        return m;
+                    });
+                    return {
+                        manifest,
+                        warnings: []
+                    };
+                }
+            ]
+        };
+    });
+    let map = null;
+    const loadMap = async (filePath)=>{
+        const config = await validation;
+        const { count, size, manifestEntries, warnings } = await getFileManifestEntries(config);
+        const injectionPoint = config.injectionPoint || "";
+        const manifestString = manifestEntries === undefined ? "undefined" : JSON.stringify(manifestEntries, null, 2);
+        logSerwistResult(filePath, {
+            count,
+            size,
+            warnings
+        });
+        const result = await (await esbuild).build({
+            sourcemap: true,
+            format: "esm",
+            target: [
+                "chrome64",
+                "edge79",
+                "firefox67",
+                "opera51",
+                "safari12"
+            ],
+            treeShaking: true,
+            minify: !isDev,
+            bundle: true,
+            ...config.esbuildOptions,
+            platform: "browser",
+            define: {
+                ...config.esbuildOptions.define,
+                ...injectionPoint ? {
+                    [injectionPoint]: manifestString
+                } : {}
+            },
+            outdir: config.cwd,
+            write: false,
+            entryNames: "[name]",
+            assetNames: "[name]-[hash]",
+            chunkNames: "[name]-[hash]",
+            entryPoints: [
+                {
+                    in: config.swSrc,
+                    out: "sw"
+                }
+            ]
+        });
+        if (result.errors.length) {
+            console.error("Failed to build the service worker.", result.errors);
+            throw new Error();
+        }
+        if (result.warnings.length) {
+            console.warn(result.warnings);
+        }
+        return new Map(result.outputFiles.map((e)=>[
+                e.path,
+                e.text
+            ]));
+    };
+    const generateStaticParams = async ()=>{
+        const config = await validation;
+        if (!map) map = await loadMap("root");
+        return [
+            ...map.keys().map((e)=>({
+                    path: path.relative(config.cwd, e)
+                }))
+        ];
+    };
+    const GET = async (_, { params })=>{
+        const { path: filePath } = await params;
+        const config = await validation;
+        if (!map) map = await loadMap(filePath);
+        return new NextResponse(map.get(path.join(config.cwd, filePath)), {
+            headers: {
+                "Content-Type": contentTypeMap[path.extname(filePath)] || "text/plain",
+                "Service-Worker-Allowed": "/"
+            }
+        });
+    };
+    return {
+        dynamic,
+        dynamicParams,
+        revalidate,
+        generateStaticParams,
+        GET
+    };
+};
+
+export { createSerwistRoute };

package/dist/index.react.d.ts

@@ -0,0 +1,16 @@
+import { Serwist } from "@serwist/window";
+import { type ReactNode } from "react";
+export interface SerwistProviderProps {
+    swUrl: string;
+    register?: boolean;
+    reloadOnOnline?: boolean;
+    options?: RegistrationOptions;
+    children?: ReactNode;
+}
+declare global {
+    interface Window {
+        serwist: Serwist;
+    }
+}
+export declare function SerwistProvider({ swUrl, register, reloadOnOnline, options, children }: SerwistProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=index.react.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.react.d.ts","sourceRoot":"","sources":["../src/index.react.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAC;AAG5D,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,OAAO,EAAE,OAAO,CAAC;KAClB;CACF;AAED,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,QAAe,EAAE,cAAqB,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,oBAAoB,+BAwBzH"}

package/dist/index.react.js

@@ -0,0 +1,49 @@
+import { jsx } from 'react/jsx-runtime';
+import { Serwist } from '@serwist/window';
+import { isCurrentPageOutOfScope } from '@serwist/window/internal';
+import { createContext, useState, useEffect } from 'react';
+
+const SerwistContext = createContext(null);
+
+function SerwistProvider({ swUrl, register = true, reloadOnOnline = true, options, children }) {
+    const [serwist] = useState(()=>{
+        if (typeof window === "undefined") return null;
+        if (!(window.serwist && window.serwist instanceof Serwist) && "serviceWorker" in navigator) {
+            window.serwist = new Serwist(swUrl, {
+                ...options,
+                type: options?.type || "module",
+                scope: options?.scope || "/"
+            });
+        }
+        return window.serwist ?? null;
+    });
+    useEffect(()=>{
+        const scope = options?.scope || "/";
+        if (register && !isCurrentPageOutOfScope(scope)) {
+            void serwist?.register();
+        }
+    }, [
+        register,
+        options?.scope,
+        serwist?.register
+    ]);
+    useEffect(()=>{
+        const reload = ()=>location.reload();
+        if (reloadOnOnline) {
+            window.addEventListener("online", reload);
+        }
+        return ()=>{
+            window.removeEventListener("online", reload);
+        };
+    }, [
+        reloadOnOnline
+    ]);
+    return jsx(SerwistContext.Provider, {
+        value: {
+            serwist
+        },
+        children: children
+    });
+}
+
+export { SerwistProvider };

package/dist/index.schema.d.ts

@@ -0,0 +1,165 @@
+import z from "zod";
+export declare const turboPartial: z.ZodObject<{
+    cwd: z.ZodPrefault<z.ZodString>;
+    nextConfig: z.ZodObject<{
+        assetPrefix: z.ZodOptional<z.ZodString>;
+        basePath: z.ZodPrefault<z.ZodString>;
+        distDir: z.ZodPrefault<z.ZodString>;
+    }, z.z.core.$strict>;
+    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
+}, z.z.core.$strict>;
+export declare const injectManifestOptions: z.ZodPipe<z.ZodObject<{
+    cwd: z.ZodPrefault<z.ZodString>;
+    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
+    nextConfig: z.ZodObject<{
+        assetPrefix: z.ZodOptional<z.ZodString>;
+        basePath: z.ZodPrefault<z.ZodString>;
+        distDir: z.ZodPrefault<z.ZodString>;
+    }, z.z.core.$strict>;
+    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strict>]>>>;
+    dontCacheBustURLsMatching: z.ZodOptional<z.ZodCustom<RegExp, RegExp>>;
+    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodCustom<z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>>, z.ZodTransform<z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>>>>>;
+    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
+    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    globFollow: z.ZodDefault<z.ZodBoolean>;
+    globIgnores: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    globPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    globStrict: z.ZodDefault<z.ZodBoolean>;
+    templatedURLs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    injectionPoint: z.ZodDefault<z.ZodString>;
+    swSrc: z.ZodString;
+    globDirectory: z.ZodOptional<z.ZodString>;
+}, z.z.core.$strict>, z.ZodTransform<{
+    swSrc: string;
+    globPatterns: string[];
+    globDirectory: string;
+    dontCacheBustURLsMatching: RegExp;
+    nextConfig: {
+        distDir: string;
+        basePath: string;
+        assetPrefix?: string | undefined;
+    };
+    cwd: string;
+    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
+    maximumFileSizeToCacheInBytes: number;
+    globFollow: boolean;
+    globIgnores: string[];
+    globStrict: boolean;
+    injectionPoint: string;
+    additionalPrecacheEntries?: (string | {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    })[] | undefined;
+    manifestTransforms?: z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>[] | undefined;
+    modifyURLPrefix?: Record<string, string> | undefined;
+    templatedURLs?: Record<string, string | string[]> | undefined;
+}, {
+    cwd: string;
+    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
+    nextConfig: {
+        basePath: string;
+        distDir: string;
+        assetPrefix?: string | undefined;
+    };
+    maximumFileSizeToCacheInBytes: number;
+    globFollow: boolean;
+    globIgnores: string[];
+    globStrict: boolean;
+    injectionPoint: string;
+    swSrc: string;
+    additionalPrecacheEntries?: (string | {
+        url: string;
+        integrity?: string | undefined;
+        revision?: string | null | undefined;
+    })[] | undefined;
+    dontCacheBustURLsMatching?: RegExp | undefined;
+    manifestTransforms?: z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
+        size: z.ZodNumber;
+        integrity: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
+        manifest: z.ZodArray<z.ZodObject<{
+            size: z.ZodNumber;
+            integrity: z.ZodOptional<z.ZodString>;
+            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            url: z.ZodString;
+        }, z.z.core.$strip>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>[] | undefined;
+    modifyURLPrefix?: Record<string, string> | undefined;
+    globPatterns?: string[] | undefined;
+    templatedURLs?: Record<string, string | string[]> | undefined;
+    globDirectory?: string | undefined;
+}>>;
+//# 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":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,eAAO,MAAM,YAAY;;;;;;;;oBAQvB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyB9B,CAAC"}

package/dist/index.schema.js

@@ -0,0 +1,107 @@
+import path from 'node:path';
+import { injectPartial, globPartial, basePartial, assertType } from '@serwist/build/schema';
+import z from 'zod';
+
+const SUPPORTED_ESBUILD_OPTIONS = [
+    "sourcemap",
+    "legalComments",
+    "sourceRoot",
+    "sourcesContent",
+    "format",
+    "globalName",
+    "target",
+    "supported",
+    "define",
+    "treeShaking",
+    "minify",
+    "mangleProps",
+    "reserveProps",
+    "mangleQuoted",
+    "mangleCache",
+    "drop",
+    "dropLabels",
+    "minifyWhitespace",
+    "minifyIdentifiers",
+    "minifySyntax",
+    "lineLimit",
+    "charset",
+    "ignoreAnnotations",
+    "jsx",
+    "jsxFactory",
+    "jsxFragment",
+    "jsxImportSource",
+    "jsxDev",
+    "jsxSideEffects",
+    "pure",
+    "keepNames",
+    "absPaths",
+    "color",
+    "logLevel",
+    "logLimit",
+    "logOverride",
+    "tsconfigRaw",
+    "bundle",
+    "splitting",
+    "preserveSymlinks",
+    "external",
+    "packages",
+    "alias",
+    "loader",
+    "resolveExtensions",
+    "mainFields",
+    "conditions",
+    "allowOverwrite",
+    "tsconfig",
+    "outExtension",
+    "publicPath",
+    "inject",
+    "banner",
+    "footer",
+    "plugins"
+];
+
+const generateGlobPatterns = (distDir)=>[
+        `${distDir}static/**/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}`,
+        "public/**/*"
+    ];
+
+const turboPartial = z.strictObject({
+    cwd: z.string().prefault(process.cwd()),
+    nextConfig: z.strictObject({
+        assetPrefix: z.string().optional(),
+        basePath: z.string().prefault("/"),
+        distDir: z.string().prefault(".next")
+    }),
+    esbuildOptions: z.partialRecord(z.literal(SUPPORTED_ESBUILD_OPTIONS), z.any()).prefault({})
+});
+const injectManifestOptions = z.strictObject({
+    ...basePartial.shape,
+    ...globPartial.shape,
+    ...injectPartial.shape,
+    ...turboPartial.shape,
+    globPatterns: z.array(z.string()).optional(),
+    globDirectory: z.string().optional()
+}).omit({
+    disablePrecacheManifest: true
+}).transform((input)=>{
+    let distDir = input.nextConfig.distDir;
+    if (distDir[0] === "/") distDir = distDir.slice(1);
+    if (distDir[distDir.length - 1] !== "/") distDir += "/";
+    return {
+        ...input,
+        swSrc: path.isAbsolute(input.swSrc) ? input.swSrc : path.join(input.cwd, input.swSrc),
+        globPatterns: input.globPatterns ?? generateGlobPatterns(distDir),
+        globDirectory: input.globDirectory ?? input.cwd,
+        dontCacheBustURLsMatching: input.dontCacheBustURLsMatching ?? new RegExp(`^${distDir}static/`),
+        nextConfig: {
+            ...input.nextConfig,
+            distDir
+        }
+    };
+});
+assertType();
+assertType();
+assertType();
+assertType();
+
+export { injectManifestOptions, turboPartial };

package/dist/index.worker.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeCaching } from "serwist";
+export declare const PAGES_CACHE_NAME: {
+    readonly rscPrefetch: "pages-rsc-prefetch";
+    readonly rsc: "pages-rsc";
+    readonly html: "pages";
+};
+/**
+ * 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=index.worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.worker.d.ts","sourceRoot":"","sources":["../src/index.worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,EAkQlC,CAAC"}