@serwist/vite 8.3.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,13 +1,22 @@
 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",
@@ -32,7 +41,7 @@ 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),
@@ -41,4 +50,4 @@ const buildPlugin = (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,14 +1,32 @@
-import { r as resolveEntry, l as loadSerwistBuild, m as mainPlugin, d as devPlugin, c as createContext, a as createApi } from '../../main.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: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'
@@ -124,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.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
@@ -156,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, api),
-        serwistSveltePlugin(ctx, api)
+        buildPlugin(ctx, api)
     ];
 };
 

package/dist/main.js

@@ -1,7 +1,9 @@
+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';
@@ -66,7 +68,7 @@ const green = kolorist(32, 39);
 const yellow = kolorist(33, 39);
 const cyan = kolorist(36, 39);
 
-var version = "8.3.0";
+var version = "8.4.0";
 
 const logSerwistResult = (buildResult, viteOptions)=>{
     const { logLevel = "info" } = viteOptions;
@@ -93,35 +95,124 @@ const loadSerwistBuild = async ()=>{
     try {
         return await import('@serwist/build');
     } catch (_) {
+        // We don't have a default export, don't worry.
         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 ?? {}
+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
     };
-    define["process.env.NODE_ENV"] = JSON.stringify(options.mode);
-    const { format, plugins, rollupOptions } = options.injectManifestRollupOptions;
-    const parsedSwDest = path.parse(options.injectManifest.swDest);
-    if (viteOptions.isProduction || options.devOptions.bundle) {
+};
+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: viteOptions.isProduction ? "info" : "warn",
-            root: viteOptions.root,
-            base: viteOptions.base,
-            resolve: viteOptions.resolve,
+            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: viteOptions.build.sourcemap,
+                sourcemap: ctx.viteConfig.build.sourcemap,
                 lib: {
-                    entry: options.injectManifest.swSrc,
+                    entry: ctx.options.injectManifest.swSrc,
                     name: "app",
                     formats: [
                         format
@@ -136,25 +227,13 @@ const generateInjectManifest = async (options, viteOptions)=>{
                 },
                 outDir: parsedSwDest.dir,
                 emptyOutDir: false,
-                minify: viteOptions.isProduction
+                minify: isProduction || ctx.options.devOptions.minify
             },
             configFile: false,
             define
         });
-    } else {
-        await fs.copyFile(options.injectManifest.swSrc, options.injectManifest.swDest);
     }
-    // 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
-    return await injectManifest(resolvedInjectManifestOptions);
+    return injectManifestResult;
 };
 
 const createApi = (ctx)=>{
@@ -166,7 +245,7 @@ const createApi = (ctx)=>{
             if (ctx.options.disable) {
                 return undefined;
             }
-            const buildResult = await generateInjectManifest(ctx.options, ctx.viteConfig);
+            const buildResult = await generateServiceWorker(ctx);
             if (buildResult) {
                 if (ctx.viteConfig.isProduction) {
                     // Log Serwist result
@@ -191,13 +270,14 @@ const createApi = (ctx)=>{
     };
 };
 
-const createContext = (userOptions)=>{
+const createContext = (userOptions, framework)=>{
     return {
         userOptions,
         options: undefined,
         viteConfig: undefined,
         useImportRegister: false,
-        devEnvironment: false
+        devEnvironment: false,
+        framework
     };
 };
 
@@ -213,7 +293,15 @@ const isAbsolute = (url)=>{
 };
 // Source: https://github.com/sveltejs/kit/blob/6419d3eaa7bf1b0a756b28f06a73f71fe042de0a/packages/kit/src/utils/filesystem.js
 // License: MIT
-const resolveEntry = (entry)=>{
+/**
+ * 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()) {
@@ -233,7 +321,14 @@ const resolveEntry = (entry)=>{
 };
 // Source: https://github.com/sveltejs/kit/blob/6419d3eaa7bf1b0a756b28f06a73f71fe042de0a/packages/kit/src/utils/filesystem.js
 // License: MIT
-function toFs(str) {
+/**
+ * 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}`;
@@ -245,7 +340,13 @@ function toFs(str) {
 // - 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.
-const devPlugin = (ctx, api)=>{
+/**
+ * Internal dev plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ const devPlugin = (ctx, api)=>{
     return {
         name: "@serwist/vite:dev",
         apply: "serve",
@@ -350,19 +451,21 @@ const configureStaticAssets = async (resolvedPluginOptions, viteConfig)=>{
 };
 
 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, devOptions, ...injectManifest } = options;
+    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 = options.scope || basePath;
+    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(/^\.*?\//, "")}`);
-    const { plugins = [], rollupOptions = {}, rollupFormat = "es", swUrl = "/sw.js", swSrc, swDest, ...userInjectManifest } = injectManifest || {};
+    validateInjectManifestOptions(injectManifest);
+    const { swSrc, swDest, ...userInjectManifest } = injectManifest || {};
     const resolvedPluginOptions = {
         base: basePath,
         type,
@@ -397,7 +500,13 @@ const resolveOptions = async (options, viteConfig)=>{
     return resolvedPluginOptions;
 };
 
-const mainPlugin = (ctx, api)=>{
+/**
+ * Internal plugin used by `@serwist/vite`.
+ * @internal
+ * @param ctx
+ * @param api
+ * @returns
+ */ const mainPlugin = (ctx, api)=>{
     return {
         name: "@serwist/vite",
         enforce: "pre",
@@ -431,4 +540,4 @@ export const swType = "${ctx.devEnvironment ? "module" : ctx.options.type}";`;
     };
 };
 
-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, resolveEntry as r, version as v, yellow as y };
+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<SerwistBuild.BuildResult | undefined>;
+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,4 +1,11 @@
 import { type Plugin } from "vite";
 import type { SerwistViteContext } from "../context.js";
 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"
@@ -44,6 +44,7 @@ export interface DevOptions {
      * 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.
@@ -155,7 +156,7 @@ export interface InjectManifestRollupOptions {
     rollupOptions: RollupOptions;
 }
 export interface ResolvedPluginOptions extends Required<BasePluginOptions>, Required<Pick<CustomInjectManifestOptions, "swUrl">> {
-    injectManifest: InjectManifestOptions;
+    injectManifest: ViteInjectManifestOptions;
     injectManifestRollupOptions: InjectManifestRollupOptions;
     devOptions: Required<DevOptions>;
 }

package/dist/utils.d.ts

@@ -2,5 +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.3.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.3.0",
-    "@serwist/window": "8.3.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.3.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.js

@@ -1,28 +0,0 @@
-import { b as cyan, v as version, g as green, e as dim, y as yellow } from './main.js';
-import 'node:fs/promises';
-import 'node:path';
-import 'vite';
-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 };