@serwist/vite 8.2.0 → 8.4.0

package/dist/context.d.ts

@@ -1,10 +1,32 @@
 import type { ResolvedConfig } from "vite";
 import type { PluginOptions, ResolvedPluginOptions } from "./types.js";
+export type SerwistViteFrameworks = "nuxt" | "sveltekit";
 export interface SerwistViteContext {
+    /**
+     * Resolved Vite config.
+     *
+     * Note: This value is set by our main plugin, located at plugins/main.ts.
+     */
     viteConfig: ResolvedConfig;
+    /**
+     * Provided options.
+     */
     userOptions: PluginOptions;
+    /**
+     * Resolved options.
+     *
+     * Note: this is different from `userOptions` in that it has been parsed, whereas
+     * `userOptions` is the raw configuration that the user provides us.
+     */
     options: ResolvedPluginOptions;
     useImportRegister: boolean;
+    /**
+     * Is the plugin running on dev?
+     *
+     * Note: This value is set by our dev plugin, located at plugins/dev.ts.
+     */
     devEnvironment: boolean;
+    /** To tailor our APIs to these frameworks. */
+    framework: SerwistViteFrameworks | undefined;
 }
-export declare const createContext: (userOptions: PluginOptions) => SerwistViteContext;
+export declare const createContext: (userOptions: PluginOptions, framework: SerwistViteFrameworks | undefined) => SerwistViteContext;

package/dist/index.d.ts

@@ -1,9 +1,17 @@
 import type { Plugin } from "vite";
+import { createApi } from "./api.js";
+import { createContext } from "./context.js";
+import { buildPlugin } from "./plugins/build.js";
+import { devPlugin } from "./plugins/dev.js";
+import { mainPlugin } from "./plugins/main.js";
 import type { PluginOptions } from "./types.js";
+import { resolveEntry, toFs } from "./utils.js";
 /**
  * Integrates Serwist into your Vite app.
  * @param userOptions
  * @returns
  */
 export declare const serwist: (userOptions: PluginOptions) => Plugin[];
+export { buildPlugin as build, createApi, createContext, devPlugin as dev, mainPlugin as main, resolveEntry, toFs };
+export type { SerwistViteContext } from "./context.js";
 export * from "./types.js";

package/dist/index.js

@@ -1,11 +1,22 @@
-import { m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from './main-dzWmj8BB.js';
+import { m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from './main.js';
+export { r as resolveEntry, t as toFs } from './main.js';
+import 'node:assert';
+import 'node:fs/promises';
 import 'node:path';
+import 'vite';
 import 'node:process';
+import '@serwist/build';
 import 'node:crypto';
 import 'node:fs';
 import 'fast-glob';
 
-const buildPlugin = (ctx, api)=>{
+/**
+ * Internal build plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ const buildPlugin = (ctx, api)=>{
     return {
         name: "@serwist/vite:build",
         enforce: "post",
@@ -30,13 +41,13 @@ const buildPlugin = (ctx, api)=>{
  * @param userOptions
  * @returns
  */ const serwist = (userOptions)=>{
-    const ctx = createContext(userOptions);
+    const ctx = createContext(userOptions, undefined);
     const api = createApi(ctx);
     return [
         mainPlugin(ctx, api),
         buildPlugin(ctx, api),
-        devPlugin(ctx)
+        devPlugin(ctx, api)
     ];
 };
 
-export { serwist };
+export { buildPlugin as build, createApi, createContext, devPlugin as dev, mainPlugin as main, serwist };

package/dist/integration/svelte/{serwist-svelte-plugin.d.ts → build.d.ts}

@@ -1,4 +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>;
+export declare const buildPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/integration/svelte/index.js

@@ -1,15 +1,47 @@
-import { l as loadSerwistBuild, m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from '../../main-dzWmj8BB.js';
+import { r as resolveEntry, m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from '../../main.js';
+import crypto from 'node:crypto';
+import os from 'node:os';
 import path from 'node:path';
+import { errors } from '@serwist/build';
+import 'node:assert';
+import 'node:fs/promises';
+import 'vite';
 import 'node:process';
-import 'node:crypto';
 import 'node:fs';
 import 'fast-glob';
 
+const buildPlugin = (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) {
+                    await api.generateSW();
+                }
+            }
+        }
+    };
+};
+
 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");
+    if (viteConfig.isProduction) {
+        options.swSrc = path.resolve(clientOutDir, "service-worker.js");
+        options.swDest = path.resolve(clientOutDir, "service-worker.js");
+    } else {
+        const swSrc = resolveEntry(path.join(viteConfig.root, kit.files?.serviceWorker ?? "src/service-worker"));
+        if (swSrc) {
+            options.swSrc = swSrc;
+            options.swDest = path.join(os.tmpdir(), `serwist-vite-integration-svelte-${crypto.randomUUID()}.js`);
+        } else {
+            throw new Error(errors["invalid-sw-src"]);
+        }
+    }
     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.
@@ -36,6 +68,9 @@ const configurateSvelteKitOptions = (viteConfig, kit, options)=>{
     if (!("dontCacheBustURLsMatching" in options)) {
         options.dontCacheBustURLsMatching = new RegExp(`${buildAssetsDir}immutable/`);
     }
+    if (!options.injectionPoint) {
+        options.injectionPoint = "self.__SW_MANIFEST";
+    }
 };
 function createManifestTransform(base, webManifestName, options) {
     return async (entries)=>{
@@ -107,30 +142,7 @@ function buildGlobIgnores(globIgnores) {
     ];
 }
 
-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);
-                }
-            }
-        }
-    };
-};
-
+// TODO: handle SvelteKit build errors.
 /**
  * Integrates Serwist into your SvelteKit app.
  * @param userOptions
@@ -139,12 +151,12 @@ const serwistSveltePlugin = (ctx, api)=>{
     if (!userOptions.integration) userOptions.integration = {};
     userOptions.integration.closeBundleOrder = "pre";
     userOptions.integration.configureOptions = (viteConfig, options)=>configurateSvelteKitOptions(viteConfig, userOptions.kit ?? {}, options);
-    const ctx = createContext(userOptions);
+    const ctx = createContext(userOptions, "sveltekit");
     const api = createApi(ctx);
     return [
         mainPlugin(ctx, api),
-        devPlugin(ctx),
-        serwistSveltePlugin(ctx, api)
+        devPlugin(ctx, api),
+        buildPlugin(ctx, api)
     ];
 };
 

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

@@ -1,7 +1,7 @@
 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"> {
+export interface KitOptions extends Pick<KitConfig, "appDir" | "files"> {
     /**
      * @see https://kit.svelte.dev/docs/adapter-static#options-fallback
      */

package/dist/main.js

@@ -0,0 +1,543 @@
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path, { resolve } from 'node:path';
+import { normalizePath } from 'vite';
+import process$1 from 'node:process';
+import { validateInjectManifestOptions } from '@serwist/build';
+import crypto from 'node:crypto';
+import fs$1 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.4.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 (_) {
+        // We don't have a default export, don't worry.
+        return require("@serwist/build");
+    }
+};
+const injectManifest = async (config)=>{
+    const { validateViteInjectManifestOptions, getFileManifestEntries, stringify } = await loadSerwistBuild();
+    const options = validateViteInjectManifestOptions(config);
+    const { count, size, manifestEntries, warnings } = await getFileManifestEntries(options);
+    const manifestString = manifestEntries === undefined ? "undefined" : stringify(manifestEntries);
+    return {
+        warnings,
+        size,
+        count,
+        manifestEntries,
+        manifestString
+    };
+};
+const generateServiceWorker = async (ctx)=>{
+    const { format, plugins, rollupOptions } = ctx.options.injectManifestRollupOptions;
+    const parsedSwDest = path.parse(ctx.options.injectManifest.swDest);
+    let injectManifestResult = undefined;
+    if (ctx.options.injectManifest.injectionPoint) {
+        await ctx.options.integration?.beforeBuildServiceWorker?.(ctx.options);
+        injectManifestResult = await injectManifest(ctx.options.injectManifest);
+    }
+    const isProduction = ctx.options.mode === "production";
+    const isDev = ctx.options.mode === "development";
+    if (isProduction && ctx.framework === "sveltekit" || isDev && !ctx.options.devOptions.bundle) {
+        if (!injectManifestResult) {
+            throw new Error(`injectManifest failed to generate results. This is likely a bug.`);
+        }
+        const { errors, escapeRegExp, getSourceMapURL, rebasePath, replaceAndUpdateSourceMap, translateURLToSourcemapPaths } = await loadSerwistBuild();
+        // Make sure we leave swSrc and swDest out of the precache manifest.
+        for (const file of [
+            ctx.options.injectManifest.swSrc,
+            ctx.options.injectManifest.swDest
+        ]){
+            ctx.options.injectManifest.globIgnores.push(rebasePath({
+                file,
+                baseDirectory: ctx.options.injectManifest.globDirectory
+            }));
+        }
+        const injectionPoint = ctx.options.injectManifest.injectionPoint;
+        const globalRegexp = new RegExp(escapeRegExp(injectionPoint), "g");
+        let swFileContents;
+        try {
+            swFileContents = await fs.readFile(ctx.options.injectManifest.swSrc, "utf8");
+        } catch (error) {
+            throw new Error(`${errors["invalid-sw-src"]} ${error instanceof Error && error.message ? error.message : ""}`);
+        }
+        const injectionResults = swFileContents.match(globalRegexp);
+        // See https://github.com/GoogleChrome/workbox/issues/2230
+        if (!injectionResults) {
+            throw new Error(`${errors["injection-point-not-found"]} ${injectionPoint}`);
+        }
+        assert(injectionResults.length === 1, `${errors["multiple-injection-points"]} ${injectionPoint}`);
+        const filesToWrite = {};
+        const url = getSourceMapURL(swFileContents);
+        // See https://github.com/GoogleChrome/workbox/issues/2957
+        const { destPath, srcPath, warning } = translateURLToSourcemapPaths(url, ctx.options.injectManifest.swSrc, ctx.options.injectManifest.swDest);
+        if (warning) {
+            injectManifestResult.warnings.push(warning);
+        }
+        // If our swSrc file contains a sourcemap, we would invalidate that
+        // mapping if we just replaced injectionPoint with the stringified manifest.
+        // Instead, we need to update the swDest contents as well as the sourcemap
+        // (assuming it's a real file, not a data: URL) at the same time.
+        // See https://github.com/GoogleChrome/workbox/issues/2235
+        // and https://github.com/GoogleChrome/workbox/issues/2648
+        if (srcPath && destPath) {
+            const { map, source } = await replaceAndUpdateSourceMap({
+                originalMap: JSON.parse(await fs.readFile(srcPath, "utf8")),
+                jsFilename: path.basename(ctx.options.injectManifest.swDest),
+                originalSource: swFileContents,
+                replaceString: injectManifestResult.manifestString,
+                searchString: injectionPoint
+            });
+            filesToWrite[ctx.options.injectManifest.swDest] = source;
+            filesToWrite[destPath] = map;
+        } else {
+            // If there's no sourcemap associated with swSrc, a simple string
+            // replacement will suffice.
+            filesToWrite[ctx.options.injectManifest.swDest] = swFileContents.replace(globalRegexp, injectManifestResult.manifestString);
+        }
+        for (const [file, contents] of Object.entries(filesToWrite)){
+            try {
+                await fs.mkdir(path.dirname(file), {
+                    recursive: true
+                });
+            } catch (error) {
+                throw new Error(errors["unable-to-make-sw-directory"] + ` '${error instanceof Error && error.message ? error.message : ""}'`);
+            }
+            await fs.writeFile(file, contents);
+        }
+    } else {
+        const define = {
+            // Nuxt does some really weird stuff. During the build, they MANUALLY
+            // set browser APIs, such as window, document, location,..., to `undefined`??
+            // Probably some Vue or server stuff. Their `define` doesn't seem to have anything
+            // particularly useful for the service worker anyway, so we don't extend it.
+            ...ctx.framework === "nuxt" ? undefined : ctx.viteConfig.define,
+            "process.env.NODE_ENV": `"${ctx.options.mode}"`
+        };
+        if (ctx.options.injectManifest.injectionPoint && injectManifestResult) {
+            define[ctx.options.injectManifest.injectionPoint] = injectManifestResult.manifestString;
+        }
+        const { build } = await import('vite');
+        await build({
+            logLevel: ctx.viteConfig.isProduction ? "info" : "warn",
+            root: ctx.viteConfig.root,
+            base: ctx.viteConfig.base,
+            resolve: ctx.viteConfig.resolve,
+            // Don't copy anything from public folder
+            publicDir: false,
+            build: {
+                sourcemap: ctx.viteConfig.build.sourcemap,
+                lib: {
+                    entry: ctx.options.injectManifest.swSrc,
+                    name: "app",
+                    formats: [
+                        format
+                    ]
+                },
+                rollupOptions: {
+                    ...rollupOptions,
+                    plugins,
+                    output: {
+                        entryFileNames: parsedSwDest.base
+                    }
+                },
+                outDir: parsedSwDest.dir,
+                emptyOutDir: false,
+                minify: isProduction || ctx.options.devOptions.minify
+            },
+            configFile: false,
+            define
+        });
+    }
+    return injectManifestResult;
+};
+
+const createApi = (ctx)=>{
+    return {
+        get disabled () {
+            return ctx?.options?.disable;
+        },
+        async generateSW () {
+            if (ctx.options.disable) {
+                return undefined;
+            }
+            const buildResult = await generateServiceWorker(ctx);
+            if (buildResult) {
+                if (ctx.viteConfig.isProduction) {
+                    // Log Serwist result
+                    logSerwistResult(buildResult, ctx.viteConfig);
+                } else if (buildResult.warnings && buildResult.warnings.length > 0) {
+                    console.warn(yellow([
+                        "[@serwist/vite] Warnings",
+                        ...buildResult.warnings.map((w)=>` - ${w}`),
+                        ""
+                    ].join("\n")));
+                }
+            }
+        },
+        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, framework)=>{
+    return {
+        userOptions,
+        options: undefined,
+        viteConfig: undefined,
+        useImportRegister: false,
+        devEnvironment: false,
+        framework
+    };
+};
+
+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);
+};
+// Source: https://github.com/sveltejs/kit/blob/6419d3eaa7bf1b0a756b28f06a73f71fe042de0a/packages/kit/src/utils/filesystem.js
+// License: MIT
+/**
+ * Internal function used by `@serwist/vite`.
+ * Resolves a file path without extension. Also handles `/index` if the path
+ * actually points to a directory.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ const resolveEntry = (entry)=>{
+    if (fs$1.existsSync(entry)) {
+        const stats = fs$1.statSync(entry);
+        if (stats.isDirectory()) {
+            return resolveEntry(path.join(entry, "index"));
+        }
+        return entry;
+    } else {
+        const dir = path.dirname(entry);
+        if (fs$1.existsSync(dir)) {
+            const base = path.basename(entry);
+            const files = fs$1.readdirSync(dir);
+            const found = files.find((file)=>file.replace(/\.[^.]+$/, "") === base);
+            if (found) return path.join(dir, found);
+        }
+    }
+    return null;
+};
+// Source: https://github.com/sveltejs/kit/blob/6419d3eaa7bf1b0a756b28f06a73f71fe042de0a/packages/kit/src/utils/filesystem.js
+// License: MIT
+/**
+ * Internal function used by `@serwist/vite`.
+ * Converts a filesystem path to a Vite `@fs` URL.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ function toFs(str) {
+    str = str.replace(/\\/g, "/");
+    // Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
+    return `/@fs${str.startsWith("/") ? "" : "/"}${str}`;
+}
+
+// This plugin handles the service worker in two ways:
+// - If `devOptions.bundle` is enabled, hook a middleware that bundles the service worker
+// through `api.generateSW()` and returns the result into Vite's dev server.
+// - Otherwise, run `injectManifest` and return the service worker through `async load(id)`. Although
+// `precacheEntries` is always `undefined`, we still do this to check the user's `injectManifest` options
+// in dev mode.
+/**
+ * Internal dev plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ const devPlugin = (ctx, api)=>{
+    return {
+        name: "@serwist/vite:dev",
+        apply: "serve",
+        configureServer (server) {
+            ctx.devEnvironment = true;
+            server.middlewares.use(async (req, res, next)=>{
+                if (!ctx.options.disable && req.url === ctx.options.swUrl) {
+                    if (ctx.options.devOptions.bundle) {
+                        await api.generateSW();
+                        const content = await fs.readFile(ctx.options.injectManifest.swDest, "utf-8");
+                        await fs.rm(ctx.options.injectManifest.swDest);
+                        res.setHeader("Content-Type", "application/javascript");
+                        res.write(content);
+                        res.end();
+                    } else {
+                        res.setHeader("Content-Type", "application/javascript");
+                        res.write(`import "${toFs(path.resolve(ctx.options.injectManifest.swSrc))}";`);
+                        res.end();
+                    }
+                } else {
+                    next();
+                }
+            });
+        },
+        async load (id) {
+            if (!ctx.options.disable && !ctx.options.devOptions.bundle) {
+                const swSrcId = normalizePath(ctx.options.injectManifest.swSrc);
+                if (id === swSrcId) {
+                    await api.generateSW();
+                    const content = await fs.readFile(ctx.options.injectManifest.swDest, "utf-8");
+                    await fs.rm(ctx.options.injectManifest.swDest);
+                    return content;
+                }
+            }
+            return undefined;
+        }
+    };
+};
+
+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$1.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 resolveOptions = async (options, viteConfig)=>{
+    const { type = "classic", mode = process$1.env.NODE_ENV || "production", injectRegister = "auto", registerType = "prompt", minify = true, base = viteConfig.base, scope: _scope, swUrl = "/sw.js", includeAssets = undefined, useCredentials = false, disable = false, integration = {}, buildBase, devOptions, plugins = [], rollupOptions = {}, rollupFormat = "es", ...injectManifest } = options;
+    const basePath = resolveBasePath(base);
+    // check typescript service worker for injectManifest strategy
+    const scope = _scope || basePath;
+    let assetsDir = slash(viteConfig.build.assetsDir ?? "assets");
+    if (assetsDir[assetsDir.length - 1] !== "/") assetsDir += "/";
+    const resolvedDevOptions = {
+        bundle: true,
+        minify: false,
+        ...devOptions
+    };
+    // remove './' prefix from assetsDir
+    const dontCacheBustURLsMatching = new RegExp(`^${assetsDir.replace(/^\.*?\//, "")}`);
+    validateInjectManifestOptions(injectManifest);
+    const { 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
+        },
+        devOptions: resolvedDevOptions
+    };
+    // calculate hash only when required
+    const calculateHash = !resolvedPluginOptions.disable && resolvedPluginOptions.includeAssets && viteConfig.command === "build";
+    if (calculateHash) await configureStaticAssets(resolvedPluginOptions, viteConfig);
+    return resolvedPluginOptions;
+};
+
+/**
+ * Internal plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ 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, createContext as c, devPlugin as d, mainPlugin as m, resolveEntry as r, toFs as t };

package/dist/modules.d.ts

@@ -1,5 +1,9 @@
 import type * as SerwistBuild from "@serwist/build";
-import type { ResolvedConfig } from "vite";
-import type { ResolvedPluginOptions } from "./types.js";
+import type { SerwistViteContext } from "./context.js";
 export declare const loadSerwistBuild: () => Promise<typeof SerwistBuild>;
-export declare const generateInjectManifest: (options: ResolvedPluginOptions, viteOptions: ResolvedConfig) => Promise<void>;
+interface BuildResult extends SerwistBuild.GetManifestResult {
+    manifestString: string;
+}
+export declare const injectManifest: (config: SerwistBuild.ViteInjectManifestOptions) => Promise<BuildResult>;
+export declare const generateServiceWorker: (ctx: SerwistViteContext) => Promise<BuildResult | undefined>;
+export {};

package/dist/plugins/build.d.ts

@@ -1,4 +1,11 @@
 import type { Plugin } from "vite";
 import type { SerwistViteContext } from "../context.js";
 import type { SerwistViteApi } from "../types.js";
+/**
+ * Internal build plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */
 export declare const buildPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/plugins/dev.d.ts

@@ -1,3 +1,11 @@
-import type { Plugin } from "vite";
+import { type Plugin } from "vite";
 import type { SerwistViteContext } from "../context.js";
-export declare const devPlugin: (ctx: SerwistViteContext) => Plugin;
+import type { SerwistViteApi } from "../types.js";
+/**
+ * Internal dev plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */
+export declare const devPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin;

package/dist/plugins/main.d.ts

@@ -1,4 +1,11 @@
 import type { Plugin } from "vite";
 import type { SerwistViteContext } from "../context.js";
 import type { SerwistViteApi } from "../types.js";
+/**
+ * Internal plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */
 export declare const mainPlugin: (ctx: SerwistViteContext, api: SerwistViteApi) => Plugin<any>;

package/dist/types.d.ts

@@ -1,8 +1,8 @@
-import type { InjectManifestOptions, ManifestEntry } from "@serwist/build";
+import type { ManifestEntry, ViteInjectManifestOptions } from "@serwist/build";
 import type { RollupOptions } from "rollup";
-import type { Plugin, ResolvedConfig } from "vite";
+import type { BuildOptions, Plugin, ResolvedConfig } from "vite";
 export type InjectManifestVitePlugins = string[] | ((vitePluginIds: string[]) => string[]);
-export interface CustomInjectManifestOptions extends Omit<InjectManifestOptions, "disablePrecacheManifest"> {
+export interface CustomInjectManifestOptions extends Omit<ViteInjectManifestOptions, "disablePrecacheManifest"> {
     /**
      * The URL to the service worker.
      * @default "/sw.js"
@@ -34,6 +34,18 @@ export interface SerwistViteHooks {
     closeBundleOrder?: "pre" | "post" | null;
     configureOptions?: (viteOptions: ResolvedConfig, options: PluginOptions) => void | Promise<void>;
 }
+export interface DevOptions {
+    /**
+     * Whether the service worker should be bundled in development mode.
+     *
+     * [Many browsers still do not support ES Modules in service workers.](https://caniuse.com/mdn-api_serviceworker_ecmascript_modules) However, in development
+     * mode, certain frameworks, such as SvelteKit, do not bundle the service worker. As a result, trying to register that service worker on browsers lacking
+     * support, such as Firefox or Safari, will fail, but doing so on browsers not lacking support will not fail. This option is provided to prevent that from
+     * happening. What the plugin does is intercepting any request to the service worker (requests for `swUrl`) and returning a bundled one.
+     */
+    bundle?: boolean;
+    minify?: BuildOptions["minify"];
+}
 /**
  * Plugin options.
  */
@@ -135,15 +147,18 @@ export interface BasePluginOptions {
      */
     buildBase?: string;
 }
-export type PluginOptions = Partial<BasePluginOptions> & CustomInjectManifestOptions;
+export interface PluginOptions extends Partial<BasePluginOptions>, CustomInjectManifestOptions {
+    devOptions?: DevOptions;
+}
 export interface InjectManifestRollupOptions {
     format: "es" | "iife";
     plugins: Plugin[];
     rollupOptions: RollupOptions;
 }
 export interface ResolvedPluginOptions extends Required<BasePluginOptions>, Required<Pick<CustomInjectManifestOptions, "swUrl">> {
-    injectManifest: InjectManifestOptions;
+    injectManifest: ViteInjectManifestOptions;
     injectManifestRollupOptions: InjectManifestRollupOptions;
+    devOptions: Required<DevOptions>;
 }
 export interface ShareTargetFiles {
     name: string;

package/dist/utils.d.ts

@@ -2,3 +2,22 @@ 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;
+/**
+ * Internal function used by `@serwist/vite`.
+ * Resolves a file path without extension. Also handles `/index` if the path
+ * actually points to a directory.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */
+export declare const resolveEntry: (entry: string) => string | null;
+/**
+ * Internal function used by `@serwist/vite`.
+ * Converts a filesystem path to a Vite `@fs` URL.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */
+export declare function toFs(str: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/vite",
-  "version": "8.2.0",
+  "version": "8.4.0",
   "type": "module",
   "description": "A module that integrates Serwist into your Vite application.",
   "files": [
@@ -29,7 +29,7 @@
   "license": "MIT",
   "repository": "serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
-  "homepage": "https://serwist.vercel.app",
+  "homepage": "https://serwist.pages.dev",
   "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -77,8 +77,8 @@
     "debug": "4.3.4",
     "fast-glob": "3.3.2",
     "pretty-bytes": "6.1.1",
-    "@serwist/build": "8.2.0",
-    "@serwist/window": "8.2.0"
+    "@serwist/build": "8.4.0",
+    "@serwist/window": "8.4.0"
   },
   "devDependencies": {
     "@playwright/test": "1.40.1",
@@ -100,7 +100,7 @@
     "typescript": "5.4.0-dev.20231226",
     "vite": "5.0.10",
     "vue": "3.3.13",
-    "@serwist/constants": "8.2.0"
+    "@serwist/constants": "8.4.0"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^1.0.0 || ^2.0.0",
@@ -133,6 +133,7 @@
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "dev": "rollup --config rollup.config.js --watch",
     "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
     "typecheck": "tsc"
   }

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

@@ -1,3 +0,0 @@
-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/log-Dyh-Moyt.js

@@ -1,26 +0,0 @@
-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/main-dzWmj8BB.js

@@ -1,348 +0,0 @@
-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 };