@serwist/turbopack 10.0.0-preview.10

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 that returns the precache manifest.
+ * @param options Options for {@linkcode getFileManifestEntries}.
+ */
+export declare const createSerwistRoute: (options: InjectManifestOptions) => {
+    dynamic: string;
+    dynamicParams: boolean;
+    revalidate: boolean;
+    generateStaticParams: () => {
+        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":"AAIA,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;;;;;;;aA8DzC,OAAO,cAAc;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE;CAYjF,CAAC"}

package/dist/index.js

@@ -0,0 +1,182 @@
+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';
+
+const mapLoggingMethodToConsole = {
+    wait: "log",
+    error: "error",
+    warn: "warn",
+    info: "log",
+    event: "log"
+};
+const prefixes = {
+    wait: `${white(bold("○"))} (serwist)`,
+    error: `${red(bold("X"))} (serwist)`,
+    warn: `${yellow(bold("⚠"))} (serwist)`,
+    info: `${white(bold("○"))} (serwist)`,
+    event: `${green(bold("✓"))} (serwist)`
+};
+const prefixedLog = (prefixType, ...message)=>{
+    const consoleMethod = mapLoggingMethodToConsole[prefixType];
+    const prefix = prefixes[prefixType];
+    if ((message[0] === "" || message[0] === undefined) && message.length === 1) {
+        message.shift();
+    }
+    if (message.length === 0) {
+        console[consoleMethod]("");
+    } else {
+        console[consoleMethod](` ${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") {
+        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)=>{
+        config.globIgnores.push(rebasePath({
+            file: config.swSrc,
+            baseDirectory: config.globDirectory
+        }));
+        if (!config.manifestTransforms) {
+            config.manifestTransforms = [];
+        }
+        config.manifestTransforms.push((manifestEntries)=>{
+            const manifest = manifestEntries.map((m)=>{
+                if (m.url.startsWith(".next/")) m.url = `/_next/${m.url.slice(6)}`;
+                if (m.url.startsWith("public/")) m.url = path.posix.join(config.basePath, m.url.slice(7));
+                return m;
+            });
+            return {
+                manifest,
+                warnings: []
+            };
+        });
+        return config;
+    });
+    const generateStaticParams = ()=>{
+        return [
+            {
+                path: "sw.js"
+            },
+            {
+                path: "sw.js.map"
+            }
+        ];
+    };
+    let map = null;
+    const loadMap = async (filePath)=>{
+        const config = await validation;
+        const { count, size, manifestEntries, warnings } = await getFileManifestEntries(config);
+        const injectionPoint = config.injectionPoint ? config.injectionPoint : "";
+        const manifestString = manifestEntries === undefined ? "undefined" : JSON.stringify(manifestEntries, null, 2);
+        logSerwistResult(filePath, {
+            count,
+            size,
+            warnings
+        });
+        const result = await (await esbuild).build({
+            entryPoints: [
+                {
+                    in: config.swSrc,
+                    out: "sw"
+                }
+            ],
+            format: "esm",
+            sourcemap: true,
+            bundle: true,
+            write: false,
+            minify: !isDev,
+            define: injectionPoint ? {
+                [injectionPoint]: manifestString
+            } : undefined,
+            outdir: process.cwd(),
+            entryNames: "[name]"
+        });
+        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 GET = async (_, { params })=>{
+        const { path: filePath } = await params;
+        if (!map) map = await loadMap(filePath);
+        return new NextResponse(map.get(path.join(process.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,48 @@
+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,
+                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,144 @@
+import z from "zod";
+export declare const injectManifestOptions: z.ZodPipe<z.ZodObject<{
+    cwd: z.ZodPrefault<z.ZodString>;
+    basePath: z.ZodString;
+    globPatterns: z.ZodPrefault<z.ZodArray<z.ZodString>>;
+    globDirectory: z.ZodOptional<z.ZodString>;
+    injectionPoint: z.ZodPrefault<z.ZodString>;
+    swSrc: z.ZodString;
+    globFollow: z.ZodDefault<z.ZodBoolean>;
+    globIgnores: z.ZodDefault<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>]>>>;
+    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>]>>>;
+    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
+    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>>;
+}, z.z.core.$strict>, z.ZodTransform<{
+    swSrc: string;
+    globDirectory: string;
+    cwd: string;
+    basePath: string;
+    globPatterns: string[];
+    injectionPoint: string;
+    globFollow: boolean;
+    globIgnores: string[];
+    globStrict: boolean;
+    disablePrecacheManifest: boolean;
+    maximumFileSizeToCacheInBytes: number;
+    templatedURLs?: Record<string, string | string[]> | undefined;
+    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;
+}, {
+    cwd: string;
+    basePath: string;
+    globPatterns: string[];
+    injectionPoint: string;
+    swSrc: string;
+    globFollow: boolean;
+    globIgnores: string[];
+    globStrict: boolean;
+    disablePrecacheManifest: boolean;
+    maximumFileSizeToCacheInBytes: number;
+    globDirectory?: string | undefined;
+    templatedURLs?: Record<string, string | string[]> | undefined;
+    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;
+}>>;
+//# 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;AAGpB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB9B,CAAC"}

package/dist/index.schema.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { injectPartial, globPartial, basePartial } from '@serwist/build/schema';
+import z from 'zod';
+
+const DEFAULT_GLOB_PATTERNS = [
+    ".next/static/**/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}",
+    "public/**/*"
+];
+
+const injectManifestOptions = z.strictObject({
+    ...basePartial.shape,
+    ...globPartial.shape,
+    ...injectPartial.shape,
+    cwd: z.string().prefault(process.cwd()),
+    basePath: z.string(),
+    globPatterns: z.array(z.string()).prefault(DEFAULT_GLOB_PATTERNS),
+    globDirectory: z.string().optional()
+}).transform((input)=>{
+    return {
+        ...input,
+        swSrc: path.isAbsolute(input.swSrc) ? input.swSrc : path.join(input.cwd, input.swSrc),
+        globDirectory: input.globDirectory ?? input.cwd
+    };
+});
+
+export { injectManifestOptions };

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,EAsQlC,CAAC"}