@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/fluent-registry.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Registry | Fluent
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Central registry of all built‑in validators and parsers.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/**
+ * 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 declare const janeRegistry: {
+    readonly validators: {
+        readonly alphaNum: import("./shapes").ValidationRule;
+        readonly alpha: import("./shapes").ValidationRule;
+        readonly array: import("./shapes").ValidationRule;
+        readonly arrayMinItems: (min: number) => import("./shapes").ValidationRule;
+        readonly arrayMaxItems: (max: number) => import("./shapes").ValidationRule;
+        readonly beforeEpoch: import("./shapes").ValidationRule;
+        readonly bigint: import("./shapes").ValidationRule;
+        readonly bigintEquals: (target: bigint) => import("./shapes").ValidationRule;
+        readonly bigintMax: (max: bigint) => import("./shapes").ValidationRule;
+        readonly bigintMin: (min: bigint) => import("./shapes").ValidationRule;
+        readonly bigintNegative: import("./shapes").ValidationRule;
+        readonly bigintNonNegative: import("./shapes").ValidationRule;
+        readonly bigintNonPositive: import("./shapes").ValidationRule;
+        readonly bigintPositive: import("./shapes").ValidationRule;
+        readonly bigintSafe: import("./shapes").ValidationRule;
+        readonly boolean: import("./shapes").ValidationRule;
+        readonly charsEqual: (exact: number) => import("./shapes").ValidationRule;
+        readonly dateNowRequired: import("./shapes").ValidationRule;
+        readonly deepEquals: (expected: unknown) => import("./shapes").ValidationRule;
+        readonly endsWith: (suffix: string) => import("./shapes").ValidationRule;
+        readonly excludes: (item: unknown) => import("./shapes").ValidationRule;
+        readonly finite: import("./shapes").ValidationRule;
+        readonly hasKey: (requiredKey: string) => import("./shapes").ValidationRule;
+        readonly hasUniqueItems: import("./shapes").ValidationRule;
+        readonly hasValue: (target: unknown) => import("./shapes").ValidationRule;
+        readonly includes: (item: unknown) => import("./shapes").ValidationRule;
+        readonly integer: import("./shapes").ValidationRule;
+        readonly isAscii: import("./shapes").ValidationRule;
+        readonly isCountryCode: import("./shapes").ValidationRule;
+        readonly isCurrencyCode: import("./shapes").ValidationRule;
+        readonly isDate: import("./shapes").ValidationRule;
+        readonly isEmail: import("./shapes").ValidationRule;
+        readonly isEmailStrict: import("./shapes").ValidationRule;
+        readonly isFalse: import("./shapes").ValidationRule;
+        readonly isFarFuture: import("./shapes").ValidationRule;
+        readonly isFuture: import("./shapes").ValidationRule;
+        readonly isIp: import("./shapes").ValidationRule;
+        readonly isPast: import("./shapes").ValidationRule;
+        readonly isPhone: import("./shapes").ValidationRule;
+        readonly isPhoneStrict: import("./shapes").ValidationRule;
+        readonly isPort: import("./shapes").ValidationRule;
+        readonly isPostalCode: import("./shapes").ValidationRule;
+        readonly isPrintable: import("./shapes").ValidationRule;
+        readonly isNull: import("./shapes").ValidationRule;
+        readonly isNullOrUndefined: import("./shapes").ValidationRule;
+        readonly isTrue: import("./shapes").ValidationRule;
+        readonly isUrl: import("./shapes").ValidationRule;
+        readonly isUndefined: import("./shapes").ValidationRule;
+        readonly isUuid: import("./shapes").ValidationRule;
+        readonly itemsEqual: (exact: number) => import("./shapes").ValidationRule;
+        readonly keysEqual: (expectedKeys: readonly string[]) => import("./shapes").ValidationRule;
+        readonly lessThan: (limit: number) => import("./shapes").ValidationRule;
+        readonly matches: (pattern: RegExp) => import("./shapes").ValidationRule;
+        readonly max: (limit: number) => import("./shapes").ValidationRule;
+        readonly maxKeys: (maximum: number) => import("./shapes").ValidationRule;
+        readonly maxLength: (max: number) => import("./shapes").ValidationRule;
+        readonly min: (limit: number) => import("./shapes").ValidationRule;
+        readonly minKeys: (minimum: number) => import("./shapes").ValidationRule;
+        readonly minLength: (min: number) => import("./shapes").ValidationRule;
+        readonly missingKey: (requiredKeys: readonly string[]) => import("./shapes").ValidationRule;
+        readonly moreThan: (limit: number) => import("./shapes").ValidationRule;
+        readonly negative: import("./shapes").ValidationRule;
+        readonly noEmptyArrayValues: import("./shapes").ValidationRule;
+        readonly noEmptyObjectValues: import("./shapes").ValidationRule;
+        readonly noEmptyStringItems: import("./shapes").ValidationRule;
+        readonly noLeadSpace: import("./shapes").ValidationRule;
+        readonly noNullItems: import("./shapes").ValidationRule;
+        readonly noNullValues: import("./shapes").ValidationRule;
+        readonly noRepeatSpace: import("./shapes").ValidationRule;
+        readonly noSpace: import("./shapes").ValidationRule;
+        readonly noTrailSpace: import("./shapes").ValidationRule;
+        readonly noUndefinedItems: import("./shapes").ValidationRule;
+        readonly noUndefinedValues: import("./shapes").ValidationRule;
+        readonly nonEmpty: import("./shapes").ValidationRule;
+        readonly nonEmptyArray: import("./shapes").ValidationRule;
+        readonly nonEmptyObject: import("./shapes").ValidationRule;
+        readonly nonNegative: import("./shapes").ValidationRule;
+        readonly nonPositive: import("./shapes").ValidationRule;
+        readonly notAfter: (max: Date) => import("./shapes").ValidationRule;
+        readonly notBefore: (min: Date) => import("./shapes").ValidationRule;
+        readonly notOneOf: (disallowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly notSparse: import("./shapes").ValidationRule;
+        readonly number: import("./shapes").ValidationRule;
+        readonly numString: import("./shapes").ValidationRule;
+        readonly oneOf: (allowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly onlyKeys: (allowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly plainObject: import("./shapes").ValidationRule;
+        readonly positive: import("./shapes").ValidationRule;
+        readonly safeInteger: import("./shapes").ValidationRule;
+        readonly sameDay: (other: Date) => import("./shapes").ValidationRule;
+        readonly sameMonth: (other: Date) => import("./shapes").ValidationRule;
+        readonly sameYear: (other: Date) => import("./shapes").ValidationRule;
+        readonly startsWith: (prefix: string) => import("./shapes").ValidationRule;
+        readonly string: import("./shapes").ValidationRule;
+        readonly tooEarly: (min: Date) => import("./shapes").ValidationRule;
+        readonly tooLate: (max: Date) => import("./shapes").ValidationRule;
+        readonly trimmed: import("./shapes").ValidationRule;
+        readonly weekday: (required: number) => import("./shapes").ValidationRule;
+        readonly weekend: import("./shapes").ValidationRule;
+    };
+    readonly parsers: {
+        readonly numeric: import("./shapes").ParseRule<unknown>;
+        readonly integer: import("./shapes").ParseRule<unknown>;
+        readonly boolean: import("./shapes").ParseRule<unknown>;
+        readonly bigint: import("./shapes").ParseRule<unknown>;
+        readonly hex: import("./shapes").ParseRule<unknown>;
+        readonly binary: import("./shapes").ParseRule<unknown>;
+        readonly octal: import("./shapes").ParseRule<unknown>;
+        readonly date: import("./shapes").ParseRule<unknown>;
+        readonly json: import("./shapes").ParseRule<unknown>;
+        readonly array: import("./shapes").ParseRule<unknown>;
+        readonly object: import("./shapes").ParseRule<unknown>;
+        readonly url: import("./shapes").ParseRule<string>;
+        readonly duration: import("./shapes").ParseRule<unknown>;
+        readonly scientific: import("./shapes").ParseRule<unknown>;
+    };
+};

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.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * 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 declare const compactSparseArray: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Flattens nested arrays by a single level, simplifying structure while
+ * preserving item order. Useful for normalizing inputs where shallow nesting
+ * appears unintentionally.
+ */
+export declare const flattenOneLevel: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes empty string entries from arrays, eliminating placeholder or
+ * accidental text values while preserving all meaningful items.
+ */
+export declare const removeEmptyStringItems: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Filters out null entries from arrays, removing structurally empty items
+ * without altering the order or meaning of defined values.
+ */
+export declare const removeNullItems: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes undefined entries from arrays, producing a cleaner and more
+ * predictable sequence of defined values.
+ */
+export declare const removeUndefinedItems: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Converts invalid Date instances (timestamp NaN) to undefined, ensuring that
+ * malformed or unparsable date values do not propagate through normalization.
+ */
+export declare const invalidDateToUndefined: NormalizationRule<unknown>;

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.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  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
+ * ----------------------------------------------------------------------------
+ */
+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';
+export { invalidDateToUndefined } from './date/invalid-date-to-undefined';
+export { infinityToUndefined } from './number/infinity-to-undefined';
+export { nanToUndefined } from './number/nan-to-undefined';
+export { normalizeNegativeZero } from './number/normalize-negative-zero';
+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';
+export { collapseWhitespace } from './string/collapse-whitespace';
+export { emptyToUndefined } from './string/empty-to-undefined';
+export { trim } from './string/trim';
+export { normalizationRuleRegistry } from './normalizer-register';