@clementine-solutions/jane-io 1.0.1 → 1.0.2

package/dist/core/field-path/utilities.js

@@ -0,0 +1,138 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Utilities
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Small helper functions supporting FieldPath construction,
+ *                  parsing, and formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Dangerous Keys                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Keys that must never appear in dotted notation.
+ *
+ * These properties interact with JavaScript’s prototype chain and are always
+ * forced into bracket‑notation to prevent prototype‑pollution vectors in
+ * formatting, parsing, and boundary evaluation.
+ */
+export const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Escape Key                                                                *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Escapes a key for bracket notation.
+ *
+ * Uses JSON string rules to preserve all characters exactly, ensuring keys
+ * round‑trip cleanly through user‑facing formatting and parsing.
+ */
+export function escapeKey(key) {
+    return JSON.stringify(key);
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Dangerous Key                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether a key is unsafe for dotted notation.
+ *
+ * Identifies prototype‑chain properties that must always be emitted in
+ * bracket‑notation to avoid prototype‑pollution vectors.
+ */
+export function isDangerousKey(key) {
+    return DANGEROUS_KEYS.has(key);
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Root                                                                   *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether a FieldPath refers to the root.
+ *
+ * A path is the root when it contains no segments, representing the top‑level
+ * position in traversal, formatting, and boundary evaluation.
+ */
+export const isRoot = (path) => path.segments.length === 0;
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Is Safe Key                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether a key is safe for dotted notation.
+ *
+ * Rejects prototype‑chain properties and ensures the key matches JavaScript
+ * identifier rules, allowing it to appear unescaped in user‑facing paths.
+ */
+export function isSafeKey(key) {
+    if (DANGEROUS_KEYS.has(key))
+        return false;
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Last Segment                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Returns the final segment of a FieldPath.
+ *
+ * Useful when validators, scanners, or boundary logic need to inspect the
+ * current traversal position without mutating the path.
+ */
+export const lastSegment = (path) => path.segments[path.segments.length - 1];
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Parent Path                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Returns the parent of a FieldPath.
+ *
+ * Removes the final segment to move one level up in traversal. Root paths
+ * remain stable—slicing an empty path yields another empty path.
+ */
+export function parentPath(path) {
+    return { segments: path.segments.slice(0, -1) };
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Path Equals                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether two FieldPaths are structurally identical.
+ *
+ * Paths are equal only when they contain the same number of segments and each
+ * corresponding segment matches, ensuring deterministic behavior in diff,
+ * explain, and boundary evaluation.
+ */
+export function pathEquals(a, b) {
+    if (a.segments.length !== b.segments.length)
+        return false;
+    return a.segments.every((segment, i) => segmentsEqual(segment, b.segments[i]));
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Path Starts With                                                          *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether one FieldPath is a prefix of another.
+ *
+ * Path **a** starts with **b** when b has no more segments than a and each
+ * corresponding segment matches. Used by diff, explain, and boundary logic
+ * to determine whether a rule or change applies to a nested position.
+ */
+export function pathStartsWith(a, b) {
+    if (b.segments.length > a.segments.length)
+        return false;
+    return b.segments.every((segment, i) => segmentsEqual(segment, a.segments[i]));
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Segments Equal                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Checks whether two segments are structurally identical.
+ *
+ * Segments must share the same kind, and their key or index values must
+ * match exactly. This is the atomic comparison used by all path‑level
+ * equality and prefix checks.
+ */
+export const segmentsEqual = (a, b) => {
+    if (a.kind !== b.kind)
+        return false;
+    return a.kind === 'index'
+        ? a.index === b.index
+        : a.key === b.key;
+};

package/dist/core/field-path/walk.js

@@ -0,0 +1,80 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Walk
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Traversal helpers that walk JSON‑like data with FieldPath
+ *                  context.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { appendSegment, setIndex, setKey } from '../field-path';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Walk                                                                      *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Recursively walks a JSON‑like value with FieldPath context.
+ *
+ * Visits the current node, then descends into arrays and plain objects,
+ * constructing child paths segment‑by‑segment. Prototype‑chain keys are
+ * skipped to avoid unsafe traversal during validation, scanning, and
+ * boundary evaluation.
+ */
+export async function walk(value, path, visit) {
+    await visit(value, path);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const child = value[i];
+            const childPath = appendSegment(path, setIndex(i));
+            await walk(child, childPath, visit);
+        }
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        for (const key of Object.keys(record)) {
+            if (!Object.prototype.hasOwnProperty.call(record, key))
+                continue;
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+                continue;
+            const child = record[key];
+            const childPath = appendSegment(path, setKey(key));
+            await walk(child, childPath, visit);
+        }
+        return;
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Walk Array                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Visits each element of an array with FieldPath context.
+ *
+ * Emits a child path for every index and invokes the visitor without
+ * descending further. Used internally by higher‑level walkers that
+ * control recursion and traversal strategy.
+ */
+export async function walkArray(value, path, visit) {
+    for (let index = 0; index < value.length; index++) {
+        await visit(value[index], appendSegment(path, setIndex(index)));
+    }
+}
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Walk Object                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Visits each own property of an object with FieldPath context.
+ *
+ * Emits a child path for every safe key and invokes the visitor without
+ * descending further. Prototype‑chain keys are skipped to avoid unsafe
+ * traversal during validation, scanning, and boundary evaluation.
+ */
+export async function walkObject(value, path, visit) {
+    for (const [key, child] of Object.entries(value)) {
+        if (!Object.prototype.hasOwnProperty.call(value, key))
+            continue;
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
+        await visit(child, appendSegment(path, setKey(key)));
+    }
+}

package/dist/core/fluent-registry.js

@@ -0,0 +1,151 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Registry | Fluent
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Central registry of all built‑in validators and parsers.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Parsers                                                                   *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+import { parseArrayString, parseBigIntString, parseBinaryString, parseBooleanString, parseDurationString, parseHexString, parseIsoDateString, parseJsonString, parseNumericString, parseObjectString, parseOctalString, parseUrlString, } from './parsers';
+import { parseIntegerString } from './parsers/parse-integer-string';
+import { parseScientificNotationString } from './parsers/parse-scientific-notation-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Validators                                                                *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+import { alpha, alphaNum, array, arrayMaxItems, arrayMinItems, beforeEpoch, bigint, bigintEquals, bigintMax, bigintMin, bigintNegative, bigintNonNegative, bigintNonPositive, bigintPositive, bigintSafe, boolean, charsEqual, dateNowRequired, deepEquals, endsWith, excludes, finite, hasKey, hasUniqueItems, hasValue, includes, integer, isAscii, isCountryCode, isCurrencyCode, isDate, isEmail, isEmailStrict, isFalse, isFarFuture, isFuture, isIp, isNull, isNullOrUndefined, isPast, isPhone, isPhoneStrict, isPort, isPostalCode, isPrintable, isTrue, isUndefined, isUrl, isUuid, itemsEqual, keysEqual, lessThan, matches, max, maxLength, maxKeys, min, minLength, minKeys, missingKey, moreThan, negative, noEmptyArrayValues, noEmptyObjectValues, noEmptyStringItems, noNullItems, noNullValues, noUndefinedItems, noUndefinedValues, nonEmptyArray, nonEmptyObject, noLeadSpace, noRepeatSpace, noSpace, noTrailSpace, nonNegative, nonPositive, notAfter, notBefore, nonEmpty, notOneOf, notSparse, number, numString, oneOf, onlyKeys, plainObject, positive, safeInteger, sameDay, sameMonth, sameYear, startsWith, string, tooEarly, tooLate, trimmed, weekday, weekend, } from './validators';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Fluent API                                                                *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Central registry of all built‑in Jane validators and parsers.
+ *
+ * This object provides a single, authoritative lookup table for every
+ * first‑party rule Jane ships with. Validators define how values are checked
+ * for correctness, while parsers convert raw input into structured forms.
+ * Keeping them together in one immutable registry ensures predictable
+ * resolution, consistent behavior across subsystems, and a stable surface
+ * for contributors extending or inspecting Jane’s rule set.
+ */
+export const janeRegistry = {
+    validators: {
+        alphaNum,
+        alpha,
+        array,
+        arrayMinItems,
+        arrayMaxItems,
+        beforeEpoch,
+        bigint,
+        bigintEquals,
+        bigintMax,
+        bigintMin,
+        bigintNegative,
+        bigintNonNegative,
+        bigintNonPositive,
+        bigintPositive,
+        bigintSafe,
+        boolean,
+        charsEqual,
+        dateNowRequired,
+        deepEquals,
+        endsWith,
+        excludes,
+        finite,
+        hasKey,
+        hasUniqueItems,
+        hasValue,
+        includes,
+        integer,
+        isAscii,
+        isCountryCode,
+        isCurrencyCode,
+        isDate,
+        isEmail,
+        isEmailStrict,
+        isFalse,
+        isFarFuture,
+        isFuture,
+        isIp,
+        isPast,
+        isPhone,
+        isPhoneStrict,
+        isPort,
+        isPostalCode,
+        isPrintable,
+        isNull,
+        isNullOrUndefined,
+        isTrue,
+        isUrl,
+        isUndefined,
+        isUuid,
+        itemsEqual,
+        keysEqual,
+        lessThan,
+        matches,
+        max,
+        maxKeys,
+        maxLength,
+        min,
+        minKeys,
+        minLength,
+        missingKey,
+        moreThan,
+        negative,
+        noEmptyArrayValues,
+        noEmptyObjectValues,
+        noEmptyStringItems,
+        noLeadSpace,
+        noNullItems,
+        noNullValues,
+        noRepeatSpace,
+        noSpace,
+        noTrailSpace,
+        noUndefinedItems,
+        noUndefinedValues,
+        nonEmpty,
+        nonEmptyArray,
+        nonEmptyObject,
+        nonNegative,
+        nonPositive,
+        notAfter,
+        notBefore,
+        notOneOf,
+        notSparse,
+        number,
+        numString,
+        oneOf,
+        onlyKeys,
+        plainObject,
+        positive,
+        safeInteger,
+        sameDay,
+        sameMonth,
+        sameYear,
+        startsWith,
+        string,
+        tooEarly,
+        tooLate,
+        trimmed,
+        weekday,
+        weekend,
+    },
+    parsers: {
+        numeric: parseNumericString,
+        integer: parseIntegerString,
+        boolean: parseBooleanString,
+        bigint: parseBigIntString,
+        hex: parseHexString,
+        binary: parseBinaryString,
+        octal: parseOctalString,
+        date: parseIsoDateString,
+        json: parseJsonString,
+        array: parseArrayString,
+        object: parseObjectString,
+        url: parseUrlString,
+        duration: parseDurationString,
+        scientific: parseScientificNotationString,
+    },
+};

package/dist/core/normalizers/array/compact-sparse-array.js

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Compact Sparse Array
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes sparse array holes while preserving all defined
+ *                  elements, producing a dense structure without altering the
+ *                  array’s semantic content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Compacts sparse arrays by removing empty slots while preserving all defined
+ * elements. This targets only structural holes—never values—ensuring arrays
+ * become dense without altering their semantic content.
+ *
+ * Useful for normalizing inputs that originate from user interfaces, spread
+ * operations, or partial constructions where sparse positions may appear
+ * unintentionally.
+ */
+export const compactSparseArray = (value, _mode, path) => {
+    if (!Array.isArray(value))
+        return [];
+    const compacted = value.filter(() => true); // removes holes only
+    if (compacted.length === value.length)
+        return [];
+    const event = normalizationEvent('info', 'array.now.compacted', path, 'Removed sparse array holes.', 'Empty array slots were removed.', { before: value, after: compacted });
+    return [
+        {
+            path,
+            nextValue: compacted,
+            lossy: 'lossless',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/array/flatten-one-level.js

@@ -0,0 +1,45 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes empty string entries from arrays, eliminating
+ *                  placeholder or accidental text values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Flattens nested arrays by a single level, simplifying structure while
+ * preserving item order. Useful for normalizing inputs where shallow nesting
+ * appears unintentionally.
+ */
+export const flattenOneLevel = (value, _mode, path) => {
+    if (!Array.isArray(value))
+        return [];
+    let changed = false;
+    const flattened = [];
+    for (const item of value) {
+        if (Array.isArray(item)) {
+            changed = true;
+            flattened.push(...item);
+        }
+        else {
+            flattened.push(item);
+        }
+    }
+    if (!changed)
+        return [];
+    const event = normalizationEvent('info', 'array.now.flattened', path, 'Flattened nested arrays by one level.', 'Nested items were simplified.', { before: value, after: flattened });
+    return [
+        {
+            path,
+            nextValue: flattened,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/array/remove-empty-string-items.js

@@ -0,0 +1,34 @@
+/*/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes empty string entries from arrays, eliminating
+ *                  placeholder or accidental text values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes empty string entries from arrays, eliminating placeholder or
+ * accidental text values while preserving all meaningful items.
+ */
+export const removeEmptyStringItems = (value, _mode, path) => {
+    if (!Array.isArray(value))
+        return [];
+    const filtered = value.filter((v) => v !== '');
+    if (filtered.length === value.length)
+        return [];
+    const event = normalizationEvent('info', 'array.without.empty-strings', path, 'Removed empty string items from array.', 'Empty text items were removed.', { before: value, after: filtered });
+    return [
+        {
+            path,
+            nextValue: filtered,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/array/remove-null-items.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Null Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Filters out null entries from arrays, removing structurally
+ *                  empty items while preserving all defined values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Filters out null entries from arrays, removing structurally empty items
+ * without altering the order or meaning of defined values.
+ */
+export const removeNullItems = (value, _mode, path) => {
+    if (!Array.isArray(value))
+        return [];
+    const filtered = value.filter((v) => v !== null);
+    if (filtered.length === value.length)
+        return [];
+    const event = normalizationEvent('info', 'array.without.null-items', path, 'Removed null items from array.', 'Empty items were removed.', { before: value, after: filtered });
+    return [
+        {
+            path,
+            nextValue: filtered,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/array/remove-undefined-items.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Undefined Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes undefined entries from arrays, producing a cleaner
+ *                  and more predictable sequence of defined values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes undefined entries from arrays, producing a cleaner and more
+ * predictable sequence of defined values.
+ */
+export const removeUndefinedItems = (value, _mode, path) => {
+    if (!Array.isArray(value))
+        return [];
+    const filtered = value.filter((v) => v !== undefined);
+    if (filtered.length === value.length)
+        return [];
+    const event = normalizationEvent('info', 'array.without.undefined-items', path, 'Removed undefined items from array.', 'Empty items were removed.', { before: value, after: filtered });
+    return [
+        {
+            path,
+            nextValue: filtered,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/date/invalid-date-to-undefined.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Invalid Date To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts invalid Date instances (timestamp NaN) to undefined,
+ *                  preventing malformed or unparsable date values from
+ *                  propagating through normalization.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts invalid Date instances (timestamp NaN) to undefined, ensuring that
+ * malformed or unparsable date values do not propagate through normalization.
+ */
+export const invalidDateToUndefined = (value, _mode, path) => {
+    if (!(value instanceof Date))
+        return [];
+    // Invalid Date → timestamp is NaN
+    if (!Number.isNaN(value.getTime()))
+        return [];
+    const event = normalizationEvent('info', 'date.now.undefined', path, 'Converted an invalid Date instance to undefined.', 'Invalid date values were removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/index.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Normalizers | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all normalization rules, providing a single,
+ *                  consolidated entry point for the normalization subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Array Values                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { compactSparseArray } from './array/compact-sparse-array';
+export { flattenOneLevel } from './array/flatten-one-level';
+export { removeEmptyStringItems } from './array/remove-empty-string-items';
+export { removeNullItems } from './array/remove-null-items';
+export { removeUndefinedItems } from './array/remove-undefined-items';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Date Values                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { invalidDateToUndefined } from './date/invalid-date-to-undefined';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Number Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { infinityToUndefined } from './number/infinity-to-undefined';
+export { nanToUndefined } from './number/nan-to-undefined';
+export { normalizeNegativeZero } from './number/normalize-negative-zero';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Object Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { removeEmptyArrayKeys } from './object/remove-empty-array-keys';
+export { removeEmptyObjectKeys } from './object/remove-empty-object-keys';
+export { removeEmptyStringKeys } from './object/remove-empty-string-keys';
+export { removeNullKeys } from './object/remove-null-keys';
+export { removeUndefinedKeys } from './object/remove-undefined-keys';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* String Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { collapseWhitespace } from './string/collapse-whitespace';
+export { emptyToUndefined } from './string/empty-to-undefined';
+export { trim } from './string/trim';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Registry                                                                  *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { normalizationRuleRegistry } from './normalizer-register';