@clementine-solutions/jane-io 1.0.0 → 1.0.2

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

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const endsWith: (suffix: string) => ValidationRule;

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

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const isAscii: ValidationRule;

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

package/dist/core/validators/string/is-printable.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Printable
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only
+ *                  printable ASCII characters (code points 0x20–0x7E).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string containing only printable ASCII
+ * characters (code points 0x20–0x7E).
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings containing characters outside the printable ASCII range emit
+ *   `string.not.printable`.
+ * - 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 isPrintable: ValidationRule;

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

@@ -0,0 +1,53 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Printable
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string containing only
+ *                  printable ASCII characters (code points 0x20–0x7E).
+ * @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 printable ASCII
+ * characters (code points 0x20–0x7E).
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings containing characters outside the printable ASCII range emit
+ *   `string.not.printable`.
+ * - 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 isPrintable = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Printable ASCII check
+    // ------------------------------------------------------------
+    const printablePattern = /^[\x20-\x7E]+$/;
+    if (!printablePattern.test(value)) {
+        return [
+            validationEvent('error', 'string.not.printable', path, `${safeStringify(value)} must contain only printable ASCII characters.`, `Please use only printable characters.`, { value, expected: 'printable ASCII', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

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

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Matches
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string matching the provided
+ *                  regular expression.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string matching the provided regular expression.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not satisfy the pattern emit `string.is.not-match`.
+ * - 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 matches: (pattern: RegExp) => ValidationRule;

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

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Matches
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string matching the provided
+ *                  regular expression.
+ * @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 matching the provided regular expression.
+ *
+ * - Non‑string values emit `string.not.string`.
+ * - Strings that do not satisfy the pattern emit `string.is.not-match`.
+ * - 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 matches = (pattern) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Pattern match check
+    // ------------------------------------------------------------
+    if (!pattern.test(value)) {
+        return [
+            validationEvent('error', 'string.is.not-match', path, `${safeStringify(value)} must match pattern ${pattern}.`, `Please provide a value matching the required format.`, { value, expected: pattern.toString(), actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/max-length.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Length (Max Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is less
+ *                  than or equal to the provided `max` value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string whose length is less than or equal to
+ * the provided `max` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings longer than `max` emit `string.too.long`.
+ * - 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 maxLength: (max: number) => ValidationRule;

package/dist/core/validators/string/max-length.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Length (Max Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is less
+ *                  than or equal to the provided `max` value.
+ * @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 less than or equal to
+ * the provided `max` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings longer than `max` emit `string.too.long`.
+ * - 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 maxLength = (max) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Maximum-length check
+    // ------------------------------------------------------------
+    if (value.length > max) {
+        return [
+            validationEvent('error', 'string.too.long', path, `String length ${value.length} must be ≤ ${max}.`, `Please enter no more than ${max} characters.`, { value, expected: `≤ ${max}`, actual: value.length }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/string/min-length.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Length (Min Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is greater
+ *                  than or equal to the provided `min` value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is a string whose length is greater than or equal to
+ * the provided `min` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings shorter than `min` emit `string.too.short`.
+ * - 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 minLength: (min: number) => ValidationRule;

package/dist/core/validators/string/min-length.js

@@ -0,0 +1,50 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Length (Min Length)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is a string whose length is greater
+ *                  than or equal to the provided `min` value.
+ * @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 greater than or equal to
+ * the provided `min` value.
+ *
+ * - Non‑string values emit `type.not.valid`.
+ * - Strings shorter than `min` emit `string.too.short`.
+ * - 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 minLength = (min) => 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Minimum-length check
+    // ------------------------------------------------------------
+    if (value.length < min) {
+        return [
+            validationEvent('error', 'string.too.short', path, `String length ${value.length} must be ≥ ${min}.`, `Please enter at least ${min} characters.`, { value, expected: `≥ ${min}`, actual: value.length }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid
+    // ------------------------------------------------------------
+    return [];
+};

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

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

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const noRepeatSpace: ValidationRule;