@epsilon-asi/foundation 0.0.11 → 0.0.13

package/build/decorators/environment/defaultSystem.d.ts

@@ -0,0 +1,6 @@
+export declare const envRegistry: import("../factory").DecoratorRegistry<import("./types").EnvDecoratorSchema>;
+export declare const Env: import("./types").EnvConfigDecorator;
+export declare const EnvConfig: import("./types").EnvConfigDecorator;
+export declare const EnvVar: import("./types").EnvVarDecoratorApi;
+export declare const loadEnv: <TClass extends import("../factory").Constructor>(target: TClass, options?: import("./types").LoadEnvOptions) => import("./types").EnvLoadResult<TClass>;
+export declare const describeEnv: <TClass extends import("../factory").Constructor>(target: TClass, options?: import("./types").DescribeEnvOptions) => readonly import("./types").EnvVariableDefinition[];

package/build/decorators/environment/defaultSystem.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeEnv = exports.loadEnv = exports.EnvVar = exports.EnvConfig = exports.Env = exports.envRegistry = void 0;
+const system_1 = require("./system");
+/** The shared env system behind the top-level Env, EnvVar and loadEnv exports. */
+const defaultEnvSystem = (0, system_1.createEnvSystem)();
+exports.envRegistry = defaultEnvSystem.registry;
+exports.Env = defaultEnvSystem.Env;
+exports.EnvConfig = defaultEnvSystem.EnvConfig;
+exports.EnvVar = defaultEnvSystem.EnvVar;
+exports.loadEnv = defaultEnvSystem.loadEnv;
+exports.describeEnv = defaultEnvSystem.describeEnv;

package/build/decorators/environment/dotenv.d.ts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_DOTENV_PATH = ".env";
+export interface DotenvOptions {
+    /**
+     * File or files to read, resolved against `cwd`. When several are listed, later files
+     * take precedence over earlier ones, e.g. ['.env', '.env.local'].
+     *
+     * Defaults to '.env'.
+     */
+    path?: string | readonly string[];
+    /** Directory that relative paths resolve from. Defaults to process.cwd() at load time. */
+    cwd?: string;
+    /**
+     * Whether dotenv values take precedence over the env source (process.env by default).
+     *
+     * Defaults to true.
+     */
+    override?: boolean;
+    /**
+     * Whether a listed file that does not exist is an error.
+     *
+     * Defaults to false, so a missing file is skipped.
+     */
+    required?: boolean;
+    /** Defaults to 'utf8'. */
+    encoding?: BufferEncoding;
+}
+/**
+ * How dotenv files feed loadEnv():
+ * - `undefined` or `true`: read the default '.env' file.
+ * - `false`: do not read any dotenv file.
+ * - a path or list of paths: read those files.
+ * - an options object: full control.
+ */
+export type DotenvSetting = boolean | string | readonly string[] | DotenvOptions;
+export interface DotenvReadResult {
+    /** Merged values from every file that was read. */
+    readonly values: Readonly<Record<string, string>>;
+    /** Absolute paths of the files that were read, in load order. */
+    readonly files: readonly string[];
+}
+/**
+ * Combines the class-level @Env({ dotenv }) setting with the loadEnv({ dotenv }) option.
+ * Dotenv is on unless one of them is `false`; the call's options are merged over the class's.
+ * Returns undefined when dotenv is turned off.
+ */
+export declare function resolveDotenvOptions(classSetting: DotenvSetting | undefined, callSetting: DotenvSetting | undefined): DotenvOptions | undefined;
+/** Reads and merges dotenv files without touching process.env. */
+export declare function readDotenvFiles(options?: DotenvOptions): DotenvReadResult;

package/build/decorators/environment/dotenv.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DOTENV_PATH = void 0;
+exports.resolveDotenvOptions = resolveDotenvOptions;
+exports.readDotenvFiles = readDotenvFiles;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const dotenv_1 = require("dotenv");
+const errors_1 = require("./errors");
+exports.DEFAULT_DOTENV_PATH = '.env';
+/**
+ * Combines the class-level @Env({ dotenv }) setting with the loadEnv({ dotenv }) option.
+ * Dotenv is on unless one of them is `false`; the call's options are merged over the class's.
+ * Returns undefined when dotenv is turned off.
+ */
+function resolveDotenvOptions(classSetting, callSetting) {
+    const fromClass = normalizeDotenvSetting(classSetting);
+    if (callSetting === undefined)
+        return fromClass;
+    const fromCall = normalizeDotenvSetting(callSetting);
+    if (fromCall === undefined)
+        return undefined;
+    return Object.assign(Object.assign({}, fromClass), definedOnly(fromCall));
+}
+/** Reads and merges dotenv files without touching process.env. */
+function readDotenvFiles(options = {}) {
+    var _a, _b;
+    const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+    const paths = isPathList(options.path) ? options.path : [(_b = options.path) !== null && _b !== void 0 ? _b : exports.DEFAULT_DOTENV_PATH];
+    const values = Object.create(null);
+    const files = [];
+    for (const entry of paths) {
+        const filePath = node_path_1.default.resolve(cwd, entry);
+        const text = readDotenvFile(filePath, options);
+        if (text === undefined)
+            continue;
+        Object.assign(values, (0, dotenv_1.parse)(text));
+        files.push(filePath);
+    }
+    return Object.freeze({
+        values: Object.freeze(values),
+        files: Object.freeze(files),
+    });
+}
+function readDotenvFile(filePath, options) {
+    var _a;
+    try {
+        return (0, node_fs_1.readFileSync)(filePath, { encoding: (_a = options.encoding) !== null && _a !== void 0 ? _a : 'utf8' });
+    }
+    catch (cause) {
+        if ((cause === null || cause === void 0 ? void 0 : cause.code) === 'ENOENT') {
+            if (options.required !== true)
+                return undefined;
+            throw new errors_1.EnvParseError(`Required dotenv file "${filePath}" does not exist.`, { filePath, cause });
+        }
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        throw new errors_1.EnvParseError(`Failed to read dotenv file "${filePath}": ${reason}`, { filePath, cause });
+    }
+}
+function normalizeDotenvSetting(setting) {
+    if (setting === false)
+        return undefined;
+    if (setting === undefined || setting === true)
+        return {};
+    if (typeof setting === 'string' || isPathList(setting))
+        return { path: setting };
+    return setting;
+}
+function isPathList(value) {
+    return Array.isArray(value);
+}
+function definedOnly(options) {
+    return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}

package/build/decorators/environment/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class EnvParseError extends Error {
+    readonly envName?: string;
+    readonly propertyName?: string;
+    /** The dotenv file involved, for errors raised while reading one. */
+    readonly filePath?: string;
+    constructor(message: string, details?: {
+        envName?: string;
+        propertyName?: string;
+        filePath?: string;
+        cause?: unknown;
+    });
+}

package/build/decorators/environment/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvParseError = void 0;
+class EnvParseError extends Error {
+    constructor(message, details = {}) {
+        super(message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.name = 'EnvParseError';
+        this.envName = details.envName;
+        this.propertyName = details.propertyName;
+        this.filePath = details.filePath;
+    }
+}
+exports.EnvParseError = EnvParseError;

package/build/decorators/environment/index.d.ts

@@ -1,164 +1,7 @@
-import type { ClassDecoratorDefinition, Constructor, DecoratorRegistry, PropertyDecoratorDefinition, RegistryMetadataSnapshot } from '../factory';
-export type EnvPrimitive = string | number | boolean;
-export type EnvPrimitiveOrUndefined = EnvPrimitive | undefined;
-export type EnvBooleanTrueValue = 'true' | '1' | 'yes' | 'y' | 'on';
-export type EnvBooleanFalseValue = 'false' | '0' | 'no' | 'n' | 'off';
-export type EnvValueKind = 'string' | 'number' | 'boolean';
-export interface EnvConfigMetadata {
-    /**
-     * Optional prefix applied to every variable lookup.
-     *
-     * Example:
-     * prefix: 'APP_'
-     * @EnvVar.string('PORT')
-     * final lookup key: APP_PORT
-     */
-    prefix?: string;
-    /** Optional human-readable description for docs/debug output. */
-    description?: string;
-}
-export type StringEnvVarMetadata = {
-    type: 'string';
-    name?: string;
-    required?: boolean;
-    default?: string;
-    description?: string;
-};
-export type NumberEnvVarMetadata = {
-    type: 'number';
-    name?: string;
-    required?: boolean;
-    default?: number;
-    min?: number;
-    max?: number;
-    integer?: boolean;
-    description?: string;
-};
-export type BooleanEnvVarMetadata = {
-    type: 'boolean';
-    name?: string;
-    required?: boolean;
-    default?: boolean;
-    description?: string;
-};
-export type EnvVarMetadata = StringEnvVarMetadata | NumberEnvVarMetadata | BooleanEnvVarMetadata;
-export type EnvDecoratorSchema = {
-    class: {
-        envConfig: ClassDecoratorDefinition<EnvConfigMetadata | undefined>;
-    };
-    property: {
-        envVar: PropertyDecoratorDefinition<EnvVarMetadata, EnvPrimitiveOrUndefined>;
-    };
-    method: {};
-    accessor: {};
-};
-export type EnvSource = Record<string, string | undefined>;
-export interface LoadEnvOptions {
-    /**
-     * Defaults to globalThis.process.env when available.
-     * Pass this in tests to avoid mutating or depending on the real process env.
-     */
-    source?: EnvSource;
-    /**
-     * Whether @EnvVar fields must be static.
-     *
-     * Defaults to true because loadEnv mutates the class constructor in place.
-     */
-    requireStatic?: boolean;
-    /**
-     * Whether empty strings and whitespace-only strings should be treated as missing.
-     *
-     * Defaults to true.
-     */
-    emptyStringAsMissing?: boolean;
-    /**
-     * Whether inherited metadata should be loaded.
-     *
-     * Defaults to true.
-     */
-    includeInherited?: boolean;
-}
-export interface DescribeEnvOptions {
-    /** Defaults to true. */
-    includeInherited?: boolean;
-}
-export interface EnvVariableDefinition {
-    readonly propertyName: string;
-    readonly envName: string;
-    readonly static: boolean;
-    readonly private: boolean;
-    readonly metadata: EnvVarMetadata;
-}
-export interface EnvLoadResult<TClass extends Constructor> {
-    readonly target: TClass;
-    readonly definitions: readonly EnvVariableDefinition[];
-    readonly values: Readonly<Record<string, EnvPrimitiveOrUndefined>>;
-    readonly snapshot: RegistryMetadataSnapshot;
-}
-export declare class EnvParseError extends Error {
-    readonly envName?: string;
-    readonly propertyName?: string;
-    constructor(message: string, details?: {
-        envName?: string;
-        propertyName?: string;
-    });
-}
-export interface EnvConfigDecorator {
-    (metadata?: EnvConfigMetadata): <TClass extends Constructor>(value: TClass, context: ClassDecoratorContext<TClass>) => void;
-}
-export interface EnvVarDecoratorApi {
-    /**
-     * Generic form:
-     *
-     * @EnvVar({ name: 'PORT', type: 'number' })
-     * static port: number;
-     */
-    (metadata: StringEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, string | undefined>) => void;
-    (metadata: NumberEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, number | undefined>) => void;
-    (metadata: BooleanEnvVarMetadata): (value: undefined, context: ClassFieldDecoratorContext<any, boolean | undefined>) => void;
-    /**
-     * @EnvVar.string('API_KEY')
-     * static apiKey: string;
-     */
-    string(name?: string, options?: Omit<StringEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, string | undefined>) => void;
-    /**
-     * @EnvVar.number('PORT', { default: 3000, integer: true })
-     * static port: number;
-     */
-    number(name?: string, options?: Omit<NumberEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, number | undefined>) => void;
-    /**
-     * @EnvVar.boolean('DEBUG', { default: false })
-     * static debug: boolean;
-     */
-    boolean(name?: string, options?: Omit<BooleanEnvVarMetadata, 'type' | 'name'>): (value: undefined, context: ClassFieldDecoratorContext<any, boolean | undefined>) => void;
-}
-export interface EnvSystem {
-    readonly registry: DecoratorRegistry<EnvDecoratorSchema>;
-    /** Preferred class decorator name. */
-    readonly Env: EnvConfigDecorator;
-    /** Alias for Env, for users who prefer a more explicit name. */
-    readonly EnvConfig: EnvConfigDecorator;
-    readonly EnvVar: EnvVarDecoratorApi;
-    /**
-     * Mutates the provided class in place by assigning parsed values to static fields.
-     */
-    loadEnv<TClass extends Constructor>(target: TClass, options?: LoadEnvOptions): EnvLoadResult<TClass>;
-    /** Reads env metadata without mutating the class. */
-    describeEnv<TClass extends Constructor>(target: TClass, options?: DescribeEnvOptions): readonly EnvVariableDefinition[];
-}
-export declare function createEnvSystem(): EnvSystem;
-export declare function getEnvConfigMetadata(snapshot: RegistryMetadataSnapshot): EnvConfigMetadata | undefined;
-export declare function toEnvKey(propertyName: string): string;
-export declare function parseEnvValue(args: {
-    envName: string;
-    propertyName: string;
-    rawValue: string | undefined;
-    metadata: EnvVarMetadata;
-    emptyStringAsMissing: boolean;
-}): EnvPrimitiveOrUndefined;
-export declare const envRegistry: DecoratorRegistry<EnvDecoratorSchema>;
-export declare const Env: EnvConfigDecorator;
-export declare const EnvConfig: EnvConfigDecorator;
-export declare const EnvVar: EnvVarDecoratorApi;
-export declare const loadEnv: <TClass extends Constructor>(target: TClass, options?: LoadEnvOptions) => EnvLoadResult<TClass>;
-export declare const describeEnv: <TClass extends Constructor>(target: TClass, options?: DescribeEnvOptions) => readonly EnvVariableDefinition[];
+export type { BooleanEnvVarMetadata, DescribeEnvOptions, EnvBooleanFalseValue, EnvBooleanTrueValue, EnvConfigDecorator, EnvConfigMetadata, EnvDecoratorSchema, EnvLoadResult, EnvPrimitive, EnvPrimitiveOrUndefined, EnvSource, EnvSystem, EnvValueKind, EnvVarDecoratorApi, EnvVariableDefinition, EnvVarMetadata, LoadEnvOptions, NumberEnvVarMetadata, StringEnvVarMetadata, } from './types';
+export type { DotenvOptions, DotenvReadResult, DotenvSetting } from './dotenv';
+export { createEnvSystem, getEnvConfigMetadata } from './system';
+export { describeEnv, Env, EnvConfig, envRegistry, EnvVar, loadEnv } from './defaultSystem';
+export { parseEnvValue, toEnvKey } from './parse';
+export { DEFAULT_DOTENV_PATH, readDotenvFiles } from './dotenv';
+export { EnvParseError } from './errors';

package/build/decorators/environment/index.js

@@ -1,223 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeEnv = exports.loadEnv = exports.EnvVar = exports.EnvConfig = exports.Env = exports.envRegistry = exports.EnvParseError = void 0;
-exports.createEnvSystem = createEnvSystem;
-exports.getEnvConfigMetadata = getEnvConfigMetadata;
-exports.toEnvKey = toEnvKey;
-exports.parseEnvValue = parseEnvValue;
-const factory_1 = require("../factory");
-class EnvParseError extends Error {
-    constructor(message, details = {}) {
-        super(message);
-        this.name = 'EnvParseError';
-        this.envName = details.envName;
-        this.propertyName = details.propertyName;
-    }
-}
-exports.EnvParseError = EnvParseError;
-function createEnvSystem() {
-    const registry = (0, factory_1.createDecoratorRegistry)({
-        namespace: 'env',
-    });
-    const RawEnvConfig = registry.class('envConfig');
-    const Env = ((metadata) => {
-        return metadata === undefined ? RawEnvConfig() : RawEnvConfig(metadata);
-    });
-    const EnvConfig = Env;
-    /**
-     * Broad scoped contract because this system decorates arbitrary env classes.
-     * The public EnvVar.string/number/boolean helper return types enforce the actual
-     * decorated property type.
-     */
-    const Scoped = registry.for();
-    const RawEnvVar = Scoped.property('envVar');
-    const EnvVar = ((metadata) => RawEnvVar(metadata));
-    EnvVar.string = (name, options = {}) => {
-        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'string' }));
-    };
-    EnvVar.number = (name, options = {}) => {
-        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'number' }));
-    };
-    EnvVar.boolean = (name, options = {}) => {
-        return RawEnvVar(Object.assign(Object.assign({}, options), { name, type: 'boolean' }));
-    };
-    function describeEnv(target, options = {}) {
-        var _a, _b;
-        const includeInherited = (_a = options.includeInherited) !== null && _a !== void 0 ? _a : true;
-        const snapshot = registry.read(target, { includeInherited });
-        const classMetadata = getEnvConfigMetadata(snapshot);
-        const prefix = (_b = classMetadata === null || classMetadata === void 0 ? void 0 : classMetadata.prefix) !== null && _b !== void 0 ? _b : '';
-        return Object.freeze(snapshot.propertyRecords('envVar').map((record) => {
-            var _a;
-            if (record.memberName === undefined) {
-                throw new EnvParseError('EnvVar metadata record is missing memberName.');
-            }
-            if (typeof record.memberName === 'symbol') {
-                throw new EnvParseError(`EnvVar does not support symbol member keys: ${String(record.memberName)}.`);
-            }
-            const metadata = record.metadata;
-            const propertyName = record.memberName;
-            const envName = prefix + ((_a = metadata.name) !== null && _a !== void 0 ? _a : toEnvKey(propertyName));
-            return Object.freeze({
-                propertyName,
-                envName,
-                static: record.static,
-                private: record.private,
-                metadata,
-            });
-        }));
-    }
-    function loadEnv(target, options = {}) {
-        var _a, _b, _c, _d;
-        const source = (_a = options.source) !== null && _a !== void 0 ? _a : getDefaultEnvSource();
-        const requireStatic = (_b = options.requireStatic) !== null && _b !== void 0 ? _b : true;
-        const emptyStringAsMissing = (_c = options.emptyStringAsMissing) !== null && _c !== void 0 ? _c : true;
-        const includeInherited = (_d = options.includeInherited) !== null && _d !== void 0 ? _d : true;
-        const snapshot = registry.read(target, { includeInherited });
-        const definitions = describeEnv(target, { includeInherited });
-        const values = {};
-        for (const definition of definitions) {
-            if (requireStatic && !definition.static) {
-                throw new EnvParseError(`@EnvVar field "${definition.propertyName}" must be static when using loadEnv().`, {
-                    envName: definition.envName,
-                    propertyName: definition.propertyName,
-                });
-            }
-            if (definition.private) {
-                throw new EnvParseError(`@EnvVar field "${definition.propertyName}" cannot be private.`, {
-                    envName: definition.envName,
-                    propertyName: definition.propertyName,
-                });
-            }
-            const rawValue = source[definition.envName];
-            const parsedValue = parseEnvValue({
-                envName: definition.envName,
-                propertyName: definition.propertyName,
-                rawValue,
-                metadata: definition.metadata,
-                emptyStringAsMissing,
-            });
-            Object.defineProperty(target, definition.propertyName, {
-                configurable: true,
-                enumerable: true,
-                writable: true,
-                value: parsedValue,
-            });
-            values[definition.propertyName] = parsedValue;
-        }
-        return Object.freeze({
-            target,
-            definitions,
-            values: Object.freeze(Object.assign({}, values)),
-            snapshot,
-        });
-    }
-    return Object.freeze({
-        registry,
-        Env,
-        EnvConfig,
-        EnvVar,
-        loadEnv,
-        describeEnv,
-    });
-}
-function getEnvConfigMetadata(snapshot) {
-    const configRecords = snapshot.classRecords('envConfig');
-    const lastRecord = configRecords[configRecords.length - 1];
-    return lastRecord === null || lastRecord === void 0 ? void 0 : lastRecord.metadata;
-}
-function toEnvKey(propertyName) {
-    return propertyName
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        .replace(/[-\s]+/g, '_')
-        .toUpperCase();
-}
-function parseEnvValue(args) {
-    const { envName, propertyName, rawValue, metadata, emptyStringAsMissing } = args;
-    const missing = rawValue === undefined || (emptyStringAsMissing && rawValue.trim() === '');
-    if (missing) {
-        if ('default' in metadata)
-            return metadata.default;
-        if (metadata.required === false)
-            return undefined;
-        throw new EnvParseError(`Missing required environment variable "${envName}".`, {
-            envName,
-            propertyName,
-        });
-    }
-    switch (metadata.type) {
-        case 'string':
-            return rawValue;
-        case 'number':
-            return parseNumberValue({
-                envName,
-                propertyName,
-                rawValue,
-                metadata,
-            });
-        case 'boolean':
-            return parseBooleanValue({
-                envName,
-                propertyName,
-                rawValue,
-            });
-        default:
-            return assertNever(metadata);
-    }
-}
-function parseNumberValue(args) {
-    const { envName, propertyName, rawValue, metadata } = args;
-    const value = Number(rawValue);
-    if (!Number.isFinite(value)) {
-        throw new EnvParseError(`Environment variable "${envName}" must be a finite number. Received "${rawValue}".`, { envName, propertyName });
-    }
-    if (metadata.integer === true && !Number.isInteger(value)) {
-        throw new EnvParseError(`Environment variable "${envName}" must be an integer. Received "${rawValue}".`, { envName, propertyName });
-    }
-    if (metadata.min !== undefined && value < metadata.min) {
-        throw new EnvParseError(`Environment variable "${envName}" must be >= ${metadata.min}. Received "${rawValue}".`, { envName, propertyName });
-    }
-    if (metadata.max !== undefined && value > metadata.max) {
-        throw new EnvParseError(`Environment variable "${envName}" must be <= ${metadata.max}. Received "${rawValue}".`, { envName, propertyName });
-    }
-    return value;
-}
-function parseBooleanValue(args) {
-    const { envName, propertyName, rawValue } = args;
-    const normalized = rawValue.trim().toLowerCase();
-    if (isTruthyEnvValue(normalized))
-        return true;
-    if (isFalsyEnvValue(normalized))
-        return false;
-    throw new EnvParseError(`Environment variable "${envName}" must be a boolean. Received "${rawValue}".`, { envName, propertyName });
-}
-function isTruthyEnvValue(value) {
-    return value === 'true'
-        || value === '1'
-        || value === 'yes'
-        || value === 'y'
-        || value === 'on';
-}
-function isFalsyEnvValue(value) {
-    return value === 'false'
-        || value === '0'
-        || value === 'no'
-        || value === 'n'
-        || value === 'off';
-}
-function getDefaultEnvSource() {
-    var _a, _b;
-    const maybeGlobal = globalThis;
-    return (_b = (_a = maybeGlobal.process) === null || _a === void 0 ? void 0 : _a.env) !== null && _b !== void 0 ? _b : {};
-}
-function assertNever(value) {
-    throw new EnvParseError(`Unsupported env metadata: ${JSON.stringify(value)}`);
-}
-const defaultEnvSystem = createEnvSystem();
-exports.envRegistry = defaultEnvSystem.registry;
-exports.Env = defaultEnvSystem.Env;
-exports.EnvConfig = defaultEnvSystem.EnvConfig;
-exports.EnvVar = defaultEnvSystem.EnvVar;
-exports.loadEnv = defaultEnvSystem.loadEnv;
-exports.describeEnv = defaultEnvSystem.describeEnv;
+exports.EnvParseError = exports.readDotenvFiles = exports.DEFAULT_DOTENV_PATH = exports.toEnvKey = exports.parseEnvValue = exports.loadEnv = exports.EnvVar = exports.envRegistry = exports.EnvConfig = exports.Env = exports.describeEnv = exports.getEnvConfigMetadata = exports.createEnvSystem = void 0;
+var system_1 = require("./system");
+Object.defineProperty(exports, "createEnvSystem", { enumerable: true, get: function () { return system_1.createEnvSystem; } });
+Object.defineProperty(exports, "getEnvConfigMetadata", { enumerable: true, get: function () { return system_1.getEnvConfigMetadata; } });
+var defaultSystem_1 = require("./defaultSystem");
+Object.defineProperty(exports, "describeEnv", { enumerable: true, get: function () { return defaultSystem_1.describeEnv; } });
+Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return defaultSystem_1.Env; } });
+Object.defineProperty(exports, "EnvConfig", { enumerable: true, get: function () { return defaultSystem_1.EnvConfig; } });
+Object.defineProperty(exports, "envRegistry", { enumerable: true, get: function () { return defaultSystem_1.envRegistry; } });
+Object.defineProperty(exports, "EnvVar", { enumerable: true, get: function () { return defaultSystem_1.EnvVar; } });
+Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return defaultSystem_1.loadEnv; } });
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "parseEnvValue", { enumerable: true, get: function () { return parse_1.parseEnvValue; } });
+Object.defineProperty(exports, "toEnvKey", { enumerable: true, get: function () { return parse_1.toEnvKey; } });
+var dotenv_1 = require("./dotenv");
+Object.defineProperty(exports, "DEFAULT_DOTENV_PATH", { enumerable: true, get: function () { return dotenv_1.DEFAULT_DOTENV_PATH; } });
+Object.defineProperty(exports, "readDotenvFiles", { enumerable: true, get: function () { return dotenv_1.readDotenvFiles; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "EnvParseError", { enumerable: true, get: function () { return errors_1.EnvParseError; } });

package/build/decorators/environment/parse.d.ts

@@ -0,0 +1,9 @@
+import type { EnvPrimitiveOrUndefined, EnvVarMetadata } from './types';
+export declare function toEnvKey(propertyName: string): string;
+export declare function parseEnvValue(args: {
+    envName: string;
+    propertyName: string;
+    rawValue: string | undefined;
+    metadata: EnvVarMetadata;
+    emptyStringAsMissing: boolean;
+}): EnvPrimitiveOrUndefined;