vite-plugin-envka 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Ireneo C. Cobar Jr
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,97 @@
+# vite-plugin-envka
+
+<!-- [![npm version](https://img.shields.io/npm/v/vite-plugin-envka.svg)](https://www.npmjs.com/package/vite-plugin-envka) -->
+
+[![Vite](https://img.shields.io/badge/vite-compatible-blue.svg)](https://vitejs.dev/)
+
+## Overview
+
+**Envka** is a vite plugin designed to enhance environment variable management in Vite projects.
+
+## Features
+
+- Validate environment variables at Vite build and dev server startup
+- TypeScript type generation (env.d.ts)
+- Generate `.env.example` from schema
+- Checking for unused and undeclared environment variables (planned)
+
+## Installation
+
+```bash
+npm install vite-plugin-envka --save-dev
+```
+
+## Usage
+
+Add to your `vite.config.ts`:
+
+```ts
+import envka from "vite-plugin-envka";
+
+export default {
+  plugins: [envka(/* options */)],
+};
+```
+
+## Configuration
+
+```ts
+import envka from "vite-plugin-envka";
+
+export default {
+  plugins: [
+    envka({
+      schema,
+      generateTypes: false /** Default */,
+    }),
+  ],
+};
+```
+
+### env.d.ts generation
+
+Generating env.d.ts is done after a successful validation. By default, its turned-off. You need to add `generateTypes: true` to turn it on.
+
+### .env.example generation
+
+Generating .env.example is done via the CLI
+
+```bash
+npx env example --schema /path/to/schema/file --output /optional/output
+```
+
+## Configuration example
+
+```ts
+import envka, { envkaValidator } from "vite-plugin-envka";
+
+/** Example using Envka Validator */
+export const builtinSchema = envkaValidator({
+  FOO: { type: "string", default: "bar" },
+  BAR: {
+    type: "number",
+    description: "A comment on your .env.example",
+  },
+  TEST_MODE: { type: "enum", enum: ["dev", "prod"] },
+});
+
+export default {
+  plugins: [
+    envka({
+      schema: builtinSchema,
+      generateTypes: true,
+    }),
+  ],
+};
+```
+
+## License
+
+BSD-3 Clause
+
+## Links
+
+<!-- - [npm](https://www.npmjs.com/package/vite-plugin-envka) -->
+
+- [Vite](https://vitejs.dev/)
+- [Issues](https://github.com/ireneo-cobarjr/vite-plugin-envka/issues)

package/dist/bin/env-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/env-cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import * as path from "path";
+import * as fs from "fs";
+import { printEnvExample } from "../src/printEnvExample.js";
+import { log } from "../src/utils/log.js";
+const program = new Command();
+program.name("env").description("Environment CLI for envka plugin");
+program
+    .command("example")
+    .description("Generate a .env.example file from a validation schema.")
+    .requiredOption("--schema <schemaPath>", "Path to the validation schema file (e.g. ./path/schema.ts)")
+    .option("--output <outputPath>", "Optional path (including filename) to save the .env.example file")
+    .action(async (opts) => {
+    const schemaPath = opts.schema;
+    if (!schemaPath) {
+        log("--schema option is required.", "error");
+        process.exit(1);
+    }
+    const absSchemaPath = path.isAbsolute(schemaPath)
+        ? schemaPath
+        : path.resolve(process.cwd(), schemaPath);
+    if (!fs.existsSync(absSchemaPath)) {
+        log(`Schema file not found at ${absSchemaPath}`, "error");
+        process.exit(1);
+    }
+    // Import the schema module
+    let imported;
+    try {
+        imported = await import(absSchemaPath);
+    }
+    catch (e) {
+        log(`Failed to import schema from ${absSchemaPath}`, "error");
+        process.exit(1);
+    }
+    // Use imported schema for .env.example generation
+    const schema = imported.default || imported.schema || imported;
+    let exampleContent;
+    try {
+        exampleContent = printEnvExample(schema);
+    }
+    catch (e) {
+        log("Failed to generate .env.example", "error");
+        process.exit(1);
+    }
+    const outputPath = opts.output
+        ? path.isAbsolute(opts.output)
+            ? opts.output
+            : path.resolve(process.cwd(), opts.output)
+        : path.resolve(process.cwd(), ".env.example");
+    fs.writeFileSync(outputPath, exampleContent);
+    log(`.env.example generated at ${outputPath}`, "success");
+});
+program.parse(process.argv);

package/dist/src/envkaValidator.d.ts

@@ -0,0 +1,28 @@
+export type EnvkaStandardSchemaV1 = EnvkaSchema & {
+    "~standard": {
+        version: 1;
+        vendor: "envka";
+        validate: (env: Record<string, any>) => {
+            valid: boolean;
+            issues?: any[];
+        };
+        generateType: () => string;
+        generateExample: () => string;
+        rawSchema: EnvkaSchema;
+    };
+};
+export type EnvkaType = "string" | "number" | "boolean" | "enum" | "union" | "range";
+export interface EnvkaField {
+    type: EnvkaType;
+    enum?: Array<string | number>;
+    union?: Array<EnvkaField>;
+    range?: [number, number];
+    description?: string;
+}
+export type EnvkaSchema = Record<string, EnvkaField>;
+/**
+ * Generates a .env.example string from an EnvkaSchema.
+ */
+export declare function generateExample(schema: EnvkaSchema): string;
+declare const envkaValidator: (schema: EnvkaSchema) => EnvkaStandardSchemaV1;
+export default envkaValidator;

package/dist/src/envkaValidator.js

@@ -0,0 +1,125 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+/**
+ * Generates a .env.example string from an EnvkaSchema.
+ */
+export function generateExample(schema) {
+    const lines = Object.entries(schema).map(([key, field]) => {
+        let comment = "";
+        if (field.description) {
+            comment = `# ${field.description}`;
+        }
+        else if (field.type === "enum" && field.enum) {
+            comment = `# enum: ${field.enum.join(", ")}`;
+        }
+        else if (field.type) {
+            comment = `# ${field.type}`;
+        }
+        else {
+            comment = "#";
+        }
+        return `${comment}\n${key}=`;
+    });
+    return lines.join("\n\n") + "\n";
+}
+function validateField(field, value) {
+    switch (field.type) {
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number";
+        case "boolean":
+            return typeof value === "boolean";
+        case "enum":
+            return field.enum?.includes(value) ?? false;
+        case "union":
+            return field.union?.some((sub) => validateField(sub, value)) ?? false;
+        case "range":
+            if (!field.range)
+                return false;
+            return (typeof value === "number" &&
+                value >= field.range[0] &&
+                value <= field.range[1]);
+        default:
+            return false;
+    }
+}
+function validateEnvka(env, schema) {
+    const issues = [];
+    const result = {};
+    for (const key in schema) {
+        const field = schema[key];
+        const value = env[key];
+        if (!validateField(field, value)) {
+            let expectedStr = field.type;
+            if (field.type === "enum" && Array.isArray(field.enum)) {
+                expectedStr = field.enum.join(" | ");
+            }
+            issues.push(`Invalid value for ${key}: got ${value} but expected ${expectedStr}`);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    if (issues.length > 0) {
+        return { issues };
+    }
+    return { value: result };
+}
+function generateEnvkaTypes(schema) {
+    const lines = Object.entries(schema).map(([key, field]) => {
+        switch (field.type) {
+            case "string":
+                return `  readonly ${key}: string;`;
+            case "number":
+                return `  readonly ${key}: number;`;
+            case "boolean":
+                return `  readonly ${key}: boolean;`;
+            case "enum":
+                return `  readonly ${key}: ${field.enum
+                    ?.map((v) => JSON.stringify(v))
+                    .join(" | ")};`;
+            case "union":
+                return `  readonly ${key}: ${field.union
+                    ?.map((sub) => {
+                    if (sub.type === "enum")
+                        return sub.enum?.map((v) => JSON.stringify(v)).join(" | ");
+                    if (sub.type === "range")
+                        return `${sub.range?.[0]} | ... | ${sub.range?.[1]}`;
+                    return sub.type;
+                })
+                    .join(" | ")};`;
+            case "range":
+                return `  readonly ${key}: number; // ${field.range?.[0]}-${field.range?.[1]}`;
+            default:
+                return `  readonly ${key}: unknown;`;
+        }
+    });
+    return renderEnvDts(lines);
+}
+const envkaValidator = (schema) => {
+    const { ["~standard"]: _, ...fields } = schema;
+    return Object.assign({}, fields, {
+        "~standard": {
+            version: 1,
+            vendor: "envka",
+            validate: (value) => {
+                const env = typeof value === "object" && value !== null
+                    ? value
+                    : {};
+                const result = validateEnvka(env, schema);
+                if (result.issues) {
+                    return {
+                        value: undefined,
+                        issues: result.issues,
+                        valid: false,
+                    };
+                }
+                return { value: result.value, issues: undefined, valid: true };
+            },
+            generateType: () => generateEnvkaTypes(schema),
+            generateExample: () => generateExample(schema),
+            rawSchema: schema,
+        },
+    });
+};
+export default envkaValidator;

package/dist/src/generateEnvTypes.d.ts

@@ -0,0 +1,2 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export declare function generateEnvTypes(schema: StandardSchemaV1, validatedResult: Record<string, unknown>): string;

package/dist/src/generateEnvTypes.js

@@ -0,0 +1,11 @@
+import { generate } from "./generateType.js";
+export function generateEnvTypes(schema, validatedResult) {
+    let vendor = schema["~standard"].vendor.toLowerCase();
+    if (!vendor) {
+        throw new Error("Schema vendor is missing or invalid.");
+    }
+    if (vendor === "envka") {
+        return schema["~standard"].generateType();
+    }
+    return generate(validatedResult);
+}

package/dist/src/generateFromArkType.d.ts

@@ -0,0 +1 @@
+export declare function generateFromArkType(schema: any): string;

package/dist/src/generateFromArkType.js

@@ -0,0 +1,35 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+// Use ArkType's toJsonSchema to extract types
+export function generateFromArkType(schema) {
+    if (typeof schema.toJsonSchema !== "function") {
+        throw new Error("ArkType schema does not have toJsonSchema method.");
+    }
+    const jsonSchema = schema.toJsonSchema();
+    if (!jsonSchema || typeof jsonSchema !== "object" || !jsonSchema.properties) {
+        throw new Error("ArkType toJsonSchema did not return expected object shape.");
+    }
+    const lines = [];
+    for (const [key, prop] of Object.entries(jsonSchema.properties)) {
+        lines.push(`  readonly ${key}: ${arkJsonSchemaTypeToTs(prop)};`);
+    }
+    return renderEnvDts(lines);
+}
+function arkJsonSchemaTypeToTs(prop) {
+    if (!prop || typeof prop !== "object")
+        return "unknown";
+    if (prop.enum) {
+        return prop.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    switch (prop.type) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "integer":
+            return "number";
+        default:
+            return "unknown";
+    }
+}

package/dist/src/generateFromGeneric.d.ts

@@ -0,0 +1 @@
+export declare function generateFromGeneric(validated: Record<string, any>): string;

package/dist/src/generateFromGeneric.js

@@ -0,0 +1,19 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+function jsTypeToTs(type) {
+    if (type === "string")
+        return "string";
+    if (type === "number")
+        return "number";
+    if (type === "boolean")
+        return "boolean";
+    return "unknown";
+}
+export function generateFromGeneric(validated) {
+    const keys = Object.keys(validated);
+    const lines = keys.map((key) => {
+        const value = validated[key];
+        const tsType = jsTypeToTs(typeof value);
+        return `  readonly ${key}: ${tsType};`;
+    });
+    return renderEnvDts(lines);
+}

package/dist/src/generateFromValibot.d.ts

@@ -0,0 +1,9 @@
+export type ValibotObjectSchema = {
+    entries?: Record<string, {
+        type: string;
+    } & Record<string, unknown>>;
+    shape?: Record<string, {
+        type: string;
+    } & Record<string, unknown>>;
+};
+export declare function generateFromValibot(schema: ValibotObjectSchema): string;

package/dist/src/generateFromValibot.js

@@ -0,0 +1,63 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+function valibotTypeToTs(valiType) {
+    if (valiType.type === "enum") {
+        // Valibot v1: enums are objects under the 'enum' property
+        if (valiType.enum && typeof valiType.enum === "object") {
+            return Object.values(valiType.enum)
+                .map((v) => JSON.stringify(v))
+                .join(" | ");
+        }
+        // fallback for older valibot: enums as array under 'values'
+        if ("values" in valiType &&
+            Array.isArray(valiType.values)) {
+            return valiType.values
+                .map((v) => JSON.stringify(v))
+                .join(" | ");
+        }
+    }
+    if (valiType.type === "union" &&
+        "options" in valiType &&
+        Array.isArray(valiType.options)) {
+        // Union: output as union of types
+        const options = valiType.options;
+        // Special case: all options are literals
+        if (options.every((opt) => typeof opt === "object" &&
+            opt !== null &&
+            "type" in opt &&
+            opt.type === "literal")) {
+            return options
+                .map((opt) => JSON.stringify(opt.value))
+                .join(" | ");
+        }
+        return options
+            .map((opt) => {
+            if (typeof opt === "object" && opt !== null && "type" in opt) {
+                return valibotTypeToTs(opt);
+            }
+            return "unknown";
+        })
+            .join(" | ");
+    }
+    if (valiType.type === "literal" && "value" in valiType) {
+        return JSON.stringify(valiType.value);
+    }
+    switch (valiType.type) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        default:
+            return "unknown";
+    }
+}
+export function generateFromValibot(schema) {
+    const shape = schema.entries ?? schema.shape ?? {};
+    const lines = Object.keys(shape).map((key) => {
+        const valiType = shape[key];
+        const tsType = valibotTypeToTs(valiType);
+        return `  readonly ${key}: ${tsType};`;
+    });
+    return renderEnvDts(lines);
+}

package/dist/src/generateFromZod.d.ts

@@ -0,0 +1,2 @@
+import { ZodObject } from "zod";
+export declare function generateFromZod(schema: ZodObject): string;

package/dist/src/generateFromZod.js

@@ -0,0 +1,59 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+import { ZodOptional, ZodNullable, ZodString, ZodNumber, ZodBoolean, ZodDate, ZodEnum, ZodLiteral, ZodUnion, ZodDefault, } from "zod";
+function zodTypeToTs(zodType) {
+    if (typeof ZodDefault !== "undefined" && zodType instanceof ZodDefault) {
+        // Unwrap ZodDefault to get the inner type
+        const innerType = zodType._def.innerType;
+        return zodTypeToTs(innerType);
+    }
+    if (typeof ZodEnum !== "undefined" && zodType instanceof ZodEnum) {
+        // ZodEnum: output as union of string literals (use .options, not .values)
+        const options = zodType.options;
+        return options.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    if (typeof ZodUnion !== "undefined" && zodType instanceof ZodUnion) {
+        // ZodUnion: output as union of types
+        const options = zodType.options;
+        // Special case: all options are ZodLiteral (e.g., union of string literals)
+        if (options.every((opt) => opt instanceof ZodLiteral)) {
+            return options
+                .map((opt) => JSON.stringify(opt.value))
+                .join(" | ");
+        }
+        // Otherwise, join the mapped types
+        return options.map(zodTypeToTs).join(" | ");
+    }
+    if (typeof ZodLiteral !== "undefined" && zodType instanceof ZodLiteral) {
+        // ZodLiteral: output as literal value
+        return JSON.stringify(zodType.value);
+    }
+    if (zodType instanceof ZodString)
+        return "string";
+    if (zodType instanceof ZodNumber)
+        return "number";
+    if (zodType instanceof ZodBoolean)
+        return "boolean";
+    if (zodType instanceof ZodDate)
+        return "Date";
+    if (zodType instanceof ZodOptional) {
+        const optionalInner = zodType.def
+            .innerType;
+        return zodTypeToTs(optionalInner) + " | undefined";
+    }
+    if (zodType instanceof ZodNullable) {
+        const nullableInner = zodType.def
+            .innerType;
+        return zodTypeToTs(nullableInner) + " | null";
+    }
+    return "unknown";
+}
+export function generateFromZod(schema) {
+    // Use .shape property (public Zod API)
+    const shape = schema.shape;
+    const lines = Object.keys(shape).map((key) => {
+        const zodType = shape[key];
+        const tsType = zodTypeToTs(zodType);
+        return `  readonly ${key}: ${tsType};`;
+    });
+    return renderEnvDts(lines);
+}

package/dist/src/generateType.d.ts

@@ -0,0 +1 @@
+export declare function generate(validated: Record<string, any>): string;

package/dist/src/generateType.js

@@ -0,0 +1,19 @@
+import { renderEnvDts } from "./utils/renderEnvDts.js";
+function jsTypeToTs(type) {
+    if (type === "string")
+        return "string";
+    if (type === "number")
+        return "number";
+    if (type === "boolean")
+        return "boolean";
+    return "unknown";
+}
+export function generate(validated) {
+    const keys = Object.keys(validated);
+    const lines = keys.map((key) => {
+        const value = validated[key];
+        const tsType = jsTypeToTs(typeof value);
+        return `  readonly ${key}: ${tsType};`;
+    });
+    return renderEnvDts(lines);
+}

package/dist/src/generateTypes.d.ts

@@ -0,0 +1,2 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export declare function generateEnvTypes(schema: StandardSchemaV1, validatedResult: Record<string, unknown>): string;

package/dist/src/generateTypes.js

@@ -0,0 +1,29 @@
+import { generateFromZod } from "./generateFromZod.js";
+import { generateFromValibot, } from "./generateFromValibot.js";
+import { generateFromArkType } from "./generateFromArkType.js";
+import { generateFromGeneric } from "./generateFromGeneric.js";
+export function generateEnvTypes(schema, validatedResult) {
+    try {
+        let vendor = schema["~standard"].vendor.toLowerCase();
+        if (!vendor) {
+            throw new Error("Schema vendor is missing or invalid.");
+        }
+        if (vendor === "zod") {
+            return generateFromZod(schema);
+        }
+        if (vendor === "valibot") {
+            return generateFromValibot(schema);
+        }
+        if (vendor === "arktype") {
+            return generateFromArkType(schema);
+        }
+        if (vendor === "envka") {
+            return schema["~standard"].generateType();
+        }
+        return generateFromGeneric(validatedResult);
+    }
+    catch (e) {
+        throw new Error("Could not determine schema vendor: " +
+            (e instanceof Error ? e.message : String(e)));
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from "vite";
+import envkaValidator from "./envkaValidator.js";
+import type { EnvkaStandardSchemaV1 } from "./envkaValidator.js";
+export type { EnvkaStandardSchemaV1, EnvkaType, EnvkaField, EnvkaSchema, } from "./envkaValidator.js";
+export interface EnvkaOptions {
+    /** Validation schema for environment variables */
+    schema: EnvkaStandardSchemaV1;
+    /** If true, generate env.d.ts after validation (default: false) */
+    generateTypes?: boolean;
+}
+export { envkaValidator };
+export default function envka(options: EnvkaOptions): Plugin;

package/dist/src/index.js

@@ -0,0 +1,69 @@
+import { loadEnv } from "vite";
+import { log } from "./utils/log.js";
+import { parseEnv } from "./utils/parseEnv.js";
+import * as fs from "fs";
+import * as path from "path";
+import envkaValidator from "./envkaValidator.js";
+export { envkaValidator };
+export default function envka(options) {
+    let envkaIssues = null;
+    const handleError = (msg, issues, command) => {
+        if (command !== "build") {
+            envkaIssues = issues;
+            log(msg, "error");
+        }
+        else {
+            throw new Error(msg);
+        }
+    };
+    return {
+        name: "vite-plugin-envka",
+        config(config, envCtx) {
+            if (!options || !options.schema) {
+                log("No schema provided for validation.", "info");
+                return;
+            }
+            if (!options.schema?.["~standard"] ||
+                typeof options.schema["~standard"].validate !== "function" ||
+                options.schema["~standard"].vendor !== "envka") {
+                const errorMsg = "Provided schema is not a valid envkaValidator schema.";
+                handleError(errorMsg, ["Provided schema is not a valid envkaValidator schema."], envCtx.command);
+                return;
+            }
+            const rootPath = config.root ?? process.cwd();
+            const envMap = loadEnv(envCtx.mode, rootPath, "");
+            const result = options.schema["~standard"].validate(parseEnv(envMap));
+            if (!result.valid) {
+                envkaIssues = result.issues ?? ["Unknown error"];
+                handleError(`Environment validation failed: ${envkaIssues.join("; ")}`, envkaIssues, envCtx.command);
+            }
+            else {
+                envkaIssues = null;
+                log("Environment validation passed.", "success");
+                if (options.generateTypes) {
+                    if (envCtx.command !== "build") {
+                        const types = options.schema["~standard"].generateType();
+                        const outPath = path.resolve(rootPath, "env.d.ts");
+                        fs.writeFileSync(outPath, types);
+                        log(`Generated env.d.ts at ${outPath}`, "success");
+                    }
+                }
+            }
+        },
+        configureServer(server) {
+            function sendOverlay() {
+                if (envkaIssues && envkaIssues.length > 0) {
+                    server.ws.send({
+                        type: "error",
+                        err: {
+                            message: `[envka] ${envkaIssues.join("\n")}`,
+                            stack: "",
+                        },
+                    });
+                }
+            }
+            sendOverlay();
+            server.ws.on("connection", sendOverlay);
+        },
+    };
+}

package/dist/src/printEnvExample.d.ts

@@ -0,0 +1,2 @@
+import { EnvkaStandardSchemaV1 } from "./envkaValidator.js";
+export declare function printEnvExample(schema: EnvkaStandardSchemaV1): string;

package/dist/src/printEnvExample.js

@@ -0,0 +1,6 @@
+export function printEnvExample(schema) {
+    if (schema && typeof schema["~standard"]?.generateExample === "function") {
+        return schema["~standard"].generateExample();
+    }
+    throw new TypeError("Provided schema is not a valid EnvkaStandardSchemaV1.");
+}

package/dist/src/types.d.ts

@@ -0,0 +1,7 @@
+import type { EnvkaStandardSchemaV1 } from "./envkaValidator.js";
+export interface EnvkaOptions {
+    /** Validation schema for environment variables (Standard Schema spec) */
+    schema: EnvkaStandardSchemaV1;
+    /** If true, generate env.d.ts after validation (default: false) */
+    generateTypes?: boolean;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/isStandardSchema.d.ts

@@ -0,0 +1,2 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export declare function isStandardSchema(schema: unknown): schema is StandardSchemaV1<any, any>;

package/dist/src/utils/isStandardSchema.js

@@ -0,0 +1,14 @@
+import { ZodType } from "zod";
+export function isStandardSchema(schema) {
+    if ((typeof schema !== "object" && typeof schema !== "function") ||
+        schema === null)
+        return false;
+    if (schema instanceof ZodType)
+        return true;
+    const std = schema["~standard"];
+    return (typeof std === "object" &&
+        std !== null &&
+        std.version === 1 &&
+        typeof std.vendor === "string" &&
+        typeof std.validate === "function");
+}

package/dist/src/utils/log.d.ts

@@ -0,0 +1,3 @@
+type LogType = "error" | "success" | "info";
+export declare function log(message: string, type?: LogType): void;
+export {};

package/dist/src/utils/log.js

@@ -0,0 +1,19 @@
+// Utility for logging
+import chalk from "chalk";
+export function log(message, type = "info") {
+    const prefix = chalk.hex("#d898ca")("[envka]");
+    let colorFn;
+    switch (type) {
+        case "error":
+            colorFn = chalk.hex("#ff6666");
+            break;
+        case "success":
+            colorFn = chalk.hex("#66ff66");
+            break;
+        case "info":
+        default:
+            colorFn = chalk.hex("#88ffff");
+            break;
+    }
+    console.log(`${prefix} ${colorFn(message)}`);
+}

package/dist/src/utils/parseEnv.d.ts

@@ -0,0 +1 @@
+export declare const parseEnv: (env: Record<string, string | undefined>) => Record<string, any>;

package/dist/src/utils/parseEnv.js

@@ -0,0 +1,22 @@
+export const parseEnv = (env) => {
+    const parsedEnv = {};
+    for (const key in env) {
+        const value = env[key];
+        if (value === undefined) {
+            parsedEnv[key] = undefined;
+        }
+        else if (value.toLowerCase() === "true") {
+            parsedEnv[key] = true;
+        }
+        else if (value.toLowerCase() === "false") {
+            parsedEnv[key] = false;
+        }
+        else if (!isNaN(Number(value))) {
+            parsedEnv[key] = Number(value);
+        }
+        else {
+            parsedEnv[key] = value;
+        }
+    }
+    return parsedEnv;
+};

package/dist/src/utils/parser.d.ts

@@ -0,0 +1 @@
+export declare const parseEnv: (env: Record<string, string | undefined>) => Record<string, any>;

package/dist/src/utils/parser.js

@@ -0,0 +1,22 @@
+export const parseEnv = (env) => {
+    const parsedEnv = {};
+    for (const key in env) {
+        const value = env[key];
+        if (value === undefined) {
+            parsedEnv[key] = undefined;
+        }
+        else if (value.toLowerCase() === "true") {
+            parsedEnv[key] = true;
+        }
+        else if (value.toLowerCase() === "false") {
+            parsedEnv[key] = false;
+        }
+        else if (!isNaN(Number(value))) {
+            parsedEnv[key] = Number(value);
+        }
+        else {
+            parsedEnv[key] = value;
+        }
+    }
+    return parsedEnv;
+};

package/dist/src/utils/renderEnvDts.d.ts

@@ -0,0 +1 @@
+export declare function renderEnvDts(lines: string[]): string;

package/dist/src/utils/renderEnvDts.js

@@ -0,0 +1,4 @@
+// Utility to render env.d.ts output for Vite
+export function renderEnvDts(lines) {
+    return `/// <reference types=\"vite/client\" />\ninterface ImportMetaEnv {\n${lines.join("\n")}\n}\n\ninterface ImportMeta {\n  readonly env: ImportMetaEnv;\n}\n`;
+}

package/dist/src/validate.d.ts

@@ -0,0 +1,10 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export declare function validateEnv(schema: StandardSchemaV1, env: Record<string, any>): {
+    valid: boolean;
+    issues: readonly StandardSchemaV1.Issue[];
+    value?: undefined;
+} | {
+    valid: boolean;
+    value: unknown;
+    issues?: undefined;
+};

package/dist/src/validate.js

@@ -0,0 +1,10 @@
+export function validateEnv(schema, env) {
+    const result = schema["~standard"].validate(env);
+    if (result instanceof Promise) {
+        throw new TypeError("Async validation is not supported.");
+    }
+    if ("issues" in result && result.issues) {
+        return { valid: false, issues: result.issues };
+    }
+    return { valid: true, value: result.value };
+}

package/dist/src/validateEnv.d.ts

@@ -0,0 +1,5 @@
+import type { EnvkaStandardSchemaV1 } from "./envkaValidator.js";
+export declare function validateEnv(schema: EnvkaStandardSchemaV1, env: Record<string, any>): {
+    valid: boolean;
+    issues?: any[];
+};

package/dist/src/validateEnv.js

@@ -0,0 +1,3 @@
+export function validateEnv(schema, env) {
+    return schema["~standard"].validate(env);
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "vite-plugin-envka",
+  "description": "Envka is a vite plugin designed to enhance environment variable management in Vite projects.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Ireneo C. Cobar Jr"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ireneo-cobarjr/vite-plugin-envka.git"
+  },
+  "homepage": "https://github.com/ireneo-cobarjr/vite-plugin-envka",
+  "bugs": {
+    "url": "https://github.com/ireneo-cobarjr/vite-plugin-envka/issues"
+  },
+  "license": "BSD-3-Clause",
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "env",
+    "environment",
+    "environment-variables",
+    "dotenv",
+    ".env",
+    "config",
+    "configuration",
+    "schema",
+    "validation",
+    "typescript",
+    "plugin",
+    "nodejs",
+    "build",
+    "cli"
+  ],
+  "type": "module",
+  "main": "dist/src/index.js",
+  "files": [
+    "dist/",
+    "bin/env-cli.js",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "bin": {
+    "env": "dist/bin/env-cli.js"
+  },
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^24.8.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.10",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1"
+  }
+}