@serwist/vite 9.0.0-preview.6 → 9.0.0-preview.8

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedConfig } from "vite";
 import type { PluginOptions, ResolvedPluginOptions } from "./types.js";
-export type SerwistViteFrameworks = "nuxt" | "sveltekit";
+export type SerwistViteFrameworks = "nuxt";
 export interface SerwistViteContext {
     /**
      * Resolved Vite config.

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEvE,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,UAAU,EAAE,cAAc,CAAC;IAC3B;;OAEG;IACH,WAAW,EAAE,aAAa,CAAC;IAC3B;;;;;OAKG;IACH,OAAO,EAAE,qBAAqB,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,8CAA8C;IAC9C,SAAS,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC9C;AAED,eAAO,MAAM,aAAa,gBAAiB,aAAa,aAAa,qBAAqB,GAAG,SAAS,KAAG,kBASxG,CAAC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEvE,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE3C,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,UAAU,EAAE,cAAc,CAAC;IAC3B;;OAEG;IACH,WAAW,EAAE,aAAa,CAAC;IAC3B;;;;;OAKG;IACH,OAAO,EAAE,qBAAqB,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,8CAA8C;IAC9C,SAAS,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC9C;AAED,eAAO,MAAM,aAAa,gBAAiB,aAAa,aAAa,qBAAqB,GAAG,SAAS,KAAG,kBASxG,CAAC"}

package/dist/index.js

@@ -1,13 +1,258 @@
-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:fs/promises';
-import 'node:path';
-import 'vite';
-import 'node:process';
-import 'node:crypto';
-import 'node:fs';
-import 'fast-glob';
-import 'node:assert';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path, { resolve } from 'node:path';
+import { normalizePath } from 'vite';
+import fs$1 from 'node:fs';
+import process$1 from 'node:process';
+import crypto from 'node:crypto';
+import fg from 'fast-glob';
+
+let enabled = true;
+const globalVar = typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};
+let supportLevel = 0;
+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) {
+        if (process.platform === 'win32') {
+            supportLevel = 3;
+        } else {
+            if (COLORTERM && (COLORTERM === 'truecolor' || COLORTERM === '24bit')) {
+                supportLevel = 3;
+            } else if (TERM && (TERM.endsWith('-256color') || TERM.endsWith('256'))) {
+                supportLevel = 2;
+            } else {
+                supportLevel = 1;
+            }
+        }
+    }
+}
+let options = {
+    enabled,
+    supportLevel
+};
+function kolorist(start, end, level = 1) {
+    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 = "9.0.0-preview.8";
+
+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)`)}`,
+            warnings && warnings.length > 0 ? yellow([
+                "⚠ warnings",
+                ...warnings.map((w)=>`  ${w}`),
+                ""
+            ].join("\n")) : ""
+        ].join("\n"));
+    }
+};
+
+const loadSerwistBuild = async ()=>{
+    try {
+        return await import('@serwist/build');
+    } catch (_) {
+        return require("@serwist/build");
+    }
+};
+const injectManifest = async (config)=>{
+    const { validateViteInjectManifestOptions, getFileManifestEntries, stringify } = await loadSerwistBuild();
+    const options = await 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 (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();
+        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);
+        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);
+        const { destPath, srcPath, warning } = translateURLToSourcemapPaths(url, ctx.options.injectManifest.swSrc, ctx.options.injectManifest.swDest);
+        if (warning) {
+            injectManifestResult.warnings.push(warning);
+        }
+        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 {
+            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 = {
+            ...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,
+            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) {
+                    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 buildPlugin = (ctx, api)=>{
     return {
@@ -29,6 +274,219 @@ const buildPlugin = (ctx, api)=>{
     };
 };
 
+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 resolveEntry = (entry)=>{
+    if (fs$1.existsSync(entry)) {
+        const stats = fs$1.statSync(entry);
+        if (stats.isDirectory()) {
+            return resolveEntry(path.join(entry, "index"));
+        }
+        return entry;
+    }
+    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;
+};
+const toFs = (str)=>{
+    str = str.replace(/\\/g, "/");
+    return `/@fs${str.startsWith("/") ? "" : "/"}${str}`;
+};
+
+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 || [];
+};
+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) {
+        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
+        });
+        if (manifestEntries.length > 0) {
+            const included = manifestEntries.map((me)=>{
+                if (typeof me === "string") return me;
+                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" || process$1.env.NODE_ENV === "development" ? 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);
+    const scope = _scope || basePath;
+    let assetsDir = slash(viteConfig.build.assetsDir ?? "assets");
+    if (assetsDir[assetsDir.length - 1] !== "/") assetsDir += "/";
+    const resolvedDevOptions = {
+        bundle: true,
+        minify: false,
+        ...devOptions
+    };
+    const dontCacheBustURLsMatching = new RegExp(`^${assetsDir.replace(/^\.*?\//, "")}`);
+    const { validateViteInjectManifestOptions } = await loadSerwistBuild();
+    const validatedInjectManifest = await validateViteInjectManifestOptions(injectManifest);
+    const { swSrc, swDest, ...userInjectManifest } = validatedInjectManifest || {};
+    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
+    };
+    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
+    };
+};
+
 const serwist = (userOptions)=>{
     const ctx = createContext(userOptions, undefined);
     const api = createApi(ctx);
@@ -39,4 +497,4 @@ const serwist = (userOptions)=>{
     ];
 };
 
-export { buildPlugin as build, createApi, createContext, devPlugin as dev, mainPlugin as main, serwist };
+export { buildPlugin as build, createApi, createContext, devPlugin as dev, mainPlugin as main, resolveEntry, serwist, toFs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/vite",
-  "version": "9.0.0-preview.6",
+  "version": "9.0.0-preview.8",
   "type": "module",
   "description": "A module that integrates Serwist into your Vite application.",
   "files": [
@@ -43,9 +43,6 @@
       ],
       "worker": [
         "./dist/index.worker.d.ts"
-      ],
-      "integration-*": [
-        "./dist/integration/*/index.d.ts"
       ]
     }
   },
@@ -62,20 +59,16 @@
       "types": "./dist/index.worker.d.ts",
       "default": "./dist/index.worker.js"
     },
-    "./integration-*": {
-      "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": "9.0.0-preview.6",
-    "@serwist/expiration": "9.0.0-preview.6",
-    "@serwist/strategies": "9.0.0-preview.6",
-    "@serwist/window": "9.0.0-preview.6"
+    "@serwist/build": "9.0.0-preview.8",
+    "@serwist/expiration": "9.0.0-preview.8",
+    "@serwist/strategies": "9.0.0-preview.8",
+    "@serwist/window": "9.0.0-preview.8"
   },
   "devDependencies": {
     "@playwright/test": "1.41.2",
@@ -96,8 +89,8 @@
     "typescript": "5.4.0-dev.20240206",
     "vite": "5.0.12",
     "vue": "3.4.15",
-    "@serwist/constants": "9.0.0-preview.6",
-    "@serwist/sw": "9.0.0-preview.6"
+    "@serwist/constants": "9.0.0-preview.8",
+    "@serwist/sw": "9.0.0-preview.8"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^1.0.0 || ^2.0.0",
@@ -108,7 +101,7 @@
     "typescript": ">=5.0.0",
     "vite": "^5.0.0",
     "vue": "^3.0.0",
-    "@serwist/sw": "9.0.0-preview.6"
+    "@serwist/sw": "9.0.0-preview.8"
   },
   "peerDependenciesMeta": {
     "@serwist/sw": {

package/src/context.ts

@@ -2,7 +2,7 @@ import type { ResolvedConfig } from "vite";
 
 import type { PluginOptions, ResolvedPluginOptions } from "./types.js";
 
-export type SerwistViteFrameworks = "nuxt" | "sveltekit";
+export type SerwistViteFrameworks = "nuxt";
 
 export interface SerwistViteContext {
   /**

package/src/modules.ts

@@ -50,7 +50,7 @@ export const generateServiceWorker = async (ctx: SerwistViteContext) => {
   const isProduction = ctx.options.mode === "production";
   const isDev = ctx.options.mode === "development";
 
-  if ((isProduction && ctx.framework === "sveltekit") || (isDev && !ctx.options.devOptions.bundle)) {
+  if (isDev && !ctx.options.devOptions.bundle) {
     if (!injectManifestResult) {
       throw new Error("injectManifest failed to generate results. This is likely a bug.");
     }

package/src/rollup.js

@@ -1,28 +1,8 @@
 // @ts-check
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
 import { getRollupOptions } from "@serwist/constants/rollup";
-import fg from "fast-glob";
 
 import packageJson from "../package.json" assert { type: "json" };
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const clientEntries = /** @type {Record<string, string>} */ ({});
-
-for (const clientPath of await fg("client/*.ts", { cwd: __dirname })) {
-  const parsedClientPath = path.parse(clientPath);
-  clientEntries[`client/${parsedClientPath.name}`] = path.join("src", clientPath);
-}
-
-const integrationEntries = /** @type {Record<string, string>} */ ({});
-
-for (const integrationPath of await fg("integration/*/index.ts", { cwd: __dirname })) {
-  const parsedClientPath = path.parse(integrationPath);
-  integrationEntries[`${parsedClientPath.dir}/${parsedClientPath.name}`] = path.join("src", integrationPath);
-}
-
 export default getRollupOptions({
   packageJson,
   jsFiles: [
@@ -31,8 +11,6 @@ export default getRollupOptions({
         index: "src/index.ts",
         "index.browser": "src/index.browser.ts",
         "index.worker": "src/index.worker.ts",
-        ...clientEntries,
-        ...integrationEntries,
       },
       output: {
         dir: "dist",

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

@@ -1,5 +0,0 @@
-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>;
-//# sourceMappingURL=build.d.ts.map

package/dist/integration/svelte/build.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/integration/svelte/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,WAAW,QAAS,kBAAkB,OAAO,cAAc,gBAevE,CAAC"}

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

@@ -1,9 +0,0 @@
-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[];
-//# sourceMappingURL=config.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/integration/svelte/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,2BAA2B,eAAgB,cAAc,OAAO,UAAU,WAAW,iBAAiB,SAiDlH,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,iBAAiB,CAqDvH;AAED,wBAAgB,iBAAiB,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,YAYxD;AAED,wBAAgB,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,YAQtD"}

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

@@ -1,10 +0,0 @@
-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";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/integration/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AASnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD;;;;GAIG;AACH,eAAO,MAAM,OAAO,iBAAiB,aAAa,KAAQ,MAAM,EAO/D,CAAC;AAEF,cAAc,YAAY,CAAC"}