@serwist/vite 9.0.0-preview.2 → 9.0.0-preview.21

package/dist/chunks/schema.js

@@ -0,0 +1,56 @@
+import { basePartial, globPartial, injectPartial, requiredSwDestPartial, requiredGlobDirectoryPartial } from '@serwist/build/schema';
+import { z } from 'zod';
+
+const hooks = z.object({
+    beforeBuildServiceWorker: z.function(z.tuple([
+        z.any()
+    ]), z.union([
+        z.promise(z.void()),
+        z.void()
+    ])).optional(),
+    closeBundleOrder: z.union([
+        z.literal("pre"),
+        z.literal("post"),
+        z.null()
+    ]).optional(),
+    configureOptions: z.function(z.tuple([
+        z.any(),
+        z.any()
+    ]), z.union([
+        z.promise(z.void()),
+        z.void()
+    ])).optional()
+});
+const devOptions = z.object({
+    bundle: z.boolean().default(true),
+    minify: z.union([
+        z.boolean(),
+        z.literal("terser"),
+        z.literal("esbuild")
+    ]).default(false)
+});
+const injectManifestPartial = z.object({
+    mode: z.union([
+        z.literal("development"),
+        z.literal("production")
+    ]),
+    type: z.union([
+        z.literal("classic"),
+        z.literal("module")
+    ]).default("classic"),
+    scope: z.string(),
+    base: z.string(),
+    disable: z.boolean().default(false),
+    integration: hooks.default({}),
+    swUrl: z.string().default("/sw.js"),
+    plugins: z.array(z.any()).default([]),
+    rollupFormat: z.union([
+        z.literal("es"),
+        z.literal("iife")
+    ]).default("es"),
+    rollupOptions: z.record(z.string(), z.any()).default({}),
+    devOptions: devOptions.default({})
+});
+const injectManifestOptions = basePartial.merge(globPartial).merge(injectPartial).merge(requiredSwDestPartial).merge(requiredGlobDirectoryPartial).merge(injectManifestPartial).strict("Do not pass invalid properties to InjectManifestOptions!");
+
+export { devOptions, hooks, injectManifestOptions, injectManifestPartial };

package/dist/index.d.ts

@@ -1,18 +1,19 @@
 import type { Plugin } from "vite";
-import { createApi } from "./api.js";
-import { createContext } from "./context.js";
+import { createApi } from "./lib/api.js";
+import { createContext } from "./lib/context.js";
+import type { DevOptions, ExtendManifestEntriesHook, Hooks, PluginOptions, PluginOptionsComplete, SerwistViteApi } from "./lib/types.js";
+import { resolveEntry, toFs } from "./lib/utils.js";
+import { validateInjectManifestOptions } from "./lib/validator.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";
+export { buildPlugin as build, createApi, createContext, devPlugin as dev, mainPlugin as main, resolveEntry, toFs, validateInjectManifestOptions };
+export type { SerwistViteContext } from "./lib/context.js";
+export type { PluginOptions, PluginOptionsComplete, Hooks, ExtendManifestEntriesHook, DevOptions, SerwistViteApi };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,OAAO,gBAAiB,aAAa,KAAG,MAAM,EAI1D,CAAC;AAGF,OAAO,EAAE,WAAW,IAAI,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,IAAI,GAAG,EAAE,UAAU,IAAI,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;AACpH,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,yBAAyB,EAAE,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACzI,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,OAAO,gBAAiB,aAAa,KAAG,MAAM,EAI1D,CAAC;AAGF,OAAO,EAAE,WAAW,IAAI,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,IAAI,GAAG,EAAE,UAAU,IAAI,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,6BAA6B,EAAE,CAAC;AACnJ,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,KAAK,EAAE,yBAAyB,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC"}

package/dist/index.js

@@ -1,13 +1,247 @@
-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 { cyan, green, dim, yellow } from 'kolorist';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fs$1 from 'node:fs';
+import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
+import { normalizePath } from 'vite';
+import process from 'node:process';
+
+var version = "9.0.0-preview.20";
+
+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 (options)=>{
+    const { getFileManifestEntries, stringify } = await loadSerwistBuild();
+    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 { plugins, rollupOptions, rollupFormat } = ctx.options;
+    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: [
+                        rollupFormat
+                    ]
+                },
+                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 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 validateInjectManifestOptions = async (input)=>{
+    const result = await (await import('./chunks/schema.js')).injectManifestOptions.spa(input, {
+        errorMap: validationErrorMap
+    });
+    if (!result.success) {
+        throw new SerwistConfigError({
+            moduleName: "@serwist/vite",
+            message: JSON.stringify(result.error.format(), null, 2)
+        });
+    }
+    return result.data;
+};
 
 const buildPlugin = (ctx, api)=>{
     return {
@@ -29,6 +263,121 @@ const buildPlugin = (ctx, api)=>{
     };
 };
 
+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 prepareConfigForValidation = (viteConfig, { mode = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "development" ? process.env.NODE_ENV : "production", base = viteConfig.base, scope: _scope, devOptions, ...injectManifest })=>{
+    const basePath = resolveBasePath(base);
+    return {
+        mode,
+        base: basePath,
+        scope: _scope || basePath,
+        devOptions,
+        ...injectManifest
+    };
+};
+const resolveOptions = async (options, viteConfig)=>{
+    const { mode, type, scope, base, disable, integration, swUrl, swSrc, swDest, plugins, rollupFormat, rollupOptions, devOptions, ...userInjectManifest } = await validateInjectManifestOptions(prepareConfigForValidation(viteConfig, options));
+    let assetsDir = slash(viteConfig.build.assetsDir ?? "assets");
+    if (assetsDir[assetsDir.length - 1] !== "/") assetsDir += "/";
+    const dontCacheBustURLsMatching = new RegExp(`^${assetsDir.replace(/^\.*?\//, "")}`);
+    const resolvedPluginOptions = {
+        mode,
+        type,
+        scope,
+        base,
+        disable,
+        integration,
+        swUrl,
+        plugins,
+        rollupFormat,
+        rollupOptions,
+        devOptions,
+        injectManifest: {
+            dontCacheBustURLsMatching,
+            ...userInjectManifest,
+            swSrc: path.resolve(viteConfig.root, swSrc),
+            swDest: path.resolve(viteConfig.root, viteConfig.build.outDir, swDest),
+            disablePrecacheManifest: !viteConfig.isProduction
+        }
+    };
+    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.base, 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 +388,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, validateInjectManifestOptions };

package/dist/index.schema.d.ts

@@ -0,0 +1,3 @@
+import { devOptions, hooks, injectManifestOptions, injectManifestPartial } from "./lib/schema.js";
+export { hooks, devOptions, injectManifestPartial, injectManifestOptions };
+//# sourceMappingURL=index.schema.d.ts.map

package/dist/index.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAElG,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.schema.js

@@ -0,0 +1,3 @@
+export { devOptions, hooks, injectManifestOptions, injectManifestPartial } from './chunks/schema.js';
+import '@serwist/build/schema';
+import 'zod';

package/dist/index.worker.d.ts

@@ -1,3 +1,9 @@
 import type { RuntimeCaching } from "@serwist/sw";
+/**
+ * The default, recommended list of caching strategies for applications
+ * built with Vite.
+ *
+ * @see https://serwist.pages.dev/docs/vite/worker-exports#default-cache
+ */
 export declare const defaultCache: RuntimeCaching[];
 //# sourceMappingURL=index.worker.d.ts.map

package/dist/index.worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.worker.d.ts","sourceRoot":"","sources":["../src/index.worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,eAAO,MAAM,YAAY,EAAE,cAAc,EA4FxC,CAAC"}
+{"version":3,"file":"index.worker.d.ts","sourceRoot":"","sources":["../src/index.worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,EA8GpC,CAAC"}