@runtime-env/vite-plugin 0.0.0 → 0.1.0

package/dist/build.js

@@ -1,11 +1,26 @@
-import { isTypeScriptProject, runRuntimeEnvCommand } from "./utils.js";
+import { isTypeScriptProject, runRuntimeEnvCommand, logError, hasRuntimeEnvScript, } from "./utils.js";
 export function buildPlugin() {
+    let config;
     return {
         name: "runtime-env-build",
-        config(config, configEnv) {
-            if (configEnv.command === "build") {
-                if (isTypeScriptProject(config.root || process.cwd())) {
-                    runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+            if (config.command === "build") {
+                if (isTypeScriptProject(config.root)) {
+                    const result = runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
+                    if (!result.success) {
+                        logError(config.logger, "Failed to generate runtime-env.d.ts", result.stderr || result.stdout);
+                        process.exit(1);
+                    }
+                }
+            }
+        },
+        transformIndexHtml(html) {
+            if (config && config.command === "build") {
+                if (!hasRuntimeEnvScript(html, config.base)) {
+                    logError(config.logger, `index.html is missing <script src="${config.base === "/" ? "" : config.base}/runtime-env.js"></script>. ` +
+                        "This script tag is mandatory for @runtime-env/vite-plugin to function correctly in production.");
+                    process.exit(1);
                 }
             }
         },

package/dist/dev.js

@@ -1,6 +1,6 @@
 import { resolve } from "path";
 import { writeFileSync, readFileSync, rmSync, existsSync } from "fs";
-import { isTypeScriptProject, runRuntimeEnvCommand, getTempDir, getViteEnvFiles, } from "./utils.js";
+import { isTypeScriptProject, runRuntimeEnvCommand, getTempDir, getViteEnvFiles, logError, clearLastError, hasRuntimeEnvScript, } from "./utils.js";
 const schemaFile = ".runtimeenvschema.json";
 export function devPlugin() {
     return {
@@ -10,13 +10,29 @@ export function devPlugin() {
                 return;
             const envDir = server.config.envDir || server.config.root;
             const envFiles = getViteEnvFiles(server.config.mode, envDir);
-            const watchFiles = [schemaFile, ...envFiles];
+            const watchFiles = [resolve(server.config.root, schemaFile), ...envFiles];
+            let hadError = false;
             function run() {
                 const devOutputDir = getTempDir("dev");
                 const devOutputPath = resolve(devOutputDir, "runtime-env.js");
-                runRuntimeEnvCommand("gen-js", devOutputPath, envFiles);
+                const jsResult = runRuntimeEnvCommand("gen-js", devOutputPath, envFiles);
+                if (!jsResult.success) {
+                    logError(server.config.logger, "Failed to generate runtime-env.js", jsResult.stderr || jsResult.stdout, server);
+                    hadError = true;
+                    return;
+                }
                 if (isTypeScriptProject(server.config.root)) {
-                    runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
+                    const tsResult = runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
+                    if (!tsResult.success) {
+                        logError(server.config.logger, "Failed to generate runtime-env.d.ts", tsResult.stderr || tsResult.stdout, server);
+                        hadError = true;
+                        return;
+                    }
+                }
+                if (hadError) {
+                    clearLastError();
+                    server.ws.send({ type: "full-reload" });
+                    hadError = false;
                 }
             }
             run();
@@ -46,11 +62,19 @@ export function devPlugin() {
             if (ctx.server && ctx.server.config.command === "serve") {
                 const envDir = ctx.server.config.envDir || ctx.server.config.root;
                 const envFiles = getViteEnvFiles(ctx.server.config.mode, envDir);
+                if (!hasRuntimeEnvScript(html, ctx.server.config.base)) {
+                    logError(ctx.server.config.logger, `index.html is missing <script src="${ctx.server.config.base === "/" ? "" : ctx.server.config.base}/runtime-env.js"></script>. ` +
+                        "Runtime values will not be available. Please add the script tag.", undefined, ctx.server);
+                }
                 const tmpDir = getTempDir("dev-interpolate");
                 try {
                     const htmlFile = resolve(tmpDir, "index.html");
                     writeFileSync(htmlFile, html, "utf8");
-                    runRuntimeEnvCommand("interpolate", htmlFile, envFiles, htmlFile);
+                    const result = runRuntimeEnvCommand("interpolate", htmlFile, envFiles, htmlFile);
+                    if (!result.success) {
+                        logError(ctx.server.config.logger, "Failed to interpolate index.html", result.stderr || result.stdout, ctx.server);
+                        return html;
+                    }
                     html = readFileSync(htmlFile, "utf8");
                     return html;
                 }

package/dist/preview.js

@@ -1,6 +1,6 @@
 import { resolve } from "path";
 import { readFileSync, writeFileSync, existsSync, rmSync } from "fs";
-import { runRuntimeEnvCommand, getTempDir, getViteEnvFiles } from "./utils.js";
+import { runRuntimeEnvCommand, getTempDir, getViteEnvFiles, logError, } from "./utils.js";
 export function previewPlugin() {
     return {
         name: "runtime-env-preview",
@@ -24,7 +24,12 @@ export function previewPlugin() {
                     const tmpDir = getTempDir("preview-gen-js");
                     const tmpPath = resolve(tmpDir, "runtime-env.js");
                     try {
-                        runRuntimeEnvCommand("gen-js", tmpPath, envFiles);
+                        const result = runRuntimeEnvCommand("gen-js", tmpPath, envFiles);
+                        if (!result.success) {
+                            logError(server.config.logger, "Failed to generate runtime-env.js", result.stderr || result.stdout);
+                            next();
+                            return;
+                        }
                         if (existsSync(tmpPath)) {
                             const content = readFileSync(tmpPath, "utf8");
                             res.setHeader("Content-Type", "application/javascript");
@@ -46,7 +51,13 @@ export function previewPlugin() {
                             const tmpHtmlPath = resolve(tmpDir, "index.html");
                             const originalHtml = readFileSync(distIndexHtml, "utf8");
                             writeFileSync(tmpHtmlPath, originalHtml, "utf8");
-                            runRuntimeEnvCommand("interpolate", tmpHtmlPath, envFiles, tmpHtmlPath);
+                            const result = runRuntimeEnvCommand("interpolate", tmpHtmlPath, envFiles, tmpHtmlPath);
+                            if (!result.success) {
+                                logError(server.config.logger, "Failed to interpolate index.html", result.stderr || result.stdout);
+                                res.setHeader("Content-Type", "text/html");
+                                res.end(originalHtml);
+                                return;
+                            }
                             const interpolatedHtml = readFileSync(tmpHtmlPath, "utf8");
                             res.setHeader("Content-Type", "text/html");
                             res.end(interpolatedHtml);

package/dist/utils.d.ts

@@ -1,5 +1,17 @@
+import type { Logger, ViteDevServer } from "vite";
+/**
+ * Clears the last error message to allow it to be logged again.
+ * This should be called when the plugin recovers from an error state.
+ */
+export declare function clearLastError(): void;
+export declare function logError(logger: Logger | undefined, message: string, error?: any, server?: ViteDevServer): void;
 export declare function isTypeScriptProject(root: string): boolean;
 export declare function getViteEnvFiles(mode: string, envDir: string): string[];
 export declare function getRuntimeEnvCommandLineArgs(command: string, outputFile: string, envFiles?: string[], inputFile?: string): string[];
-export declare function runRuntimeEnvCommand(command: string, outputFile: string, envFiles?: string[], inputFile?: string): void;
+export declare function runRuntimeEnvCommand(command: string, outputFile: string, envFiles?: string[], inputFile?: string): {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+};
 export declare function getTempDir(subDir: string): string;
+export declare function hasRuntimeEnvScript(html: string, base: string): boolean;

package/dist/utils.js

@@ -5,6 +5,51 @@ import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const schemaFile = ".runtimeenvschema.json";
 const globalVariableName = "runtimeEnv";
+let lastErrorMessage = null;
+/**
+ * Clears the last error message to allow it to be logged again.
+ * This should be called when the plugin recovers from an error state.
+ */
+export function clearLastError() {
+    lastErrorMessage = null;
+}
+export function logError(logger, message, error, server) {
+    const prefix = "[@runtime-env/vite-plugin]";
+    const fullMessage = `${prefix} ${message}`;
+    const errorDetails = error
+        ? typeof error === "string"
+            ? error
+            : error instanceof Error
+                ? error.message
+                : JSON.stringify(error)
+        : "";
+    const completeErrorMessage = errorDetails
+        ? `${fullMessage}\n${errorDetails}`
+        : fullMessage;
+    if (completeErrorMessage !== lastErrorMessage) {
+        if (!logger) {
+            console.error(fullMessage);
+            if (error)
+                console.error(errorDetails);
+        }
+        else {
+            logger.error(fullMessage, { timestamp: true });
+            if (error) {
+                logger.error(errorDetails, { timestamp: true });
+            }
+        }
+        lastErrorMessage = completeErrorMessage;
+    }
+    if (server) {
+        server.ws.send({
+            type: "error",
+            err: {
+                message: completeErrorMessage,
+                stack: "",
+            },
+        });
+    }
+}
 export function isTypeScriptProject(root) {
     return existsSync(resolve(root, "tsconfig.json"));
 }
@@ -45,7 +90,12 @@ export function runRuntimeEnvCommand(command, outputFile, envFiles = [], inputFi
         // Fallback to local node_modules/.bin if require.resolve fails (e.g. during development or in some monorepo setups)
         cliPath = resolve("node_modules", ".bin", "runtime-env");
     }
-    spawnSync("node", [cliPath, ...args]);
+    const result = spawnSync("node", [cliPath, ...args], { encoding: "utf8" });
+    return {
+        success: result.status === 0,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
 }
 export function getTempDir(subDir) {
     const root = process.cwd();
@@ -53,3 +103,22 @@ export function getTempDir(subDir) {
     mkdirSync(tempDir, { recursive: true });
     return tempDir;
 }
+export function hasRuntimeEnvScript(html, base) {
+    // Normalize base: ensure it starts with / and doesn't end with / (unless it's just /)
+    const normalizedBase = base.startsWith("/") ? base : `/${base}`;
+    const finalBase = normalizedBase.endsWith("/") && normalizedBase.length > 1
+        ? normalizedBase.slice(0, -1)
+        : normalizedBase;
+    const expectedSrc = `${finalBase === "/" ? "" : finalBase}/runtime-env.js`;
+    // Regex to find script tag with src matching runtime-env.js
+    // It accounts for varying whitespace, attribute order, and quote types.
+    const scriptRegex = /<script\b[^>]*?\bsrc\s*=\s*(['"])([^'"]*\/runtime-env\.js)\1[^>]*?>\s*<\/script>/gi;
+    let match;
+    while ((match = scriptRegex.exec(html)) !== null) {
+        const src = match[2];
+        if (src === expectedSrc || src === "/runtime-env.js") {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/vitest.js

@@ -1,25 +1,14 @@
 import { resolve } from "path";
 import { rmSync } from "fs";
-import { isTypeScriptProject, runRuntimeEnvCommand, getTempDir, getViteEnvFiles, } from "./utils.js";
+import { isTypeScriptProject, runRuntimeEnvCommand, getTempDir, getViteEnvFiles, logError, } from "./utils.js";
 export function vitestPlugin() {
     return {
         name: "runtime-env-vitest",
         config(config, configEnv) {
-            if (config.mode === "test") {
-                const root = config.root || process.cwd();
-                // Generate runtime-env.d.ts for Vitest type checking
-                if (isTypeScriptProject(root)) {
-                    runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
-                }
-                const envDir = config.envDir || root;
-                const envFiles = getViteEnvFiles(config.mode, envDir);
+            if (config.mode === "test" || configEnv.mode === "test") {
                 // Generate runtime-env.js for Vitest runtime access
                 const vitestOutputDir = getTempDir("vitest");
                 const vitestOutputPath = resolve(vitestOutputDir, "runtime-env.js");
-                // Ensure directory is clean
-                rmSync(vitestOutputDir, { recursive: true, force: true });
-                getTempDir("vitest"); // Re-create it clean
-                runRuntimeEnvCommand("gen-js", vitestOutputPath, envFiles);
                 // Automatically inject setupFiles for Vitest
                 const vitestConfig = config.test || {};
                 const setupFiles = vitestConfig.setupFiles || [];
@@ -35,5 +24,31 @@ export function vitestPlugin() {
                 };
             }
         },
+        configResolved(config) {
+            if (config.mode === "test") {
+                const root = config.root || process.cwd();
+                // Generate runtime-env.d.ts for Vitest type checking
+                if (isTypeScriptProject(root)) {
+                    const result = runRuntimeEnvCommand("gen-ts", "src/runtime-env.d.ts");
+                    if (!result.success) {
+                        logError(config.logger, "Failed to generate runtime-env.d.ts", result.stderr || result.stdout);
+                        process.exit(1);
+                    }
+                }
+                const envDir = config.envDir || root;
+                const envFiles = getViteEnvFiles(config.mode, envDir);
+                // Generate runtime-env.js for Vitest runtime access
+                const vitestOutputDir = getTempDir("vitest");
+                const vitestOutputPath = resolve(vitestOutputDir, "runtime-env.js");
+                // Ensure directory is clean
+                rmSync(vitestOutputDir, { recursive: true, force: true });
+                getTempDir("vitest"); // Re-create it clean
+                const result = runRuntimeEnvCommand("gen-js", vitestOutputPath, envFiles);
+                if (!result.success) {
+                    logError(config.logger, "Failed to generate runtime-env.js", result.stderr || result.stdout);
+                    process.exit(1);
+                }
+            }
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtime-env/vite-plugin",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Opinionated Vite plugin for runtime-env",
   "license": "MIT",
   "author": "Ernest",
@@ -34,10 +34,13 @@
     "url": "https://github.com/runtime-env/runtime-env/issues"
   },
   "homepage": "https://github.com/runtime-env/runtime-env#readme",
-  "dependencies": {
-    "@runtime-env/cli": "^0.7.8"
+  "dependencies": {},
+  "peerDependencies": {
+    "@runtime-env/cli": "*",
+    "vite": "*"
   },
   "devDependencies": {
+    "@runtime-env/cli": "^1.0.0",
     "vite": "7.3.0"
   },
   "type": "module"