@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/validators/string/no-repeat-space.js

@@ -0,0 +1,52 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Repeated Whitespace (No Repeat Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not contain
+ *                  repeated consecutive space characters.
+ * @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 that does not contain repeated
+ * consecutive space characters.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing `"  "` (two or more consecutive spaces) emit
+ *   `string.has.repeating-whitespace`.
+ * - 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 noRepeatSpace = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Repeated-space check
+    // ------------------------------------------------------------
+    if (/ {2,}/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.repeating-whitespace', path, `${safeStringify(value)} must not contain repeated spaces.`, `Please remove extra spaces.`, { value, expected: 'no repeated spaces', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-space.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Whitespace (No Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing no
+ *                  whitespace characters.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string containing no whitespace characters.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any whitespace (spaces, tabs, newlines, etc.) emit
+ *   `string.has.whitespace`.
+ * - 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 declare const noSpace: ValidationRule;

package/dist/core/validators/string/no-space.js

@@ -0,0 +1,51 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Whitespace (No Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing no
+ *                  whitespace characters.
+ * @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 no whitespace characters.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any whitespace (spaces, tabs, newlines, etc.) emit
+ *   `string.has.whitespace`.
+ * - 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 noSpace = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Whitespace check
+    // ------------------------------------------------------------
+    if (/\s/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.whitespace', path, `${safeStringify(value)} must not contain whitespace.`, `Please remove spaces.`, { value, expected: 'no whitespace', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/no-trail-space.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Trailing Whitespace (No Trail Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not end with
+ *                  whitespace.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string that does not end with whitespace.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings ending with whitespace emit `string.has.trailing-whitespace`.
+ * - 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 declare const noTrailSpace: ValidationRule;

package/dist/core/validators/string/no-trail-space.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | No Trailing Whitespace (No Trail Space)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that does not end with
+ *                  whitespace.
+ * @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 that does not end with whitespace.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings ending with whitespace emit `string.has.trailing-whitespace`.
+ * - 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 noTrailSpace = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Trailing whitespace check
+    // ------------------------------------------------------------
+    if (/\s$/.test(value)) {
+        return [
+            validationEvent('error', 'string.has.trailing-whitespace', path, `${safeStringify(value)} must not end with whitespace.`, `Please remove trailing spaces.`, { value, expected: 'no trailing space', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/non-empty.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Empty
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a non-empty string.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a non-empty string.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Empty strings emit `string.is.empty`.
+ * - 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 declare const nonEmpty: ValidationRule;

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

@@ -0,0 +1,48 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Empty
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a non-empty string.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a non-empty string.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Empty strings emit `string.is.empty`.
+ * - 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 nonEmpty = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Non-empty check
+    // ------------------------------------------------------------
+    if (value.length === 0) {
+        return [
+            validationEvent('error', 'string.is.empty', path, `String must not be empty.`, `Please enter a non-empty string.`, { value, expected: 'non-empty', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/not-one-of.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that is *not* included
+ *                  in the provided `disallowed` list.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string that is *not* included in the provided
+ * `disallowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings that appear in the disallowed list emit `string.is.disallowed`.
+ * - 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 declare const notOneOf: (disallowed: readonly string[]) => ValidationRule;

package/dist/core/validators/string/not-one-of.js

@@ -0,0 +1,51 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string that is *not* included
+ *                  in the provided `disallowed` list.
+ * @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 that is *not* included in the provided
+ * `disallowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings that appear in the disallowed list emit `string.is.disallowed`.
+ * - 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 notOneOf = (disallowed) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Disallowed membership check
+    // ------------------------------------------------------------
+    if (disallowed.includes(value)) {
+        return [
+            validationEvent('error', 'string.is.disallowed', path, `${safeStringify(value)} must not be one of: ${disallowed.join(', ')}.`, `Please enter a different value.`, { value, expected: `not in ${disallowed}`, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/num-string.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Number String (Num String)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  digits (`0–9`).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string containing only ASCII digits (`0–9`).
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any non-digit character emit `string.not.numeric`.
+ * - 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 declare const numString: ValidationRule;

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

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Number String (Num String)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only ASCII
+ *                  digits (`0–9`).
+ * @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 digits (`0–9`).
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings containing any non-digit character emit `string.not.numeric`.
+ * - 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 numString = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Digit-only check
+    // ------------------------------------------------------------
+    if (!/^[0-9]+$/.test(value)) {
+        return [
+            validationEvent('error', 'string.not.numeric', path, `${safeStringify(value)} must contain only digits.`, `Please use only numbers.`, { value, expected: '0-9', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/one-of.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string included in the
+ *                  provided `allowed` list.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string included in the provided `allowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings not present in the allowed list emit `string.not.allowed`.
+ * - 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 declare const oneOf: (allowed: readonly string[]) => ValidationRule;

package/dist/core/validators/string/one-of.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | One Of
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string included in the
+ *                  provided `allowed` list.
+ * @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 included in the provided `allowed` list.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings not present in the allowed list emit `string.not.allowed`.
+ * - 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 oneOf = (allowed) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Allowed membership check
+    // ------------------------------------------------------------
+    if (!allowed.includes(value)) {
+        return [
+            validationEvent('error', 'string.not.allowed', path, `${safeStringify(value)} must be one of: ${allowed.join(', ')}.`, `Please enter one of the allowed values.`, { value, expected: allowed, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/starts-with.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Starts With
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string beginning with the
+ *                  provided `prefix`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string beginning with the provided `prefix`.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not begin with `prefix` emit `string.must.start-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 declare const startsWith: (prefix: string) => ValidationRule;

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

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Starts With
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string beginning with the
+ *                  provided `prefix`.
+ * @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 beginning with the provided `prefix`.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not begin with `prefix` emit `string.must.start-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 startsWith = (prefix) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Starts-with check
+    // ------------------------------------------------------------
+    if (!value.startsWith(prefix)) {
+        return [
+            validationEvent('error', 'string.must.start-with', path, `${safeStringify(value)} must start with ${safeStringify(prefix)}.`, `Please begin the value with ${prefix}.`, { value, expected: `startsWith(${prefix})`, actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

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

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Returns an empty array when the value is a valid string.
+ *
+ * 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 declare const string: ValidationRule;

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

@@ -0,0 +1,39 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that the value is a string.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Returns an empty array when the value is a valid string.
+ *
+ * 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 string = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};