@clementine-solutions/jane-io 1.0.1 → 1.0.2

package/dist/core/validators/date/same-year.js

@@ -0,0 +1,56 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Year
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a date in
+ *                  the same calendar year as the provided `other` date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance representing a date in the
+ * same calendar year as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same year emit `date.not.same-year`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const sameYear = (other) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        if (value.getUTCFullYear() !== other.getUTCFullYear()) {
+            return [
+                validationEvent('error', 'date.not.same-year', path, `${safeStringify(value)} must be in the same year as ${other.toISOString()}.`, `Please provide a date in the correct year.`, {
+                    value,
+                    expected: other.toISOString().slice(0, 4),
+                    actual: value.toISOString().slice(0, 4),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/too-early.js

@@ -0,0 +1,57 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Too Early
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not earlier
+ *                  than the provided `min` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that is not earlier than the
+ * provided `min` boundary. The comparison is inclusive: value must be
+ * ≥ min.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates < min emit `date.too.early`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const tooEarly = (min) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        if (value.getTime() < min.getTime()) {
+            return [
+                validationEvent('error', 'date.too.early', path, `${safeStringify(value)} must not be earlier than ${min.toISOString()}.`, `Please provide a later date.`, {
+                    value: value.toISOString(),
+                    expected: `>= ${min.toISOString()}`,
+                    actual: value.toISOString(),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/too-late.js

@@ -0,0 +1,57 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Too Early
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not later than
+ *                  the provided `max` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that is not later than the
+ * provided `max` boundary. The comparison is inclusive: value must be
+ * ≤ max.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates > max emit `date.too.late`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const tooLate = (max) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        if (value.getTime() > max.getTime()) {
+            return [
+                validationEvent('error', 'date.too.late', path, `${safeStringify(value)} must not be later than ${max.toISOString()}.`, `Please provide an earlier date.`, {
+                    value: value.toISOString(),
+                    expected: `<= ${max.toISOString()}`,
+                    actual: value.toISOString(),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/weekday.js

@@ -0,0 +1,65 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Weekday
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance whose weekday (0–6)
+ *                  matches the required weekday.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance whose weekday (0–6) matches
+ * the required weekday. JavaScript uses:
+ *
+ *   0 = Sunday
+ *   1 = Monday
+ *   2 = Tuesday
+ *   3 = Wednesday
+ *   4 = Thursday
+ *   5 = Friday
+ *   6 = Saturday
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Mismatched weekdays emit `date.not.weekday`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const weekday = (required) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        const actualWeekday = value.getUTCDay();
+        if (actualWeekday !== required) {
+            return [
+                validationEvent('error', 'date.not.weekday', path, `${safeStringify(value)} must fall on weekday ${required}.`, `Please provide a date on the correct weekday.`, {
+                    value: value.toISOString(),
+                    expected: required,
+                    actual: actualWeekday,
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/weekend.js

@@ -0,0 +1,56 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Weekend
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that falls on a
+ *                  weekend.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that falls on a weekend.
+ *
+ * JavaScript weekday values:
+ *   0 = Sunday
+ *   6 = Saturday
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Weekdays (1–5) emit `date.not.weekend`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const weekend = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!(value instanceof Date)) {
+        return [
+            validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+        ];
+    }
+    if (isNaN(value.getTime())) {
+        return [
+            validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+        ];
+    }
+    const weekday = value.getUTCDay();
+    const isWeekend = weekday === 0 || weekday === 6;
+    if (!isWeekend) {
+        return [
+            validationEvent('error', 'date.not.weekend', path, `${safeStringify(value)} must fall on a weekend.`, `Please provide a Saturday or Sunday date.`, {
+                value: value.toISOString(),
+                expected: 'weekend',
+                actual: weekday,
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/index.js

@@ -0,0 +1,139 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Validators | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all built‑in validation rules, providing a single
+ *                  cohesive entry point for Jane’s validation subsystem. This
+ *                  keeps contributor onboarding simple and ensures consistent,
+ *                  predictable resolution of validator names across the
+ *                  framework.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Array Values                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { array } from './array/array';
+export { arrayMaxItems } from './array/array-max-items';
+export { arrayMinItems } from './array/array-min-items';
+export { excludes } from './array/excludes';
+export { hasUniqueItems } from './array/has-unique-items';
+export { includes } from './array/includes';
+export { itemsEqual } from './array/items-equal';
+export { noEmptyStringItems } from './array/no-empty-string-items';
+export { noNullItems } from './array/no-null-items';
+export { noUndefinedItems } from './array/no-undefined-items';
+export { nonEmptyArray } from './array/non-empty-array';
+export { notSparse } from './array/not-sparse';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Bigint Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { bigint } from './bigint/bigint';
+export { bigintEquals } from './bigint/bigint-equals';
+export { bigintMax } from './bigint/bigint-max';
+export { bigintMin } from './bigint/bigint-min';
+export { bigintNegative } from './bigint/bigint-negative';
+export { bigintNonNegative } from './bigint/bigint-non-negative';
+export { bigintNonPositive } from './bigint/bigint-non-positive';
+export { bigintPositive } from './bigint/bigint-positive';
+export { bigintSafe } from './bigint/bigint-safe';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Boolean Values                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { boolean } from './boolean/boolean';
+export { isFalse } from './boolean/is-false';
+export { isTrue } from './boolean/is-true';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Common Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { isCountryCode } from './common/is-country-code';
+export { isCurrencyCode } from './common/is-currency-code';
+export { isEmail } from './common/is-email';
+export { isEmailStrict } from './common/is-email-strict';
+export { isIp } from './common/is-ip';
+export { isPhone } from './common/is-phone';
+export { isPhoneStrict } from './common/is-phone-strict';
+export { isPort } from './common/is-port';
+export { isPostalCode } from './common/is-postal-code';
+export { isUrl } from './common/is-url';
+export { isUuid } from './common/is-uuid';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Date Values                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { beforeEpoch } from './date/before-epoch';
+export { dateNowRequired } from './date/date-now-required';
+export { isDate } from './date/is-date';
+export { isFarFuture } from './date/is-far-future';
+export { isFuture } from './date/is-future';
+export { isPast } from './date/is-past';
+export { notAfter } from './date/not-after';
+export { notBefore } from './date/not-before';
+export { sameDay } from './date/same-day';
+export { sameMonth } from './date/same-month';
+export { sameYear } from './date/same-year';
+export { tooEarly } from './date/too-early';
+export { tooLate } from './date/too-late';
+export { weekday } from './date/weekday';
+export { weekend } from './date/weekend';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Nullish Values                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { isNull } from './nullish/is-null';
+export { isNullOrUndefined } from './nullish/is-null-or-undefined';
+export { isUndefined } from './nullish/is-undefined';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Number Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { finite } from './number/finite';
+export { integer } from './number/integer';
+export { lessThan } from './number/less-than';
+export { max } from './number/max';
+export { min } from './number/min';
+export { moreThan } from './number/more-than';
+export { negative } from './number/negative';
+export { nonNegative } from './number/non-negative';
+export { nonPositive } from './number/non-positive';
+export { number } from './number/number';
+export { positive } from './number/positive';
+export { safeInteger } from './number/safe-integer';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Object Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { deepEquals } from './object/deep-equals';
+export { hasKey } from './object/has-key';
+export { hasValue } from './object/has-value';
+export { keysEqual } from './object/keys-equal';
+export { maxKeys } from './object/max-keys';
+export { minKeys } from './object/min-keys';
+export { missingKey } from './object/missing-key';
+export { noEmptyArrayValues } from './object/no-empty-array-values';
+export { noEmptyObjectValues } from './object/no-empty-object-values';
+export { noNullValues } from './object/no-null-values';
+export { noUndefinedValues } from './object/no-undefined-values';
+export { nonEmptyObject } from './object/non-empty-object';
+export { plainObject } from './object/plain-object';
+export { onlyKeys } from './object/only-keys';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* String Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { alpha } from './string/alpha';
+export { alphaNum } from './string/alpha-num';
+export { charsEqual } from './string/chars-equal';
+export { endsWith } from './string/ends-with';
+export { isAscii } from './string/is-ascii';
+export { isPrintable } from './string/is-printable';
+export { matches } from './string/matches';
+export { maxLength } from './string/max-length';
+export { minLength } from './string/min-length';
+export { noLeadSpace } from './string/no-lead-space';
+export { noRepeatSpace } from './string/no-repeat-space';
+export { noSpace } from './string/no-space';
+export { noTrailSpace } from './string/no-trail-space';
+export { nonEmpty } from './string/non-empty';
+export { notOneOf } from './string/not-one-of';
+export { numString } from './string/num-string';
+export { oneOf } from './string/one-of';
+export { startsWith } from './string/starts-with';
+export { string } from './string/string';
+export { trimmed } from './string/trimmed';

package/dist/core/validators/nullish/is-null-or-undefined.js

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Null Or Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is either `null` or `undefined`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is either `null` or `undefined`.
+ *
+ * - Any value other than `null` or `undefined` emits
+ *   `value.not.null-or-undefined`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const isNullOrUndefined = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Nullish check
+    // ------------------------------------------------------------
+    if (value !== null && value !== undefined) {
+        return [
+            validationEvent('error', 'value.not.null-or-undefined', path, `Value must be null or undefined.`, `Please provide a null or undefined value.`, { value, expected: 'null | undefined', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/nullish/is-null.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Null
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is exactly `null`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is exactly `null`.
+ *
+ * - Any value other than `null` emits `value.not.null`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const isNull = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Null check
+    // ------------------------------------------------------------
+    if (value !== null) {
+        return [
+            validationEvent('error', 'value.not.null', path, `Value must be null.`, `Please provide a null value.`, { value, expected: 'null', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/nullish/is-undefined.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is exactly `undefined`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is exactly `undefined`.
+ *
+ * - Any value other than `undefined` emits `value.not.undefined`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export const isUndefined = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Undefined check
+    // ------------------------------------------------------------
+    if (value !== undefined) {
+        return [
+            validationEvent('error', 'value.not.undefined', path, `Value must be undefined.`, `Please provide an undefined value.`, { value, expected: 'undefined', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/number/finite.js

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Finite
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a finite number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that the value is a finite number.
+ *
+ * This rule accepts only JavaScript numbers that are both numeric and finite.
+ * Non-number values, NaN, Infinity, and -Infinity are rejected.
+ *
+ * If the value is not a number, a type.not.valid event is emitted.
+ * If the value is a number but not finite, a number.not.finite event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const finite = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (!Number.isFinite(value)) {
+        return [
+            validationEvent('error', 'number.not.finite', path, `${safeStringify(value)} must be a valid, bounded number.`, `Please enter a valid number.`, { expected: 'finite number', actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/integer.js

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is an integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that the value is an integer.
+ *
+ * This rule accepts only JavaScript numbers that are both numeric and integer‑valued.
+ * Non-number values and non-integer numbers are rejected.
+ *
+ * If the value is not a number, a type.not.valid event is emitted.
+ * If the value is a number but not an integer, a number.not.integer event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const integer = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (!Number.isInteger(value)) {
+        return [
+            validationEvent('error', 'number.not.integer', path, `${safeStringify(value)} must be an integer-based number.`, `Please enter a valid number.`, { expected: 'integer', actual: value }),
+        ];
+    }
+    return [];
+};