@sinclair/typebox 0.32.15 → 0.32.16

package/build/require/value/transform/decode.js

@@ -20,20 +20,24 @@ const type_1 = require("../../type/guard/type");
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
+// prettier-ignore
 class TransformDecodeCheckError extends index_2.TypeBoxError {
     constructor(schema, value, error) {
-        super(`Unable to decode due to invalid value`);
+        super(`Unable to decode value as it does not match the expected schema`);
         this.schema = schema;
         this.value = value;
         this.error = error;
     }
 }
 exports.TransformDecodeCheckError = TransformDecodeCheckError;
+// prettier-ignore
 class TransformDecodeError extends index_2.TypeBoxError {
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+    constructor(schema, path, value, error) {
+        super(error instanceof Error ? error.message : 'Unknown error');
         this.schema = schema;
+        this.path = path;
         this.value = value;
+        this.error = error;
     }
 }
 exports.TransformDecodeError = TransformDecodeError;
@@ -41,144 +45,144 @@ exports.TransformDecodeError = TransformDecodeError;
 // Decode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema, value) {
+function Default(schema, path, value) {
     try {
         return (0, type_1.IsTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
     }
     catch (error) {
-        throw new TransformDecodeError(schema, value, error);
+        throw new TransformDecodeError(schema, path, value, error);
     }
 }
 // prettier-ignore
-function FromArray(schema, references, value) {
+function FromArray(schema, references, path, value) {
     return ((0, index_7.IsArray)(value))
-        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
-        : Default(schema, value);
+        ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromIntersect(schema, references, value) {
+function FromIntersect(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
-function FromNot(schema, references, value) {
-    return Default(schema, Visit(schema.not, references, value));
+function FromNot(schema, references, path, value) {
+    return Default(schema, path, Visit(schema.not, references, path, value));
 }
 // prettier-ignore
-function FromObject(schema, references, value) {
+function FromObject(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRecord(schema, references, value) {
+function FromRecord(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
     const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
         return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRef(schema, references, value) {
+function FromRef(schema, references, path, value) {
     const target = (0, index_5.Deref)(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromThis(schema, references, value) {
+function FromThis(schema, references, path, value) {
     const target = (0, index_5.Deref)(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromTuple(schema, references, value) {
+function FromTuple(schema, references, path, value) {
     return ((0, index_7.IsArray)(value) && (0, index_7.IsArray)(schema.items))
-        ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-        : Default(schema, value);
+        ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromUnion(schema, references, value) {
+function FromUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
         // note: ensure interior is decoded first
-        const decoded = Visit(subschema, references, value);
-        return Default(schema, decoded);
+        const decoded = Visit(subschema, references, path, value);
+        return Default(schema, path, decoded);
     }
-    return Default(schema, value);
+    return Default(schema, path, value);
 }
 // prettier-ignore
-function Visit(schema, references, value) {
+function Visit(schema, references, path, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[index_1.Kind]) {
         case 'Array':
-            return FromArray(schema_, references_, value);
+            return FromArray(schema_, references_, path, value);
         case 'Intersect':
-            return FromIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, path, value);
         case 'Not':
-            return FromNot(schema_, references_, value);
+            return FromNot(schema_, references_, path, value);
         case 'Object':
-            return FromObject(schema_, references_, value);
+            return FromObject(schema_, references_, path, value);
         case 'Record':
-            return FromRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return FromRef(schema_, references_, value);
+            return FromRef(schema_, references_, path, value);
         case 'Symbol':
-            return Default(schema_, value);
+            return Default(schema_, path, value);
         case 'This':
-            return FromThis(schema_, references_, value);
+            return FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return FromTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, path, value);
         case 'Union':
-            return FromUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, path, value);
         default:
-            return Default(schema_, value);
+            return Default(schema_, path, value);
     }
 }
 /**
@@ -187,6 +191,6 @@ function Visit(schema, references, value) {
  * undefined behavior. Refer to the `Value.Decode()` for implementation details.
  */
 function TransformDecode(schema, references, value) {
-    return Visit(schema, references, value);
+    return Visit(schema, references, '', value);
 }
 exports.TransformDecode = TransformDecode;

package/build/require/value/transform/encode.d.ts

@@ -9,8 +9,10 @@ export declare class TransformEncodeCheckError extends TypeBoxError {
 }
 export declare class TransformEncodeError extends TypeBoxError {
     readonly schema: TSchema;
+    readonly path: string;
     readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
 }
 /**
  * `[Internal]` Encodes the value and returns the result. This function expects the

package/build/require/value/transform/encode.js

@@ -19,20 +19,24 @@ const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
+// prettier-ignore
 class TransformEncodeCheckError extends index_2.TypeBoxError {
     constructor(schema, value, error) {
-        super(`Unable to encode due to invalid value`);
+        super(`The encoded value does not match the expected schema`);
         this.schema = schema;
         this.value = value;
         this.error = error;
     }
 }
 exports.TransformEncodeCheckError = TransformEncodeCheckError;
+// prettier-ignore
 class TransformEncodeError extends index_2.TypeBoxError {
-    constructor(schema, value, error) {
+    constructor(schema, path, value, error) {
         super(`${error instanceof Error ? error.message : 'Unknown error'}`);
         this.schema = schema;
+        this.path = path;
         this.value = value;
+        this.error = error;
     }
 }
 exports.TransformEncodeError = TransformEncodeError;
@@ -40,56 +44,56 @@ exports.TransformEncodeError = TransformEncodeError;
 // Encode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema, value) {
+function Default(schema, path, value) {
     try {
         return (0, type_1.IsTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
     }
     catch (error) {
-        throw new TransformEncodeError(schema, value, error);
+        throw new TransformEncodeError(schema, path, value, error);
     }
 }
 // prettier-ignore
-function FromArray(schema, references, value) {
-    const defaulted = Default(schema, value);
+function FromArray(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
     return (0, index_7.IsArray)(defaulted)
-        ? defaulted.map((value) => Visit(schema.items, references, value))
+        ? defaulted.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value))
         : defaulted;
 }
 // prettier-ignore
-function FromIntersect(schema, references, value) {
-    const defaulted = Default(schema, value);
+function FromIntersect(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
     if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromNot(schema, references, value) {
-    return Default(schema.not, Default(schema, value));
+function FromNot(schema, references, path, value) {
+    return Default(schema.not, path, Default(schema, path, value));
 }
 // prettier-ignore
-function FromObject(schema, references, value) {
-    const defaulted = Default(schema, value);
+function FromObject(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
     if (!(0, index_7.IsStandardObject)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in value
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
@@ -99,93 +103,93 @@ function FromObject(schema, references, value) {
     const additionalProperties = schema.additionalProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromRecord(schema, references, value) {
-    const defaulted = Default(schema, value);
+function FromRecord(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
     if (!(0, index_7.IsStandardObject)(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
     const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
         return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromRef(schema, references, value) {
+function FromRef(schema, references, path, value) {
     const target = (0, index_5.Deref)(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
 }
 // prettier-ignore
-function FromThis(schema, references, value) {
+function FromThis(schema, references, path, value) {
     const target = (0, index_5.Deref)(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
 }
 // prettier-ignore
-function FromTuple(schema, references, value) {
-    const value1 = Default(schema, value);
-    return (0, index_7.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
+function FromTuple(schema, references, path, value) {
+    const value1 = Default(schema, path, value);
+    return (0, index_7.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
 }
 // prettier-ignore
-function FromUnion(schema, references, value) {
+function FromUnion(schema, references, path, value) {
     // test value against union variants
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
-        const value1 = Visit(subschema, references, value);
-        return Default(schema, value1);
+        const value1 = Visit(subschema, references, path, value);
+        return Default(schema, path, value1);
     }
     // test transformed value against union variants
     for (const subschema of schema.anyOf) {
-        const value1 = Visit(subschema, references, value);
+        const value1 = Visit(subschema, references, path, value);
         if (!(0, index_6.Check)(schema, references, value1))
             continue;
-        return Default(schema, value1);
+        return Default(schema, path, value1);
     }
-    return Default(schema, value);
+    return Default(schema, path, value);
 }
 // prettier-ignore
-function Visit(schema, references, value) {
+function Visit(schema, references, path, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[index_1.Kind]) {
         case 'Array':
-            return FromArray(schema_, references_, value);
+            return FromArray(schema_, references_, path, value);
         case 'Intersect':
-            return FromIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, path, value);
         case 'Not':
-            return FromNot(schema_, references_, value);
+            return FromNot(schema_, references_, path, value);
         case 'Object':
-            return FromObject(schema_, references_, value);
+            return FromObject(schema_, references_, path, value);
         case 'Record':
-            return FromRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return FromRef(schema_, references_, value);
+            return FromRef(schema_, references_, path, value);
         case 'This':
-            return FromThis(schema_, references_, value);
+            return FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return FromTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, path, value);
         case 'Union':
-            return FromUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, path, value);
         default:
-            return Default(schema_, value);
+            return Default(schema_, path, value);
     }
 }
 /**
@@ -195,6 +199,6 @@ function Visit(schema, references, value) {
  * `Value.Encode()` function for implementation details.
  */
 function TransformEncode(schema, references, value) {
-    return Visit(schema, references, value);
+    return Visit(schema, references, '', value);
 }
 exports.TransformEncode = TransformEncode;

package/build/require/value/value/value.js

@@ -63,7 +63,7 @@ function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     const encoded = (0, index_1.TransformEncode)(schema, references, value);
     if (!Check(schema, references, encoded))
-        throw new index_1.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
+        throw new index_1.TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;
 }
 exports.Encode = Encode;

package/package.json

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

package/readme.md

@@ -1694,6 +1694,7 @@ The following is a list of community packages that offer general tooling, extend
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
+| [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |