@sinclair/typebox 0.31.18 → 0.31.20

package/errors/errors.d.ts

@@ -75,6 +75,7 @@ export declare class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare function EscapeKey(key: string): string;
 export declare class ValueErrorIterator {
     private readonly iterator;
     constructor(iterator: IterableIterator<ValueError>);

package/errors/errors.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Errors = exports.ValueErrorIterator = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
+exports.Errors = exports.ValueErrorIterator = exports.EscapeKey = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const guard_1 = require("../value/guard");
 const system_1 = require("../system/system");
 const deref_1 = require("../value/deref");
@@ -113,6 +113,13 @@ class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
 // --------------------------------------------------------------------------
+// EscapeKey
+// --------------------------------------------------------------------------
+function EscapeKey(key) {
+    return key.replace(/~/g, '~0').replace(/\//g, '~1'); // RFC6901 Path
+}
+exports.EscapeKey = EscapeKey;
+// --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
 function IsDefined(value) {
@@ -338,12 +345,12 @@ function* TObject(schema, references, path, value) {
     for (const requiredKey of requiredKeys) {
         if (unknownKeys.includes(requiredKey))
             continue;
-        yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${requiredKey}`, undefined);
+        yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${EscapeKey(requiredKey)}`, undefined);
     }
     if (schema.additionalProperties === false) {
         for (const valueKey of unknownKeys) {
             if (!knownKeys.includes(valueKey)) {
-                yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${valueKey}`, value[valueKey]);
+                yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(valueKey)}`, value[valueKey]);
             }
         }
     }
@@ -351,20 +358,20 @@ function* TObject(schema, references, path, value) {
         for (const valueKey of unknownKeys) {
             if (knownKeys.includes(valueKey))
                 continue;
-            yield* Visit(schema.additionalProperties, references, `${path}/${valueKey}`, value[valueKey]);
+            yield* Visit(schema.additionalProperties, references, `${path}/${EscapeKey(valueKey)}`, value[valueKey]);
         }
     }
     for (const knownKey of knownKeys) {
         const property = schema.properties[knownKey];
         if (schema.required && schema.required.includes(knownKey)) {
-            yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
+            yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
             if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
-                yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${knownKey}`, undefined);
+                yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, undefined);
             }
         }
         else {
             if (system_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-                yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
+                yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
             }
         }
     }
@@ -386,19 +393,19 @@ function* TRecord(schema, references, path, value) {
     const regex = new RegExp(patternKey);
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
         if (regex.test(propertyKey))
-            yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue);
+            yield* Visit(patternSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
     }
     if (typeof schema.additionalProperties === 'object') {
         for (const [propertyKey, propertyValue] of Object.entries(value)) {
             if (!regex.test(propertyKey))
-                yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue);
+                yield* Visit(schema.additionalProperties, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
         }
     }
     if (schema.additionalProperties === false) {
         for (const [propertyKey, propertyValue] of Object.entries(value)) {
             if (regex.test(propertyKey))
                 continue;
-            return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${propertyKey}`, propertyValue);
+            return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
         }
     }
 }

package/package.json

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

package/typebox.d.ts

@@ -337,6 +337,7 @@ export type TRecordFromUnionLiteralString<K extends TLiteralString, T extends TS
 export type TRecordFromUnionLiteralNumber<K extends TLiteralNumber, T extends TSchema> = {
     [_ in K['const']]: T;
 };
+export type TRecordFromEnumKey<K extends TEnum, T extends TSchema> = Ensure<TRecord<K, T>>;
 export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K extends [infer L, ...infer R] ? (L extends TUnion<infer S> ? TRecordFromUnionRest<S, T> & TRecordFromUnionRest<AssertRest<R>, T> : L extends TLiteralString ? TRecordFromUnionLiteralString<L, T> & TRecordFromUnionRest<AssertRest<R>, T> : L extends TLiteralNumber ? TRecordFromUnionLiteralNumber<L, T> & TRecordFromUnionRest<AssertRest<R>, T> : {}) : {};
 export type TRecordFromUnion<K extends TSchema[], T extends TSchema> = Ensure<TObject<AssertProperties<Evaluate<TRecordFromUnionRest<K, T>>>>>;
 export type TRecordFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
@@ -353,7 +354,7 @@ export type TRecordFromLiteralNumberKey<K extends TLiteralNumber, T extends TSch
 export type TRecordFromStringKey<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>;
 export type TRecordFromNumberKey<K extends TNumber, T extends TSchema> = Ensure<TRecord<K, T>>;
 export type TRecordFromIntegerKey<K extends TInteger, T extends TSchema> = Ensure<TRecord<K, T>>;
-export type TRecordResolve<K extends TSchema, T extends TSchema> = K extends TUnion<infer S> ? TRecordFromUnion<S, T> : K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> : K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> : K extends TLiteralNumber ? TRecordFromLiteralNumberKey<K, T> : K extends TString ? TRecordFromStringKey<K, T> : K extends TNumber ? TRecordFromNumberKey<K, T> : K extends TInteger ? TRecordFromIntegerKey<K, T> : TNever;
+export type TRecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer _> ? TRecordFromEnumKey<K, T> : K extends TUnion<infer S> ? TRecordFromUnion<S, T> : K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> : K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> : K extends TLiteralNumber ? TRecordFromLiteralNumberKey<K, T> : K extends TString ? TRecordFromStringKey<K, T> : K extends TNumber ? TRecordFromNumberKey<K, T> : K extends TInteger ? TRecordFromIntegerKey<K, T> : TNever;
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;