@e-n-v/env 0.0.2 → 0.0.5

package/dist/src-meUnCASg.cjs

@@ -0,0 +1,413 @@
+
+//#region ../core/src/schemas/EnvVarSchemaBase.ts
+var EnvVarSchemaBase = class {
+	required;
+	default;
+	description;
+	process;
+	constructor(input) {
+		this.required = input?.required ?? true;
+		this.default = input?.default;
+		this.description = input?.description;
+		this.process = input.process;
+	}
+};
+
+//#endregion
+//#region ../core/src/processing/helpers/toList.ts
+/**
+* Convert array of items to natural language list.
+* Examples:
+* - [] => ""
+* - ["one"] => "one"
+* - ["one", "two"] => "one and two"
+* - ["one", "two", "three"] => "one, two, and three"
+*/
+function toList(items) {
+	if (items.length === 0) return "";
+	if (items.length === 1) return items[0];
+	if (items.length === 2) return `${items[0]} and ${items[1]}`;
+	return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+//#endregion
+//#region ../core/src/processing/helpers/validate.ts
+/**
+* Run checks and aggregate errors.
+* Throws an error with all validation requirements if any check fails.
+*/
+function validate(value, checks) {
+	const allRequirements = checks.map((check) => check(value)).flat();
+	if (allRequirements.length > 0) {
+		const message = toList(allRequirements);
+		throw new Error(`Must be ${message}`);
+	}
+	return value;
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/string.ts
+/**
+* String processor with optional validation checks.
+* This is the primary string processor - the base stringProcessor() calls this with no checks.
+*/
+function string$1(...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		if (input === "") return;
+		if (checks.length > 0) return validate(input, checks);
+		return input;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/number.ts
+/**
+* Number processor with optional validation checks.
+* This is the primary number processor - the base numberProcessor() calls this with no checks.
+*/
+function number$1(...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim();
+		if (trimmed === "") return;
+		const parsed = parseFloat(trimmed);
+		if (isNaN(parsed)) throw new Error(`"${input}" is not a valid number`);
+		if (checks.length > 0) return validate(parsed, checks);
+		return parsed;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/constants/FALSE_STRINGS.ts
+const FALSE_STRINGS = [
+	"false",
+	"0",
+	"no",
+	"off"
+];
+
+//#endregion
+//#region ../core/src/processing/constants/TRUE_STRINGS.ts
+const TRUE_STRINGS = [
+	"true",
+	"1",
+	"yes",
+	"on"
+];
+
+//#endregion
+//#region ../core/src/processing/processors/typed/boolean.ts
+/**
+* Boolean processor.
+* This is the primary boolean processor - the base booleanProcessor() calls this.
+*/
+function boolean$1() {
+	const trueValues = new Set(TRUE_STRINGS);
+	const falseValues = new Set(FALSE_STRINGS);
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim().toLowerCase();
+		if (trimmed === "") return;
+		if (trueValues.has(trimmed)) return true;
+		if (falseValues.has(trimmed)) return false;
+		const trueList = [...TRUE_STRINGS].join("/");
+		const falseList = [...FALSE_STRINGS].join("/");
+		throw new Error(`"${input}" is not a valid boolean. Use: ${trueList} or ${falseList}`);
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/enumeration.ts
+/**
+* Enum processor with optional validation checks.
+* This is the primary enum processor - the base enumProcessor() calls this with no checks.
+*/
+function enumeration$1(allowedValues, ...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim();
+		if (trimmed === "") return;
+		if (!allowedValues.includes(trimmed)) throw new Error(`"${input}" is not a valid option. Must be one of: ${allowedValues.join(", ")}`);
+		if (checks.length > 0) return validate(trimmed, checks);
+		return trimmed;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/processors.ts
+/**
+* Default processors for environment variable types.
+* Each processor factory returns a function that takes a value and returns T | undefined.
+* Returns undefined for empty/null values, throws descriptive errors for invalid values.
+*/
+const processors = {
+	boolean: boolean$1,
+	enum: enumeration$1,
+	number: number$1,
+	string: string$1
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/BooleanEnvVarSchema.ts
+var BooleanEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "boolean";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.boolean()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/EnumEnvVarSchema.ts
+var EnumEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "enum";
+	values;
+	constructor(input) {
+		super({
+			...input,
+			process: input.process ?? processors.enum(input.values)
+		});
+		this.values = input.values;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/NumberEnvVarSchema.ts
+var NumberEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "number";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.number()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/StringEnvVarSchema.ts
+var StringEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "string";
+	secret;
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.string()
+		});
+		this.secret = input.secret;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/EnvVarSchema.ts
+/**
+* Type guard to check if a value is a EnvVarSchema instance
+*/
+function isEnvVarSchema(value) {
+	return value instanceof StringEnvVarSchema || value instanceof NumberEnvVarSchema || value instanceof BooleanEnvVarSchema || value instanceof EnumEnvVarSchema;
+}
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/number.ts
+/**
+* Create a number preprocessor that strips commas and whitespace
+*/
+const number = () => (value) => {
+	try {
+		const cleaned = value.replace(/,/g, "").trim();
+		if (/^-?\d*\.?\d+$/.test(cleaned)) return cleaned;
+	} catch {}
+	return value;
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/boolean.ts
+const boolean = (options = {
+	true: TRUE_STRINGS,
+	false: FALSE_STRINGS
+}) => {
+	const normalize = (candidate) => candidate.toLowerCase().trim();
+	const trueValues = new Set(options.true.map(normalize));
+	const falseValues = new Set(options.false.map(normalize));
+	for (const candidate of trueValues) if (falseValues.has(candidate)) throw new Error(`Boolean preprocessor option value "${candidate}" cannot map to both true and false`);
+	return (value) => {
+		try {
+			const cleaned = normalize(value);
+			if (trueValues.has(cleaned)) return true;
+			if (falseValues.has(cleaned)) return false;
+		} catch {}
+		return value;
+	};
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/enumeration.ts
+/**
+* Create an enum preprocessor - pass through unchanged
+*/
+const enumeration = () => (value) => value;
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/string.ts
+/**
+* Create a string preprocessor - pass through unchanged
+*/
+const string = () => (value) => value;
+
+//#endregion
+//#region ../core/src/processing/preprocessors/preprocessors.ts
+/**
+* Default preprocessors map for each environment variable type
+*/
+const preprocessors = {
+	boolean,
+	enum: enumeration,
+	number,
+	string
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/resolvePreprocessor.ts
+const defaultFactories = {
+	number: preprocessors.number,
+	boolean: preprocessors.boolean,
+	string: void 0,
+	enum: void 0
+};
+const explicitFactories = {
+	number: preprocessors.number,
+	boolean: preprocessors.boolean,
+	string: preprocessors.string,
+	enum: preprocessors.enum
+};
+/**
+* Resolve the effective preprocessor for a given environment variable type.
+* Respects custom overrides and falls back to built-in defaults (number, boolean).
+*/
+function resolvePreprocessor(envVarType, preprocessorOptions) {
+	const override = preprocessorOptions?.[envVarType];
+	if (override === void 0) {
+		const factory = defaultFactories[envVarType];
+		return factory ? factory() : void 0;
+	}
+	if (override === false) return;
+	if (override === true) return explicitFactories[envVarType]();
+	if (typeof override === "function") return override;
+	return preprocessors.boolean(override);
+}
+
+//#endregion
+//#region ../core/src/schemas/schema.ts
+const schema = {
+	string: (input = {}) => new StringEnvVarSchema(input),
+	number: (input = {}) => new NumberEnvVarSchema(input),
+	boolean: (input = {}) => new BooleanEnvVarSchema(input),
+	enum: (input) => new EnumEnvVarSchema(input)
+};
+const s = schema;
+
+//#endregion
+Object.defineProperty(exports, 'BooleanEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return BooleanEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'EnumEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return EnumEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'EnvVarSchemaBase', {
+  enumerable: true,
+  get: function () {
+    return EnvVarSchemaBase;
+  }
+});
+Object.defineProperty(exports, 'NumberEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return NumberEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'StringEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return StringEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'boolean', {
+  enumerable: true,
+  get: function () {
+    return boolean$1;
+  }
+});
+Object.defineProperty(exports, 'enumeration', {
+  enumerable: true,
+  get: function () {
+    return enumeration$1;
+  }
+});
+Object.defineProperty(exports, 'isEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return isEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'number', {
+  enumerable: true,
+  get: function () {
+    return number$1;
+  }
+});
+Object.defineProperty(exports, 'preprocessors', {
+  enumerable: true,
+  get: function () {
+    return preprocessors;
+  }
+});
+Object.defineProperty(exports, 'processors', {
+  enumerable: true,
+  get: function () {
+    return processors;
+  }
+});
+Object.defineProperty(exports, 'resolvePreprocessor', {
+  enumerable: true,
+  get: function () {
+    return resolvePreprocessor;
+  }
+});
+Object.defineProperty(exports, 's', {
+  enumerable: true,
+  get: function () {
+    return s;
+  }
+});
+Object.defineProperty(exports, 'schema', {
+  enumerable: true,
+  get: function () {
+    return schema;
+  }
+});
+Object.defineProperty(exports, 'string', {
+  enumerable: true,
+  get: function () {
+    return string$1;
+  }
+});
+Object.defineProperty(exports, 'toList', {
+  enumerable: true,
+  get: function () {
+    return toList;
+  }
+});
+Object.defineProperty(exports, 'validate', {
+  enumerable: true,
+  get: function () {
+    return validate;
+  }
+});

package/dist/validate-BxA3a-ns.d.cts

@@ -0,0 +1,203 @@
+import { d as EnvVarType, f as Processor } from "./StringEnvVarSchema-BF6C0nyT.cjs";
+import { n as Preprocessor, t as BooleanMap } from "./BooleanMap-B2eIP3tZ.cjs";
+
+//#region ../core/src/schemas/EnvVarSchemaDetails.d.ts
+interface EnvVarSchemaDetails<T> {
+  type: EnvVarType;
+  required: boolean;
+  default?: T;
+  description?: string;
+  process?: Processor<T>;
+}
+//#endregion
+//#region ../core/src/processing/types/Check.d.ts
+/**
+ * Check type definition.
+ * A check returns an array of requirement strings if the check fails, or an empty array if valid.
+ */
+type Check<T> = (value: T) => string[];
+//#endregion
+//#region ../core/src/processing/processors/typed/string.d.ts
+/**
+ * String processor with optional validation checks.
+ * This is the primary string processor - the base stringProcessor() calls this with no checks.
+ */
+declare function string(...checks: Array<Check<string>>): Processor<string>;
+//#endregion
+//#region ../core/src/processing/processors/typed/number.d.ts
+/**
+ * Number processor with optional validation checks.
+ * This is the primary number processor - the base numberProcessor() calls this with no checks.
+ */
+declare function number(...checks: Array<Check<number>>): Processor<number>;
+//#endregion
+//#region ../core/src/processing/processors/typed/boolean.d.ts
+/**
+ * Boolean processor.
+ * This is the primary boolean processor - the base booleanProcessor() calls this.
+ */
+declare function boolean(): Processor<boolean>;
+//#endregion
+//#region ../core/src/processing/processors/typed/enumeration.d.ts
+/**
+ * Enum processor with optional validation checks.
+ * This is the primary enum processor - the base enumProcessor() calls this with no checks.
+ */
+declare function enumeration(allowedValues: readonly string[], ...checks: Array<Check<string>>): Processor<string>;
+//#endregion
+//#region ../core/src/processing/processors/processors.d.ts
+/**
+ * Default processors for environment variable types.
+ * Each processor factory returns a function that takes a value and returns T | undefined.
+ * Returns undefined for empty/null values, throws descriptive errors for invalid values.
+ */
+declare const processors: {
+  readonly boolean: typeof boolean;
+  readonly enum: typeof enumeration;
+  readonly number: typeof number;
+  readonly string: typeof string;
+};
+//#endregion
+//#region ../core/src/processing/preprocessors/preprocessors.d.ts
+/**
+ * Default preprocessors map for each environment variable type
+ */
+declare const preprocessors: {
+  readonly boolean: (options?: BooleanMap) => Preprocessor<boolean>;
+  readonly enum: () => Preprocessor<string>;
+  readonly number: () => Preprocessor<number>;
+  readonly string: () => Preprocessor<string>;
+};
+//#endregion
+//#region ../core/src/processing/options/PreprocessorOptions.d.ts
+type PreprocessorOptions = Partial<{
+  /**
+   * Custom string preprocessing function
+   * Receives the string value and should return a string value
+   * @param value - The raw string value from the environment variable
+   * @returns Preprocessed string value
+   */
+  string?: Preprocessor<string> | boolean;
+  /**
+   * Custom number preprocessing function
+   * Receives the string value and should return a string or the target number type
+   * @param value - The raw string value from the environment variable
+   * @returns Preprocessed string or number value
+   */
+  number?: Preprocessor<number> | boolean;
+  /**
+   * Custom boolean preprocessing function
+   * Receives the string value and should return a string or the target boolean type
+   * @param value - The raw string value from the environment variable
+   * @returns Preprocessed string or boolean value
+   */
+  boolean?: boolean | Preprocessor<boolean> | BooleanMap;
+  /**
+   * Custom enum preprocessing function
+   * Receives the string value and should return a string value
+   * @param value - The raw string value from the environment variable
+   * @returns Preprocessed string value
+   */
+  enum?: Preprocessor<string> | boolean;
+}>;
+//#endregion
+//#region ../core/src/processing/preprocessors/resolvePreprocessor.d.ts
+type DefaultPreprocessor<T extends EnvVarType> = T extends "number" ? Preprocessor<number> : T extends "boolean" ? Preprocessor<boolean> : Preprocessor<string>;
+/**
+ * Resolve the effective preprocessor for a given environment variable type.
+ * Respects custom overrides and falls back to built-in defaults (number, boolean).
+ */
+declare function resolvePreprocessor<T extends EnvVarType>(envVarType: T, preprocessorOptions?: PreprocessorOptions): DefaultPreprocessor<T> | undefined;
+//#endregion
+//#region ../core/src/processing/checks/minLength.d.ts
+/**
+ * String check: minimum length.
+ */
+declare function minLength(min: number, trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/maxLength.d.ts
+/**
+ * String check: maximum length.
+ */
+declare function maxLength(max: number, trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/lengthBetween.d.ts
+/**
+ * String check: length within a range.
+ */
+declare function lengthBetween(min: number, max: number, trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/exactLength.d.ts
+/**
+ * String check: exact length.
+ */
+declare function exactLength(length: number, trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/pattern.d.ts
+/**
+ * String check: regex pattern match.
+ */
+declare function pattern(regex: RegExp, trait: string | readonly string[]): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/url.d.ts
+/**
+ * String check: valid URL.
+ */
+declare function url(trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/oneOf.d.ts
+/**
+ * String check: value must be one of the provided values.
+ */
+declare function oneOf<T extends string>(values: readonly T[], trait?: string): Check<string>;
+//#endregion
+//#region ../core/src/processing/checks/integer.d.ts
+/**
+ * Number check: must be an integer.
+ */
+declare function integer(trait?: string): Check<number>;
+//#endregion
+//#region ../core/src/processing/checks/min.d.ts
+/**
+ * Number check: minimum value.
+ */
+declare function min(minimum: number, trait?: string): Check<number>;
+//#endregion
+//#region ../core/src/processing/checks/max.d.ts
+/**
+ * Number check: maximum value.
+ */
+declare function max(maximum: number, trait?: string): Check<number>;
+//#endregion
+//#region ../core/src/processing/checks/between.d.ts
+/**
+ * Number check: value within a range.
+ */
+declare function between(minimum: number, maximum: number, trait?: string): Check<number>;
+//#endregion
+//#region ../core/src/processing/checks/custom.d.ts
+/**
+ * Custom check with user-defined validation function.
+ * Can return multiple traits.
+ */
+declare function custom<T>(fn: (value: T) => boolean, ...traits: string[]): Check<T>;
+//#endregion
+//#region ../core/src/processing/helpers/toList.d.ts
+/**
+ * Convert array of items to natural language list.
+ * Examples:
+ * - [] => ""
+ * - ["one"] => "one"
+ * - ["one", "two"] => "one and two"
+ * - ["one", "two", "three"] => "one, two, and three"
+ */
+declare function toList(items: string[]): string;
+//#endregion
+//#region ../core/src/processing/helpers/validate.d.ts
+/**
+ * Run checks and aggregate errors.
+ * Throws an error with all validation requirements if any check fails.
+ */
+declare function validate<T>(value: T, checks: Array<Check<T>>): T;
+//#endregion
+export { Check as C, string as S, preprocessors as _, max as a, boolean as b, oneOf as c, exactLength as d, lengthBetween as f, PreprocessorOptions as g, resolvePreprocessor as h, between as i, url as l, minLength as m, toList as n, min as o, maxLength as p, custom as r, integer as s, validate as t, pattern as u, processors as v, EnvVarSchemaDetails as w, number as x, enumeration as y };