typebox 0.0.1 → 1.0.0-rc

package/build/schema/engine/schema.mjs

@@ -0,0 +1,322 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { BuildStandardSchemaV1, CheckStandardSchemaV1, ErrorStandardSchemaV1 } from './_standard.mjs';
+import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
+import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
+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 { BuildConst, CheckConst, ErrorConst } from './const.mjs';
+import { BuildContains, CheckContains, ErrorContains } from './contains.mjs';
+import { BuildDependencies, CheckDependencies, ErrorDependencies } from './dependencies.mjs';
+import { BuildDependentRequired, CheckDependentRequired, ErrorDependentRequired } from './dependentRequired.mjs';
+import { BuildDependentSchemas, CheckDependentSchemas, ErrorDependentSchemas } from './dependentSchemas.mjs';
+import { BuildEnum, CheckEnum, ErrorEnum } from './enum.mjs';
+import { BuildExclusiveMaximum, CheckExclusiveMaximum, ErrorExclusiveMaximum } from './exclusiveMaximum.mjs';
+import { BuildExclusiveMinimum, CheckExclusiveMinimum, ErrorExclusiveMinimum } from './exclusiveMinimum.mjs';
+import { BuildFormat, CheckFormat, ErrorFormat } from './format.mjs';
+import { BuildIf, CheckIf, ErrorIf } from './if.mjs';
+import { BuildItems, CheckItems, ErrorItems } from './items.mjs';
+import { BuildMaxContains, CheckMaxContains, ErrorMaxContains } from './maxContains.mjs';
+import { BuildMaximum, CheckMaximum, ErrorMaximum } from './maximum.mjs';
+import { BuildMaxItems, CheckMaxItems, ErrorMaxItems } from './maxItems.mjs';
+import { BuildMaxLength, CheckMaxLength, ErrorMaxLength } from './maxLength.mjs';
+import { BuildMaxProperties, CheckMaxProperties, ErrorMaxProperties } from './maxProperties.mjs';
+import { BuildMinContains, CheckMinContains, ErrorMinContains } from './minContains.mjs';
+import { BuildMinimum, CheckMinimum, ErrorMinimum } from './minimum.mjs';
+import { BuildMinItems, CheckMinItems, ErrorMinItems } from './minItems.mjs';
+import { BuildMinLength, CheckMinLength, ErrorMinLength } from './minLength.mjs';
+import { BuildMinProperties, CheckMinProperties, ErrorMinProperties } from './minProperties.mjs';
+import { BuildMultipleOf, CheckMultipleOf, ErrorMultipleOf } from './multipleOf.mjs';
+import { BuildNot, CheckNot, ErrorNot } from './not.mjs';
+import { BuildOneOf, CheckOneOf, ErrorOneOf } from './oneOf.mjs';
+import { BuildPattern, CheckPattern, ErrorPattern } from './pattern.mjs';
+import { BuildPatternProperties, CheckPatternProperties, ErrorPatternProperties } from './patternProperties.mjs';
+import { BuildPrefixItems, CheckPrefixItems, ErrorPrefixItems } from './prefixItems.mjs';
+import { BuildProperties, CheckProperties, ErrorProperties } from './properties.mjs';
+import { BuildPropertyNames, CheckPropertyNames, ErrorPropertyNames } from './propertyNames.mjs';
+import { BuildRef, CheckRef, ErrorRef } from './ref.mjs';
+import { BuildRequired, CheckRequired, ErrorRequired } from './required.mjs';
+import { BuildType, CheckType, ErrorType } from './type.mjs';
+import { BuildUnevaluatedItems, CheckUnevaluatedItems, ErrorUnevaluatedItems } from './unevaluatedItems.mjs';
+import { BuildUnevaluatedProperties, CheckUnevaluatedProperties, ErrorUnevaluatedProperties } from './unevaluatedProperties.mjs';
+import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueItems.mjs';
+// ----------------------------------------------------------------
+// HasTypeName
+// ----------------------------------------------------------------
+function HasTypeName(schema, typename) {
+    return S.IsType(schema) &&
+        (G.IsArray(schema.type) && schema.type.includes(typename) ||
+            G.IsEqual(schema.type, typename));
+}
+// ----------------------------------------------------------------
+// HasObject
+// ----------------------------------------------------------------
+function HasObjectType(schema) {
+    return HasTypeName(schema, 'object');
+}
+function HasObjectKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsAdditionalProperties(schema) ||
+        S.IsDependencies(schema) ||
+        S.IsDependentRequired(schema) ||
+        S.IsDependentSchemas(schema) ||
+        S.IsProperties(schema) ||
+        S.IsPatternProperties(schema) ||
+        S.IsPropertyNames(schema) ||
+        S.IsMinProperties(schema) ||
+        S.IsMaxProperties(schema) ||
+        S.IsRequired(schema) ||
+        S.IsUnevaluatedProperties(schema));
+}
+// ----------------------------------------------------------------
+// HasArray
+// ----------------------------------------------------------------
+function HasArrayType(schema) {
+    return HasTypeName(schema, 'array');
+}
+function HasArrayKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsAdditionalItems(schema) ||
+        S.IsItems(schema) ||
+        S.IsContains(schema) ||
+        S.IsMaxContains(schema) ||
+        S.IsMaxItems(schema) ||
+        S.IsMinContains(schema) ||
+        S.IsMinItems(schema) ||
+        S.IsPrefixItems(schema) ||
+        S.IsUnevaluatedItems(schema) ||
+        S.IsUniqueItems(schema));
+}
+// ----------------------------------------------------------------
+// HasString
+// ----------------------------------------------------------------
+function HasStringType(schema) {
+    return HasTypeName(schema, 'string');
+}
+function HasStringKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsMinLength(schema) ||
+        S.IsMaxLength(schema) ||
+        S.IsFormat(schema) ||
+        S.IsPattern(schema));
+}
+// ----------------------------------------------------------------
+// HasNumber
+// ----------------------------------------------------------------
+function HasNumberType(schema) {
+    return HasTypeName(schema, 'number') || HasTypeName(schema, 'bigint');
+}
+function HasNumberKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsMinimum(schema) ||
+        S.IsMaximum(schema) ||
+        S.IsExclusiveMaximum(schema) ||
+        S.IsExclusiveMinimum(schema) ||
+        S.IsMultipleOf(schema));
+}
+// ----------------------------------------------------------------
+// Build
+// ----------------------------------------------------------------
+export function BuildSchema(context, schema, value) {
+    const conditions = [];
+    if (S.IsBooleanSchema(schema))
+        return BuildBooleanSchema(context, schema, value);
+    if (S.IsType(schema))
+        conditions.push(BuildType(context, schema, value));
+    if (HasObjectKeywords(schema)) {
+        const constraints = [];
+        if (S.IsRequired(schema))
+            constraints.push(BuildRequired(context, schema, value));
+        if (S.IsAdditionalProperties(schema))
+            constraints.push(BuildAdditionalProperties(context, schema, value));
+        if (S.IsDependencies(schema))
+            constraints.push(BuildDependencies(context, schema, value));
+        if (S.IsDependentRequired(schema))
+            constraints.push(BuildDependentRequired(context, schema, value));
+        if (S.IsDependentSchemas(schema))
+            constraints.push(BuildDependentSchemas(context, schema, value));
+        if (S.IsPatternProperties(schema))
+            constraints.push(BuildPatternProperties(context, schema, value));
+        if (S.IsProperties(schema))
+            constraints.push(BuildProperties(context, schema, value));
+        if (S.IsPropertyNames(schema))
+            constraints.push(BuildPropertyNames(context, schema, value));
+        if (S.IsMinProperties(schema))
+            constraints.push(BuildMinProperties(context, schema, value));
+        if (S.IsMaxProperties(schema))
+            constraints.push(BuildMaxProperties(context, schema, value));
+        const reduced = E.ReduceAnd(constraints);
+        const guarded = E.Or(E.Not(E.IsObjectNotArray(value)), reduced);
+        conditions.push(HasObjectType(schema) ? reduced : guarded);
+    }
+    if (HasArrayKeywords(schema)) {
+        const constraints = [];
+        if (S.IsAdditionalItems(schema))
+            constraints.push(BuildAdditionalItems(context, schema, value));
+        if (S.IsContains(schema))
+            constraints.push(BuildContains(context, schema, value));
+        if (S.IsItems(schema))
+            constraints.push(BuildItems(context, schema, value));
+        if (S.IsMaxContains(schema))
+            constraints.push(BuildMaxContains(context, schema, value));
+        if (S.IsMaxItems(schema))
+            constraints.push(BuildMaxItems(context, schema, value));
+        if (S.IsMinContains(schema))
+            constraints.push(BuildMinContains(context, schema, value));
+        if (S.IsMinItems(schema))
+            constraints.push(BuildMinItems(context, schema, value));
+        if (S.IsPrefixItems(schema))
+            constraints.push(BuildPrefixItems(context, schema, value));
+        if (S.IsUniqueItems(schema))
+            constraints.push(BuildUniqueItems(context, schema, value));
+        const reduced = E.ReduceAnd(constraints);
+        const guarded = E.Or(E.Not(E.IsArray(value)), reduced);
+        conditions.push(HasArrayType(schema) ? reduced : guarded);
+    }
+    if (HasStringKeywords(schema)) {
+        const constraints = [];
+        if (S.IsFormat(schema))
+            constraints.push(BuildFormat(context, schema, value));
+        if (S.IsMaxLength(schema))
+            constraints.push(BuildMaxLength(context, schema, value));
+        if (S.IsMinLength(schema))
+            constraints.push(BuildMinLength(context, schema, value));
+        if (S.IsPattern(schema))
+            constraints.push(BuildPattern(context, schema, value));
+        const reduced = E.ReduceAnd(constraints);
+        const guarded = E.Or(E.Not(E.IsString(value)), reduced);
+        conditions.push(HasStringType(schema) ? reduced : guarded);
+    }
+    if (HasNumberKeywords(schema)) {
+        const constraints = [];
+        if (S.IsExclusiveMaximum(schema))
+            constraints.push(BuildExclusiveMaximum(context, schema, value));
+        if (S.IsExclusiveMinimum(schema))
+            constraints.push(BuildExclusiveMinimum(context, schema, value));
+        if (S.IsMaximum(schema))
+            constraints.push(BuildMaximum(context, schema, value));
+        if (S.IsMinimum(schema))
+            constraints.push(BuildMinimum(context, schema, value));
+        if (S.IsMultipleOf(schema))
+            constraints.push(BuildMultipleOf(context, schema, value));
+        const reduced = E.ReduceAnd(constraints);
+        const guarded = E.Or(E.Not(E.Or(E.IsNumber(value), E.IsBigInt(value))), reduced);
+        conditions.push(HasNumberType(schema) ? reduced : guarded);
+    }
+    if (S.IsRef(schema))
+        conditions.push(BuildRef(context, schema, value));
+    if (S.IsConst(schema))
+        conditions.push(BuildConst(context, schema, value));
+    if (S.IsEnum(schema))
+        conditions.push(BuildEnum(context, schema, value));
+    if (S.IsStandardSchemaV1(schema))
+        conditions.push(BuildStandardSchemaV1(context, schema, value));
+    if (S.IsIf(schema))
+        conditions.push(BuildIf(context, schema, value));
+    if (S.IsNot(schema))
+        conditions.push(BuildNot(context, schema, value));
+    if (S.IsAllOf(schema))
+        conditions.push(BuildAllOf(context, schema, value));
+    if (S.IsAnyOf(schema))
+        conditions.push(BuildAnyOf(context, schema, value));
+    if (S.IsOneOf(schema))
+        conditions.push(BuildOneOf(context, schema, value));
+    if (S.IsUnevaluatedItems(schema))
+        conditions.push(E.Or(E.Not(E.IsArray(value)), BuildUnevaluatedItems(context, schema, value)));
+    if (S.IsUnevaluatedProperties(schema))
+        conditions.push(E.Or(E.Not(E.IsObject(value)), BuildUnevaluatedProperties(context, schema, value)));
+    if (S.IsRefine(schema))
+        conditions.push(BuildRefine(context, schema, value));
+    return E.ReduceAnd(conditions);
+}
+// ----------------------------------------------------------------
+// Check
+// ----------------------------------------------------------------
+export function CheckSchema(context, schema, value) {
+    return S.IsBooleanSchema(schema) ? CheckBooleanSchema(context, schema, value) : ((!S.IsType(schema) || CheckType(context, schema, value)) &&
+        (!(G.IsObject(value) && !G.IsArray(value)) || ((!S.IsRequired(schema) || CheckRequired(context, schema, value)) &&
+            (!S.IsAdditionalProperties(schema) || CheckAdditionalProperties(context, schema, value)) &&
+            (!S.IsDependencies(schema) || CheckDependencies(context, schema, value)) &&
+            (!S.IsDependentRequired(schema) || CheckDependentRequired(context, schema, value)) &&
+            (!S.IsDependentSchemas(schema) || CheckDependentSchemas(context, schema, value)) &&
+            (!S.IsPatternProperties(schema) || CheckPatternProperties(context, schema, value)) &&
+            (!S.IsProperties(schema) || CheckProperties(context, schema, value)) &&
+            (!S.IsPropertyNames(schema) || CheckPropertyNames(context, schema, value)) &&
+            (!S.IsMinProperties(schema) || CheckMinProperties(context, schema, value)) &&
+            (!S.IsMaxProperties(schema) || CheckMaxProperties(context, schema, value)))) &&
+        (!G.IsArray(value) || ((!S.IsAdditionalItems(schema) || CheckAdditionalItems(context, schema, value)) &&
+            (!S.IsContains(schema) || CheckContains(context, schema, value)) &&
+            (!S.IsItems(schema) || CheckItems(context, schema, value)) &&
+            (!S.IsMaxContains(schema) || CheckMaxContains(context, schema, value)) &&
+            (!S.IsMaxItems(schema) || CheckMaxItems(context, schema, value)) &&
+            (!S.IsMinContains(schema) || CheckMinContains(context, schema, value)) &&
+            (!S.IsMinItems(schema) || CheckMinItems(context, schema, value)) &&
+            (!S.IsPrefixItems(schema) || CheckPrefixItems(context, schema, value)) &&
+            (!S.IsUniqueItems(schema) || CheckUniqueItems(context, schema, value)))) &&
+        (!G.IsString(value) || ((!S.IsFormat(schema) || CheckFormat(context, schema, value)) &&
+            (!S.IsMaxLength(schema) || CheckMaxLength(context, schema, value)) &&
+            (!S.IsMinLength(schema) || CheckMinLength(context, schema, value)) &&
+            (!S.IsPattern(schema) || CheckPattern(context, schema, value)))) &&
+        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!S.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(context, schema, value)) &&
+            (!S.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(context, schema, value)) &&
+            (!S.IsMaximum(schema) || CheckMaximum(context, schema, value)) &&
+            (!S.IsMinimum(schema) || CheckMinimum(context, schema, value)) &&
+            (!S.IsMultipleOf(schema) || CheckMultipleOf(context, schema, value)))) &&
+        (!S.IsRef(schema) || CheckRef(context, schema, value)) &&
+        (!S.IsConst(schema) || CheckConst(context, schema, value)) &&
+        (!S.IsEnum(schema) || CheckEnum(context, schema, value)) &&
+        (!S.IsStandardSchemaV1(schema) || CheckStandardSchemaV1(context, schema, value)) &&
+        (!S.IsIf(schema) || CheckIf(context, schema, value)) &&
+        (!S.IsNot(schema) || CheckNot(context, schema, value)) &&
+        (!S.IsAllOf(schema) || CheckAllOf(context, schema, value)) &&
+        (!S.IsAnyOf(schema) || CheckAnyOf(context, schema, value)) &&
+        (!S.IsOneOf(schema) || CheckOneOf(context, schema, value)) &&
+        (!S.IsUnevaluatedItems(schema) || (!G.IsArray(value) || CheckUnevaluatedItems(context, schema, value))) &&
+        (!S.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || CheckUnevaluatedProperties(context, schema, value))) &&
+        (!S.IsRefine(schema) || CheckRefine(context, schema, value)));
+}
+// ----------------------------------------------------------------
+// Error
+// ----------------------------------------------------------------
+export function ErrorSchema(context, schemaPath, instancePath, schema, value) {
+    return (S.IsBooleanSchema(schema)) ? ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) : (!!(+(!S.IsType(schema) || ErrorType(context, schemaPath, instancePath, schema, value)) &
+        +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!S.IsRequired(schema) || ErrorRequired(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsAdditionalProperties(schema) || ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependencies(schema) || ErrorDependencies(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependentRequired(schema) || ErrorDependentRequired(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependentSchemas(schema) || ErrorDependentSchemas(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPatternProperties(schema) || ErrorPatternProperties(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsProperties(schema) || ErrorProperties(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPropertyNames(schema) || ErrorPropertyNames(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinProperties(schema) || ErrorMinProperties(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxProperties(schema) || ErrorMaxProperties(context, schemaPath, instancePath, schema, value)))) &
+        +(!G.IsArray(value) || !!(+(!S.IsAdditionalItems(schema) || ErrorAdditionalItems(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsContains(schema) || ErrorContains(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsItems(schema) || ErrorItems(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxContains(schema) || ErrorMaxContains(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxItems(schema) || ErrorMaxItems(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinContains(schema) || ErrorMinContains(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinItems(schema) || ErrorMinItems(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPrefixItems(schema) || ErrorPrefixItems(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsUniqueItems(schema) || ErrorUniqueItems(context, schemaPath, instancePath, schema, value)))) &
+        +(!G.IsString(value) || !!(+(!S.IsFormat(schema) || ErrorFormat(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxLength(schema) || ErrorMaxLength(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinLength(schema) || ErrorMinLength(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPattern(schema) || ErrorPattern(context, schemaPath, instancePath, schema, value)))) &
+        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!S.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaximum(schema) || ErrorMaximum(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinimum(schema) || ErrorMinimum(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMultipleOf(schema) || ErrorMultipleOf(context, schemaPath, instancePath, schema, value)))) &
+        +(!S.IsRef(schema) || ErrorRef(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsEnum(schema) || ErrorEnum(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsStandardSchemaV1(schema) || ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsIf(schema) || ErrorIf(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsNot(schema) || ErrorNot(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsAllOf(schema) || ErrorAllOf(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsAnyOf(schema) || ErrorAnyOf(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsOneOf(schema) || ErrorOneOf(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsUnevaluatedItems(schema) || (!G.IsArray(value) || ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value))) &
+        +(!S.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value)))) &&
+        (!S.IsRefine(schema) || ErrorRefine(context, schemaPath, instancePath, schema, value)));
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildType(context: BuildContext, schema: S.XType, value: string): string;
+export declare function CheckType(context: CheckContext, schema: S.XType, value: unknown): boolean;
+export declare function ErrorType(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XType, value: unknown): boolean;

package/build/schema/engine/type.mjs

@@ -0,0 +1,74 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// TypeName
+// ------------------------------------------------------------------
+function BuildTypeName(context, type, value) {
+    return (
+    // jsonschema
+    G.IsEqual(type, 'object') ? E.IsObjectNotArray(value) :
+        G.IsEqual(type, 'array') ? E.IsArray(value) :
+            G.IsEqual(type, 'boolean') ? E.IsBoolean(value) :
+                G.IsEqual(type, 'integer') ? E.IsInteger(value) :
+                    G.IsEqual(type, 'number') ? E.IsNumber(value) :
+                        G.IsEqual(type, 'null') ? E.IsNull(value) :
+                            G.IsEqual(type, 'string') ? E.IsString(value) :
+                                // xschema
+                                G.IsEqual(type, 'asyncIterator') ? E.IsAsyncIterator(value) :
+                                    G.IsEqual(type, 'bigint') ? E.IsBigInt(value) :
+                                        G.IsEqual(type, 'constructor') ? E.IsConstructor(value) :
+                                            G.IsEqual(type, 'function') ? E.IsFunction(value) :
+                                                G.IsEqual(type, 'iterator') ? E.IsIterator(value) :
+                                                    G.IsEqual(type, 'symbol') ? E.IsSymbol(value) :
+                                                        G.IsEqual(type, 'undefined') ? E.IsUndefined(value) :
+                                                            G.IsEqual(type, 'void') ? E.IsUndefined(value) :
+                                                                E.Constant(true));
+}
+function CheckTypeName(context, type, schema, value) {
+    return (
+    // jsonschema
+    G.IsEqual(type, 'object') ? G.IsObjectNotArray(value) :
+        G.IsEqual(type, 'array') ? G.IsArray(value) :
+            G.IsEqual(type, 'boolean') ? G.IsBoolean(value) :
+                G.IsEqual(type, 'integer') ? G.IsInteger(value) :
+                    G.IsEqual(type, 'number') ? G.IsNumber(value) :
+                        G.IsEqual(type, 'null') ? G.IsNull(value) :
+                            G.IsEqual(type, 'string') ? G.IsString(value) :
+                                // xschema
+                                G.IsEqual(type, 'asyncIterator') ? G.IsAsyncIterator(value) :
+                                    G.IsEqual(type, 'bigint') ? G.IsBigInt(value) :
+                                        G.IsEqual(type, 'constructor') ? G.IsConstructor(value) :
+                                            G.IsEqual(type, 'function') ? G.IsFunction(value) :
+                                                G.IsEqual(type, 'iterator') ? G.IsIterator(value) :
+                                                    G.IsEqual(type, 'symbol') ? G.IsSymbol(value) :
+                                                        G.IsEqual(type, 'undefined') ? G.IsUndefined(value) :
+                                                            G.IsEqual(type, 'void') ? G.IsUndefined(value) :
+                                                                true);
+}
+// ------------------------------------------------------------------
+// TypeNames
+// ------------------------------------------------------------------
+function BuildTypeNames(context, typenames, value) {
+    return E.ReduceOr(typenames.map(type => BuildTypeName(context, type, value)));
+}
+function CheckTypeNames(context, types, schema, value) {
+    return types.some(type => CheckTypeName(context, type, schema, value));
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export function BuildType(context, schema, value) {
+    return G.IsArray(schema.type) ? BuildTypeNames(context, schema.type, value) : BuildTypeName(context, schema.type, value);
+}
+export function CheckType(context, schema, value) {
+    return G.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
+}
+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`,
+        instancePath,
+        params: { type: schema.type }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildUnevaluatedItems(context: BuildContext, schema: S.XUnevaluatedItems, value: string): string;
+export declare function CheckUnevaluatedItems(context: CheckContext, schema: S.XUnevaluatedItems, value: unknown[]): boolean;
+export declare function ErrorUnevaluatedItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUnevaluatedItems, value: unknown[]): boolean;

package/build/schema/engine/unevaluatedItems.mjs

@@ -0,0 +1,49 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildUnevaluatedItems(context, schema, value) {
+    const indices = E.Call(E.Member('context', 'GetIndices'), []);
+    const hasIndex = E.Call(E.Member('indices', 'has'), ['index']);
+    const isSchema = BuildSchema(context, schema.unevaluatedItems, 'value');
+    const addIndex = E.Call(E.Member('context', 'AddIndex'), ['index']);
+    const isEvery = E.Call(E.Member(value, 'every'), [E.ArrowFunction(['value', 'index'], E.And(E.Or(hasIndex, isSchema), addIndex))]);
+    return E.Call(E.ArrowFunction(['context'], E.Statements([
+        E.ConstDeclaration('indices', indices),
+        E.Return(isEvery)
+    ])), ['context']);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckUnevaluatedItems(context, schema, value) {
+    const indices = context.GetIndices();
+    return G.Every(value, (value, index) => {
+        return (indices.has(index) || CheckSchema(context, schema.unevaluatedItems, value))
+            && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value) {
+    const indices = context.GetIndices();
+    const unevaluatedItems = [];
+    const isUnevaluatedItems = G.EveryAll(value, (value, index) => {
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isEvaluatedItem = (indices.has(index) || ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedItems, value))
+            && context.AddIndex(index);
+        if (!isEvaluatedItem)
+            unevaluatedItems.push(index);
+        return isEvaluatedItem;
+    });
+    return isUnevaluatedItems || context.AddError({
+        keyword: 'unevaluatedItems',
+        schemaPath: `${schemaPath}/unevaluatedItems`,
+        instancePath,
+        params: { unevaluatedItems }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildUnevaluatedProperties(context: BuildContext, schema: S.XUnevaluatedProperties, value: string): string;
+export declare function CheckUnevaluatedProperties(context: CheckContext, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorUnevaluatedProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/unevaluatedProperties.mjs

@@ -0,0 +1,49 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildUnevaluatedProperties(context, schema, value) {
+    const keys = E.Call(E.Member('context', 'GetKeys'), []);
+    const hasKey = E.Call(E.Member('keys', 'has'), ['key']);
+    const addKey = E.Call(E.Member('context', 'AddKey'), ['key']);
+    const isSchema = BuildSchema(context, schema.unevaluatedProperties, `value`);
+    const isEvery = E.Call(E.Member(E.Entries(value), 'every'), [E.ArrowFunction(['[key, value]'], E.Or(hasKey, E.And(isSchema, addKey)))]);
+    return E.Call(E.ArrowFunction(['context'], E.Statements([
+        E.ConstDeclaration('keys', keys),
+        E.Return(isEvery)
+    ])), ['context']);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckUnevaluatedProperties(context, schema, value) {
+    const keys = context.GetKeys();
+    return G.Every(G.Entries(value), ([key, value]) => {
+        return keys.has(key)
+            || (CheckSchema(context, schema.unevaluatedProperties, value) && context.AddKey(key));
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value) {
+    const keys = context.GetKeys();
+    const unevaluatedProperties = [];
+    const isUnevaluatedProperties = G.EveryAll(G.Entries(value), ([key, value]) => {
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isEvaluatedProperty = keys.has(key)
+            || (ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedProperties, value) && context.AddKey(key));
+        if (!isEvaluatedProperty)
+            unevaluatedProperties.push(key);
+        return isEvaluatedProperty;
+    });
+    return isUnevaluatedProperties || context.AddError({
+        keyword: 'unevaluatedProperties',
+        schemaPath: `${schemaPath}/unevaluatedProperties`,
+        instancePath,
+        params: { unevaluatedProperties }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildUniqueItems(context: BuildContext, schema: S.XUniqueItems, value: string): string;
+export declare function CheckUniqueItems(context: CheckContext, schema: S.XUniqueItems, value: unknown[]): boolean;
+export declare function ErrorUniqueItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUniqueItems, value: unknown[]): boolean;

package/build/schema/engine/uniqueItems.mjs

@@ -0,0 +1,51 @@
+// deno-fmt-ignore-file
+import { Hashing } from '../../system/hashing/index.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return !G.IsEqual(schema.uniqueItems, false);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildUniqueItems(context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const set = E.Member(E.New('Set', [E.Call(E.Member(value, 'map'), [E.Member('Hashing', 'Hash')])]), 'size');
+    const isLength = E.Member(value, 'length');
+    return E.IsEqual(set, isLength);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckUniqueItems(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const set = new Set(value.map(Hashing.Hash)).size;
+    const isLength = value.length;
+    return G.IsEqual(set, isLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorUniqueItems(context, schemaPath, instancePath, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const set = new Set();
+    const duplicateItems = value.reduce((result, value, index) => {
+        const hash = Hashing.Hash(value);
+        if (set.has(hash))
+            return [...result, index];
+        set.add(hash);
+        return result;
+    }, []);
+    const isUniqueItems = G.IsEqual(duplicateItems.length, 0);
+    return isUniqueItems || context.AddError({
+        keyword: 'uniqueItems',
+        schemaPath: `${schemaPath}/uniqueItems`,
+        instancePath,
+        params: { duplicateItems },
+    });
+}

package/build/schema/errors.d.mts

@@ -0,0 +1,6 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type XSchemaLike } from './types/index.mjs';
+/** Checks a value and returns validation errors */
+export declare function Errors(schema: XSchemaLike, value: unknown): [boolean, TLocalizedValidationError[]];
+/** Checks a value and returns validation errors */
+export declare function Errors(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): [boolean, TLocalizedValidationError[]];

package/build/schema/errors.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Settings } from '../system/settings/index.mjs';
+import { Get as LocaleGet } from '../system/locale/_config.mjs';
+import { Guard } from '../guard/index.mjs';
+import { ErrorSchema, ErrorContext } from './engine/index.mjs';
+/** Checks a value and returns validation errors */
+export function Errors(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    const settings = Settings.Get();
+    const locale = LocaleGet();
+    const errors = [];
+    const errorContext = new ErrorContext(context, schema, error => {
+        if (Guard.IsGreaterEqualThan(errors.length, settings.maxErrors))
+            return;
+        return errors.push({ ...error, message: locale(error) });
+    });
+    const result = ErrorSchema(errorContext, '#', '', schema, value);
+    return [result, errors];
+}

package/build/schema/index.d.mts

@@ -0,0 +1,16 @@
+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;

package/build/schema/index.mjs

@@ -0,0 +1,19 @@
+// ------------------------------------------------------------------
+// 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';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Build, BuildResult } from './build.mjs';
+import { Check } from './check.mjs';
+import { Errors } from './errors.mjs';
+export default { Build, BuildResult, Check, Errors };