typebox 1.3.1 → 1.3.2

package/build/format/_idna.mjs

@@ -1,3 +1,4 @@
+import { Unreachable } from '../system/unreachable/index.mjs';
 import * as Puny from './_puny.mjs';
 // ------------------------------------------------------------------
 // Unicode General Category Helper (RFC 5892)
@@ -102,8 +103,10 @@ function IsVirama(cp) {
 // IsUnicodeLabel
 // ------------------------------------------------------------------
 function IsUnicodeLabel(value) {
+    // deno-coverage-ignore-start - unable to reach via format guards
     if (value.length === 0)
-        return false;
+        return Unreachable(); // false
+    // deno-coverage-ignore-stop
     // Use spread to handle surrogate pairs and provide O(1) neighbor access
     const cps = [...value].map((c) => c.codePointAt(0));
     const len = cps.length;

package/build/format/_puny.mjs

@@ -1,3 +1,4 @@
+import { Unreachable } from '../system/unreachable/index.mjs';
 // ------------------------------------------------------------------
 // PunyCode (RFC 3492)
 // ------------------------------------------------------------------
@@ -52,8 +53,10 @@ export function Decode(value) {
                 digit = ch - 0x61; // a-z => 0-25
             else if (ch >= 0x30 && ch <= 0x39)
                 digit = ch - 0x30 + 26; // 0-9 => 26-35
+            // deno-coverage-ignore-start - _idna.ts maps input to lowercase, so we can't reach here
             else if (ch >= 0x41 && ch <= 0x5a)
-                digit = ch - 0x41; // A-Z => 0-25
+                Unreachable(); // digit = ch - 0x41 // A-Z => 0-25
+            // deno-coverage-ignore-stop
             else
                 throw new Error('Invalid punycode: bad digit character');
             i += digit * w;

package/build/schema/engine/boolean.d.mts

@@ -1,5 +1,5 @@
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildBooleanSchema(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckBooleanSchema(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorBooleanSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;
+export declare function BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
+export declare function ErrorSchemaBoolean(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

package/build/schema/engine/boolean.mjs

@@ -3,20 +3,20 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildBooleanSchema(_stack, _context, schema, _value) {
+export function BuildSchemaBoolean(_stack, _context, schema, _value) {
     return schema ? E.Constant(true) : E.Constant(false);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckBooleanSchema(_stack, _context, schema, _value) {
+export function CheckSchemaBoolean(_stack, _context, schema, _value) {
     return schema;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckBooleanSchema(stack, context, schema, value) || context.AddError({
+export function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckSchemaBoolean(stack, context, schema, value) || context.AddError({
         keyword: 'boolean',
         schemaPath,
         instancePath,

package/build/schema/engine/schema.mjs

@@ -6,7 +6,7 @@ import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
 import { BuildAnyOf, CheckAnyOf, ErrorAnyOf } from './anyOf.mjs';
-import { BuildBooleanSchema, CheckBooleanSchema, ErrorBooleanSchema } from './boolean.mjs';
+import { BuildSchemaBoolean, CheckSchemaBoolean, ErrorSchemaBoolean } from './boolean.mjs';
 import { BuildConst, CheckConst, ErrorConst } from './const.mjs';
 import { BuildContains, CheckContains, ErrorContains } from './contains.mjs';
 import { BuildDependencies, CheckDependencies, ErrorDependencies } from './dependencies.mjs';
@@ -125,8 +125,8 @@ export function BuildSchemaPushStack(stack, context, schema, value) {
 export function BuildSchema(stack, context, schema, value) {
     stack.Push(schema);
     const conditions = [];
-    if (Schema.IsBooleanSchema(schema))
-        return BuildBooleanSchema(stack, context, schema, value);
+    if (Schema.IsSchemaBoolean(schema))
+        return BuildSchemaBoolean(stack, context, schema, value);
     if (Schema.IsType(schema))
         conditions.push(BuildType(stack, context, schema, value));
     if (HasObjectKeywords(schema)) {
@@ -247,7 +247,7 @@ export function CheckSchemaPushStack(stack, context, schema, value) {
 }
 export function CheckSchema(stack, context, schema, value) {
     stack.Push(schema);
-    const result = Schema.IsBooleanSchema(schema) ? CheckBooleanSchema(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
+    const result = Schema.IsSchemaBoolean(schema) ? CheckSchemaBoolean(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
         (!(G.IsObject(value) && !G.IsArray(value)) || ((!Schema.IsRequired(schema) || CheckRequired(stack, context, schema, value)) &&
             (!Schema.IsAdditionalProperties(schema) || CheckAdditionalProperties(stack, context, schema, value)) &&
             (!Schema.IsDependencies(schema) || CheckDependencies(stack, context, schema, value)) &&
@@ -300,7 +300,7 @@ export function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, s
 }
 export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
     stack.Push(schema);
-    const result = (Schema.IsBooleanSchema(schema)) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
+    const result = (Schema.IsSchemaBoolean(schema)) ? ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
         +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!Schema.IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsAdditionalProperties(schema) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsDependencies(schema) || ErrorDependencies(stack, context, schemaPath, instancePath, schema, value)) &

package/build/schema/types/schema.d.mts

@@ -3,7 +3,7 @@ export type XSchemaObject = object;
 export declare function IsSchemaObject(value: unknown): value is XSchemaObject;
 export type XSchemaBoolean = boolean;
 /** Returns true if this value is a boolean */
-export declare function IsBooleanSchema(value: unknown): value is XSchemaBoolean;
+export declare function IsSchemaBoolean(value: unknown): value is XSchemaBoolean;
 export type XSchema = XSchemaObject | XSchemaBoolean;
 /** Returns true if this value is schema like */
 export declare function IsSchema(value: unknown): value is XSchema;

package/build/schema/types/schema.mjs

@@ -5,10 +5,10 @@ export function IsSchemaObject(value) {
     return Guard.IsObject(value) && !Guard.IsArray(value);
 }
 /** Returns true if this value is a boolean */
-export function IsBooleanSchema(value) {
+export function IsSchemaBoolean(value) {
     return Guard.IsBoolean(value);
 }
 /** Returns true if this value is schema like */
 export function IsSchema(value) {
-    return IsSchemaObject(value) || IsBooleanSchema(value);
+    return IsSchemaObject(value) || IsSchemaBoolean(value);
 }

package/build/type/types/enum.d.mts

@@ -3,6 +3,8 @@ import { type TTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum
 import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
 export type TEnumValue = string | number;
+/** Returns true if the given value is a EnumValue */
+export declare function IsEnumValue(value: unknown): value is TEnumValue;
 /** Represents an Enum type. */
 export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
     '~kind': 'Enum';

package/build/type/types/enum.mjs

@@ -1,8 +1,13 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';
 import { IsTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+/** Returns true if the given value is a EnumValue */
+export function IsEnumValue(value) {
+    return Guard.IsString(value) || Guard.IsNumber(value);
+}
 /** Creates an Enum type. */
 export function Enum(value, options) {
     const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;

package/build/typebox.d.mts

@@ -37,7 +37,7 @@ export { Boolean, IsBoolean, type TBoolean } from './type/types/boolean.mjs';
 export { Call, IsCall, type TCall } from './type/types/call.mjs';
 export { Constructor, IsConstructor, type TConstructor } from './type/types/constructor.mjs';
 export { Cyclic, IsCyclic, type TCyclic } from './type/types/cyclic.mjs';
-export { Enum, IsEnum, type TEnum, type TEnumValue } from './type/types/enum.mjs';
+export { Enum, IsEnum, IsEnumValue, type TEnum, type TEnumValue } from './type/types/enum.mjs';
 export { Function, IsFunction, type TFunction } from './type/types/function.mjs';
 export { Generic, IsGeneric, type TGeneric } from './type/types/generic.mjs';
 export { Identifier, IsIdentifier, type TIdentifier } from './type/types/identifier.mjs';

package/build/typebox.mjs

@@ -55,7 +55,7 @@ export { Boolean, IsBoolean } from './type/types/boolean.mjs';
 export { Call, IsCall } from './type/types/call.mjs';
 export { Constructor, IsConstructor } from './type/types/constructor.mjs';
 export { Cyclic, IsCyclic } from './type/types/cyclic.mjs';
-export { Enum, IsEnum } from './type/types/enum.mjs';
+export { Enum, IsEnum, IsEnumValue } from './type/types/enum.mjs';
 export { Function, IsFunction } from './type/types/function.mjs';
 export { Generic, IsGeneric } from './type/types/generic.mjs';
 export { Identifier, IsIdentifier } from './type/types/identifier.mjs';

package/build/value/repair/from_type.mjs

@@ -40,6 +40,17 @@ function AssertRepairableType(context, type, value) {
     }
 }
 // ------------------------------------------------------------------
+// CreateWhenUndefined
+//
+// If the value is 'undefined' AND the type is not TUndefined, then 
+// we know the value must be created. We handle this case for undefined 
+// only as it enables 'default' annotation to be initialized via Create 
+// before we applying subsequent Repair logic.
+// ------------------------------------------------------------------
+function CreateWhenUndefined(context, type, value) {
+    return (Guard.IsUndefined(value) && !T.IsUndefined(type)) ? Create(context, type) : value;
+}
+// ------------------------------------------------------------------
 // FinalizeRepair
 //
 // When a type includes the ~refine modifier, a post-repair validation
@@ -62,15 +73,16 @@ function FinalizeRepair(context, type, repaired) {
 export function FromType(context, type, value) {
     AssertRepairableValue(context, type, value);
     AssertRepairableType(context, type, value);
-    const repaired = (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsEnum(type) ? FromEnum(context, type, value) :
-            T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                T.IsObject(type) ? FromObject(context, type, value) :
-                    T.IsRecord(type) ? FromRecord(context, type, value) :
-                        T.IsRef(type) ? FromRef(context, type, value) :
-                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                T.IsTuple(type) ? FromTuple(context, type, value) :
-                                    T.IsUnion(type) ? FromUnion(context, type, value) :
-                                        FromUnknown(context, type, value));
+    const candidate = CreateWhenUndefined(context, type, value);
+    const repaired = (T.IsArray(type) ? FromArray(context, type, candidate) :
+        T.IsEnum(type) ? FromEnum(context, type, candidate) :
+            T.IsIntersect(type) ? FromIntersect(context, type, candidate) :
+                T.IsObject(type) ? FromObject(context, type, candidate) :
+                    T.IsRecord(type) ? FromRecord(context, type, candidate) :
+                        T.IsRef(type) ? FromRef(context, type, candidate) :
+                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, candidate) :
+                                T.IsTuple(type) ? FromTuple(context, type, candidate) :
+                                    T.IsUnion(type) ? FromUnion(context, type, candidate) :
+                                        FromUnknown(context, type, candidate));
     return FinalizeRepair(context, type, repaired);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "keywords": [
     "typescript",
     "jsonschema"