typebox 1.0.65 → 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,8 +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 Unicode Grapheme Clusters */
-export declare function StringGraphemeCount(value: string): number;
+/** 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 */

package/build/guard/guard.mjs

@@ -1,3 +1,4 @@
+import * as String from './string.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -129,9 +130,17 @@ export function IsValueLike(value) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-/** Returns the number of Unicode Grapheme Clusters */
-export function StringGraphemeCount(value) {
-    return Array.from(value).length;
+/** 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

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.65",
+  "version": "1.0.67",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -25,9 +25,13 @@ $ npm install typebox
 
 ## Usage
 
+A TypeScript engine for Json Schema [Reference](https://tsplay.dev/wOyMRm)
+
 ```typescript
 import Type from 'typebox'
 
+// Json Schema
+
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
   y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
@@ -43,6 +47,26 @@ type T = Type.Static<typeof T>                      // type T = {
                                                     //   y: number,
                                                     //   z: number
                                                     // }
+
+// TypeScript
+
+const { S } = Type.Script({ T }, `
+  type RenameKey<K> = 
+    K extends 'x' ? 'a' :
+    K extends 'y' ? 'b' :
+    K extends 'z' ? 'c' :
+    K
+
+  type S = {
+    readonly [K in keyof T as RenameKey<K>]: string
+  }
+`)
+
+type S = Type.Static<typeof S>                    // type S = {
+                                                  //   readonly a: string,
+                                                  //   readonly b: string,
+                                                  //   readonly c: string
+                                                  // }
 ```
 
 ## Overview
@@ -75,9 +99,9 @@ If upgrading from `@sinclair/typebox` refer to the 1.0 migration guide at the fo
 
 ## Type
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgYwgDsBneBOAXkSIDoB5YgK1Q0YACgDecSVOkzZcuAHoFcOkxbs4YypLIAuTmi4A5AK4hiqKCICUAGnkPHspVMJp9eCAKEw8t7XBI+siGpuaWNvZO0Q4uklCoAI4mwAkAJvoA2ngU9nhIfvgAXngAuv6SRcHcYRZW1jGNcnFwYNhosMCojPpaAL4NTUPDisrSeppwbqge9GZ1eHB9FSOrjS2SQZPTs-OWi8sBa8exY1JV20S74VAHRycP0i1994+PLi+U04gaIahcAGUYABDGDAGgAHmmEAwiAAfCcXN9WBwtG90aMpBM5jcVhiHi0tji6nj8ccWhdiZZXmSRh8gA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://tsplay.dev/NaMoBN)
 
-TypeBox includes many functions to create Json Schema types. Each function returns a small Json Schema fragment that corresponds to a TypeScript type. TypeBox uses function composition to combine schema fragments into more complex types. It provides a set of functions that are used to model Json Schema schematics as well as a set of functions that model constructs native to JavaScript and TypeScript.
+TypeBox provides many functions to create Json Schema types. Each function returns a small Json Schema fragment that can be composed into more complex types. TypeBox includes a set of functions that are used to construct Json Schema compliant schematics as well as a set of extended functions that return schematics for constructs native to JavaScript.
 
 ## Example
 
@@ -123,9 +147,9 @@ const S = Type.Number({                            // const S = {
 
 ## Value
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBANQIYBsCuBTOAzKERwDkMAnmBgEYQAeA9AG6qaEBQokscAKmVrvkVLkq1ViwDGEAHYBneFzgBebrwB0AeQoArDOJgAKAN4s4cagC4V5VQDk0IChij6AlABoTcEpZ7W7Dp1cPUwAvHzV-R2cXFgBfGIlpOTgAQSVEJgxVAAUkKBkMfS43OENTcorKqqraWjhJWXgUy2NTCzgARhLqnt6+vtry9ql7KOCvSwAGbv7ZuerB0284EYCocbC4Sfmd3bhFuE3VqLiXPfOdwdj01VugA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://tsplay.dev/W4YE1w)
 
-The Value module provides functions that perform typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, Decode and as well as advanced functions to perform structural Diff and Patch on dynamic JavaScript values.
+The Value submodule provides functions for validation and other typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, and Decode, as well as advanced functions for performing structural Diff and Patch operations on dynamic JavaScript values.
 
 ```typescript
 import Value from 'typebox/value'
@@ -154,9 +178,9 @@ const A = Value.Parse(T, {                          // const A: {
 
 ## Compile
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1IChRJY4AKlRxES5YXXrcurAHYBneMjgBeFGw4AKIdQB0AeRoArLMxiakcK9Zu3bjRnDmKUALjgA1AIYZgAEy8YaAAeBFwAGkFDEzNQrit6dx0sXQA5AFcQGiwoTQBKSLsi4pKrB2tEwQysnPD4uAok4TTM7NyC0s6u8qtGqtba+oAvJr1qtvyuqZKeuBH+mqguXDy86fWNm3LcAD4drhkIBXgAQVUUXQAFLyh5LAtNjfLnU-cEesqABkLH37tZyqyAZQOq9dwARh+f2hcFmfSBi1Bc3cnxhaNhjis8wRbWWa3RBO2510JKAA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://tsplay.dev/WyraZw)
 
-The Compile module is a high-performance JIT compiler that transforms types into efficient runtime validators. The compiler is optimized for both fast compilation and validation.
+The Compile submodule is a high-performance Json Schema compliant JIT compiler that compiles schematics into efficient runtime validators. The compiler is optimized for fast compilation and validation and is known to be one of the fastest validation solutions available for JavaScript.
 
 ```typescript
 import { Compile } from 'typebox/compile' 
@@ -182,9 +206,9 @@ const A = C.Parse({                                 // const A: {
 
 ## Script
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgGUBjKYMGVAE0SOqYgB2AZ3gI4AXh5oAdM1bsAFAAMA3nEpw4ZAFxwBAVxDFUUADTrNSXSNYCA5uY1wAXrtIQANqgCGA9QF8lAEpNULDwiMio6PC6OH5hUV0EAHliACtUJhgAHhUnGMKi4rC4zR1EADlDYzMCkobG0vpLZIYYWwd6pp7ispdkgCEITx8Bbt7JqLj-AD5qOIApIUFGJgALVBBvOABJAQ6IITRs4EFqBGlCNCnb0Li8CAysmCpLqFQAR31gD+47npxADaeAo5jwSDw4OceAAupRLmBsGhYMBUEIAY04moKtI8eYrHA8dJzK4iXi4P4FvQ5GwONxkDcFABhHBgfT0oJ8QQiRgSKSoWQsOkKNRifzmVROIEAaTgwD8AGtUEgIBhELDkrLYXAAD56fQeDyUQIhTF3OIJXkMZJpTLZPITc2TfoVBAAVQEZwEOSBCGqRhM5n9ho8sNmpidzsBLTghI9XsEvoQ7U6weqRvDkejAP6ZIT3uTw1GvnTofDUZzDRm81oNJgvk43ig3H2GBMqAETFQ1Gu6AY-MZgva3hgwCYOT7asYs1ucT7fMk+Src9jFQMgageoNRuzK5dscJNgVdm3Bl3lf3hTzbhGXl8Z9Dl6v0RmQA) | [Example 2](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgAkIA3VKOGAC1QGd0NocYADsMbVMIDG6ABQ9OEAK4AbACZwQAQxiTOHbnB6SowMDFTrCaAJSVUZSLA5E4AMQgQ4AXkREAdADKMNrAkgA8VqgQGG4eAHx2DtDwkXAAQprsPshogcEwoRFE0emZCbT0AMIQYEhwmsLqYJo85ogBzmg8QsIwnjmogcamMDJ+49b1jXAA5qjwxJqSANadqAC0PJpicABSAQDyAHJwAbqoWomO8JIQwq1wAN6xEAA0pewAvt6+uWcmZhkAANKKl3J4fI9KHA4GQAFxwYSKEDENjQuBIBFIlFomEALyxyNRUEon2oqQyWSe6KgqE0qjuyjqAG0ANI9ODLVBIErg+rdACymjAYVZcQAugiAIKqZgNaSqUVxOAAHxebPFpPJLhlcqkFlF3PeADVMsAGjBuj48AANPCq-AATXtarwAC08MqfDJ0QAdIG+gAkjwAqmA0FBJC1UIakHFPkHHqaTBaeJ91qBIDweMBiMpUP7KLZQS4hSLWdyvXAwxGo3wwuiK3V7OZGt08BQ4AB+fCae1wxvcuAtiSqdtIe09vDEfuD5tkVtj-B4yf4SSzmHCVCsEnlIG2OhwA6KGBgE9rbqZfgqJlwWkYfOSYJ59D7Y6nc6XcF+VIwv---9DzwCBiAAK1QJ97TgShvzAbAIwKXgAL-Q9nnhOBxj8d5MQw8Z3gJXC-DgMlv1pABHRRgFpdRkJQ+hmQ7PB3jwCdmJXcUgA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://tsplay.dev/Wk6L1m) | [Example 2](https://tsplay.dev/NnrJoN)
 
-TypeBox includes a TypeScript scripting engine able to parse TypeScript types directly into Json Schema. The engine uses symmetric runtime and type-level parsing and returns typed safe schematics from TypeScript types (including computed types). The engine is designed for TypeScript 7 native compiler but is supported in TypeScript 5 and above.
+TypeBox is a runtime TypeScript DSL engine that can create, transform, and compute Json Schema using native TypeScript syntax. The engine is implemented symmetrically at runtime and within the TypeScript type system, and is intended for use with the TypeScript 7 native compiler and above.
 
 ```typescript
 // Scripted Type
@@ -228,7 +252,7 @@ type S = Type.Static<typeof S>                      // type S = {
 
 ## Schema
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1ICgfWA7AM7xkcALwo2HABQIucOJWoAuMhBoArLMxikANHLhQsARwCuwIwBMVAbVL09ZCo9IAvUgF198sMWqxgLAEVWXl5ehCFKiwVUj5TEBosKFI8bzCKSMUYsnjE5NTcdPlXLOjYvKSUvANcLlwASl4IQXgAQTEUADoABQBDKAEsGTDRsfGJycZGOH4hODaQgwi4AAZdSc2t7YnpsJXK5PTMtY2d84uxvfkTw6h00rgARkvXy+u4R7v6hre-95m+HEXRBQA) | [Example 2](https://tsplay.dev/mxrl7w)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://tsplay.dev/Wvrv3W) | [Example 2](https://tsplay.dev/m3g0ym)
 
 TypeBox is built upon a high-performance validation infrastructure that supports the direct compilation and inference of Json Schema schematics. TypeBox implements Draft 3 to 2020-12 and is compliance tested via the official Json Schema [Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite). It offers high-performance JIT compilation with automatic fallback to dynamic checking in JIT restricted environments.