@clementine-solutions/jane-io 1.0.0 → 1.0.2

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';

package/dist/core/normalizers/normalizer-register.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Public | Normalizer Registry
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Exposes the full mapping of structural types to their
+ *                  associated normalization rules, defining Jane’s public
+ *                  normalization pipeline surface.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule, StructuralType } from '../shapes';
+/**
+ * Maps each structural type to the normalization rules that apply to it,
+ * defining the full normalization pipeline Jane runs for incoming values.
+ */
+export declare const normalizationRuleRegistry: Record<StructuralType, readonly NormalizationRule[]>;

package/dist/core/normalizers/normalizer-register.js

@@ -0,0 +1,41 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Public | Normalizer Registry
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Exposes the full mapping of structural types to their
+ *                  associated normalization rules, defining Jane’s public
+ *                  normalization pipeline surface.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { collapseWhitespace, compactSparseArray, emptyToUndefined, flattenOneLevel, infinityToUndefined, invalidDateToUndefined, nanToUndefined, normalizeNegativeZero, removeEmptyArrayKeys, removeEmptyObjectKeys, removeEmptyStringItems, removeEmptyStringKeys, removeNullItems, removeNullKeys, removeUndefinedItems, removeUndefinedKeys, trim, } from '.';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Normalization Rule Registry                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Maps each structural type to the normalization rules that apply to it,
+ * defining the full normalization pipeline Jane runs for incoming values.
+ */
+export const normalizationRuleRegistry = {
+    string: [trim, collapseWhitespace, emptyToUndefined],
+    number: [normalizeNegativeZero, nanToUndefined, infinityToUndefined],
+    boolean: [],
+    array: [
+        compactSparseArray,
+        flattenOneLevel,
+        removeEmptyStringItems,
+        removeNullItems,
+        removeUndefinedItems,
+    ],
+    object: [
+        removeUndefinedKeys,
+        removeNullKeys,
+        removeEmptyStringKeys,
+        removeEmptyArrayKeys,
+        removeEmptyObjectKeys,
+    ],
+    date: [invalidDateToUndefined],
+    unknown: [],
+    bigint: [],
+};

package/dist/core/normalizers/number/infinity-to-undefined.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Infinity To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `Infinity` and `-Infinity` to `undefined`, removing
+ *                  non‑finite numeric values that cannot be represented or
+ *                  validated safely.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Converts `Infinity` and `-Infinity` to `undefined`, removing non‑finite
+ * numeric values that cannot be represented safely across serialization or
+ * downstream validation.
+ */
+export declare const infinityToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/number/infinity-to-undefined.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Infinity To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `Infinity` and `-Infinity` to `undefined`, removing
+ *                  non‑finite numeric values that cannot be represented or
+ *                  validated safely.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts `Infinity` and `-Infinity` to `undefined`, removing non‑finite
+ * numeric values that cannot be represented safely across serialization or
+ * downstream validation.
+ */
+export const infinityToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (value !== Infinity && value !== -Infinity)
+        return [];
+    const event = normalizationEvent('info', 'number.now.undefined', path, 'Converted Infinity or -Infinity to undefined.', 'Infinite values were removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/number/nan-to-undefined.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | NaN to Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `NaN` to `undefined`, eliminating invalid numeric
+ *                  states that cannot be compared, serialized, or reasoned
+ *                  about reliably.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Converts `NaN` to `undefined`, eliminating invalid numeric states that cannot
+ * be meaningfully compared, serialized, or validated.
+ */
+export declare const nanToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/number/nan-to-undefined.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | NaN to Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `NaN` to `undefined`, eliminating invalid numeric
+ *                  states that cannot be compared, serialized, or reasoned
+ *                  about reliably.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts `NaN` to `undefined`, eliminating invalid numeric states that cannot
+ * be meaningfully compared, serialized, or validated.
+ */
+export const nanToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (!Number.isNaN(value))
+        return [];
+    const event = normalizationEvent('info', 'number.now.undefined', path, 'Converted NaN to undefined.', 'Invalid numeric values were removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/number/normalize-negative-zero.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Normalize Negative Zero
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Normalizes `-0` to `0`, removing a JavaScript‑specific edge
+ *                  case while preserving the value’s intended semantics.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Normalizes `-0` to `0`, removing a JavaScript‑specific numeric edge case
+ * while preserving the value’s intended semantics.
+ */
+export declare const normalizeNegativeZero: NormalizationRule<unknown>;

package/dist/core/normalizers/number/normalize-negative-zero.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Normalize Negative Zero
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Normalizes `-0` to `0`, removing a JavaScript‑specific edge
+ *                  case while preserving the value’s intended semantics.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Normalizes `-0` to `0`, removing a JavaScript‑specific numeric edge case
+ * while preserving the value’s intended semantics.
+ */
+export const normalizeNegativeZero = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (!Object.is(value, -0))
+        return [];
+    const event = normalizationEvent('info', 'number.now.positive-zero', path, 'Normalized -0 to 0.', 'Negative zero was corrected.', { before: value, after: 0 });
+    return [
+        {
+            path,
+            nextValue: 0,
+            lossy: 'lossless',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-array-keys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Array Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty arrays, eliminating
+ *                  structurally empty list fields while preserving all
+ *                  non‑empty array data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty arrays, eliminating structurally empty
+ * list fields while preserving all non‑empty array values.
+ */
+export declare const removeEmptyArrayKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-empty-array-keys.js

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Array Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty arrays, eliminating
+ *                  structurally empty list fields while preserving all
+ *                  non‑empty array data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty arrays, eliminating structurally empty
+ * list fields while preserving all non‑empty array values.
+ */
+export const removeEmptyArrayKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => !Array.isArray(v) || v.length > 0);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-arrays', path, 'Removed keys whose values were empty arrays.', 'Empty lists were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-object-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Object Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty plain objects, clearing
+ *                  fields that carry no structural or semantic content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty plain objects, filtering out fields that
+ * carry no structural or semantic content.
+ */
+export declare const removeEmptyObjectKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-empty-object-keys.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Object Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty plain objects, clearing
+ *                  fields that carry no structural or semantic content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty plain objects, filtering out fields that
+ * carry no structural or semantic content.
+ */
+export const removeEmptyObjectKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            return Object.keys(v).length > 0;
+        }
+        return true;
+    });
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-objects', path, 'Removed keys whose values were empty objects.', 'Empty objects were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-string-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty strings, eliminating
+ *                  placeholder or accidental text fields.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty strings, clearing out placeholder or
+ * accidental text fields while retaining all meaningful values.
+ */
+export declare const removeEmptyStringKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-empty-string-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty strings, eliminating
+ *                  placeholder or accidental text fields.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty strings, clearing out placeholder or
+ * accidental text fields while retaining all meaningful values.
+ */
+export const removeEmptyStringKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== '');
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-strings', path, 'Removed keys whose values were empty strings.', 'Empty text values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-null-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Null Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are null, stripping explicitly
+ *                  empty fields while preserving all defined data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are null, eliminating explicitly empty fields while
+ * preserving all defined data.
+ */
+export declare const removeNullKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-null-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Null Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are null, stripping explicitly
+ *                  empty fields while preserving all defined data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are null, eliminating explicitly empty fields while
+ * preserving all defined data.
+ */
+export const removeNullKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== null);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.null-keys', path, 'Removed keys whose values were null.', 'Null values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-undefined-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Undefined Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are undefined, producing a cleaner
+ *                  and more predictable object shape.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are undefined, producing a cleaner and more
+ * predictable object shape by stripping absent fields.
+ */
+export declare const removeUndefinedKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-undefined-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Undefined Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are undefined, producing a cleaner
+ *                  and more predictable object shape.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are undefined, producing a cleaner and more
+ * predictable object shape by stripping absent fields.
+ */
+export const removeUndefinedKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== undefined);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.undefined-keys', path, 'Removed keys whose values were undefined.', 'Undefined values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/collapse-whitespace.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Collapse Whitespace
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Collapses repeated internal whitespace into a single space,
+ *                  producing cleaner, more consistent text without altering
+ *                  meaning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Collapses repeated internal whitespace into a single space, producing a
+ * cleaner and more consistent text structure without altering meaning.
+ */
+export declare const collapseWhitespace: NormalizationRule<unknown>;

package/dist/core/normalizers/string/collapse-whitespace.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Collapse Whitespace
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Collapses repeated internal whitespace into a single space,
+ *                  producing cleaner, more consistent text without altering
+ *                  meaning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Collapses repeated internal whitespace into a single space, producing a
+ * cleaner and more consistent text structure without altering meaning.
+ */
+export const collapseWhitespace = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const collapsed = value.replace(/\s+/g, ' ');
+    if (collapsed === value)
+        return [];
+    const event = normalizationEvent('info', 'string.now.collapsed', path, 'Collapsed repeated internal whitespace into a single space.', 'Extra spaces inside the text were cleaned up.', { before: value, after: collapsed });
+    return [
+        {
+            path,
+            nextValue: collapsed,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/empty-to-undefined.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Empty To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts empty strings to undefined, removing text fields
+ *                  that contain no meaningful content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Converts empty strings to undefined, removing text fields that contain no
+ * meaningful content.
+ */
+export declare const emptyToUndefined: NormalizationRule<unknown>;