@sinclair/typebox 0.26.7 → 0.27.0

package/value/check.d.ts

@@ -4,8 +4,8 @@ export declare class ValueCheckUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueCheckDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueCheck {
     function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean;

package/value/check.js

@@ -315,13 +315,6 @@ var ValueCheck;
         const target = references[index];
         return Visit(target, references, value);
     }
-    function Self(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCheckDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
     function String(schema, references, value) {
         if (!IsString(value)) {
             return false;
@@ -353,6 +346,19 @@ var ValueCheck;
         }
         return true;
     }
+    function TemplateLiteral(schema, references, value) {
+        if (!IsString(value)) {
+            return false;
+        }
+        return new RegExp(schema.pattern).test(value);
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCheckDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
     function Tuple(schema, references, value) {
         if (!globalThis.Array.isArray(value)) {
             return false;
@@ -442,12 +448,14 @@ var ValueCheck;
                 return Record(schema_, references_, value);
             case 'Ref':
                 return Ref(schema_, references_, value);
-            case 'Self':
-                return Self(schema_, references_, value);
             case 'String':
                 return String(schema_, references_, value);
             case 'Symbol':
                 return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
             case 'Tuple':
                 return Tuple(schema_, references_, value);
             case 'Undefined':

package/value/convert.d.ts

@@ -4,8 +4,8 @@ export declare class ValueConvertUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueConvertDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueConvert {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown;

package/value/convert.js

@@ -252,19 +252,22 @@ var ValueConvert;
         const target = references[index];
         return Visit(target, references, value);
     }
-    function Self(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueConvertDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
     function String(schema, references, value) {
         return TryConvertString(value);
     }
     function Symbol(schema, references, value) {
         return value;
     }
+    function TemplateLiteral(schema, references, value) {
+        return value;
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
     function Tuple(schema, references, value) {
         if (IsArray(value) && schema.items !== undefined) {
             return value.map((value, index) => {
@@ -335,12 +338,14 @@ var ValueConvert;
                 return Record(schema_, references_, value);
             case 'Ref':
                 return Ref(schema_, references_, value);
-            case 'Self':
-                return Self(schema_, references_, value);
             case 'String':
                 return String(schema_, references_, value);
             case 'Symbol':
                 return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
             case 'Tuple':
                 return Tuple(schema_, references_, value);
             case 'Undefined':

package/value/create.d.ts

@@ -11,9 +11,13 @@ export declare class ValueCreateIntersectTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateTempateLiteralTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueCreateDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -54,6 +54,13 @@ class ValueCreateIntersectTypeError extends Error {
     }
 }
 exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+class ValueCreateTempateLiteralTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
 class ValueCreateDereferenceError extends Error {
     constructor(schema) {
         super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`);
@@ -241,7 +248,7 @@ var ValueCreate;
         if ('default' in schema) {
             return schema.default;
         }
-        else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
+        else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
             const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
             return propertyKeys.reduce((acc, key) => {
                 return { ...acc, [key]: Create(valueSchema, references) };
@@ -263,18 +270,6 @@ var ValueCreate;
             return Visit(target, references);
         }
     }
-    function Self(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
-            if (index === -1)
-                throw new ValueCreateDereferenceError(schema);
-            const target = references[index];
-            return Visit(target, references);
-        }
-    }
     function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (!('default' in schema)) {
@@ -317,6 +312,28 @@ var ValueCreate;
             return globalThis.Symbol();
         }
     }
+    function TemplateLiteral(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
+        if (!Types.TemplateLiteralFinite.Check(expression))
+            throw new ValueCreateTempateLiteralTypeError(schema);
+        const sequence = Types.TemplateLiteralGenerator.Generate(expression);
+        return sequence.next().value;
+    }
+    function This(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
+        }
+    }
     function Tuple(schema, references) {
         if ('default' in schema) {
             return schema.default;
@@ -423,12 +440,14 @@ var ValueCreate;
                 return Record(schema_, references_);
             case 'Ref':
                 return Ref(schema_, references_);
-            case 'Self':
-                return Self(schema_, references_);
             case 'String':
                 return String(schema_, references_);
             case 'Symbol':
                 return Symbol(schema_, references_);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_);
+            case 'This':
+                return This(schema_, references_);
             case 'Tuple':
                 return Tuple(schema_, references_);
             case 'Undefined':