@sinclair/typebox 0.31.17 → 0.31.19

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.17",
+  "version": "0.31.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -52,7 +52,7 @@
     "publish:dev": "hammer task publish_dev"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.17.1",
+    "@sinclair/hammer": "^0.18.0",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.11.9",
     "ajv": "^8.12.0",

package/value/transform.js

@@ -439,12 +439,20 @@ var EncodeTransform;
         return (0, guard_1.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
     }
     function TUnion(schema, references, value) {
+        // test value against union variants
         for (const subschema of schema.anyOf) {
             if (!checkFunction(subschema, references, value))
                 continue;
             const value1 = Visit(subschema, references, value);
             return Default(schema, value1);
         }
+        // test transformed value against union variants
+        for (const subschema of schema.anyOf) {
+            const value1 = Visit(subschema, references, value);
+            if (!checkFunction(schema, references, value1))
+                continue;
+            return Default(schema, value1);
+        }
         return Default(schema, value);
     }
     function Visit(schema, references, value) {