@sinclair/typebox 0.34.11 → 0.34.12

package/build/cjs/value/mutate/mutate.js

@@ -8,6 +8,12 @@ const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
 const index_4 = require("../../type/error/index");
 // ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return (0, index_1.IsObject)(value) && !(0, index_1.IsArray)(value);
+}
+// ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
 class ValueMutateError extends index_4.TypeBoxError {
@@ -17,7 +23,7 @@ class ValueMutateError extends index_4.TypeBoxError {
 }
 exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
-    if (!(0, index_1.IsObject)(current)) {
+    if (!IsStandardObject(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
@@ -69,7 +75,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if ((0, index_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if ((0, index_1.IsObject)(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
@@ -82,8 +88,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return (((0, index_1.IsObject)(current) && (0, index_1.IsArray)(next)) ||
-        ((0, index_1.IsArray)(current) && (0, index_1.IsObject)(next)));
+    return ((IsStandardObject(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/esm/value/mutate/mutate.mjs

@@ -3,6 +3,12 @@ import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value);
+}
+// ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
 export class ValueMutateError extends TypeBoxError {
@@ -11,7 +17,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsObject(current)) {
+    if (!IsStandardObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +69,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsObject(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +82,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsObject(next)));
+    return ((IsStandardObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.11",
+  "version": "0.34.12",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -68,6 +68,7 @@ License MIT
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
+  - [Recursive](#types-recursive)
   - [Modules](#types-modules)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
@@ -759,21 +760,51 @@ const T = Nullable(Type.String())                    // const T = {
 type T = Static<typeof T>                            // type T = string | null
 ```
 
-<a name='types-modules'></a>
+<a name='types-recursive'></a>
 
-### Module Types
+### Recursive Types
 
-TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
+Use the Recursive function to create a singular recursive type.
 
-#### Usage
+```typescript
+const Node = Type.Recursive(Self => Type.Object({    // const Node = {
+  id: Type.String(),                                 //   $id: 'Node',
+  nodes: Type.Array(Self)                            //   type: 'object',
+}), { $id: 'Node' })                                 //   properties: {
+                                                     //     id: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     nodes: {
+                                                     //       type: 'array',
+                                                     //       items: {
+                                                     //         $ref: 'Node'
+                                                     //       }
+                                                     //     }
+                                                     //   },
+                                                     //   required: [
+                                                     //     'id',
+                                                     //     'nodes'
+                                                     //   ]
+                                                     // }
 
-The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
+type Node = Static<typeof Node>                      // type Node = {
+                                                     //   id: string
+                                                     //   nodes: Node[]
+                                                     // }
 
-```typescript
-// Module with PartialUser and User types
+function test(node: Node) {
+  const id = node.nodes[0].nodes[0].id               // id is string
+}
+```
 
-const Module = Type.Module({
+<a name='types-modules'></a>
+
+### Module Types
 
+Module types are containers for a set of referential types. Modules act as namespaces, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive references, as well as deferred dereferencing for computed types such as Partial. Types imported from a module are expressed using the Json Schema `$defs` keyword. 
+
+```typescript
+const Module = Type.Module({
   PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
 
   User: Type.Object({                           // TObject<{
@@ -781,11 +812,7 @@ const Module = Type.Module({
     name: Type.String(),                        //   name: TString,
     email: Type.String()                        //   email: TString
   }),                                           // }>
-  
 })
-
-// Types must be imported before use.
-
 const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
 type User = Static<typeof User>                  // type User = { 
@@ -803,7 +830,6 @@ type PartialUser = Static<typeof PartialUser>    // type PartialUser = {
                                                  // }
 ```
 
-
 <a name='types-template-literal'></a>
 
 ### Template Literal Types