@sinclair/typebox 0.30.2 → 0.30.3

package/compiler/compiler.js

@@ -429,7 +429,9 @@ var TypeCompiler;
         yield IsVoidCheck(value);
     }
     function* TKind(schema, references, value) {
-        yield `kind('${schema[Types.Kind]}', ${value})`;
+        const instance = state.instances.size;
+        state.instances.set(instance, schema);
+        yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
         const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
@@ -525,7 +527,8 @@ var TypeCompiler;
     const state = {
         language: 'javascript',
         functions: new Map(),
-        variables: new Map(), // local variables
+        variables: new Map(),
+        instances: new Map() // exterior kind instances
     };
     // -------------------------------------------------------------------
     // Compiler Factory
@@ -583,6 +586,7 @@ var TypeCompiler;
         state.language = options.language;
         state.variables.clear();
         state.functions.clear();
+        state.instances.clear();
         if (!Types.TypeGuard.TSchema(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)
@@ -595,9 +599,10 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         const generatedCode = Code(schema, references, { language: 'javascript' });
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
-        function typeRegistryFunction(kind, value) {
-            if (!Types.TypeRegistry.Has(kind))
+        function typeRegistryFunction(kind, instance, value) {
+            if (!Types.TypeRegistry.Has(kind) || !state.instances.has(instance))
                 return false;
+            const schema = state.instances.get(instance);
             const checkFunc = Types.TypeRegistry.Get(kind);
             return checkFunc(schema, value);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.2",
+  "version": "0.30.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -72,7 +72,6 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
-- [Features](#features)
 - [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)
@@ -84,9 +83,9 @@ License MIT
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
-  - [Intrinsic String](#types-intrinsic-string)
   - [Indexed](#types-indexed)
   - [Negated](#types-negated)
+  - [Intrinsic](#types-intrinsic)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
@@ -876,34 +875,6 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      // }
 ```
 
-<a name='types-intrinsic-string'></a>
-
-### Intrinsic String Types
-
-TypeBox supports a set of intrinsic string mapping functions which can be used on string literals. These functions match the TypeScript string intrinsic types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These functions are supported for literal strings, template literals and union types. The following shows the literal string usage.
-
-```typescript
-// TypeScript
-
-type A = Uncapitalize<'HELLO'>                      // type A = 'hELLO'
-
-type B = Capitalize<'hello'>                        // type B = 'Hello'
-
-type C = Uppercase<'hello'>                         // type C = 'HELLO'
-
-type D = Lowercase<'HELLO'>                         // type D = 'hello'
-
-// TypeBox
-
-const A = Type.Uncapitalize(Type.Literal('HELLO')) // const A: TLiteral<'hELLO'>
-
-const B = Type.Capitalize(Type.Literal('hello'))   // const B: TLiteral<'Hello'>
-
-const C = Type.Uppercase(Type.Literal('hello'))    // const C: TLiteral<'HELLO'>
-
-const D = Type.Lowercase(Type.Literal('HELLO'))    // const D: TLiteral<'hello'>
-```
-
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
@@ -986,6 +957,41 @@ const Even = Type.Number({ multipleOf: 2 })
 
 const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])          
 ```
+
+<a name='types-intrinsic'></a>
+
+### Intrinsic String Types
+
+TypeBox supports TypeScript intrinsic string manipulation types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These can be applied to string literals, template literals and unions. The following shows general usage.
+
+```typescript
+// TypeScript
+
+type A = Capitalize<'hello'>                        // type A = 'Hello'
+
+type B = Capitalize<'hello' | 'world'>              // type C = 'Hello' | 'World'
+
+type C = Capitalize<`hello${1|2|3}`>                // type B = 'Hello1' | 'Hello2' | 'Hello3'
+
+// TypeBox
+
+const A = Type.Capitalize(Type.Literal('hello'))    // const A: TLiteral<'Hello'>
+
+const B = Type.Capitalize(Type.Union([              // const B: TUnion<[
+  Type.Literal('hello'),                            //   TLiteral<'Hello'>,
+  Type.Literal('world')                             //   TLiteral<'World'>
+]))                                                 // ]>
+
+const C = Type.Capitalize(                          // const C: TTemplateLiteral<[
+  Type.TemplateLiteral('hello${1|2|3}')             //   TLiteral<'Hello'>,
+)                                                   //   TUnion<[
+                                                    //     TLiteral<'1'>,
+                                                    //     TLiteral<'2'>,
+                                                    //     TLiteral<'3'>
+                                                    //   ]>
+                                                    // ]>
+```
+
 <a name='types-rest'></a>
 
 ### Rest Types