@serwist/vite 9.0.0-preview.0 → 9.0.0-preview.10

package/dist/main.js

@@ -1,542 +0,0 @@
-import fs from 'node:fs/promises';
-import path, { resolve } from 'node:path';
-import { normalizePath } from 'vite';
-import process$1 from 'node:process';
-import crypto from 'node:crypto';
-import fs$1 from 'node:fs';
-import fg from 'fast-glob';
-import assert from 'node:assert';
-
-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 = "9.0.0-preview.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 = 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 (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;
-    }
-    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
- */ const 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;
-                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(/^\.*?\//, "")}`);
-    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
-    };
-    // 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/src/integration/svelte/build.ts

@@ -1,21 +0,0 @@
-import type { Plugin } from "vite";
-
-import type { SerwistViteContext } from "../../context.js";
-import type { SerwistViteApi } from "../../types.js";
-
-export const buildPlugin = (ctx: SerwistViteContext, api: SerwistViteApi) => {
-  return <Plugin>{
-    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();
-        }
-      },
-    },
-  };
-};