typebox 1.0.66 → 1.0.67

package/build/guard/emit.d.mts

@@ -34,7 +34,8 @@ export declare function IsGreaterThan(left: string, right: string): string;
 export declare function IsLessThan(left: string, right: string): string;
 export declare function IsLessEqualThan(left: string, right: string): string;
 export declare function IsGreaterEqualThan(left: string, right: string): string;
-export declare function StringGraphemeCount(value: string): string;
+export declare function IsMinLength(value: string, length: string): string;
+export declare function IsMaxLength(value: string, length: string): string;
 export declare function Every(value: string, offset: string, params: [value: string, index: string], expression: string): string;
 export declare function Entries(value: string): string;
 export declare function Keys(value: string): string;

package/build/guard/emit.mjs

@@ -104,8 +104,11 @@ export function IsGreaterEqualThan(left, right) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-export function StringGraphemeCount(value) {
-    return `Guard.StringGraphemeCount(${value})`;
+export function IsMinLength(value, length) {
+    return `Guard.IsMinLength(${value}, ${length})`;
+}
+export function IsMaxLength(value, length) {
+    return `Guard.IsMaxLength(${value}, ${length})`;
 }
 // --------------------------------------------------------------------------
 // Array
@@ -181,7 +184,7 @@ export function ReduceOr(operands) {
     return G.IsEqual(operands.length, 0) ? 'false' : operands.reduce((left, right) => Or(left, right));
 }
 // --------------------------------------------------------------------------
-// Arithmatic
+// Arithmetic
 // --------------------------------------------------------------------------
 export function PrefixIncrement(expression) {
     return `++${expression}`;

package/build/guard/guard.d.mts

@@ -37,6 +37,12 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
+/** Returns the number of grapheme clusters in the string */
+export declare function GraphemeCount(value: string): number;
+/** Returns true if the string has at most the given number of graphemes */
+export declare function IsMaxLength(value: string, length: number): boolean;
+/** Returns true if the string has at least the given number of graphemes */
+export declare function IsMinLength(value: string, length: number): boolean;
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if this value has this property key */
@@ -55,5 +61,3 @@ export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
 /** Tests values for deep equality */
 export declare function IsDeepEqual(left: unknown, right: unknown): boolean;
-/** Returns the number of Unicode Grapheme Clusters */
-export declare function StringGraphemeCount(value: string): number;

package/build/guard/guard.mjs

@@ -1,3 +1,4 @@
+import * as String from './string.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -127,6 +128,21 @@ export function IsValueLike(value) {
         IsUndefined(value);
 }
 // --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in the string */
+export function GraphemeCount(value) {
+    return String.GraphemeCount(value);
+}
+/** Returns true if the string has at most the given number of graphemes */
+export function IsMaxLength(value, length) {
+    return String.IsMaxLengthFast(value, length);
+}
+/** Returns true if the string has at least the given number of graphemes */
+export function IsMinLength(value, length) {
+    return String.IsMinLengthFast(value, length);
+}
+// --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, callback) {
@@ -190,84 +206,3 @@ function DeepEqualArray(left, right) {
 export function IsDeepEqual(left, right) {
     return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
 }
-// --------------------------------------------------------------------------
-// StringGraphemeCountIntl - Intl.Segmenter Polyfill
-// --------------------------------------------------------------------------
-//
-// const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' })
-// function StringGraphemeCountIntl(value: string): number {
-//   const iterator = segmenter.segment(value)[Symbol.iterator]()
-//   let length = 0
-//   while (!iterator.next().done) length++
-//   return length
-// }
-//
-// --------------------------------------------------------------------------
-function IsRegionalIndicator(value) {
-    return value >= 0x1F1E6 && value <= 0x1F1FF;
-}
-function IsVariationSelector(value) {
-    return value >= 0xFE00 && value <= 0xFE0F;
-}
-function IsCombiningMark(value) {
-    return ((value >= 0x0300 && value <= 0x036F) ||
-        (value >= 0x1AB0 && value <= 0x1AFF) ||
-        (value >= 0x1DC0 && value <= 0x1DFF) ||
-        (value >= 0xFE20 && value <= 0xFE2F));
-}
-function CodePointLength(value) {
-    return value > 0xFFFF ? 2 : 1;
-}
-function StringGraphemeCountIntl(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        const start = value.codePointAt(index);
-        let clusterEnd = index + CodePointLength(start);
-        // Combining marks & variation selectors
-        while (clusterEnd < value.length) {
-            const next = value.codePointAt(clusterEnd);
-            if (IsCombiningMark(next) || IsVariationSelector(next)) {
-                clusterEnd += CodePointLength(next);
-            }
-            else {
-                break;
-            }
-        }
-        // ZWJ sequences
-        while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
-            const next = value.codePointAt(clusterEnd + 1);
-            clusterEnd += 1 + CodePointLength(next);
-        }
-        // Regional indicator pairs (flags)
-        const first = IsRegionalIndicator(start);
-        const second = clusterEnd < value.length && IsRegionalIndicator(value.codePointAt(clusterEnd));
-        if (first && second) {
-            const next = value.codePointAt(clusterEnd);
-            clusterEnd += CodePointLength(next);
-        }
-        count++;
-        index = clusterEnd;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
-// StringGraphemeCount
-// --------------------------------------------------------------------------
-function IsComplexGraphemeCodeUnit(value) {
-    return ((value >= 0xD800 && value <= 0xDBFF) || // High surrogate
-        (value >= 0x0300 && value <= 0x036F) || // Combining diacritical marks
-        (value === 0x200D) // Zero-width joiner
-    );
-}
-/** Returns the number of Unicode Grapheme Clusters */
-export function StringGraphemeCount(value) {
-    let count = 0;
-    for (let index = 0; index < value.length; index++) {
-        if (IsComplexGraphemeCodeUnit(value.charCodeAt(index))) {
-            return StringGraphemeCountIntl(value);
-        }
-        count++;
-    }
-    return count;
-}

package/build/guard/string.d.mts

@@ -0,0 +1,10 @@
+/** Returns the number of grapheme clusters in a string */
+export declare function GraphemeCount(value: string): number;
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export declare function IsMinLength(value: string, minLength: number): boolean;
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export declare function IsMinLengthFast(value: string, minLength: number): boolean;
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;

package/build/guard/string.mjs

@@ -0,0 +1,154 @@
+// --------------------------------------------------------------------------
+// IsBetween
+// --------------------------------------------------------------------------
+function IsBetween(value, min, max) {
+    return value >= min && value <= max;
+}
+// --------------------------------------------------------------------------
+// IsRegionalIndicator
+// --------------------------------------------------------------------------
+function IsRegionalIndicator(value) {
+    return IsBetween(value, 0x1F1E6, 0x1F1FF);
+}
+// --------------------------------------------------------------------------
+// IsVariationSelector
+// --------------------------------------------------------------------------
+function IsVariationSelector(value) {
+    return IsBetween(value, 0xFE00, 0xFE0F);
+}
+// --------------------------------------------------------------------------
+// IsCombiningMark
+// --------------------------------------------------------------------------
+function IsCombiningMark(value) {
+    return (IsBetween(value, 0x0300, 0x036F) ||
+        IsBetween(value, 0x1AB0, 0x1AFF) ||
+        IsBetween(value, 0x1DC0, 0x1DFF) ||
+        IsBetween(value, 0xFE20, 0xFE2F));
+}
+// --------------------------------------------------------------------------
+// CodePointLength
+// --------------------------------------------------------------------------
+function CodePointLength(value) {
+    return value > 0xFFFF ? 2 : 1;
+}
+// --------------------------------------------------------------------------
+// ConsumeModifiers (helper)
+// --------------------------------------------------------------------------
+function ConsumeModifiers(value, index) {
+    while (index < value.length) {
+        const point = value.codePointAt(index);
+        if (IsCombiningMark(point) || IsVariationSelector(point)) {
+            index += CodePointLength(point);
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+}
+// --------------------------------------------------------------------------
+// NextGraphemeClusterIndex
+// --------------------------------------------------------------------------
+function NextGraphemeClusterIndex(value, clusterStart) {
+    const startCP = value.codePointAt(clusterStart);
+    let clusterEnd = clusterStart + CodePointLength(startCP);
+    // Consume combining marks & variation selectors
+    clusterEnd = ConsumeModifiers(value, clusterEnd);
+    // Handle multi-ZWJ sequences
+    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+        const nextCP = value.codePointAt(clusterEnd + 1);
+        clusterEnd += 1 + CodePointLength(nextCP);
+        clusterEnd = ConsumeModifiers(value, clusterEnd);
+    }
+    // Handle regional indicator pairs (flags)
+    if (IsRegionalIndicator(startCP) &&
+        clusterEnd < value.length &&
+        IsRegionalIndicator(value.codePointAt(clusterEnd))) {
+        clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
+    }
+    return clusterEnd;
+}
+// --------------------------------------------------------------------------
+// IsGraphemeCodePoint
+// --------------------------------------------------------------------------
+function IsGraphemeCodePoint(value) {
+    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
+        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
+        (value === 0x200D) // Zero-width joiner
+    );
+}
+// --------------------------------------------------------------------------
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export function IsMinLength(value, minLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export function IsMaxLength(value, maxLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count > maxLength)
+            return false;
+    }
+    return true;
+}
+// --------------------------------------------------------------------------
+// IsMinLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export function IsMinLengthFast(value, minLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMinLength(value, minLength);
+        }
+        index++;
+        if (index >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export function IsMaxLengthFast(value, maxLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMaxLength(value, maxLength);
+        }
+        index++;
+        if (index > maxLength)
+            return false;
+    }
+    return true;
+}

package/build/schema/engine/maxLength.mjs

@@ -4,13 +4,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildMaxLength(stack, context, schema, value) {
-    return E.IsLessEqualThan(E.StringGraphemeCount(value), E.Constant(schema.maxLength));
+    return E.IsMaxLength(value, E.Constant(schema.maxLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckMaxLength(stack, context, schema, value) {
-    return G.IsLessEqualThan(G.StringGraphemeCount(value), schema.maxLength);
+    return G.IsMaxLength(value, schema.maxLength);
 }
 // ------------------------------------------------------------------
 // Error

package/build/schema/engine/minLength.mjs

@@ -4,13 +4,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildMinLength(stack, context, schema, value) {
-    return E.IsGreaterEqualThan(E.StringGraphemeCount(value), E.Constant(schema.minLength));
+    return E.IsMinLength(value, E.Constant(schema.minLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckMinLength(stack, context, schema, value) {
-    return G.IsGreaterEqualThan(G.StringGraphemeCount(value), schema.minLength);
+    return G.IsMinLength(value, schema.minLength);
 }
 // ------------------------------------------------------------------
 // Error

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "keywords": [
     "typescript",
     "jsonschema"