@clementine-solutions/jane-io 1.0.1 → 1.0.2

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

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Keys (Min Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains at least a specified
+ *                  number 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 at least 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 fewer than the required number of keys, an object.too.few-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const minKeys = (minimum) => 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 < minimum) {
+        return [
+            validationEvent('error', 'object.too.few-keys', path, `Object has ${keyCount} keys but must have ≥ ${minimum}.`, `Please provide at least ${minimum} keys.`, { expected: `≥ ${minimum}`, actual: keyCount }),
+        ];
+    }
+    return [];
+};

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

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Missing Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains all required own
+ *                  enumerable 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 all required own enumerable 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 one or more required keys are missing, an object.missing-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const missingKey = (requiredKeys) => 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 missing = requiredKeys.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    if (missing.length > 0) {
+        return [
+            validationEvent('error', 'object.has.missing-key', path, `Object is missing required keys: ${missing.join(', ')}.`, `Please include all required keys.`, { expected: requiredKeys, actual: Object.keys(value) }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/no-empty-array-values.js

@@ -0,0 +1,44 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Empty Array Values
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object does not contain any empty
+ *                  array values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object does not contain any empty array values.
+ *
+ * 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.
+ *
+ * Each own enumerable property is inspected. If any property value is an array with length 0,
+ * an object.empty-array-value event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noEmptyArrayValues = 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 }),
+        ];
+    }
+    for (const key of Object.keys(value)) {
+        const propertyValue = value[key];
+        if (Array.isArray(propertyValue) && propertyValue.length === 0) {
+            return [
+                validationEvent('error', 'object.has.empty-array', path, `Object must not contain empty arrays (found at key '${key}').`, `Please remove empty arrays.`, { expected: 'no empty arrays', actual: key }),
+            ];
+        }
+    }
+    return [];
+};

package/dist/core/validators/object/no-empty-object-values.js

@@ -0,0 +1,44 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Empty Object Values
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object does not contain any empty
+ *                  plain-object values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object does not contain any empty plain-object values.
+ *
+ * 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.
+ *
+ * Each own enumerable property is inspected. If any property value is a plain object
+ * with zero keys, an object.empty-object-value event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noEmptyObjectValues = 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 }),
+        ];
+    }
+    for (const key of Object.keys(value)) {
+        const propertyValue = value[key];
+        if (isPlainObject(propertyValue) && Object.keys(propertyValue).length === 0) {
+            return [
+                validationEvent('error', 'object.has.empty-object', path, `Object must not contain empty objects (found at key '${key}').`, `Please remove empty objects.`, { expected: 'no empty objects', actual: key }),
+            ];
+        }
+    }
+    return [];
+};

package/dist/core/validators/object/no-null-values.js

@@ -0,0 +1,44 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Null Values
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object does not contain any null
+ *                  values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object does not contain any null values.
+ *
+ * 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.
+ *
+ * Each own enumerable property is inspected. If any property value is null,
+ * an object.null-value event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noNullValues = 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 }),
+        ];
+    }
+    for (const key of Object.keys(value)) {
+        const propertyValue = value[key];
+        if (propertyValue === null) {
+            return [
+                validationEvent('error', 'object.has.null-value', path, `Object must not contain null values (found at key '${key}').`, `Please remove null values.`, { expected: 'no null values', actual: key }),
+            ];
+        }
+    }
+    return [];
+};

package/dist/core/validators/object/no-undefined-values.js

@@ -0,0 +1,44 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Undefined Values
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object does not contain any
+ *                  undefined values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object does not contain any undefined values.
+ *
+ * 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.
+ *
+ * Each own enumerable property is inspected. If any property value is undefined,
+ * an object.undefined-value event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const noUndefinedValues = 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 }),
+        ];
+    }
+    for (const key of Object.keys(value)) {
+        const propertyValue = value[key];
+        if (propertyValue === undefined) {
+            return [
+                validationEvent('error', 'object.has.undefined-value', path, `Object must not contain undefined values (found at key '${key}').`, `Please remove undefined values.`, { expected: 'no undefined values', actual: key }),
+            ];
+        }
+    }
+    return [];
+};

package/dist/core/validators/object/non-empty-object.js

@@ -0,0 +1,40 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Empty Object
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object is not empty.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object is not empty.
+ *
+ * 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 object contains zero own enumerable keys, an object.empty-object event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const nonEmptyObject = 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 === 0) {
+        return [
+            validationEvent('error', 'object.is.empty', path, `Object must not be empty.`, `Please provide at least one key.`, { expected: 'non-empty object', actual: 0 }),
+        ];
+    }
+    return [];
+};

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

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Only Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains only the allowed 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 only the allowed 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 object contains any keys not included in the allowed list,
+ * an object.has.extra-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const onlyKeys = (allowed) => 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 keys = Object.keys(value);
+    const extraKeys = keys.filter((key) => !allowed.includes(key));
+    if (extraKeys.length > 0) {
+        return [
+            validationEvent('error', 'object.has.extra-key', path, `Object contains disallowed keys: ${extraKeys.join(', ')}.`, `Please remove the extra keys.`, { expected: allowed, actual: keys }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/plain-object.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Object
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a JSON-compatible plain object.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that the value is a JSON-compatible plain object.
+ *
+ * This rule accepts only 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.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const plainObject = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value) || false) {
+        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 }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/string/alpha-num.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Alpha-Numeric (Alpha Num)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  letters and digits.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing only ASCII letters and digits.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing characters outside `[A-Za-z0-9]` emit `string.not.alphanumeric`.
+ * - 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 alphaNum = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Alphanumeric check
+    // ------------------------------------------------------------
+    if (!/^[A-Za-z0-9]+$/.test(value)) {
+        return [
+            validationEvent('error', 'string.not.alphanumeric', path, `${safeStringify(value)} must contain only letters and numbers.`, `Please use only letters and numbers.`, { value, expected: 'A-Z, 0-9', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/alpha.js

@@ -0,0 +1,51 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Alphabetic (Alpha)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  alphabetic characters (`A–Z` and `a–z`).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing only ASCII alphabetic
+ * characters (`A–Z` and `a–z`).
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing characters outside `[A-Za-z]` emit `string.not.alpha`.
+ * - 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 alpha = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Alphabetic check
+    // ------------------------------------------------------------
+    if (!/^[A-Za-z]+$/.test(value)) {
+        return [
+            validationEvent('error', 'string.not.alpha', path, `${safeStringify(value)} must contain only alphabetic characters.`, `Please use only letters.`, { value, expected: 'A–Z only', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/chars-equal.js

@@ -0,0 +1,49 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Characters Equal (Chars Equal)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is
+ *                  exactly `exact`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string whose length is exactly `exact`.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings whose length does not match `exact` emit `string.has.invalid-length`.
+ * - 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 charsEqual = (exact) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Exact-length check
+    // ------------------------------------------------------------
+    if (value.length !== exact) {
+        return [
+            validationEvent('error', 'string.has.invalid-length', path, `String length ${value.length} must be exactly ${exact}.`, `Please enter a string that is exactly ${exact} characters long.`, { value, expected: exact, actual: value.length }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/ends-with.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Ends With
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string ending with the
+ *                  provided `suffix`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string ending with the provided `suffix`.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not end with `suffix` emit `string.must.end-with`.
+ * - 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 endsWith = (suffix) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${structuralType}'.`, `Please provide a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Ends-with check
+    // ------------------------------------------------------------
+    if (!value.endsWith(suffix)) {
+        return [
+            validationEvent('error', 'string.must.end-with', path, `${safeStringify(value)} must end with ${safeStringify(suffix)}.`, `Please end the value with ${suffix}.`, { value, expected: `endsWith(${suffix})`, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/is-ascii.js

@@ -0,0 +1,53 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Ascii
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  characters (code points 0x00–0x7F).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string containing only ASCII characters
+ * (code points 0x00–0x7F).
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings containing characters outside the ASCII range emit `string.not.ascii`.
+ * - 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 isAscii = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check
+    // ------------------------------------------------------------
+    if (typeof value !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${structuralType}'.`, `Please enter a valid string.`, { value, expected: 'string', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // ASCII check
+    // ------------------------------------------------------------
+    // eslint-disable-next-line no-control-regex
+    const nonAsciiPattern = new RegExp('[^\\x00-\\x7F]');
+    if (nonAsciiPattern.test(value)) {
+        return [
+            validationEvent('error', 'string.not.ascii', path, `${safeStringify(value)} must contain only ASCII characters.`, `Please use only ASCII characters.`, { value, expected: 'ASCII', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};