@clementine-solutions/jane-io 1.0.1 → 1.0.2

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

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Safe Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a safe integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that a value is a safe integer.
+ *
+ * Safe integers must be whole numbers that fall within JavaScript’s
+ * IEEE‑754 safe range. This protects downstream logic from precision loss,
+ * overflow‑adjacent behavior, and malformed numeric input that appears valid
+ * but cannot be represented exactly.
+ */
+export const safeInteger = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (typeof value !== 'number') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${type}'.`, `Please enter a valid number.`, { value, expected: 'number', actual: type }),
+        ];
+    }
+    if (!Number.isInteger(value)) {
+        return [
+            validationEvent('error', 'number.not.integer', path, `${safeStringify(value)} must be an integer.`, `Please enter a whole number.`, { value, expected: 'integer', actual: value }),
+        ];
+    }
+    if (!Number.isSafeInteger(value)) {
+        return [
+            validationEvent('error', 'number.not.safe-integer', path, `${safeStringify(value)} must be a safe integer.`, `Please enter a whole number within safe bounds.`, { value, expected: 'safe integer', actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/deep-equals.js

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Deep Equals
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a value is deeply equal to an expected
+ *                  structural value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { deepEqual, isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a value is deeply equal to an expected structural value.
+ *
+ * Deep equality is performed against JSON-compatible values only:
+ * - primitives
+ * - arrays
+ * - plain objects (no class instances, Maps, Sets, Dates, etc.)
+ *
+ * If the value is not structural, an object.not.plain-object event is emitted.
+ * If the value is structural but not deeply equal, an object.not.deeply-equal event is emitted.
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const deepEquals = (expected) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // Accept primitives, arrays, and plain objects
+    const isStructuralValue = value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        isPlainObject(value);
+    if (!isStructuralValue) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Deep equality requires a structural value, but received '${structuralType}'.`, `Please provide a JSON-compatible value.`, { expected, actual: structuralType }),
+        ];
+    }
+    if (!deepEqual(value, expected)) {
+        return [
+            validationEvent('error', 'object.not.deeply-equal', path, `Value does not match the expected structure.`, `Please provide the correct value.`, { expected, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/has-key.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Key
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains a required own
+ *                  enumerable key.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains a required own enumerable key.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the required key is missing, an object.missing-key event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const hasKey = (requiredKey) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const hasOwnKey = Object.prototype.hasOwnProperty.call(value, requiredKey);
+    if (!hasOwnKey) {
+        return [
+            validationEvent('error', 'object.has.missing-key', path, `Object must contain key '${requiredKey}'.`, `Please include the required key.`, { expected: requiredKey, actual: Object.keys(value) }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/has-value.js

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Value
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array or plain object contains a value
+ *                  deeply equal to the target.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { deepEqual, isPlainObject, safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array or plain object contains a value deeply equal to the target.
+ *
+ * This rule accepts only JSON-compatible arrays and plain objects.
+ * Primitives, null, class instances, Maps, Sets, Dates, and other non-collection
+ * values are rejected.
+ *
+ * Arrays are searched using deep equality on each element.
+ * Objects are searched using deep equality on each own enumerable value.
+ *
+ * If the value is not a collection, an object.not.collection event is emitted.
+ * If the target value is not found, a value.not.found event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const hasValue = (target) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    const isArray = structuralType === 'array';
+    const isPlainObjectValue = structuralType === 'object' && isPlainObject(value);
+    if (!isArray && !isPlainObjectValue) {
+        return [
+            validationEvent('error', 'object.has.missing-value', path, `Expected array or plain object but received '${structuralType}'.`, `Please provide a collection value.`, { expected: 'array | plain object', actual: structuralType }),
+        ];
+    }
+    const found = deepContainsValue(value, target);
+    if (!found) {
+        return [
+            validationEvent('error', 'value.not.found', path, `Value does not contain ${safeStringify(target)}.`, `Please include the required value.`, { expected: target, actual: value }),
+        ];
+    }
+    return [];
+};
+function deepContainsValue(container, target) {
+    if (deepEqual(container, target))
+        return true;
+    if (Array.isArray(container)) {
+        return container.some((item) => deepContainsValue(item, target));
+    }
+    if (isPlainObject(container)) {
+        return Object.values(container).some((item) => deepContainsValue(item, target));
+    }
+    return false;
+}

package/dist/core/validators/object/keys-equal.js

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Keys Equal
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains exactly the expected
+ *                  set of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains exactly the expected set of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * The object must contain the same number of keys and the same key names as expectedKeys.
+ * Order does not matter. Keys must match exactly.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the key set does not match, an object.invalid-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const keysEqual = (expectedKeys) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const actualKeys = Object.keys(value);
+    const sameLength = actualKeys.length === expectedKeys.length;
+    const sameMembers = sameLength && expectedKeys.every((key) => actualKeys.includes(key));
+    if (!sameMembers) {
+        return [
+            validationEvent('error', 'object.has.invalid-key', path, `Object keys must match exactly: ${expectedKeys.join(', ')}.`, `Please provide the correct set of keys.`, { expected: expectedKeys, actual: actualKeys }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/max-keys.js

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Keys (Max Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains no more than a
+ *                  specified number of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { isPlainObject } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains no more than a specified number of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the object contains more than the allowed number of keys, an object.too.many-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const maxKeys = (maximum) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const keyCount = Object.keys(value).length;
+    if (keyCount > maximum) {
+        return [
+            validationEvent('error', 'object.too.many-keys', path, `Object has ${keyCount} keys but must have ≤ ${maximum}.`, `Please provide no more than ${maximum} keys.`, { expected: `≤ ${maximum}`, actual: keyCount }),
+        ];
+    }
+    return [];
+};