@sinclair/typebox 0.23.1 → 0.23.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/readme.md

@@ -42,7 +42,7 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using industry standard JSON Schema validation.
+TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
 
@@ -263,19 +263,19 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │    Type.Object({               │    x: number                │    allOf: [{                   │
 │       x: Type.Number()         │ } & {                       │       type: 'object',          │
 │    }),                         │    y: number                │       properties: {            │
-│    Type.Object({               │ }                           │          a: {                  │
+│    Type.Object({               │ }                           │          x: {                  │
 │       y: Type.Number()         │                             │            type: 'number'      │
 │   })                           │                             │          }                     │
 │ })                             │                             │       },                       │
-│                                │                             │       required: ['a']          │
+│                                │                             │       required: ['x']          │
 │                                │                             │    }, {                        │
 │                                │                             │       type: 'object',          │
 │                                │                             │       properties: {            │
-│                                │                             │          b: {                  │
+│                                │                             │          y: {                  │
 │                                │                             │            type: 'number'      │
 │                                │                             │          }                     │
 │                                │                             │       },                       │
-│                                │                             │       required: ['b']          │
+│                                │                             │       required: ['y']          │
 │                                │                             │    }]                          │
 │                                │                             │ }                              │
 │                                │                             │                                │

package/typebox.d.ts

@@ -340,9 +340,9 @@ export declare class TypeBuilder {
     Ref<T extends TSchema>(schema: T): TRef<T>;
     /** `Experimental` Creates a recursive type */
     Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
-    /** Conditionally stores and schema if it contains an $id and returns.  */
-    protected Store(schema: any): any;
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
-    protected Deref(schema: any): any;
+    /** Conditionally stores and schema if it contains an $id and returns  */
+    protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T;
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
+    protected Deref<T extends TSchema>(schema: T): any;
 }
 export declare const Type: TypeBuilder;

package/typebox.js

@@ -320,20 +320,22 @@ class TypeBuilder {
         const self = callback({ $ref: `${$id}#/$defs/self` });
         return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } });
     }
-    /** Conditionally stores and schema if it contains an $id and returns.  */
+    /** Conditionally stores and schema if it contains an $id and returns  */
     Store(schema) {
-        if (!schema.$id)
-            return schema;
-        this.schemas.set(schema.$id, schema);
-        return schema;
+        const $schema = schema;
+        if (!$schema['$id'])
+            return $schema;
+        this.schemas.set($schema['$id'], $schema);
+        return $schema;
     }
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
     Deref(schema) {
-        if (schema.kind !== exports.RefKind)
+        const $schema = schema;
+        if ($schema['kind'] !== exports.RefKind)
             return schema;
-        if (!this.schemas.has(schema.$ref))
-            throw Error(`Unable to locate schema with $id '${schema.$ref}'`);
-        return this.Deref(this.schemas.get(schema.$ref));
+        if (!this.schemas.has($schema['$ref']))
+            throw Error(`Unable to locate schema with $id '${$schema['$ref']}'`);
+        return this.Deref(this.schemas.get($schema['$ref']));
     }
 }
 exports.TypeBuilder = TypeBuilder;