molex-env 0.3.2 → 0.3.3

package/src/lib/cast.js

@@ -1,124 +1,133 @@
-'use strict';
-
-const { invalidTypeError } = require('./errors');
-
-/**
- * Normalize cast options into explicit booleans.
- * @param {boolean|{boolean?: boolean, number?: boolean, json?: boolean, date?: boolean}} cast
- * @returns {{boolean: boolean, number: boolean, json: boolean, date: boolean}}
- */
-function normalizeCast(cast)
-{
-    if (cast === true || cast === undefined)
-    {
-        return { boolean: true, number: true, json: true, date: true };
-    }
-    if (cast === false)
-    {
-        return { boolean: false, number: false, json: false, date: false };
-    }
-    return {
-        boolean: cast.boolean !== false,
-        number: cast.number !== false,
-        json: cast.json !== false,
-        date: cast.date !== false
-    };
-}
-
-/**
- * Check if a string is a number.
- * @param {string} value
- * @returns {boolean}
- */
-function isNumber(value)
-{
-    return /^-?\d+(\.\d+)?$/.test(value);
-}
-
-/**
- * Check if a string looks like an ISO date.
- * @param {string} value
- * @returns {boolean}
- */
-function isIsoDate(value)
-{
-    return /^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$/.test(value);
-}
-
-/**
- * Coerce a raw string to the requested type.
- * @param {string} raw
- * @param {string} type
- * @param {string} file
- * @param {number} line
- * @returns {any}
- */
-function coerceType(raw, type, file, line)
-{
-    if (type === 'string') return raw;
-    if (type === 'boolean')
-    {
-        if (raw.toLowerCase() === 'true') return true;
-        if (raw.toLowerCase() === 'false') return false;
-        throw invalidTypeError('boolean', raw, file, line);
-    }
-    if (type === 'number')
-    {
-        if (!isNumber(raw)) throw invalidTypeError('number', raw, file, line);
-        return Number(raw);
-    }
-    if (type === 'json')
-    {
-        return JSON.parse(raw);
-    }
-    if (type === 'date')
-    {
-        const date = new Date(raw);
-        if (Number.isNaN(date.getTime())) throw invalidTypeError('date', raw, file, line);
-        return date;
-    }
-    return raw;
-}
-
-/**
- * Auto-cast a raw string based on enabled rules.
- * @param {string} raw
- * @param {{boolean: boolean, number: boolean, json: boolean, date: boolean}} cast
- * @returns {any}
- */
-function autoCast(raw, cast)
-{
-    const trimmed = raw.trim();
-    if (cast.boolean)
-    {
-        const lower = trimmed.toLowerCase();
-        if (lower === 'true') return true;
-        if (lower === 'false') return false;
-    }
-    if (cast.number && isNumber(trimmed))
-    {
-        return Number(trimmed);
-    }
-    if (cast.json && (trimmed.startsWith('{') || trimmed.startsWith('[')))
-    {
-        try
-        {
-            return JSON.parse(trimmed);
-        } catch (err)
-        {
-            return trimmed;
-        }
-    }
-    if (cast.date && isIsoDate(trimmed))
-    {
-        const date = new Date(trimmed);
-        if (!Number.isNaN(date.getTime())) return date;
-    }
-    return trimmed;
-}
-
-module.exports = {
-    normalizeCast,
-    coerceType,
-    autoCast
-};
+'use strict';
+
+const { invalidTypeError } = require('./errors');
+
+/* ------------------------------------------------------------------ */
+/*  Constants                                                         */
+/* ------------------------------------------------------------------ */
+
+const CAST_ALL_ON = { boolean: true, number: true, json: true, date: true };
+const CAST_ALL_OFF = { boolean: false, number: false, json: false, date: false };
+const NUMBER_RE = /^-?\d+(\.\d+)?$/;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$/;
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                           */
+/* ------------------------------------------------------------------ */
+
+/** @returns {boolean} */
+function isNumber(value)
+{
+    return NUMBER_RE.test(value);
+}
+
+/** @returns {boolean} */
+function isIsoDate(value)
+{
+    return ISO_DATE_RE.test(value);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Public API                                                        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Normalize cast options into explicit booleans.
+ * @param {boolean|{boolean?: boolean, number?: boolean, json?: boolean, date?: boolean}} cast
+ * @returns {{boolean: boolean, number: boolean, json: boolean, date: boolean}}
+ */
+function normalizeCast(cast)
+{
+    if (cast === true || cast === undefined) return { ...CAST_ALL_ON };
+    if (cast === false) return { ...CAST_ALL_OFF };
+    return {
+        boolean: cast.boolean !== false,
+        number: cast.number !== false,
+        json: cast.json !== false,
+        date: cast.date !== false,
+    };
+}
+
+/**
+ * Coerce a raw string to the requested schema type.
+ * @param {string} raw
+ * @param {string} type
+ * @param {string} file
+ * @param {number} line
+ * @returns {any}
+ */
+function coerceType(raw, type, file, line)
+{
+    switch (type)
+    {
+        case 'string':
+            return raw;
+
+        case 'boolean': {
+            const lower = raw.toLowerCase();
+            if (lower === 'true') return true;
+            if (lower === 'false') return false;
+            throw invalidTypeError('boolean', raw, file, line);
+        }
+
+        case 'number':
+            if (!isNumber(raw)) throw invalidTypeError('number', raw, file, line);
+            return Number(raw);
+
+        case 'json':
+            return JSON.parse(raw);
+
+        case 'date': {
+            const date = new Date(raw);
+            if (Number.isNaN(date.getTime())) throw invalidTypeError('date', raw, file, line);
+            return date;
+        }
+
+        default:
+            return raw;
+    }
+}
+
+/**
+ * Auto-cast a raw string based on enabled casting rules.
+ * @param {string} raw
+ * @param {{boolean: boolean, number: boolean, json: boolean, date: boolean}} cast
+ * @returns {any}
+ */
+function autoCast(raw, cast)
+{
+    const trimmed = raw.trim();
+
+    if (cast.boolean)
+    {
+        const lower = trimmed.toLowerCase();
+        if (lower === 'true') return true;
+        if (lower === 'false') return false;
+    }
+
+    if (cast.number && isNumber(trimmed))
+    {
+        return Number(trimmed);
+    }
+
+    if (cast.json && (trimmed.startsWith('{') || trimmed.startsWith('[')))
+    {
+        try
+        {
+            return JSON.parse(trimmed);
+        } catch (_err)
+        {
+            return trimmed;
+        }
+    }
+
+    if (cast.date && isIsoDate(trimmed))
+    {
+        const date = new Date(trimmed);
+        if (!Number.isNaN(date.getTime())) return date;
+    }
+
+    return trimmed;
+}
+
+module.exports = { normalizeCast, coerceType, autoCast };

package/src/lib/core.js

@@ -1,148 +1,161 @@
-'use strict';
-
-const fs = require('fs');
-
-const { normalizeCast } = require('./cast');
-const { normalizeSchema, applySchemaDefaults } = require('./schema');
-const { parseEntries } = require('./parser');
-const { applyEntry } = require('./apply');
-const { resolveFiles } = require('./files');
-const { deepFreeze } = require('./utils');
-
-/**
- * Build a new parsing state container.
- * @returns {{values: object, origins: object, seenPerFile: Map<string, Set<string>>}}
- */
-function buildState()
-{
-    return {
-        values: {},
-        origins: {},
-        seenPerFile: new Map()
-    };
-}
-
-/**
- * Export parsed values to process.env if enabled.
- * @param {object} values
- * @param {object} options
- * @returns {void}
- */
-function exportToEnv(values, options)
-{
-    if (!options.exportEnv) return;
-    for (const [key, value] of Object.entries(values))
-    {
-        if (!options.override && Object.prototype.hasOwnProperty.call(process.env, key))
-        {
-            continue;
-        }
-        process.env[key] = value === undefined ? '' : String(value);
-    }
-}
-
-/**
- * Attach parsed values to process.menv unless disabled.
- * @param {object} values
- * @param {object} options
- * @returns {void}
- */
-function attachToProcess(values, options)
-{
-    if (options.attach === false) return;
-    process.menv = values;
-}
-
-/**
- * Load .menv files and return parsed values with origins.
- * @param {object} options
- * @returns {{parsed: object, origins: object, files: string[]}}
- */
-function load(options = {})
-{
-    const normalizedSchema = normalizeSchema(options.schema);
-    const cast = normalizeCast(options.cast);
-    const strict = Boolean(options.strict);
-
-    const state = buildState();
-    const files = resolveFiles(options);
-    const readFiles = [];
-
-    for (const filePath of files)
-    {
-        if (!fs.existsSync(filePath)) continue;
-        const text = fs.readFileSync(filePath, 'utf8');
-        const entries = parseEntries(text, { strict, filePath });
-        for (const entry of entries)
-        {
-            applyEntry(state, entry, {
-                schema: normalizedSchema,
-                strict,
-                cast,
-                onWarning: options.onWarning,
-                debug: options.debug
-            }, filePath);
-        }
-        readFiles.push(filePath);
-    }
-
-    applySchemaDefaults(state.values, state.origins, normalizedSchema, strict);
-    exportToEnv(state.values, options);
-
-    if (options.freeze !== false)
-    {
-        deepFreeze(state.values);
-    }
-
-    attachToProcess(state.values, options);
-
-    return {
-        parsed: state.values,
-        origins: state.origins,
-        files: readFiles
-    };
-}
-
-/**
- * Parse a string containing .menv content.
- * @param {string} text
- * @param {object} options
- * @returns {{parsed: object, origins: object, files: string[]}}
- */
-function parse(text, options = {})
-{
-    const normalizedSchema = normalizeSchema(options.schema);
-    const cast = normalizeCast(options.cast);
-    const strict = Boolean(options.strict);
-    const state = buildState();
-    const filePath = options.filePath || '<inline>';
-
-    const entries = parseEntries(text, { strict, filePath });
-    for (const entry of entries)
-    {
-        applyEntry(state, entry, {
-            schema: normalizedSchema,
-            strict,
-            cast,
-            onWarning: options.onWarning
-        }, filePath);
-    }
-
-    applySchemaDefaults(state.values, state.origins, normalizedSchema, strict);
-
-    if (options.freeze !== false)
-    {
-        deepFreeze(state.values);
-    }
-
-    return {
-        parsed: state.values,
-        origins: state.origins,
-        files: options.filePath ? [options.filePath] : []
-    };
-}
-
-module.exports = {
-    load,
-    parse
-};
+'use strict';
+
+const fs = require('fs');
+
+const { normalizeCast } = require('./cast');
+const { normalizeSchema, applySchemaDefaults } = require('./schema');
+const { parseEntries } = require('./parser');
+const { applyEntry } = require('./apply');
+const { resolveFiles } = require('./files');
+const { deepFreeze } = require('./utils');
+
+/* ------------------------------------------------------------------ */
+/*  Internal helpers (shared pipeline)                                 */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Create a fresh processing state container.
+ * @returns {{values: object, raw: object, origins: object, seenPerFile: Map}}
+ */
+function createState()
+{
+    return {
+        values: {},
+        raw: {},
+        origins: {},
+        seenPerFile: new Map(),
+    };
+}
+
+/**
+ * Normalize user options into a consistent internal format.
+ * @param {object} options - Raw user options.
+ * @returns {object} Normalized processing options.
+ */
+function normalizeOptions(options)
+{
+    return {
+        schema: normalizeSchema(options.schema),
+        cast: normalizeCast(options.cast),
+        strict: Boolean(options.strict),
+        freeze: options.freeze !== false,
+        onWarning: options.onWarning,
+        debug: options.debug,
+    };
+}
+
+/**
+ * Process a block of .menv text into the state.
+ * @param {object} state
+ * @param {string} text
+ * @param {string} filePath
+ * @param {object} opts - Normalized options.
+ */
+function processText(state, text, filePath, opts)
+{
+    const entries = parseEntries(text, { strict: opts.strict, filePath });
+    for (const entry of entries)
+    {
+        applyEntry(state, entry, opts, filePath);
+    }
+}
+
+/**
+ * Apply schema defaults and optionally deep-freeze the result.
+ * @param {object} state
+ * @param {object} opts - Normalized options.
+ */
+function finalizeState(state, opts)
+{
+    applySchemaDefaults(state.values, state.origins, opts.schema, opts.strict);
+    if (opts.freeze) deepFreeze(state.values);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Side-effect helpers                                                */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Write parsed values to process.env when enabled.
+ * @param {object} values
+ * @param {object} options - Raw user options.
+ */
+function exportToEnv(values, options)
+{
+    if (!options.exportEnv) return;
+    for (const [key, value] of Object.entries(values))
+    {
+        if (!options.override && Object.prototype.hasOwnProperty.call(process.env, key)) continue;
+        process.env[key] = value === undefined ? '' : String(value);
+    }
+}
+
+/**
+ * Attach parsed values to process.menv unless disabled.
+ * @param {object} values
+ * @param {object} options - Raw user options.
+ */
+function attachToProcess(values, options)
+{
+    if (options.attach !== false) process.menv = values;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Public API                                                         */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Load .menv files, merge, parse, and validate.
+ * @param {object} [options]
+ * @returns {{parsed: object, raw: object, origins: object, files: string[]}}
+ */
+function load(options = {})
+{
+    const opts = normalizeOptions(options);
+    const state = createState();
+    const filePaths = resolveFiles(options);
+    const readFiles = [];
+
+    for (const filePath of filePaths)
+    {
+        if (!fs.existsSync(filePath)) continue;
+        processText(state, fs.readFileSync(filePath, 'utf8'), filePath, opts);
+        readFiles.push(filePath);
+    }
+
+    finalizeState(state, opts);
+    exportToEnv(state.values, options);
+    attachToProcess(state.values, options);
+
+    return {
+        parsed: state.values,
+        raw: state.raw,
+        origins: state.origins,
+        files: readFiles,
+    };
+}
+
+/**
+ * Parse a string of .menv content without loading files.
+ * @param {string} text
+ * @param {object} [options]
+ * @returns {{parsed: object, raw: object, origins: object, files: string[]}}
+ */
+function parse(text, options = {})
+{
+    const opts = normalizeOptions(options);
+    const state = createState();
+    const filePath = options.filePath || '<inline>';
+
+    processText(state, text, filePath, opts);
+    finalizeState(state, opts);
+
+    return {
+        parsed: state.values,
+        raw: state.raw,
+        origins: state.origins,
+        files: options.filePath ? [options.filePath] : [],
+    };
+}
+
+module.exports = { load, parse };