pi-proactive 0.2.0-beta.5 → 0.2.0-beta.6

package/node_modules/typebox/build/schema/engine/prefixItems.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPrefixItems(stack: Stack, context: BuildContext, schema: Schema.XPrefixItems, value: string): string;
-export declare function CheckPrefixItems(stack: Stack, context: CheckContext, schema: Schema.XPrefixItems, value: unknown[]): boolean;
-export declare function ErrorPrefixItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPrefixItems, value: unknown[]): boolean;

package/node_modules/typebox/build/schema/engine/prefixItems.mjs

@@ -1,35 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildPrefixItems(stack, context, schema, value) {
-    return E.ReduceAnd(schema.prefixItems.map((schema, index) => {
-        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
-        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
-        const addIndex = context.AddIndex(E.Constant(index));
-        const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-        return E.Or(isLength, guarded);
-    }));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckPrefixItems(stack, context, schema, value) {
-    return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 0, (schema, index) => {
-        return G.IsLessEqualThan(value.length, index)
-            || (CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index));
-    });
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorPrefixItems(stack, context, schemaPath, instancePath, schema, value) {
-    return G.IsEqual(value.length, 0) || G.EveryAll(schema.prefixItems, 0, (schema, index) => {
-        const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
-        const nextInstancePath = `${instancePath}/${index}`;
-        return G.IsLessEqualThan(value.length, index)
-            || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
-    });
-}

package/node_modules/typebox/build/schema/engine/properties.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildProperties(stack: Stack, context: BuildContext, schema: Schema.XProperties, value: string): string;
-export declare function CheckProperties(stack: Stack, context: CheckContext, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/properties.mjs

@@ -1,75 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
-import { InexactOptionalCheck, InexactOptionalBuild, IsExactOptional } from './_exact_optional.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildProperties(stack, context, schema, value) {
-    const required = Schema.IsRequired(schema) ? schema.required : [];
-    const everyKey = G.Entries(schema.properties).map(([key, schema]) => {
-        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchemaPushStack(stack, context, schema, E.Member(value, key));
-        const addKey = context.AddKey(E.Constant(key));
-        const guarded = context.UseUnevaluated() ? E.And(isSchema, addKey) : isSchema;
-        // --------------------------------------------------------------
-        // Optimization
-        //
-        // If a key is required, we can skip the `notKey` check since this
-        // condition is already enforced by Required. This optimization is
-        // only valid when Required is evaluated before Properties.
-        //
-        // --------------------------------------------------------------
-        const isProperty = required.includes(key) ? guarded : E.Or(notKey, guarded);
-        // --------------------------------------------------------------
-        // ExactOptionalProperties
-        //
-        // By default, TypeScript allows optional properties to be assigned
-        // undefined. This is a bit misleading, since 'optional' is usually
-        // understood to mean 'the key may be absent', not 'the key may be
-        // present with an undefined value'.
-        //
-        // The 'IsExactOptional' check returns false by default, matching
-        // TypeScript's behavior. When exactOptionalPropertyTypes is enabled
-        // in tsconfig.json, TypeBox can be configured to use the stricter 
-        // semantics via System settings:
-        //
-        //   Settings.Set({ exactOptionalPropertyTypes: true })
-        //
-        // --------------------------------------------------------------
-        return IsExactOptional(required, key)
-            ? isProperty
-            : E.Or(InexactOptionalBuild(value, key), isProperty);
-    });
-    return E.ReduceAnd(everyKey);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckProperties(stack, context, schema, value) {
-    const required = Schema.IsRequired(schema) ? schema.required : [];
-    const isProperties = G.Every(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const isProperty = !G.HasPropertyKey(value, key) || (CheckSchemaPushStack(stack, context, schema, value[key]) && context.AddKey(key));
-        return IsExactOptional(required, key)
-            ? isProperty
-            : InexactOptionalCheck(value, key) || isProperty;
-    });
-    return isProperties;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorProperties(stack, context, schemaPath, instancePath, schema, value) {
-    const required = Schema.IsRequired(schema) ? schema.required : [];
-    const isProperties = G.EveryAll(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/properties/${key}`;
-        const nextInstancePath = `${instancePath}/${key}`;
-        // Defer error generation for IsExactOptional
-        const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
-        return IsExactOptional(required, key)
-            ? isProperty()
-            : InexactOptionalCheck(value, key) || isProperty();
-    });
-    return isProperties;
-}

package/node_modules/typebox/build/schema/engine/propertyNames.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPropertyNames(stack: Stack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
-export declare function CheckPropertyNames(stack: Stack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPropertyNames(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/propertyNames.mjs

@@ -1,37 +0,0 @@
-// deno-fmt-ignore-file
-import { Unique } from './_unique.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildPropertyNames(stack, context, schema, value) {
-    const [key, _index] = [Unique(), Unique()];
-    return E.Every(E.Keys(value), E.Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckPropertyNames(stack, context, schema, value) {
-    return G.Every(G.Keys(value), 0, (key, _index) => CheckSchema(stack, context, schema.propertyNames, key));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
-    const propertyNames = [];
-    const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextInstancePath = `${instancePath}/${key}`;
-        const nextSchemaPath = `${schemaPath}/propertyNames`;
-        const isPropertyName = ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
-        if (!isPropertyName)
-            propertyNames.push(key);
-        return isPropertyName;
-    });
-    return isPropertyNames || context.AddError({
-        keyword: 'propertyNames',
-        schemaPath,
-        instancePath,
-        params: { propertyNames }
-    });
-}

package/node_modules/typebox/build/schema/engine/recursiveRef.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRecursiveRef(stack: Stack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
-export declare function CheckRecursiveRef(stack: Stack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/recursiveRef.mjs

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-import * as Functions from './_functions.mjs';
-import * as Schema from '../types/index.mjs';
-import { CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return Functions.CreateFunction(stack, context, target, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
-}

package/node_modules/typebox/build/schema/engine/ref.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRef(stack: Stack, context: BuildContext, schema: Schema.XRef, value: string): string;
-export declare function CheckRef(stack: Stack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
-export declare function ErrorRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/ref.mjs

@@ -1,52 +0,0 @@
-// deno-fmt-ignore-file
-import * as Functions from './_functions.mjs';
-import * as Schema from '../types/index.mjs';
-import { CheckContext, ErrorContext } from './_context.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// BuildRef
-// ------------------------------------------------------------------
-function BuildRefStandard(stack, context, target, value) {
-    const interior = E.ArrowFunction(['context', 'value'], Functions.CreateFunction(stack, context, target, 'value'));
-    const exterior = E.ArrowFunction(['context', 'value'], E.Statements([
-        E.ConstDeclaration('nextContext', E.New('CheckContext', [])),
-        E.ConstDeclaration('result', E.Call(interior, ['nextContext', 'value'])),
-        E.If('result', context.Merge('[nextContext]')),
-        E.Return('result')
-    ]));
-    return E.Call(exterior, ['context', value]);
-}
-function BuildRefFast(stack, context, target, value) {
-    return Functions.CreateFunction(stack, context, target, value);
-}
-export function BuildRef(stack, context, schema, value) {
-    const target = stack.Ref(schema) ?? false;
-    return context.UseUnevaluated()
-        ? BuildRefStandard(stack, context, target, value)
-        : BuildRefFast(stack, context, target, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRef(stack, context, schema, value) {
-    const target = stack.Ref(schema) ?? false;
-    const nextContext = new CheckContext();
-    const result = (Schema.IsSchema(target) && CheckSchema(stack, nextContext, target, value));
-    if (result)
-        context.Merge([nextContext]);
-    return result;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.Ref(schema) ?? false;
-    const nextContext = new ErrorContext();
-    const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
-    if (result)
-        context.Merge([nextContext]);
-    if (!result)
-        nextContext.GetErrors().forEach(error => context.AddError(error));
-    return result;
-}

package/node_modules/typebox/build/schema/engine/required.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRequired(_stack: Stack, _context: BuildContext, schema: Schema.XRequired, value: string): string;
-export declare function CheckRequired(_stack: Stack, _context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/required.mjs

@@ -1,32 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildRequired(_stack, _context, schema, value) {
-    return E.ReduceAnd(schema.required.map((key) => E.HasPropertyKey(value, E.Constant(key))));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRequired(_stack, _context, schema, value) {
-    return G.Every(schema.required, 0, (key) => G.HasPropertyKey(value, key));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRequired(_stack, context, schemaPath, instancePath, schema, value) {
-    const requiredProperties = [];
-    const isRequired = G.EveryAll(schema.required, 0, (key) => {
-        const hasKey = G.HasPropertyKey(value, key);
-        if (!hasKey)
-            requiredProperties.push(key);
-        return hasKey;
-    });
-    return isRequired || context.AddError({
-        keyword: 'required',
-        schemaPath,
-        instancePath,
-        params: { requiredProperties }
-    });
-}

package/node_modules/typebox/build/schema/engine/schema.d.mts

@@ -1,9 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaPushStack(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
-export declare function BuildSchema(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
-export declare function CheckSchemaPushStack(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
-export declare function CheckSchema(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
-export declare function ErrorSchemaPushStack(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
-export declare function ErrorSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;