typebox 1.0.64 → 1.0.66

package/build/guard/guard.d.mts

@@ -37,8 +37,6 @@ 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;
 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 */
@@ -57,3 +55,5 @@ 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

@@ -127,13 +127,6 @@ export function IsValueLike(value) {
         IsUndefined(value);
 }
 // --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-/** Returns the number of Unicode Grapheme Clusters */
-export function StringGraphemeCount(value) {
-    return Array.from(value).length;
-}
-// --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, callback) {
@@ -197,3 +190,84 @@ 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/schema/static/if.d.mts

@@ -0,0 +1,8 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XElse } from '../types/else.mjs';
+import type { XThen } from '../types/then.mjs';
+type XStaticIfReduce<Types extends unknown[], Result extends unknown = never> = (Types extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XStaticIfReduce<Right, Result | Left> : Result);
+export type XStaticIf<Stack extends string[], Root extends XSchema, Schema extends XIf, IfSchema extends XSchema, Then extends unknown[] = Schema extends XThen<infer ThenSchema extends XSchema> ? [XStaticSchema<Stack, Root, IfSchema> & XStaticSchema<Stack, Root, ThenSchema>] : [], Else extends unknown[] = Schema extends XElse<infer ElseSchema extends XSchema> ? [...Then, XStaticSchema<Stack, Root, ElseSchema>] : Then, Result extends unknown = Else extends [] ? unknown : XStaticIfReduce<Else>> = Result;
+export {};

package/build/schema/static/if.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/schema.d.mts

@@ -3,6 +3,7 @@ import type { XAnyOf } from '../types/anyOf.mjs';
 import type { XAllOf } from '../types/allOf.mjs';
 import type { XConst } from '../types/const.mjs';
 import type { XEnum } from '../types/enum.mjs';
+import type { XIf } from '../types/if.mjs';
 import type { XItems } from '../types/items.mjs';
 import type { XOneOf } from '../types/oneOf.mjs';
 import type { XPatternProperties } from '../types/patternProperties.mjs';
@@ -18,6 +19,7 @@ import type { XStaticAllOf } from './allOf.mjs';
 import type { XStaticAnyOf } from './anyOf.mjs';
 import type { XStaticConst } from './const.mjs';
 import type { XStaticEnum } from './enum.mjs';
+import type { XStaticIf } from './if.mjs';
 import type { XStaticItems } from './items.mjs';
 import type { XStaticOneOf } from './oneOf.mjs';
 import type { XStaticPatternProperties } from './patternProperties.mjs';
@@ -32,7 +34,7 @@ type TFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
     Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
     Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
     Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
-    Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
     Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
     Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
     Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "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.