@clementine-solutions/jane-io 1.0.0 → 1.0.2

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

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Finite
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a finite number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const finite: ValidationRule;

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

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is an integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const integer: ValidationRule;

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 [];
+};

package/dist/core/validators/number/less-than.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Less Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly less than the
+ *                  given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number strictly less than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but not less than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const lessThan: (limit: number) => ValidationRule;

package/dist/core/validators/number/less-than.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Less Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly less than the
+ *                  given limit.
+ * @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 number strictly less than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but not less than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const lessThan = (limit) => 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 (!(value < limit)) {
+        return [
+            validationEvent('error', 'number.too.high', path, `${safeStringify(value)} must be < ${limit}.`, `Please enter a number less than ${limit}.`, { expected: `< ${limit}`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/max.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum (Max)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number less than or equal to
+ *                  the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number less than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but greater than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const max: (limit: number) => ValidationRule;

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

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum (Max)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number less than or equal to
+ *                  the given limit.
+ * @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 number less than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but greater than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const max = (limit) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (value > limit) {
+        return [
+            validationEvent('error', 'number.too.high', path, `${safeStringify(value)} must be ≤ ${limit}.`, `Please enter a number no greater than ${limit}.`, { expected: `≤ ${limit}`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/min.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum (Min)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number greater than or equal
+ *                  to the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number greater than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but less than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const min: (limit: number) => ValidationRule;

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

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum (Min)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number greater than or equal
+ *                  to the given limit.
+ * @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 number greater than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but less than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const min = (limit) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (value < limit) {
+        return [
+            validationEvent('error', 'number.too.low', path, `${safeStringify(value)} must be ≥ ${limit}.`, `Please enter a number at least ${limit}.`, { expected: `≥ ${limit}`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/more-than.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | More Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly greater than
+ *                  the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number strictly greater than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not greater than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const moreThan: (limit: number) => ValidationRule;

package/dist/core/validators/number/more-than.js

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | More Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly greater than
+ *                  the given limit.
+ * @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 number strictly greater than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not greater than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const moreThan = (limit) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (!(value > limit)) {
+        return [
+            validationEvent('error', 'number.too.low', path, `${safeStringify(value)} must be > ${limit}.`, `Please enter a number greater than ${limit}.`, { expected: `> ${limit}`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/negative.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a negative number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly less than zero, a number.not.negative
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const negative: ValidationRule;

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

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a negative 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 negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly less than zero, a number.not.negative
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const negative = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (!(value < 0)) {
+        return [
+            validationEvent('error', 'number.not.negative', path, `${safeStringify(value)} must be < 0.`, `Please enter a negative number.`, { expected: `< 0`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/non-negative.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑negative number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a non‑negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but less than zero, a number.not.non-negative event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const nonNegative: ValidationRule;

package/dist/core/validators/number/non-negative.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑negative 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 non‑negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but less than zero, a number.not.non-negative event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const nonNegative = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (value < 0) {
+        return [
+            validationEvent('error', 'number.not.non-negative', path, `${safeStringify(value)} must be ≥ 0.`, `Please enter zero or a positive number.`, { expected: `≥ 0`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/non-positive.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑positive number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a non‑positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but greater than zero, a number.not.non-positive event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const nonPositive: ValidationRule;

package/dist/core/validators/number/non-positive.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑positive 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 non‑positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but greater than zero, a number.not.non-positive event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const nonPositive = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (value > 0) {
+        return [
+            validationEvent('error', 'number.not.non-positive', path, `${safeStringify(value)} must be ≤ 0.`, `Please enter zero or a negative number.`, { expected: `≤ 0`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/number.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Number
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a JavaScript number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a JavaScript number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is not a number, a type.not.valid event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const number: ValidationRule;

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

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