@serwist/vite 8.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Anthony Fu <https://github.com/antfu>, 2023 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 is a work-in-progress.

package/dist/api.d.ts

@@ -0,0 +1,3 @@
+import type { SerwistViteContext } from "./context.js";
+import type { SerwistViteApi } from "./types.js";
+export declare const createApi: (ctx: SerwistViteContext) => SerwistViteApi;

package/dist/assets.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig } from "vite";
+import type { ResolvedPluginOptions } from "./types.js";
+export declare const configureStaticAssets: (resolvedPluginOptions: ResolvedPluginOptions, viteConfig: ResolvedConfig) => Promise<void>;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const INTERNAL_SERWIST_VIRTUAL = "virtual:internal-serwist";
+export declare const RESOLVED_INTERNAL_SERWIST_VIRTUAL = "\0virtual:internal-serwist";

package/dist/context.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedConfig } from "vite";
+import type { PluginOptions, ResolvedPluginOptions } from "./types.js";
+export interface SerwistViteContext {
+    viteConfig: ResolvedConfig;
+    userOptions: PluginOptions;
+    options: ResolvedPluginOptions;
+    useImportRegister: boolean;
+    devEnvironment: boolean;
+}
+export declare const createContext: (userOptions: PluginOptions) => SerwistViteContext;

package/dist/index.browser.d.ts

@@ -0,0 +1 @@
+export declare const getSerwist: () => Promise<import("@serwist/window").Serwist | undefined>;

package/dist/index.browser.js

@@ -0,0 +1,13 @@
+import { swUrl, swScope, swType } from 'virtual:internal-serwist';
+
+const getSerwist = async ()=>{
+    if ("serviceWorker" in navigator) {
+        return new (await import('@serwist/window')).Serwist(swUrl, {
+            scope: swScope,
+            type: swType
+        });
+    }
+    return undefined;
+};
+
+export { getSerwist };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vite";
+import type { PluginOptions } from "./types.js";
+/**
+ * Integrates Serwist into your Vite app.
+ * @param userOptions
+ * @returns
+ */
+export declare const serwist: (userOptions: PluginOptions) => Plugin[];
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,42 @@
+import { m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from './main-dzWmj8BB.js';
+import 'node:path';
+import 'node:process';
+import 'node:crypto';
+import 'node:fs';
+import 'fast-glob';
+
+const buildPlugin = (ctx, api)=>{
+    return {
+        name: "@serwist/vite:build",
+        enforce: "post",
+        apply: "build",
+        closeBundle: {
+            sequential: true,
+            order: ctx.userOptions?.integration?.closeBundleOrder,
+            async handler () {
+                if (!ctx.viteConfig.build.ssr && !ctx.options.disable) {
+                    await api.generateSW();
+                }
+            }
+        },
+        async buildEnd (error) {
+            if (error) throw error;
+        }
+    };
+};
+
+/**
+ * Integrates Serwist into your Vite app.
+ * @param userOptions
+ * @returns
+ */ const serwist = (userOptions)=>{
+    const ctx = createContext(userOptions);
+    const api = createApi(ctx);
+    return [
+        mainPlugin(ctx, api),
+        buildPlugin(ctx, api),
+        devPlugin(ctx)
+    ];
+};
+
+export { serwist };

package/dist/index.worker.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeCaching } from "@serwist/build";
+export declare const defaultCache: RuntimeCaching[];

package/dist/index.worker.js

@@ -0,0 +1,95 @@
+const defaultCache = [
+    {
+        urlPattern: /^https:\/\/fonts\.(?:googleapis|gstatic)\.com\/.*/i,
+        handler: "CacheFirst",
+        options: {
+            cacheName: "google-fonts",
+            expiration: {
+                maxEntries: 4,
+                maxAgeSeconds: 365 * 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\.(?:eot|otf|ttc|ttf|woff|woff2|font.css)$/i,
+        handler: "StaleWhileRevalidate",
+        options: {
+            cacheName: "static-font-assets",
+            expiration: {
+                maxEntries: 4,
+                maxAgeSeconds: 7 * 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\.(?:jpg|jpeg|gif|png|svg|ico|webp)$/i,
+        handler: "StaleWhileRevalidate",
+        options: {
+            cacheName: "static-image-assets",
+            expiration: {
+                maxEntries: 64,
+                maxAgeSeconds: 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\.(?:js)$/i,
+        handler: "StaleWhileRevalidate",
+        options: {
+            cacheName: "static-js-assets",
+            expiration: {
+                maxEntries: 32,
+                maxAgeSeconds: 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\.(?:css|less)$/i,
+        handler: "StaleWhileRevalidate",
+        options: {
+            cacheName: "static-style-assets",
+            expiration: {
+                maxEntries: 32,
+                maxAgeSeconds: 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\.(?:json|xml|csv)$/i,
+        handler: "NetworkFirst",
+        options: {
+            cacheName: "static-data-assets",
+            expiration: {
+                maxEntries: 32,
+                maxAgeSeconds: 24 * 60 * 60
+            }
+        }
+    },
+    {
+        urlPattern: /\/api\/.*$/i,
+        handler: "NetworkFirst",
+        method: "GET",
+        options: {
+            cacheName: "apis",
+            expiration: {
+                maxEntries: 16,
+                maxAgeSeconds: 24 * 60 * 60
+            },
+            networkTimeoutSeconds: 10
+        }
+    },
+    {
+        urlPattern: /.*/i,
+        handler: "NetworkFirst",
+        options: {
+            cacheName: "others",
+            expiration: {
+                maxEntries: 32,
+                maxAgeSeconds: 24 * 60 * 60
+            },
+            networkTimeoutSeconds: 10
+        }
+    }
+];
+
+export { defaultCache };

package/dist/integration/svelte/config.d.ts

@@ -0,0 +1,8 @@
+import type { ManifestTransform } from "@serwist/build";
+import type { ResolvedConfig } from "vite";
+import type { PluginOptions as BasePluginOptions } from "../../types.js";
+import type { KitOptions } from "./types.js";
+export declare const configurateSvelteKitOptions: (viteConfig: ResolvedConfig, kit: KitOptions, options: BasePluginOptions) => void;
+export declare function createManifestTransform(base: string, webManifestName?: string, options?: KitOptions): ManifestTransform;
+export declare function buildGlobPatterns(globPatterns?: string[]): string[];
+export declare function buildGlobIgnores(globIgnores?: string[]): string[];

package/dist/integration/svelte/index.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vite";
+import type { PluginOptions } from "./types.js";
+/**
+ * Integrates Serwist into your SvelteKit app.
+ * @param userOptions
+ * @returns
+ */
+export declare const serwist: (userOptions?: PluginOptions) => Plugin[];
+export * from "./types.js";

package/dist/integration/svelte/index.js

@@ -0,0 +1,151 @@
+import { l as loadSerwistBuild, m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from '../../main-dzWmj8BB.js';
+import path from 'node:path';
+import 'node:process';
+import 'node:crypto';
+import 'node:fs';
+import 'fast-glob';
+
+const configurateSvelteKitOptions = (viteConfig, kit, options)=>{
+    const clientOutDir = path.resolve(viteConfig.root, viteConfig.build.outDir, "../client");
+    // Kit fixes the service worker's name to 'service-worker.js'
+    options.swSrc = path.resolve(clientOutDir, "service-worker.js");
+    options.swDest = path.resolve(clientOutDir, "service-worker.js");
+    options.swUrl = "/service-worker.js";
+    // SvelteKit's outDir is `.svelte-kit/output/client`.
+    // We need to include the parent folder in globDirectory since SvelteKit will generate SSG in `.svelte-kit/output/prerendered` folder.
+    if (!options.globDirectory) {
+        options.globDirectory = path.resolve(clientOutDir, "..");
+    }
+    if (!options.manifestTransforms) {
+        options.manifestTransforms = [
+            createManifestTransform(viteConfig.base, undefined, kit)
+        ];
+    }
+    let buildAssetsDir = kit.appDir ?? "_app/";
+    if (buildAssetsDir[0] === "/") buildAssetsDir = buildAssetsDir.slice(1);
+    if (buildAssetsDir[buildAssetsDir.length - 1] !== "/") buildAssetsDir += "/";
+    if (!options.modifyURLPrefix) {
+        options.globPatterns = buildGlobPatterns(options.globPatterns);
+        if (kit.includeVersionFile) {
+            options.globPatterns.push(`client/${buildAssetsDir}version.json`);
+        }
+    }
+    // Exclude server assets: sw is built on SSR build
+    options.globIgnores = buildGlobIgnores(options.globIgnores);
+    // Vite 5 support: allow override dontCacheBustURLsMatching
+    if (!("dontCacheBustURLsMatching" in options)) {
+        options.dontCacheBustURLsMatching = new RegExp(`${buildAssetsDir}immutable/`);
+    }
+};
+function createManifestTransform(base, webManifestName, options) {
+    return async (entries)=>{
+        const defaultAdapterFallback = "prerendered/fallback.html";
+        const suffix = options?.trailingSlash === "always" ? "/" : "";
+        let adapterFallback = options?.adapterFallback;
+        let excludeFallback = false;
+        // the fallback will be always generated by SvelteKit.
+        // The adapter will copy the fallback only if it is provided in its options: we need to exclude it
+        if (!adapterFallback) {
+            adapterFallback = defaultAdapterFallback;
+            excludeFallback = true;
+        }
+        // the fallback will be always in .svelte-kit/output/prerendered/fallback.html
+        const manifest = entries.filter(({ url })=>!(excludeFallback && url === defaultAdapterFallback)).map((e)=>{
+            let url = e.url;
+            // client assets in `.svelte-kit/output/client` folder.
+            // SSG pages in `.svelte-kit/output/prerendered/pages` folder.
+            // fallback page in `.svelte-kit/output/prerendered` folder (fallback.html is the default).
+            if (url.startsWith("client/")) url = url.slice(7);
+            else if (url.startsWith("prerendered/pages/")) url = url.slice(18);
+            else if (url === defaultAdapterFallback) url = adapterFallback;
+            if (url.endsWith(".html")) {
+                if (url.startsWith("/")) url = url.slice(1);
+                if (url === "index.html") {
+                    url = base;
+                } else {
+                    const idx = url.lastIndexOf("/");
+                    if (idx > -1) {
+                        // abc/index.html -> abc/?
+                        if (url.endsWith("/index.html")) url = `${url.slice(0, idx)}${suffix}`;
+                        else url = `${url.substring(0, url.lastIndexOf("."))}${suffix}`;
+                    } else {
+                        // xxx.html -> xxx/?
+                        url = `${url.substring(0, url.lastIndexOf("."))}${suffix}`;
+                    }
+                }
+            }
+            e.url = url;
+            return e;
+        });
+        if (!webManifestName) return {
+            manifest
+        };
+        return {
+            manifest: manifest.filter((e)=>e.url !== webManifestName)
+        };
+    };
+}
+function buildGlobPatterns(globPatterns) {
+    if (globPatterns) {
+        if (!globPatterns.some((g)=>g.startsWith("prerendered/"))) globPatterns.push("prerendered/**/*.html");
+        if (!globPatterns.some((g)=>g.startsWith("client/"))) globPatterns.push("client/**/*.{js,css,ico,png,svg,webp,webmanifest}");
+        if (!globPatterns.some((g)=>g.includes("webmanifest"))) globPatterns.push("client/*.webmanifest");
+        return globPatterns;
+    }
+    return [
+        "client/**/*.{js,css,ico,png,svg,webp,webmanifest}",
+        "prerendered/**/*.html"
+    ];
+}
+function buildGlobIgnores(globIgnores) {
+    if (globIgnores) {
+        if (!globIgnores.some((g)=>g.startsWith("server/"))) globIgnores.push("server/*.*");
+        return globIgnores;
+    }
+    return [
+        "server/*.*"
+    ];
+}
+
+const serwistSveltePlugin = (ctx, api)=>{
+    return {
+        name: "@serwist/vite/integration-svelte:build",
+        apply: "build",
+        enforce: "pre",
+        closeBundle: {
+            sequential: true,
+            enforce: "pre",
+            async handler () {
+                if (api && !api.disabled && ctx.viteConfig.build.ssr) {
+                    const [injectManifest, logSerwistResult] = await Promise.all([
+                        loadSerwistBuild().then((m)=>m.injectManifest),
+                        import('../../log-Dyh-Moyt.js').then((m)=>m.logSerwistResult)
+                    ]);
+                    // Inject the manifest
+                    const buildResult = await injectManifest(ctx.options.injectManifest);
+                    // Log Serwist result
+                    logSerwistResult(buildResult, ctx.viteConfig);
+                }
+            }
+        }
+    };
+};
+
+/**
+ * Integrates Serwist into your SvelteKit app.
+ * @param userOptions
+ * @returns
+ */ const serwist = (userOptions = {})=>{
+    if (!userOptions.integration) userOptions.integration = {};
+    userOptions.integration.closeBundleOrder = "pre";
+    userOptions.integration.configureOptions = (viteConfig, options)=>configurateSvelteKitOptions(viteConfig, userOptions.kit ?? {}, options);
+    const ctx = createContext(userOptions);
+    const api = createApi(ctx);
+    return [
+        mainPlugin(ctx, api),
+        devPlugin(ctx),
+        serwistSveltePlugin(ctx, api)
+    ];
+};
+
+export { serwist };

package/dist/integration/svelte/log.d.ts

@@ -0,0 +1,3 @@
+import type { BuildResult } from "@serwist/build";
+import type { ResolvedConfig } from "vite";
+export declare function logSerwistResult(buildResult: Pick<BuildResult, "count" | "size" | "warnings">, viteOptions: ResolvedConfig): void;

package/dist/integration/svelte/serwist-svelte-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { SerwistViteContext } from "../../context.js";
+import type { SerwistViteApi } from "../../types.js";
+export declare const serwistSveltePlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/integration/svelte/types.d.ts

@@ -0,0 +1,23 @@
+import type { KitConfig } from "@sveltejs/kit";
+import type { PluginOptions as BasePluginOptions } from "../../types.js";
+import type { Optional } from "../../utils-types.js";
+export interface KitOptions extends Pick<KitConfig, "appDir"> {
+    /**
+     * @see https://kit.svelte.dev/docs/adapter-static#options-fallback
+     */
+    adapterFallback?: string;
+    /**
+     * `trailingSlash` in `+page.{ts,js}` or `+layout.{ts,js}` files.
+     * @default "never"
+     */
+    trailingSlash?: "never" | "always" | "ignore";
+    /**
+     * Should `"${appDir}/version.json"` be included in the service worker's precache manifest?
+     *
+     * @default false
+     */
+    includeVersionFile?: boolean;
+}
+export interface PluginOptions extends Optional<Omit<BasePluginOptions, "swSrc" | "swDest" | "swUrl">, "globDirectory"> {
+    kit?: KitOptions;
+}

package/dist/log-Dyh-Moyt.js

@@ -0,0 +1,26 @@
+import { b as cyan, v as version, g as green, e as dim, y as yellow } from './main-dzWmj8BB.js';
+import 'node:path';
+import 'node:process';
+import 'node:crypto';
+import 'node:fs';
+import 'fast-glob';
+
+function logSerwistResult(buildResult, viteOptions) {
+    const { logLevel = "info" } = viteOptions;
+    if (logLevel === "silent") return;
+    const { count, size, warnings } = buildResult;
+    if (logLevel === "info") {
+        console.info([
+            "",
+            `${cyan(`@serwist/vite/integration-svelte v${version}`)} ${green("files generated.")}`,
+            `${green("✓")} ${count} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}`,
+            warnings && warnings.length > 0 ? yellow([
+                "⚠ warnings",
+                ...warnings.map((w)=>`  ${w}`),
+                ""
+            ].join("\n")) : ""
+        ].join("\n"));
+    }
+}
+
+export { logSerwistResult };

package/dist/log.d.ts

@@ -0,0 +1,3 @@
+import type { BuildResult } from "@serwist/build";
+import type { ResolvedConfig } from "vite";
+export declare const logSerwistResult: (buildResult: Pick<BuildResult, "count" | "size" | "warnings">, viteOptions: ResolvedConfig) => void;

package/dist/main-dzWmj8BB.js

@@ -0,0 +1,348 @@
+import path, { resolve } from 'node:path';
+import process$1 from 'node:process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import fg from 'fast-glob';
+
+let enabled = true;
+// Support both browser and node environments
+const globalVar = typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};
+/**
+ * Detect how much colors the current terminal supports
+ */ let supportLevel = 0 /* none */ ;
+if (globalVar.process && globalVar.process.env && globalVar.process.stdout) {
+    const { FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, COLORTERM } = globalVar.process.env;
+    if (NODE_DISABLE_COLORS || NO_COLOR || FORCE_COLOR === '0') {
+        enabled = false;
+    } else if (FORCE_COLOR === '1' || FORCE_COLOR === '2' || FORCE_COLOR === '3') {
+        enabled = true;
+    } else if (TERM === 'dumb') {
+        enabled = false;
+    } else if ('CI' in globalVar.process.env && [
+        'TRAVIS',
+        'CIRCLECI',
+        'APPVEYOR',
+        'GITLAB_CI',
+        'GITHUB_ACTIONS',
+        'BUILDKITE',
+        'DRONE'
+    ].some((vendor)=>vendor in globalVar.process.env)) {
+        enabled = true;
+    } else {
+        enabled = process.stdout.isTTY;
+    }
+    if (enabled) {
+        // Windows supports 24bit True Colors since Windows 10 revision #14931,
+        // see https://devblogs.microsoft.com/commandline/24-bit-color-in-the-windows-console/
+        if (process.platform === 'win32') {
+            supportLevel = 3 /* trueColor */ ;
+        } else {
+            if (COLORTERM && (COLORTERM === 'truecolor' || COLORTERM === '24bit')) {
+                supportLevel = 3 /* trueColor */ ;
+            } else if (TERM && (TERM.endsWith('-256color') || TERM.endsWith('256'))) {
+                supportLevel = 2 /* ansi256 */ ;
+            } else {
+                supportLevel = 1 /* ansi */ ;
+            }
+        }
+    }
+}
+let options = {
+    enabled,
+    supportLevel
+};
+function kolorist(start, end, level = 1 /* ansi */ ) {
+    const open = `\x1b[${start}m`;
+    const close = `\x1b[${end}m`;
+    const regex = new RegExp(`\\x1b\\[${end}m`, 'g');
+    return (str)=>{
+        return options.enabled && options.supportLevel >= level ? open + ('' + str).replace(regex, open) + close : '' + str;
+    };
+}
+const dim = kolorist(2, 22);
+const green = kolorist(32, 39);
+const yellow = kolorist(33, 39);
+const cyan = kolorist(36, 39);
+
+var version = "8.2.0";
+
+const logSerwistResult = (buildResult, viteOptions)=>{
+    const { logLevel = "info" } = viteOptions;
+    if (logLevel === "silent") return;
+    const { count, size, warnings } = buildResult;
+    if (logLevel === "info") {
+        console.info([
+            "",
+            `${cyan(`@serwist/vite v${version}`)} ${green("files generated.")}`,
+            `${green("✓")} ${count} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}`,
+            // log build warning
+            warnings && warnings.length > 0 ? yellow([
+                "⚠ warnings",
+                ...warnings.map((w)=>`  ${w}`),
+                ""
+            ].join("\n")) : ""
+        ].join("\n"));
+    }
+};
+
+const loadSerwistBuild = async ()=>{
+    // "@serwist/build" is large and makes config loading slow.
+    // Since it is not always used, we only load this when it is needed.
+    try {
+        return await import('@serwist/build');
+    } catch (_) {
+        return require("@serwist/build");
+    }
+};
+const generateInjectManifest = async (options, viteOptions)=>{
+    // We will have something like this from swSrc:
+    /*
+  // sw.js
+  import { precacheAndRoute } from 'workbox-precaching'
+  // self.__WB_MANIFEST is default injection point
+  precacheAndRoute(self.__WB_MANIFEST)
+  */ const { build } = await import('vite');
+    const define = {
+        ...viteOptions.define ?? {}
+    };
+    define["process.env.NODE_ENV"] = JSON.stringify(options.mode);
+    const { format, plugins, rollupOptions } = options.injectManifestRollupOptions;
+    const parsedSwDest = path.parse(options.injectManifest.swDest);
+    await build({
+        root: viteOptions.root,
+        base: viteOptions.base,
+        resolve: viteOptions.resolve,
+        // Don't copy anything from public folder
+        publicDir: false,
+        build: {
+            sourcemap: viteOptions.build.sourcemap,
+            lib: {
+                entry: options.injectManifest.swSrc,
+                name: "app",
+                formats: [
+                    format
+                ]
+            },
+            rollupOptions: {
+                ...rollupOptions,
+                plugins,
+                output: {
+                    entryFileNames: parsedSwDest.base
+                }
+            },
+            outDir: parsedSwDest.dir,
+            emptyOutDir: false
+        },
+        configFile: false,
+        define
+    });
+    // If the user doesn't have an injectionPoint, skip injectManifest.
+    if (!options.injectManifest.injectionPoint) return;
+    await options.integration?.beforeBuildServiceWorker?.(options);
+    const resolvedInjectManifestOptions = {
+        ...options.injectManifest,
+        // This will not fail since there is an injectionPoint
+        swSrc: options.injectManifest.swDest
+    };
+    const { injectManifest } = await loadSerwistBuild();
+    // Inject the manifest
+    const buildResult = await injectManifest(resolvedInjectManifestOptions);
+    // Log workbox result
+    logSerwistResult(buildResult, viteOptions);
+};
+
+const createApi = (ctx)=>{
+    return {
+        get disabled () {
+            return ctx?.options?.disable;
+        },
+        async generateSW () {
+            if (ctx.options.disable) {
+                return undefined;
+            }
+            return await generateInjectManifest(ctx.options, ctx.viteConfig);
+        },
+        extendManifestEntries (fn) {
+            const { options } = ctx;
+            if (options.disable) return;
+            const result = fn(options.injectManifest.additionalPrecacheEntries || []);
+            if (result != null) {
+                options.injectManifest.additionalPrecacheEntries = result;
+            }
+        }
+    };
+};
+
+const createContext = (userOptions)=>{
+    return {
+        userOptions,
+        options: undefined,
+        viteConfig: undefined,
+        useImportRegister: false,
+        devEnvironment: false
+    };
+};
+
+const devPlugin = (ctx)=>{
+    return {
+        name: "@serwist/vite:dev",
+        apply: "serve",
+        configureServer () {
+            ctx.devEnvironment = true;
+        }
+    };
+};
+
+const INTERNAL_SERWIST_VIRTUAL = "virtual:internal-serwist";
+const RESOLVED_INTERNAL_SERWIST_VIRTUAL = `\0${INTERNAL_SERWIST_VIRTUAL}`;
+
+const buildManifestEntry = (publicDir, url)=>{
+    return new Promise((resolve$1, reject)=>{
+        const cHash = crypto.createHash("MD5");
+        const stream = fs.createReadStream(resolve(publicDir, url));
+        stream.on("error", (err)=>{
+            reject(err);
+        });
+        stream.on("data", (chunk)=>{
+            cHash.update(chunk);
+        });
+        stream.on("end", ()=>{
+            return resolve$1({
+                url,
+                revision: `${cHash.digest("hex")}`
+            });
+        });
+    });
+};
+const lookupAdditionalPrecacheEntries = (serwistOptions)=>{
+    return serwistOptions.additionalPrecacheEntries || [];
+};
+// we need to make icons relative, we can have for example icon entries with: /pwa.png
+// fast-glob will not resolve absolute paths
+const normalizeIconPath = (path)=>{
+    return path.startsWith("/") ? path.substring(1) : path;
+};
+const configureStaticAssets = async (resolvedPluginOptions, viteConfig)=>{
+    const { injectManifest, includeAssets } = resolvedPluginOptions;
+    const { publicDir } = viteConfig;
+    const globs = [];
+    const manifestEntries = lookupAdditionalPrecacheEntries(injectManifest);
+    if (includeAssets) {
+        // we need to make icons relative, we can have for example icon entries with: /pwa.png
+        // fast-glob will not resolve absolute paths
+        if (Array.isArray(includeAssets)) globs.push(...includeAssets.map(normalizeIconPath));
+        else globs.push(normalizeIconPath(includeAssets));
+    }
+    if (globs.length > 0) {
+        let assets = await fg(globs, {
+            cwd: publicDir,
+            onlyFiles: true,
+            unique: true
+        });
+        // we also need to remove from the list existing included by the user
+        if (manifestEntries.length > 0) {
+            const included = manifestEntries.map((me)=>{
+                if (typeof me === "string") return me;
+                else return me.url;
+            });
+            assets = assets.filter((a)=>!included.includes(a));
+        }
+        const assetsEntries = await Promise.all(assets.map((a)=>{
+            return buildManifestEntry(publicDir, a);
+        }));
+        manifestEntries.push(...assetsEntries);
+    }
+    if (manifestEntries.length > 0) {
+        injectManifest.additionalPrecacheEntries = manifestEntries;
+    }
+};
+
+const slash = (str)=>{
+    return str.replace(/\\/g, "/");
+};
+const resolveBasePath = (base)=>{
+    if (isAbsolute(base)) return base;
+    return !base.startsWith("/") && !base.startsWith("./") ? `/${base}` : base;
+};
+const isAbsolute = (url)=>{
+    return url.match(/^(?:[a-z]+:)?\/\//i);
+};
+
+const resolveOptions = async (options, viteConfig)=>{
+    const { type = "classic", mode = process$1.env.NODE_ENV || "production", injectRegister = "auto", registerType = "prompt", minify = true, base = viteConfig.base, includeAssets = undefined, useCredentials = false, disable = false, integration = {}, buildBase, ...injectManifest } = options;
+    const basePath = resolveBasePath(base);
+    // check typescript service worker for injectManifest strategy
+    const scope = options.scope || basePath;
+    let assetsDir = slash(viteConfig.build.assetsDir ?? "assets");
+    if (assetsDir[assetsDir.length - 1] !== "/") assetsDir += "/";
+    // remove './' prefix from assetsDir
+    const dontCacheBustURLsMatching = new RegExp(`^${assetsDir.replace(/^\.*?\//, "")}`);
+    const { plugins = [], rollupOptions = {}, rollupFormat = "es", swUrl = "/sw.js", swSrc, swDest, ...userInjectManifest } = injectManifest || {};
+    const resolvedPluginOptions = {
+        base: basePath,
+        type,
+        mode,
+        injectRegister,
+        registerType,
+        useCredentials,
+        swUrl,
+        injectManifest: {
+            dontCacheBustURLsMatching,
+            ...userInjectManifest,
+            swSrc: path.resolve(viteConfig.root, swSrc),
+            swDest: path.resolve(viteConfig.root, viteConfig.build.outDir, swDest),
+            disablePrecacheManifest: !viteConfig.isProduction
+        },
+        scope,
+        minify,
+        includeAssets,
+        disable,
+        integration,
+        buildBase: buildBase ?? basePath,
+        injectManifestRollupOptions: {
+            plugins,
+            rollupOptions,
+            format: rollupFormat
+        }
+    };
+    // calculate hash only when required
+    const calculateHash = !resolvedPluginOptions.disable && resolvedPluginOptions.includeAssets && viteConfig.command === "build";
+    if (calculateHash) await configureStaticAssets(resolvedPluginOptions, viteConfig);
+    return resolvedPluginOptions;
+};
+
+const mainPlugin = (ctx, api)=>{
+    return {
+        name: "@serwist/vite",
+        enforce: "pre",
+        config () {
+            return {
+                ssr: {
+                    noExternal: []
+                }
+            };
+        },
+        async configResolved (config) {
+            ctx.viteConfig = config;
+            ctx.userOptions?.integration?.configureOptions?.(config, ctx.userOptions);
+            ctx.options = await resolveOptions(ctx.userOptions, config);
+        },
+        resolveId (id) {
+            if (id === INTERNAL_SERWIST_VIRTUAL) {
+                return RESOLVED_INTERNAL_SERWIST_VIRTUAL;
+            }
+            return undefined;
+        },
+        load (id) {
+            if (id === RESOLVED_INTERNAL_SERWIST_VIRTUAL) {
+                return `export const swUrl = "${path.posix.join(ctx.options.buildBase, ctx.options.swUrl)}";
+export const swScope = "${ctx.options.scope}";
+export const swType = "${ctx.devEnvironment ? "module" : ctx.options.type}";`;
+            }
+            return undefined;
+        },
+        api
+    };
+};
+
+export { createApi as a, cyan as b, createContext as c, devPlugin as d, dim as e, green as g, loadSerwistBuild as l, mainPlugin as m, version as v, yellow as y };

package/dist/modules.d.ts

@@ -0,0 +1,5 @@
+import type * as SerwistBuild from "@serwist/build";
+import type { ResolvedConfig } from "vite";
+import type { ResolvedPluginOptions } from "./types.js";
+export declare const loadSerwistBuild: () => Promise<typeof SerwistBuild>;
+export declare const generateInjectManifest: (options: ResolvedPluginOptions, viteOptions: ResolvedConfig) => Promise<void>;

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig } from "vite";
+import type { PluginOptions, ResolvedPluginOptions } from "./types.js";
+export declare const resolveOptions: (options: PluginOptions, viteConfig: ResolvedConfig) => Promise<ResolvedPluginOptions>;

package/dist/plugins/build.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { SerwistViteContext } from "../context.js";
+import type { SerwistViteApi } from "../types.js";
+export declare const buildPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/plugins/dev.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+import type { SerwistViteContext } from "../context.js";
+export declare const devPlugin: (ctx: SerwistViteContext) => Plugin;

package/dist/plugins/main.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { SerwistViteContext } from "../context.js";
+import type { SerwistViteApi } from "../types.js";
+export declare const mainPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/types.d.ts

@@ -0,0 +1,176 @@
+import type { InjectManifestOptions, ManifestEntry } from "@serwist/build";
+import type { RollupOptions } from "rollup";
+import type { Plugin, ResolvedConfig } from "vite";
+export type InjectManifestVitePlugins = string[] | ((vitePluginIds: string[]) => string[]);
+export interface CustomInjectManifestOptions extends Omit<InjectManifestOptions, "disablePrecacheManifest"> {
+    /**
+     * The URL to the service worker.
+     * @default "/sw.js"
+     */
+    swUrl?: string;
+    /**
+     * Configure the format to use in the Rollup build.
+     *
+     * @default 'es'
+     */
+    rollupFormat?: "es" | "iife";
+    /**
+     * Since `v0.15.0` you can add plugins to build your service worker.
+     *
+     * When using `injectManifest` there are 2 builds, your application and the service worker.
+     * If you're using custom configuration for your service worker (for example custom plugins) you can use this option to configure the service worker build.
+     * Both configurations cannot be shared, and so you'll need to duplicate the configuration, with the exception of `define`.
+     *
+     * **WARN**: this option is for advanced usage, be aware that you may break your application build.
+     */
+    plugins?: Plugin[];
+    /**
+     * Since `v0.15.0` you can add custom Rollup options to build your service worker: we expose the same configuration to build a worker using Vite.
+     */
+    rollupOptions?: Omit<RollupOptions, "plugins" | "output">;
+}
+export interface SerwistViteHooks {
+    beforeBuildServiceWorker?: (options: ResolvedPluginOptions) => void | Promise<void>;
+    closeBundleOrder?: "pre" | "post" | null;
+    configureOptions?: (viteOptions: ResolvedConfig, options: PluginOptions) => void | Promise<void>;
+}
+/**
+ * Plugin options.
+ */
+export interface BasePluginOptions {
+    /**
+     * Build mode
+     *
+     * @default
+     * process.env.NODE_ENV // or "production" if undefined
+     */
+    mode?: "development" | "production";
+    /**
+     * The service worker type.
+     *
+     * @default "classic"
+     */
+    type?: WorkerType;
+    /**
+     * The scope to register the Service Worker
+     *
+     * @default `viteOptions.base`
+     */
+    scope?: string;
+    /**
+     * Inject the service worker register inlined in the index.html
+     *
+     * If set to "auto", depends on whether you used the `import { registerSW } from 'virtual:pwa-register'`
+     * it will do nothing or use the `script` mode
+     *
+     * `"inline"` - inject a simple register, inlined with the generated html
+     *
+     * `"script"` - inject `<script/>` in `<head>` with `src` attribute to a generated script to register the service worker
+     *
+     * `"script-defer"` - inject `<script defer />` in `<head>`, with `src` attribute to a generated script to register the service worker
+     *
+     * `null` - do nothing. You will need to register the service worker yourself or import `registerSW` from `virtual:pwa-register`.
+     *
+     * @default "auto"
+     */
+    injectRegister: "inline" | "script" | "script-defer" | "auto" | null | false;
+    /**
+     * Mode for the virtual register.
+     * This is NOT available if `injectRegister` is set to `"inline"` or `"script"`
+     *
+     * `"prompt"` - you will need to show a popup/dialog to the user to confirm the reload.
+     *
+     * `"autoUpdate"` - when new content is available, the new service worker will update caches and reload all browser
+     * windows/tabs with the application open automatically, it must take the control for the application to work
+     * properly.
+     *
+     * @default "prompt"
+     */
+    registerType?: "prompt" | "autoUpdate";
+    /**
+     * Minify the generated manifest
+     *
+     * @default true
+     */
+    minify: boolean;
+    /**
+     * Whether to add the `crossorigin="use-credentials"` attribute to `<link rel="manifest">`
+     * @default false
+     */
+    useCredentials?: boolean;
+    /**
+     * Override Vite's base options for `@serwist/vite`.
+     *
+     * @default viteOptions.base
+     */
+    base?: string;
+    /**
+     * `public` resources to be added to the PWA manifest.
+     *
+     * You don't need to add `manifest` icons here, it will be auto included.
+     *
+     * The `public` directory will be resolved from Vite's `publicDir` option directory.
+     */
+    includeAssets: string | string[] | undefined;
+    /**
+     * Whether Serwist should be disabled.
+     *
+     * @default false
+     */
+    disable: boolean;
+    /**
+     * `@serwist/vite` integration.
+     */
+    integration?: SerwistViteHooks;
+    /**
+     * When Vite's build folder is not the same as your base root folder, configure it here.
+     *
+     * This option will be useful for integrations like `vite-plugin-laravel` where Vite's build folder is `public/build` but Laravel's base path is `public`.
+     *
+     * This option will be used to configure the path for the service worker, "registerSW.js" and the web manifest assets.
+     *
+     * For example, if your base path is `/`, then, in your Laravel PWA configuration use `buildPath: '/build/'`.
+     *
+     * By default: `vite.base`.
+     */
+    buildBase?: string;
+}
+export type PluginOptions = Partial<BasePluginOptions> & CustomInjectManifestOptions;
+export interface InjectManifestRollupOptions {
+    format: "es" | "iife";
+    plugins: Plugin[];
+    rollupOptions: RollupOptions;
+}
+export interface ResolvedPluginOptions extends Required<BasePluginOptions>, Required<Pick<CustomInjectManifestOptions, "swUrl">> {
+    injectManifest: InjectManifestOptions;
+    injectManifestRollupOptions: InjectManifestRollupOptions;
+}
+export interface ShareTargetFiles {
+    name: string;
+    accept: string | string[];
+}
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/Manifest/launch_handler#launch_handler_item_values
+ */
+export type LaunchHandlerClientMode = "auto" | "focus-existing" | "navigate-existing" | "navigate-new";
+export type Display = "fullscreen" | "standalone" | "minimal-ui" | "browser";
+export type DisplayOverride = Display | "window-controls-overlay";
+export type IconPurpose = "monochrome" | "maskable" | "any";
+interface Nothing {
+}
+/**
+ * type StringLiteralUnion<'maskable'> = 'maskable' | string
+ * This has auto completion whereas `'maskable' | string` doesn't
+ * Adapted from https://github.com/microsoft/TypeScript/issues/29729
+ */
+export type StringLiteralUnion<T extends U, U = string> = T | (U & Nothing);
+export interface SerwistViteApi {
+    /**
+     * Is the plugin disabled?
+     */
+    disabled: boolean;
+    extendManifestEntries(fn: ExtendManifestEntriesHook): void;
+    generateSW(): Promise<void>;
+}
+export type ExtendManifestEntriesHook = (manifestEntries: (string | ManifestEntry)[]) => (string | ManifestEntry)[] | undefined;
+export {};

package/dist/utils-types.d.ts

@@ -0,0 +1 @@
+export type Optional<T, U extends keyof T> = Omit<T, U> & Partial<Pick<T, U>>;

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const slash: (str: string) => string;
+export declare const resolveBasePath: (base: string) => string;
+export declare const isAbsolute: (url: string) => RegExpMatchArray | null;
+export declare const normalizePath: (path: string) => string;

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "@serwist/vite",
+  "version": "8.2.0",
+  "type": "module",
+  "description": "A module that integrates Serwist into your Vite application.",
+  "files": [
+    "dist",
+    "!dist/dts"
+  ],
+  "keywords": [
+    "react",
+    "remix",
+    "vue",
+    "preact",
+    "svelte",
+    "sveltekit",
+    "solidjs",
+    "vite",
+    "vite-plugin",
+    "serwist",
+    "serwistjs",
+    "pwa",
+    "sw",
+    "service worker",
+    "web",
+    "service-worker"
+  ],
+  "author": "antfu <anthonyfu117@hotmail.com>, Serwist's Team",
+  "license": "MIT",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://serwist.vercel.app",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "./dist/index.browser.d.ts"
+      ],
+      "worker": [
+        "./dist/index.worker.d.ts"
+      ],
+      "integration-*": [
+        "./dist/integration/*/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./browser": {
+      "import": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      }
+    },
+    "./worker": {
+      "import": {
+        "types": "./dist/index.worker.d.ts",
+        "default": "./dist/index.worker.js"
+      }
+    },
+    "./integration-*": {
+      "import": {
+        "types": "./dist/integration/*/index.d.ts",
+        "default": "./dist/integration/*/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "debug": "4.3.4",
+    "fast-glob": "3.3.2",
+    "pretty-bytes": "6.1.1",
+    "@serwist/build": "8.2.0",
+    "@serwist/window": "8.2.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.40.1",
+    "@sveltejs/kit": "2.0.6",
+    "@types/debug": "4.1.12",
+    "@types/node": "20.10.5",
+    "@types/prompts": "2.4.9",
+    "@types/react": "18.2.45",
+    "bumpp": "9.2.1",
+    "eslint": "8.56.0",
+    "kolorist": "1.8.0",
+    "preact": "10.19.3",
+    "prompts": "2.4.2",
+    "publint": "0.2.7",
+    "react": "18.2.0",
+    "rollup": "4.9.1",
+    "solid-js": "1.8.7",
+    "svelte": "5.0.0-next.26",
+    "typescript": "5.4.0-dev.20231226",
+    "vite": "5.0.10",
+    "vue": "3.3.13",
+    "@serwist/constants": "8.2.0"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": "^1.0.0 || ^2.0.0",
+    "preact": "^10.0.0",
+    "react": "^18.0.0",
+    "solid-js": "^1.8.7",
+    "svelte": "^4.0.0 || ^5.0.0",
+    "vite": "^5.0.0",
+    "vue": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@sveltejs/kit": {
+      "optional": true
+    },
+    "preact": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}