typebox 1.0.10 → 1.0.12

package/build/schema/index.d.mts

@@ -1,16 +1,3 @@
-export * as Schema from './schema.mjs';
-export * from './engine/index.mjs';
-export * from './types/index.mjs';
-export * from './build.mjs';
-export * from './check.mjs';
-export * from './errors.mjs';
-import { Build, BuildResult } from './build.mjs';
-import { Check } from './check.mjs';
-import { Errors } from './errors.mjs';
-declare const _default: {
-    Build: typeof Build;
-    BuildResult: typeof BuildResult;
-    Check: typeof Check;
-    Errors: typeof Errors;
-};
-export default _default;
+export * from './schema.mjs';
+import * as Schema from './schema.mjs';
+export default Schema;

package/build/schema/index.mjs

@@ -1,19 +1,9 @@
 // ------------------------------------------------------------------
-// Named
-// ------------------------------------------------------------------
-export * as Schema from './schema.mjs';
-// ------------------------------------------------------------------
 // Barrel
 // ------------------------------------------------------------------
-export * from './engine/index.mjs';
-export * from './types/index.mjs';
-export * from './build.mjs';
-export * from './check.mjs';
-export * from './errors.mjs';
+export * from './schema.mjs';
 // ------------------------------------------------------------------
 // Default
 // ------------------------------------------------------------------
-import { Build, BuildResult } from './build.mjs';
-import { Check } from './check.mjs';
-import { Errors } from './errors.mjs';
-export default { Build, BuildResult, Check, Errors };
+import * as Schema from './schema.mjs';
+export default Schema;

package/build/value/assert/assert.d.mts

@@ -5,4 +5,4 @@ export declare class AssertError extends Error {
 /** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
 export declare function Assert<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): asserts value is Result;
 /** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
-export declare function Assert<const Type extends TSchema, Result extends unknown = Static<Type>>(type: TSchema, value: unknown): asserts value is Result;
+export declare function Assert<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type, value: unknown): asserts value is Result;

package/build/value/clean/from-union.mjs

@@ -5,7 +5,7 @@ import { FromType } from './from-type.mjs';
 export function FromUnion(context, type, value) {
     for (const schema of type.anyOf) {
         const clean = FromType(context, schema, Clone(value));
-        if (Check(context, type, clean))
+        if (Check(context, schema, clean))
             return clean;
     }
     return value;

package/build/value/codec/decode.d.mts

@@ -3,6 +3,8 @@ import { AssertError } from '../assert/index.mjs';
 export declare class DecodeError extends AssertError {
     constructor(value: unknown, errors: object[]);
 }
+/** Executes Decode callbacks only */
+export declare function DecodeUnsafe(context: TProperties, type: TSchema, value: unknown): unknown;
 /**
  * Decodes a value against the given type by applying a sequence of Clone,
  * Default, Convert, and Clone operations, then executing any embedded Decode

package/build/value/codec/decode.mjs

@@ -23,6 +23,13 @@ function Assert(context, type, value) {
     return value;
 }
 // ------------------------------------------------------------------
+// DecodeUnsafe
+// ------------------------------------------------------------------
+/** Executes Decode callbacks only */
+export function DecodeUnsafe(context, type, value) {
+    return FromType('Decode', context, type, value);
+}
+// ------------------------------------------------------------------
 // Decoder
 // ------------------------------------------------------------------
 const Decoder = Pipeline([
@@ -31,7 +38,7 @@ const Decoder = Pipeline([
     (context, type, value) => Convert(context, type, value),
     (context, type, value) => Clean(context, type, value),
     (context, type, value) => Assert(context, type, value),
-    (context, type, value) => FromType('Decode', context, type, value)
+    (context, type, value) => DecodeUnsafe(context, type, value)
 ]);
 /**
  * Decodes a value against the given type by applying a sequence of Clone,

package/build/value/codec/encode.d.mts

@@ -3,6 +3,8 @@ import { AssertError } from '../assert/index.mjs';
 export declare class EncodeError extends AssertError {
     constructor(value: unknown, errors: object[]);
 }
+/** Executes Encode callbacks only */
+export declare function EncodeUnsafe(context: TProperties, type: TSchema, value: unknown): unknown;
 /** Encodes a value. */
 export declare function Encode<const Type extends TSchema, Result extends unknown = StaticEncode<Type>>(type: Type, value: unknown): Result;
 /** Encodes a value. */

package/build/value/codec/encode.mjs

@@ -23,11 +23,18 @@ function Assert(context, type, value) {
     return value;
 }
 // ------------------------------------------------------------------
+// EncodeUnsafe
+// ------------------------------------------------------------------
+/** Executes Encode callbacks only */
+export function EncodeUnsafe(context, type, value) {
+    return FromType('Encode', context, type, value);
+}
+// ------------------------------------------------------------------
 // Encoder
 // ------------------------------------------------------------------
 const Encoder = Pipeline([
     (_context, _type, value) => Clone(value),
-    (context, type, value) => FromType('Encode', context, type, value),
+    (context, type, value) => EncodeUnsafe(context, type, value),
     (context, type, value) => Default(context, type, value),
     (context, type, value) => Convert(context, type, value),
     (context, type, value) => Clean(context, type, value),

package/build/value/codec/from-object.mjs

@@ -3,6 +3,7 @@ import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { Callback } from './callback.mjs';
+import { IsOptionalUndefined } from '../shared/index.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
@@ -12,7 +13,8 @@ function Decode(direction, context, type, value) {
         return Unreachable();
     // deno-coverage-ignore-stop
     for (const key of Guard.Keys(type.properties)) {
-        if (!Guard.HasPropertyKey(value, key))
+        // Ignore for non-present or optional-undefined
+        if (!Guard.HasPropertyKey(value, key) || IsOptionalUndefined(type.properties[key], key, value))
             continue;
         value[key] = FromType(direction, context, type.properties[key], value[key]);
     }
@@ -26,7 +28,8 @@ function Encode(direction, context, type, value) {
     if (!Guard.IsObjectNotArray(exterior))
         return exterior;
     for (const key of Guard.Keys(type.properties)) {
-        if (!Guard.HasPropertyKey(exterior, key))
+        // Ignore for non-present or optional-undefined
+        if (!Guard.HasPropertyKey(exterior, key) || IsOptionalUndefined(type.properties[key], key, exterior))
             continue;
         exterior[key] = FromType(direction, context, type.properties[key], exterior[key]);
     }

package/build/value/convert/from-object.mjs

@@ -1,20 +1,8 @@
 // deno-fmt-ignore-file
-import { IsOptional } from '../../type/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { FromAdditionalProperties } from './from-additional.mjs';
-// ------------------------------------------------------------------
-// IsOptionalUndefined
-//
-// Determines whether a property should be excluded from conversion
-// because it is both optional and has an undefined value. This case
-// cannot be safely converted, since it introduces ambiguity between
-// an omitted optional property and a property explicitly set to the
-// value undefined.
-// ------------------------------------------------------------------
-function IsOptionalUndefined(property, key, value) {
-    return IsOptional(property) && Guard.IsUndefined(value[key]);
-}
+import { IsOptionalUndefined } from '../shared/index.mjs';
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
@@ -23,11 +11,10 @@ function FromProperties(context, type, value) {
     const keys = Guard.Keys(value);
     for (const [regexp, property] of entries) {
         for (const key of keys) {
-            // Only convert the property if the value key matches a schema key,
-            // and the property is not optional with an undefined value.
-            if (regexp.test(key) && !IsOptionalUndefined(property, key, value)) {
-                value[key] = FromType(context, property, value[key]);
-            }
+            // Ignore for non-present or optional-undefined
+            if (!regexp.test(key) || IsOptionalUndefined(property, key, value))
+                continue;
+            value[key] = FromType(context, property, value[key]);
         }
     }
     return (Guard.HasPropertyKey(type, 'additionalProperties') && Guard.IsObject(type.additionalProperties)

package/build/value/shared/index.d.mts

@@ -0,0 +1 @@
+export * from './optional-undefined.mjs';

package/build/value/shared/index.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export * from './optional-undefined.mjs';

package/build/value/shared/optional-undefined.d.mts

@@ -0,0 +1,2 @@
+import { type TSchema } from '../../type/index.mjs';
+export declare function IsOptionalUndefined(property: TSchema, key: PropertyKey, value: Record<PropertyKey, unknown>): boolean;

package/build/value/shared/optional-undefined.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsOptional } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// IsOptionalUndefined
+//
+// Indicates whether a key should be excluded from processing when it is 
+// defined as optional in the schema and its corresponding value is undefined. 
+// This case cannot be reliably distinguished from an omitted key, and therefore 
+// introduces ambiguity between a key that is not provided and one that is 
+// explicitly assigned an undefined value.
+// ------------------------------------------------------------------
+export function IsOptionalUndefined(property, key, value) {
+    return IsOptional(property) && Guard.IsUndefined(value[key]);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "keywords": [
     "typescript",
     "jsonschema"