@tcfed/vite-plugin-ci-build 0.1.8

package/dist/cli.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+export interface ViteBuildCliArgs {
+    env: Record<string, string>;
+    nodeArgs: string[];
+    viteArgs: string[];
+}
+export interface RunViteBuildOptions {
+    argv?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function parseViteBuildArgs(argv: string[]): ViteBuildCliArgs;
+export declare function getViteBuildNodeArgs(parsed: Pick<ViteBuildCliArgs, "nodeArgs">, env: NodeJS.ProcessEnv): string[];
+export declare function isCliEntrypoint(moduleUrl: string, argvPath?: string): boolean;
+export declare function runViteBuild(options?: RunViteBuildOptions): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function readValue(args, index, name) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${name}`);
+    }
+    return value;
+}
+function formatMaxOldSpaceSize(value) {
+    return `--max-old-space-size=${value}`;
+}
+function readEqualsArg(arg, name) {
+    if (!arg.startsWith(`${name}=`))
+        return undefined;
+    return arg.slice(name.length + 1);
+}
+export function parseViteBuildArgs(argv) {
+    const env = {};
+    const nodeArgs = [];
+    const viteArgs = [];
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === "--") {
+            continue;
+        }
+        if (arg === "--release-version") {
+            env.RELEASE_VERSION = readValue(argv, index, arg);
+            index++;
+            continue;
+        }
+        if (arg.startsWith("--release-version=")) {
+            env.RELEASE_VERSION = arg.slice("--release-version=".length);
+            continue;
+        }
+        const maxOldSpaceSizeArg = [
+            "--max_old_space_size",
+            "--max-old-space-size",
+        ].find((name) => arg === name || arg.startsWith(`${name}=`));
+        if (maxOldSpaceSizeArg) {
+            const value = readEqualsArg(arg, maxOldSpaceSizeArg) ??
+                readValue(argv, index, maxOldSpaceSizeArg);
+            nodeArgs.push(formatMaxOldSpaceSize(value));
+            if (arg === maxOldSpaceSizeArg)
+                index++;
+            continue;
+        }
+        viteArgs.push(arg);
+    }
+    return { env, nodeArgs, viteArgs };
+}
+export function getViteBuildNodeArgs(parsed, env) {
+    if (parsed.nodeArgs.length > 0)
+        return parsed.nodeArgs;
+    const maxOldSpaceSize = env.npm_config_max_old_space_size;
+    return maxOldSpaceSize ? [formatMaxOldSpaceSize(maxOldSpaceSize)] : [];
+}
+export function isCliEntrypoint(moduleUrl, argvPath) {
+    if (!argvPath)
+        return false;
+    try {
+        return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(argvPath);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveViteBin(cwd) {
+    const projectRequire = createRequire(join(cwd, "package.json"));
+    const vitePackagePath = projectRequire.resolve("vite/package.json");
+    const vitePackageJson = projectRequire(vitePackagePath);
+    const viteBin = typeof vitePackageJson.bin === "string"
+        ? vitePackageJson.bin
+        : vitePackageJson.bin?.vite;
+    if (!viteBin) {
+        throw new Error("[ci-build] Missing vite bin in vite/package.json");
+    }
+    return join(dirname(vitePackagePath), viteBin);
+}
+export function runViteBuild(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const parsed = parseViteBuildArgs(options.argv ?? process.argv.slice(2));
+    const env = {
+        ...process.env,
+        ...options.env,
+        ...parsed.env,
+    };
+    const nodeArgs = getViteBuildNodeArgs(parsed, env);
+    const vitePath = resolveViteBin(cwd);
+    const child = spawn(process.execPath, [...nodeArgs, vitePath, "build", ...parsed.viteArgs], {
+        cwd,
+        stdio: "inherit",
+        env,
+    });
+    return new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}
+async function main() {
+    const code = await runViteBuild();
+    process.exitCode = code;
+}
+if (isCliEntrypoint(import.meta.url, process.argv[1])) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import type { Plugin } from "vite";
+interface CiBuildEnv {
+    name: string;
+    cdnBaseUrl: string;
+    fileName?: string;
+}
+interface CiBuildOptions {
+    enabled?: boolean;
+    entryHtml?: string;
+    envs: CiBuildEnv[];
+}
+interface CreateCiBuildPluginOptions {
+    enabled?: boolean;
+}
+interface CiBuildManifest {
+    multiCdn: string[];
+    releaseVersion: string;
+    sentryProjectName: string;
+    targetBranch: string;
+    currentBranch: string;
+    earlyCommit: string;
+    lastCommit: string;
+    moduleEntries: string[];
+    builtModuleEntries: string[];
+    requirements: string[];
+    codeZipFile: string;
+    codeMapZipFile: string;
+    success: boolean;
+}
+export declare function getCiBuildHtmlFileName(entryHtml: string, env: CiBuildEnv): string;
+export declare function rewriteCiBuildAssetUrls(html: string, cdnBaseUrl: string, virtualPath: string): string;
+export declare function getCiBuildPackageFileNames(virtualPath: string): {
+    map: string;
+    dynamic: string;
+};
+export declare function isMapPackageFile(path: string): boolean;
+export declare function isDynamicPackageFile(path: string): boolean;
+export declare function getCiBuildPackageEntryPath(root: string, file: string): string;
+export declare function createCiBuildPackages(root: string, outDir: string, virtualPath: string): Promise<{
+    codeZipFile: string;
+    codeMapZipFile: string;
+}>;
+export declare function createCiBuildManifest(root: string, _virtualPath: string, packageFiles: Pick<CiBuildManifest, "codeZipFile" | "codeMapZipFile">): Promise<string>;
+export declare function ciBuild(options: CiBuildOptions): Plugin;
+export declare function createCiBuildPlugin(options: CreateCiBuildPluginOptions): Plugin<any>;
+export {};

package/dist/index.js

@@ -0,0 +1,277 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, } from "node:path";
+import { promisify } from "node:util";
+import { deflateRawSync } from "node:zlib";
+import { getBuildVirtualPath, joinCdnUrl } from "@tcfed/build-path";
+import { checkRequirements, ciRequirementsDefaults, } from "@tcfed/vite-plugin-ci-requirements";
+const execFileAsync = promisify(execFile);
+const packagesDir = "packages";
+const codeCdnBaseUrls = ["https://oss.ly.com/statics/"];
+const ciBuildEnvs = [
+    {
+        name: "inte",
+        cdnBaseUrl: "https://oss.ly.com/qa-statics/",
+    },
+    {
+        name: "rc",
+        cdnBaseUrl: "https://oss.ly.com/qa-statics/",
+    },
+    {
+        name: "prod",
+        cdnBaseUrl: "https://oss.ly.com/statics/",
+        fileName: "index.html",
+    },
+];
+const crcTable = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[i] = c >>> 0;
+}
+function getOutDir(config) {
+    return isAbsolute(config.build.outDir)
+        ? config.build.outDir
+        : join(config.root, config.build.outDir);
+}
+function readPackageName(root) {
+    const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+    const packageName = packageJson.name?.trim();
+    if (!packageName) {
+        throw new Error("[ci-build] Missing name in package.json");
+    }
+    return packageName;
+}
+function normalizeZipPath(path) {
+    return path.replace(/\\/g, "/");
+}
+function getVirtualPathRoot(virtualPath) {
+    return virtualPath.replace(/^\/+/, "").split("/")[0];
+}
+function getReleaseVersion() {
+    return (process.env.RELEASE_VERSION ??
+        process.env.VITE_RELEASE_VERSION ??
+        process.env.npm_config_release_version ??
+        "");
+}
+function getDosDateTime(date = new Date()) {
+    const year = Math.max(date.getFullYear(), 1980);
+    const dosTime = (date.getHours() << 11) |
+        (date.getMinutes() << 5) |
+        (date.getSeconds() >> 1);
+    const dosDate = ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+    return { dosDate, dosTime };
+}
+function getCrc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function writeUInt16(value) {
+    const buffer = Buffer.allocUnsafe(2);
+    buffer.writeUInt16LE(value, 0);
+    return buffer;
+}
+function writeUInt32(value) {
+    const buffer = Buffer.allocUnsafe(4);
+    buffer.writeUInt32LE(value >>> 0, 0);
+    return buffer;
+}
+async function collectFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory())
+            return collectFiles(fullPath);
+        return [fullPath];
+    }));
+    return files.flat();
+}
+function createZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    const { dosDate, dosTime } = getDosDateTime();
+    for (const entry of entries) {
+        const name = Buffer.from(entry.path);
+        const compressed = deflateRawSync(entry.data);
+        const crc = getCrc32(entry.data);
+        const localHeader = Buffer.concat([
+            writeUInt32(0x04034b50),
+            writeUInt16(20),
+            writeUInt16(0),
+            writeUInt16(8),
+            writeUInt16(dosTime),
+            writeUInt16(dosDate),
+            writeUInt32(crc),
+            writeUInt32(compressed.length),
+            writeUInt32(entry.data.length),
+            writeUInt16(name.length),
+            writeUInt16(0),
+            name,
+        ]);
+        const centralHeader = Buffer.concat([
+            writeUInt32(0x02014b50),
+            writeUInt16(20),
+            writeUInt16(20),
+            writeUInt16(0),
+            writeUInt16(8),
+            writeUInt16(dosTime),
+            writeUInt16(dosDate),
+            writeUInt32(crc),
+            writeUInt32(compressed.length),
+            writeUInt32(entry.data.length),
+            writeUInt16(name.length),
+            writeUInt16(0),
+            writeUInt16(0),
+            writeUInt16(0),
+            writeUInt16(0),
+            writeUInt32(0),
+            writeUInt32(offset),
+            name,
+        ]);
+        localParts.push(localHeader, compressed);
+        centralParts.push(centralHeader);
+        offset += localHeader.length + compressed.length;
+    }
+    const centralDir = Buffer.concat(centralParts);
+    const endOfCentralDir = Buffer.concat([
+        writeUInt32(0x06054b50),
+        writeUInt16(0),
+        writeUInt16(0),
+        writeUInt16(entries.length),
+        writeUInt16(entries.length),
+        writeUInt32(centralDir.length),
+        writeUInt32(offset),
+        writeUInt16(0),
+    ]);
+    return Buffer.concat([...localParts, centralDir, endOfCentralDir]);
+}
+async function getCurrentBranch(root) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: root });
+        return stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function getCiBuildHtmlFileName(entryHtml, env) {
+    if (env.fileName)
+        return env.fileName;
+    const ext = extname(entryHtml) || ".html";
+    const name = basename(entryHtml, ext);
+    return `${name}-${env.name}${ext}`;
+}
+export function rewriteCiBuildAssetUrls(html, cdnBaseUrl, virtualPath) {
+    return html.replace(/\b(src|href)=(["'])\/assets\/([^"']+)\2/g, (_, attr, quote, assetPath) => `${attr}=${quote}${joinCdnUrl(cdnBaseUrl, virtualPath, `assets/${assetPath}`)}${quote}`);
+}
+export function getCiBuildPackageFileNames(virtualPath) {
+    const prefix = getVirtualPathRoot(virtualPath);
+    return {
+        map: `${prefix}-dynamic.map.zip`,
+        dynamic: `${prefix}-dynamic.zip`,
+    };
+}
+export function isMapPackageFile(path) {
+    return path.endsWith(".js") || path.endsWith(".map");
+}
+export function isDynamicPackageFile(path) {
+    return !path.endsWith(".map");
+}
+export function getCiBuildPackageEntryPath(root, file) {
+    const rootRelativePath = normalizeZipPath(relative(root, file));
+    return rootRelativePath.replace(/^dist\//, "");
+}
+export async function createCiBuildPackages(root, outDir, virtualPath) {
+    const packageDir = join(root, packagesDir);
+    const fileNames = getCiBuildPackageFileNames(virtualPath);
+    const outDirParentManifest = join(dirname(outDir), "manifest.json");
+    const files = [
+        ...(existsSync(outDirParentManifest) ? [outDirParentManifest] : []),
+        ...(await collectFiles(outDir)),
+    ];
+    const entries = await Promise.all(files.map(async (file) => ({
+        path: getCiBuildPackageEntryPath(root, file),
+        data: await readFile(file),
+    })));
+    await mkdir(packageDir, { recursive: true });
+    await writeFile(join(packageDir, fileNames.map), createZip(entries.filter((entry) => isMapPackageFile(entry.path))));
+    await writeFile(join(packageDir, fileNames.dynamic), createZip(entries.filter((entry) => isDynamicPackageFile(entry.path))));
+    return {
+        codeZipFile: `${packagesDir}/${fileNames.dynamic}`,
+        codeMapZipFile: `${packagesDir}/${fileNames.map}`,
+    };
+}
+export async function createCiBuildManifest(root, _virtualPath, packageFiles) {
+    const requirements = await checkRequirements({
+        branch: ciRequirementsDefaults.branch,
+        projectCwd: root,
+    });
+    const manifest = {
+        multiCdn: codeCdnBaseUrls,
+        releaseVersion: getReleaseVersion(),
+        sentryProjectName: readPackageName(root),
+        targetBranch: ciRequirementsDefaults.branch,
+        currentBranch: await getCurrentBranch(root),
+        earlyCommit: requirements.earlyCommit,
+        lastCommit: requirements.lastCommit,
+        moduleEntries: [],
+        builtModuleEntries: [],
+        requirements: requirements.requirements,
+        codeZipFile: packageFiles.codeZipFile,
+        codeMapZipFile: packageFiles.codeMapZipFile,
+        success: true,
+    };
+    const outputPath = join(root, packagesDir, "manifest.json");
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+    return outputPath;
+}
+export function ciBuild(options) {
+    const entryHtml = options.entryHtml ?? "index.html";
+    let config;
+    let virtualPath;
+    return {
+        name: "vite-plugin-ci-build",
+        apply: "build",
+        enforce: "post",
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+            virtualPath = getBuildVirtualPath(resolvedConfig.env, {
+                root: resolvedConfig.root,
+            });
+        },
+        async closeBundle() {
+            if (!options.enabled)
+                return;
+            const outDir = getOutDir(config);
+            const entryHtmlPath = join(outDir, entryHtml);
+            const sourceHtml = await readFile(entryHtmlPath, "utf-8");
+            await Promise.all(options.envs.map(async (env) => {
+                const fileName = getCiBuildHtmlFileName(entryHtml, env);
+                const outputPath = join(outDir, dirname(entryHtml), fileName);
+                const html = rewriteCiBuildAssetUrls(sourceHtml, env.cdnBaseUrl, virtualPath);
+                await mkdir(dirname(outputPath), { recursive: true });
+                await writeFile(outputPath, html, "utf-8");
+                console.log(`  [ci-build] emitted: ${fileName}`);
+            }));
+            const packageFiles = await createCiBuildPackages(config.root, outDir, virtualPath);
+            console.log(`  [ci-build] emitted: ${packageFiles.codeMapZipFile}`);
+            console.log(`  [ci-build] emitted: ${packageFiles.codeZipFile}`);
+            const manifest = await createCiBuildManifest(config.root, virtualPath, packageFiles);
+            console.log(`  [ci-build] emitted: ${manifest}`);
+        },
+    };
+}
+export function createCiBuildPlugin(options) {
+    return ciBuild({
+        enabled: options.enabled,
+        envs: ciBuildEnvs,
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@tcfed/vite-plugin-ci-build",
+  "version": "0.1.8",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js"
+    }
+  },
+  "bin": {
+    "vite-ci-build": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
+    "test": "vitest run src",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@tcfed/build-path": "workspace:*",
+    "@tcfed/vite-plugin-ci-requirements": "workspace:*",
+    "@types/node": "^24.12.4",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.12",
+    "vitest": "^4.1.7"
+  },
+  "peerDependencies": {
+    "@tcfed/build-path": "0.1.4",
+    "@tcfed/vite-plugin-ci-requirements": "0.1.3",
+    "vite": ">=5"
+  }
+}