typebox 1.0.4 → 1.0.6

package/build/guard/guard.d.mts

@@ -34,6 +34,8 @@ export declare function IsLessThan<Type extends number | bigint>(left: Type, rig
 export declare function IsLessEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
 export declare function IsGreaterEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
 export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint | number): boolean;
+/** Returns true if the value appears to be an instance of a class. */
+export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
 /** Returns the number of Unicode Grapheme Clusters */
 export declare function StringGraphemeCount(value: string): number;

package/build/guard/guard.mjs

@@ -102,6 +102,20 @@ export function IsMultipleOf(dividend, divisor) {
     return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
 }
 // ------------------------------------------------------------------
+// IsClassInstance
+// ------------------------------------------------------------------
+/** Returns true if the value appears to be an instance of a class. */
+export function IsClassInstance(value) {
+    if (!IsObject(value))
+        return false;
+    const proto = globalThis.Object.getPrototypeOf(value);
+    if (IsNull(proto))
+        return false;
+    return IsEqual(typeof proto.constructor, 'function') &&
+        !(IsEqual(proto.constructor, globalThis.Object) ||
+            IsEqual(proto.constructor.name, 'Object'));
+}
+// ------------------------------------------------------------------
 // IsValueLike
 // ------------------------------------------------------------------
 export function IsValueLike(value) {

package/build/schema/engine/_refine.mjs

@@ -21,7 +21,7 @@ export function ErrorRefine(context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], (refinement, index) => {
         return refinement.callback(value) || context.AddError({
             keyword: '~refine',
-            schemaPath: `${schemaPath}/~refine`,
+            schemaPath,
             instancePath,
             params: { index, message: refinement.message },
         });

package/build/schema/engine/_standard.mjs

@@ -20,7 +20,7 @@ export function ErrorStandardSchemaV1(context, schemaPath, instancePath, schema,
     const result = schema['~standard'].validate(value);
     return !G.HasPropertyKey(result, 'issues') || context.AddError({
         keyword: '~standard',
-        schemaPath: `${schemaPath}/~standard`,
+        schemaPath,
         instancePath,
         params: { vendor: schema[`~standard`].vendor, issues: result.issues },
     });

package/build/schema/engine/additionalProperties.mjs

@@ -96,7 +96,7 @@ export function ErrorAdditionalProperties(context, schemaPath, instancePath, sch
     });
     return isAdditionalProperties || context.AddError({
         keyword: 'additionalProperties',
-        schemaPath: `${schemaPath}/additionalProperties`,
+        schemaPath,
         instancePath: instancePath,
         params: { additionalProperties },
     });

package/build/schema/engine/anyOf.mjs

@@ -45,7 +45,7 @@ export function ErrorAnyOf(context, schemaPath, instancePath, schema, value) {
         failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
     return isAnyOf || context.AddError({
         keyword: 'anyOf',
-        schemaPath: `${schemaPath}/anyOf`,
+        schemaPath,
         instancePath,
         params: {}
     });

package/build/schema/engine/boolean.mjs

@@ -18,7 +18,7 @@ export function CheckBooleanSchema(context, schema, value) {
 export function ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) {
     return CheckBooleanSchema(context, schema, value) || context.AddError({
         keyword: 'boolean',
-        schemaPath: `${schemaPath}/${schema}`,
+        schemaPath,
         instancePath,
         params: {}
     });

package/build/schema/engine/const.mjs

@@ -23,7 +23,7 @@ export function CheckConst(context, schema, value) {
 export function ErrorConst(context, schemaPath, instancePath, schema, value) {
     return CheckConst(context, schema, value) || context.AddError({
         keyword: 'const',
-        schemaPath: `${schemaPath}/const`,
+        schemaPath,
         instancePath,
         params: { allowedValue: schema.const },
     });

package/build/schema/engine/contains.mjs

@@ -33,7 +33,7 @@ export function CheckContains(context, schema, value) {
 export function ErrorContains(context, schemaPath, instancePath, schema, value) {
     return CheckContains(context, schema, value) || context.AddError({
         keyword: 'contains',
-        schemaPath: `${schemaPath}/contains`,
+        schemaPath,
         instancePath,
         params: { minContains: 1 },
     });

package/build/schema/engine/dependencies.mjs

@@ -36,7 +36,7 @@ export function ErrorDependencies(context, schemaPath, instancePath, schema, val
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
             ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
                 keyword: 'dependencies',
-                schemaPath: `${schemaPath}/dependencies`,
+                schemaPath,
                 instancePath,
                 params: { property: key, dependencies: schema },
             })) : ErrorSchema(context, nextSchemaPath, instancePath, schema, value));

package/build/schema/engine/dependentRequired.mjs

@@ -31,7 +31,7 @@ export function ErrorDependentRequired(context, schemaPath, instancePath, schema
     const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), ([key, keys]) => {
         return !G.HasPropertyKey(value, key) || G.EveryAll(keys, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
             keyword: 'dependentRequired',
-            schemaPath: `${schemaPath}/dependentRequired`,
+            schemaPath,
             instancePath,
             params: { property: key, dependencies: keys },
         }));

package/build/schema/engine/enum.mjs

@@ -26,7 +26,7 @@ export function CheckEnum(context, schema, value) {
 export function ErrorEnum(context, schemaPath, instancePath, schema, value) {
     return CheckEnum(context, schema, value) || context.AddError({
         keyword: 'enum',
-        schemaPath: `${schemaPath}/enum`,
+        schemaPath,
         instancePath,
         params: { allowedValues: schema.enum }
     });

package/build/schema/engine/exclusiveMaximum.mjs

@@ -18,7 +18,7 @@ export function CheckExclusiveMaximum(context, schema, value) {
 export function ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value) {
     return CheckExclusiveMaximum(context, schema, value) || context.AddError({
         keyword: 'exclusiveMaximum',
-        schemaPath: `${schemaPath}/exclusiveMaximum`,
+        schemaPath,
         instancePath,
         params: { comparison: '<', limit: schema.exclusiveMaximum }
     });

package/build/schema/engine/exclusiveMinimum.mjs

@@ -18,7 +18,7 @@ export function CheckExclusiveMinimum(context, schema, value) {
 export function ErrorExclusiveMinimum(context, schemaPath, instancePath, schema, value) {
     return CheckExclusiveMinimum(context, schema, value) || context.AddError({
         keyword: 'exclusiveMinimum',
-        schemaPath: `${schemaPath}/exclusiveMinimum`,
+        schemaPath,
         instancePath,
         params: { comparison: '>', limit: schema.exclusiveMinimum }
     });

package/build/schema/engine/format.mjs

@@ -19,7 +19,7 @@ export function CheckFormat(context, schema, value) {
 export function ErrorFormat(context, schemaPath, instancePath, schema, value) {
     return CheckFormat(context, schema, value) || context.AddError({
         keyword: 'format',
-        schemaPath: `${schemaPath}/format`,
+        schemaPath,
         instancePath,
         params: { format: schema.format },
     });

package/build/schema/engine/if.mjs

@@ -31,13 +31,13 @@ export function ErrorIf(context, schemaPath, instancePath, schema, value) {
     const isIf = ErrorSchema(trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
         ? ErrorSchema(trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
             keyword: 'if',
-            schemaPath: `${schemaPath}/if`,
+            schemaPath,
             instancePath,
             params: { failingKeyword: 'then' },
         })
         : ErrorSchema(context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
             keyword: 'if',
-            schemaPath: `${schemaPath}/if`,
+            schemaPath,
             instancePath,
             params: { failingKeyword: 'else' },
         });

package/build/schema/engine/maxContains.mjs

@@ -33,7 +33,7 @@ export function ErrorMaxContains(context, schemaPath, instancePath, schema, valu
     const minContains = S.IsMinContains(schema) ? schema.minContains : 1;
     return CheckMaxContains(context, schema, value) || context.AddError({
         keyword: 'contains',
-        schemaPath: `${schemaPath}/contains`,
+        schemaPath,
         instancePath,
         params: { minContains, maxContains: schema.maxContains },
     });

package/build/schema/engine/maxItems.mjs

@@ -18,7 +18,7 @@ export function CheckMaxItems(context, schema, value) {
 export function ErrorMaxItems(context, schemaPath, instancePath, schema, value) {
     return CheckMaxItems(context, schema, value) || context.AddError({
         keyword: 'maxItems',
-        schemaPath: `${schemaPath}/maxItems`,
+        schemaPath,
         instancePath,
         params: { limit: schema.maxItems }
     });

package/build/schema/engine/maxLength.mjs

@@ -18,7 +18,7 @@ export function CheckMaxLength(context, schema, value) {
 export function ErrorMaxLength(context, schemaPath, instancePath, schema, value) {
     return CheckMaxLength(context, schema, value) || context.AddError({
         keyword: 'maxLength',
-        schemaPath: `${schemaPath}/maxLength`,
+        schemaPath,
         instancePath,
         params: { limit: schema.maxLength }
     });

package/build/schema/engine/maxProperties.mjs

@@ -18,7 +18,7 @@ export function CheckMaxProperties(context, schema, value) {
 export function ErrorMaxProperties(context, schemaPath, instancePath, schema, value) {
     return CheckMaxProperties(context, schema, value) || context.AddError({
         keyword: 'maxProperties',
-        schemaPath: `${schemaPath}/maxProperties`,
+        schemaPath,
         instancePath,
         params: { limit: schema.maxProperties },
     });

package/build/schema/engine/maximum.mjs

@@ -18,7 +18,7 @@ export function CheckMaximum(context, schema, value) {
 export function ErrorMaximum(context, schemaPath, instancePath, schema, value) {
     return CheckMaximum(context, schema, value) || context.AddError({
         keyword: 'maximum',
-        schemaPath: `${schemaPath}/maximum`,
+        schemaPath,
         instancePath,
         params: { comparison: '<=', limit: schema.maximum }
     });

package/build/schema/engine/minContains.mjs

@@ -32,7 +32,7 @@ export function CheckMinContains(context, schema, value) {
 export function ErrorMinContains(context, schemaPath, instancePath, schema, value) {
     return CheckMinContains(context, schema, value) || context.AddError({
         keyword: 'contains',
-        schemaPath: `${schemaPath}/contains`,
+        schemaPath,
         instancePath,
         params: { minContains: schema.minContains }
     });

package/build/schema/engine/minItems.mjs

@@ -18,7 +18,7 @@ export function CheckMinItems(context, schema, value) {
 export function ErrorMinItems(context, schemaPath, instancePath, schema, value) {
     return CheckMinItems(context, schema, value) || context.AddError({
         keyword: 'minItems',
-        schemaPath: `${schemaPath}/minItems`,
+        schemaPath,
         instancePath,
         params: { limit: schema.minItems }
     });

package/build/schema/engine/minLength.mjs

@@ -18,7 +18,7 @@ export function CheckMinLength(context, schema, value) {
 export function ErrorMinLength(context, schemaPath, instancePath, schema, value) {
     return CheckMinLength(context, schema, value) || context.AddError({
         keyword: 'minLength',
-        schemaPath: `${schemaPath}/minLength`,
+        schemaPath,
         instancePath,
         params: { limit: schema.minLength }
     });

package/build/schema/engine/minProperties.mjs

@@ -18,7 +18,7 @@ export function CheckMinProperties(context, schema, value) {
 export function ErrorMinProperties(context, schemaPath, instancePath, schema, value) {
     return CheckMinProperties(context, schema, value) || context.AddError({
         keyword: 'minProperties',
-        schemaPath: `${schemaPath}/minProperties`,
+        schemaPath,
         instancePath,
         params: { limit: schema.minProperties },
     });

package/build/schema/engine/minimum.mjs

@@ -18,7 +18,7 @@ export function CheckMinimum(context, schema, value) {
 export function ErrorMinimum(context, schemaPath, instancePath, schema, value) {
     return CheckMinimum(context, schema, value) || context.AddError({
         keyword: 'minimum',
-        schemaPath: `${schemaPath}/minimum`,
+        schemaPath,
         instancePath,
         params: { comparison: '>=', limit: schema.minimum }
     });

package/build/schema/engine/multipleOf.mjs

@@ -18,7 +18,7 @@ export function CheckMultipleOf(context, schema, value) {
 export function ErrorMultipleOf(context, schemaPath, instancePath, schema, value) {
     return CheckMultipleOf(context, schema, value) || context.AddError({
         keyword: 'multipleOf',
-        schemaPath: `${schemaPath}/multipleOf`,
+        schemaPath,
         instancePath,
         params: { multipleOf: schema.multipleOf }
     });

package/build/schema/engine/not.mjs

@@ -29,7 +29,7 @@ export function CheckNot(context, schema, value) {
 export function ErrorNot(context, schemaPath, instancePath, schema, value) {
     return CheckNot(context, schema, value) || context.AddError({
         keyword: 'not',
-        schemaPath: `${schemaPath}/not`,
+        schemaPath,
         instancePath,
         params: {},
     });

package/build/schema/engine/oneOf.mjs

@@ -51,7 +51,7 @@ export function ErrorOneOf(context, schemaPath, instancePath, schema, value) {
         failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
     return isOneOf || context.AddError({
         keyword: 'oneOf',
-        schemaPath: `${schemaPath}/oneOf`,
+        schemaPath,
         instancePath,
         params: { passingSchemas },
     });

package/build/schema/engine/pattern.mjs

@@ -21,7 +21,7 @@ export function CheckPattern(context, schema, value) {
 export function ErrorPattern(context, schemaPath, instancePath, schema, value) {
     return CheckPattern(context, schema, value) || context.AddError({
         keyword: 'pattern',
-        schemaPath: `${schemaPath}/pattern`,
+        schemaPath,
         instancePath,
         params: { pattern: schema.pattern }
     });

package/build/schema/engine/propertyNames.mjs

@@ -30,8 +30,8 @@ export function ErrorPropertyNames(context, schemaPath, instancePath, schema, va
     });
     return isPropertyNames || context.AddError({
         keyword: 'propertyNames',
-        schemaPath: `${schemaPath}/propertyNames`,
-        instancePath: instancePath,
+        schemaPath,
+        instancePath,
         params: { propertyNames }
     });
 }

package/build/schema/engine/required.mjs

@@ -25,7 +25,7 @@ export function ErrorRequired(context, schemaPath, instancePath, schema, value)
     });
     return isRequired || context.AddError({
         keyword: 'required',
-        schemaPath: `${schemaPath}/required`,
+        schemaPath,
         instancePath,
         params: { requiredProperties }
     });

package/build/schema/engine/type.mjs

@@ -67,7 +67,7 @@ export function ErrorType(context, schemaPath, instancePath, schema, value) {
     const isType = G.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
     return isType || context.AddError({
         keyword: 'type',
-        schemaPath: `${schemaPath}/type`,
+        schemaPath,
         instancePath,
         params: { type: schema.type }
     });

package/build/schema/engine/unevaluatedItems.mjs

@@ -42,7 +42,7 @@ export function ErrorUnevaluatedItems(context, schemaPath, instancePath, schema,
     });
     return isUnevaluatedItems || context.AddError({
         keyword: 'unevaluatedItems',
-        schemaPath: `${schemaPath}/unevaluatedItems`,
+        schemaPath,
         instancePath,
         params: { unevaluatedItems }
     });

package/build/schema/engine/unevaluatedProperties.mjs

@@ -42,7 +42,7 @@ export function ErrorUnevaluatedProperties(context, schemaPath, instancePath, sc
     });
     return isUnevaluatedProperties || context.AddError({
         keyword: 'unevaluatedProperties',
-        schemaPath: `${schemaPath}/unevaluatedProperties`,
+        schemaPath,
         instancePath,
         params: { unevaluatedProperties }
     });

package/build/schema/engine/uniqueItems.mjs

@@ -44,7 +44,7 @@ export function ErrorUniqueItems(context, schemaPath, instancePath, schema, valu
     const isUniqueItems = G.IsEqual(duplicateItems.length, 0);
     return isUniqueItems || context.AddError({
         keyword: 'uniqueItems',
-        schemaPath: `${schemaPath}/uniqueItems`,
+        schemaPath,
         instancePath,
         params: { duplicateItems },
     });

package/build/value/clone/clone.mjs

@@ -1,9 +1,22 @@
 // deno-fmt-ignore-file
 import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Object
+// ClassInstance
+//
+// TypeBox does not support cloning arbitrary class instances. It treats
+// class instances as atomic values, similar to number, boolean, and
+// string. In the future, an implementation could detect the presence of
+// a .clone() method, but no formal specification for this behavior
+// exists, so we don't.
+//
 // ------------------------------------------------------------------
-function FromObject(value) {
+function FromClassInstance(value) {
+    return value; // atomic
+}
+// ------------------------------------------------------------------
+// ObjectInstance
+// ------------------------------------------------------------------
+function FromObjectInstance(value) {
     const result = {};
     for (const key of Object.getOwnPropertyNames(value)) {
         result[key] = Clone(value[key]);
@@ -14,6 +27,14 @@ function FromObject(value) {
     return result;
 }
 // ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value)
+        ? FromClassInstance(value)
+        : FromObjectInstance(value));
+}
+// ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
 function FromArray(value) {

package/package.json

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

package/readme.md

@@ -49,7 +49,7 @@ type T = Static<typeof T>                           // type T = {
 
 ## Overview
 
-[Documentation](https://sinclairzx81.github.io/typebox/)
+[Documentation](https://sinclairzx81.github.io/typebox/) | [1.0 Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
 
 TypeBox is a runtime type system that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type system that can be statically checked by TypeScript and validated at runtime using standard Json Schema.