@sinclair/typebox 0.25.4 → 0.25.6

package/conditional/conditional.d.ts

@@ -6,7 +6,7 @@ export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extend
 export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> extends Types.TUnion<any[]> {
     static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
 }
-/** Conditional Types */
+/** Conditional type mapping for TypeBox types */
 export declare namespace Conditional {
     /** (Experimental) Creates a conditional expression type */
     function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U>;

package/conditional/conditional.js

@@ -31,7 +31,7 @@ exports.Conditional = void 0;
 const Types = require("../typebox");
 const structural_1 = require("./structural");
 const index_1 = require("../guard/index");
-/** Conditional Types */
+/** Conditional type mapping for TypeBox types */
 var Conditional;
 (function (Conditional) {
     /** (Experimental) Creates a conditional expression type */

package/errors/errors.d.ts

@@ -60,6 +60,7 @@ export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {
     function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
 }

package/errors/errors.js

@@ -94,17 +94,21 @@ class ValueErrorsUnknownTypeError extends Error {
     }
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 var ValueErrors;
 (function (ValueErrors) {
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
     function* Any(schema, references, path, value) { }
     function* Array(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
             return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` };
         }
-        if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+        if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
             yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
         }
-        if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+        if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
             yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
         }
         if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
@@ -126,16 +130,16 @@ var ValueErrors;
         if (!(value instanceof globalThis.Date)) {
             return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` };
         }
-        if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+        if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
             yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+        if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
             yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` };
         }
-        if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+        if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
             yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` };
         }
-        if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+        if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
             yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` };
         }
     }
@@ -151,19 +155,19 @@ var ValueErrors;
         if (!globalThis.Number.isInteger(value)) {
             yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
         }
-        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+        if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
         }
-        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+        if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
             yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+        if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
             yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
         }
-        if (schema.minimum && !(value >= schema.minimum)) {
+        if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
             yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
         }
-        if (schema.maximum && !(value <= schema.maximum)) {
+        if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
             yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
         }
     }
@@ -185,19 +189,19 @@ var ValueErrors;
         if (!(typeof value === 'number')) {
             return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
         }
-        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+        if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
         }
-        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+        if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
             yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+        if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
             yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
         }
-        if (schema.minimum && !(value >= schema.minimum)) {
+        if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
             yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
         }
-        if (schema.maximum && !(value <= schema.maximum)) {
+        if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
             yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
@@ -205,10 +209,10 @@ var ValueErrors;
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
             return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
         }
-        if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+        if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
             yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
         }
-        if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+        if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
             yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
         const propertyKeys = globalThis.Object.keys(schema.properties);
@@ -283,10 +287,10 @@ var ValueErrors;
         if (!(typeof value === 'string')) {
             return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
         }
-        if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
+        if (IsNumber(schema.minLength) && !(value.length >= schema.minLength)) {
             yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
         }
-        if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
+        if (IsNumber(schema.maxLength) && !(value.length <= schema.maxLength)) {
             yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
         }
         if (schema.pattern !== undefined) {
@@ -348,10 +352,10 @@ var ValueErrors;
         if (!(value instanceof globalThis.Uint8Array)) {
             return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` };
         }
-        if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+        if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
             yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
         }
-        if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+        if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
             yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
         }
     }

package/format/format.d.ts

@@ -1,5 +1,5 @@
 export declare type FormatValidationFunction = (value: string) => boolean;
-/** Shared string formats used by the TypeCompiler and Value modules */
+/** Provides functions to create custom string formats */
 export declare namespace Format {
     /** Clears all formats */
     function Clear(): void;

package/format/format.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Format = void 0;
-/** Shared string formats used by the TypeCompiler and Value modules */
+/** Provides functions to create custom string formats */
 var Format;
 (function (Format) {
     const formats = new Map();

package/guard/guard.d.ts

@@ -3,7 +3,7 @@ export declare class TypeGuardInvalidTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
 }
-/** TypeGuard tests that values conform to a known TypeBox type specification */
+/** Provides functionality to test if values are TypeBox types */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
     function TAny(schema: unknown): schema is Types.TAny;

package/guard/guard.js

@@ -36,7 +36,7 @@ class TypeGuardInvalidTypeError extends Error {
     }
 }
 exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
-/** TypeGuard tests that values conform to a known TypeBox type specification */
+/** Provides functionality to test if values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
     function IsObject(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.4",
+  "version": "0.25.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/value/pointer.d.ts

@@ -9,7 +9,7 @@ export declare class ValuePointerRootDeleteError extends Error {
     readonly path: string;
     constructor(value: unknown, path: string);
 }
-/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+/** Provides functionality to update values through RFC6901 string pointers */
 export declare namespace ValuePointer {
     /** Formats the given pointer into navigable key components */
     function Format(pointer: string): IterableIterator<string>;

package/value/pointer.js

@@ -45,7 +45,7 @@ class ValuePointerRootDeleteError extends Error {
     }
 }
 exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
-/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+/** Provides functionality to update values through RFC6901 string pointers */
 var ValuePointer;
 (function (ValuePointer) {
     function Escape(component) {

package/value/value.d.ts

@@ -1,8 +1,8 @@
 import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
 import { Edit } from './delta';
-export type { Edit } from './delta';
-/** Value performs immutable operations on values */
+export { Edit, Insert, Update, Delete } from './delta';
+/** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
     /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;

package/value/value.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = void 0;
+exports.Value = exports.Delete = exports.Update = exports.Insert = exports.Edit = void 0;
 const index_1 = require("../errors/index");
 const equal_1 = require("./equal");
 const cast_1 = require("./cast");
@@ -35,7 +35,12 @@ const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const delta_1 = require("./delta");
-/** Value performs immutable operations on values */
+var delta_2 = require("./delta");
+Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_2.Edit; } });
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_2.Insert; } });
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_2.Update; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_2.Delete; } });
+/** Provides functions to perform structural updates to JavaScript values */
 var Value;
 (function (Value) {
     function Cast(...args) {