@sinclair/typebox 0.26.8 → 0.27.1

package/compiler/compiler.js

@@ -363,10 +363,6 @@ var TypeCompiler;
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
-    function* Self(schema, references, value) {
-        const func = CreateFunctionName(schema.$ref);
-        yield `${func}(${value})`;
-    }
     function* String(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if (IsNumber(schema.minLength))
@@ -384,6 +380,15 @@ var TypeCompiler;
     function* Symbol(schema, references, value) {
         yield `(typeof ${value} === 'symbol')`;
     }
+    function* TemplateLiteral(schema, references, value) {
+        yield `(typeof ${value} === 'string')`;
+        const local = PushLocal(`${new RegExp(schema.pattern)};`);
+        yield `${local}.test(${value})`;
+    }
+    function* This(schema, references, value) {
+        const func = CreateFunctionName(schema.$ref);
+        yield `${func}(${value})`;
+    }
     function* Tuple(schema, references, value) {
         yield `(Array.isArray(${value}))`;
         if (schema.items === undefined)
@@ -470,12 +475,14 @@ var TypeCompiler;
                 return yield* Record(schema_, references_, value);
             case 'Ref':
                 return yield* Ref(schema_, references_, value);
-            case 'Self':
-                return yield* Self(schema_, references_, value);
             case 'String':
                 return yield* String(schema_, references_, value);
             case 'Symbol':
                 return yield* Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return yield* TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return yield* This(schema_, references_, value);
             case 'Tuple':
                 return yield* Tuple(schema_, references_, value);
             case 'Undefined':

package/errors/errors.d.ts

@@ -79,8 +79,8 @@ export declare class ValueErrorsUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueErrorsDereferenceError 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);
 }
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {

package/errors/errors.js

@@ -410,7 +410,7 @@ var ValueErrors;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
         if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-            const numeric = keyPattern === '^(0|[1-9][0-9]*)$';
+            const numeric = keyPattern === Types.PatternNumberExact;
             const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
             const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
             return yield { type, schema, path, value, message };
@@ -426,13 +426,6 @@ var ValueErrors;
         const target = references[index];
         yield* Visit(target, references, path, value);
     }
-    function* Self(schema, references, path, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueErrorsDereferenceError(schema);
-        const target = references[index];
-        yield* Visit(target, references, path, value);
-    }
     function* String(schema, references, path, value) {
         if (!IsString(value)) {
             return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
@@ -466,6 +459,22 @@ var ValueErrors;
             return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' };
         }
     }
+    function* TemplateLiteral(schema, references, path, value) {
+        if (!IsString(value)) {
+            return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
+        }
+        const regex = new RegExp(schema.pattern);
+        if (!regex.test(value)) {
+            yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
+        }
+    }
+    function* This(schema, references, path, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueErrorsDereferenceError(schema);
+        const target = references[index];
+        yield* Visit(target, references, path, value);
+    }
     function* Tuple(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
             return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' };
@@ -566,12 +575,14 @@ var ValueErrors;
                 return yield* Record(schema_, references_, path, value);
             case 'Ref':
                 return yield* Ref(schema_, references_, path, value);
-            case 'Self':
-                return yield* Self(schema_, references_, path, value);
             case 'String':
                 return yield* String(schema_, references_, path, value);
             case 'Symbol':
                 return yield* Symbol(schema_, references_, path, value);
+            case 'TemplateLiteral':
+                return yield* TemplateLiteral(schema_, references_, path, value);
+            case 'This':
+                return yield* This(schema_, references_, path, value);
             case 'Tuple':
                 return yield* Tuple(schema_, references_, path, value);
             case 'Undefined':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.8",
+  "version": "0.27.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,7 +37,7 @@
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.11.9",
-    "ajv": "^8.11.2",
+    "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",