pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

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

@@ -1,9 +1,8 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import * as Pathing from './_pathing.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';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -64,8 +63,8 @@ export function CheckProperties(stack, context, schema, value) {
 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/${Pathing.EncodeFragment(key)}`;
-        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
+        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)

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPropertyNames(stack: Stack.XStack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
-export declare function CheckPropertyNames(stack: Stack.XStack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPropertyNames(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+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,13 +1,12 @@
 // deno-fmt-ignore-file
-import * as Pathing from './_pathing.mjs';
-import * as Unique from './_unique.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+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.CreateUnique(), Unique.CreateUnique()];
+    const [key, _index] = [Unique(), Unique()];
     return E.Every(E.Keys(value), E.Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------
@@ -22,13 +21,17 @@ export function CheckPropertyNames(stack, context, schema, value) {
 export function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
     const propertyNames = [];
     const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
+        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('propertyNames', schemaPath, instancePath, { propertyNames });
+    return isPropertyNames || context.AddError({
+        keyword: 'propertyNames',
+        schemaPath,
+        instancePath,
+        params: { propertyNames }
+    });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRecursiveRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
-export declare function CheckRecursiveRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;
+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,29 +1,25 @@
 // deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
 import * as Functions from './_functions.mjs';
-import { Resolve } from '../resolve/index.mjs';
+import * as Schema from '../types/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildRecursiveRef(stack, context, schema, value) {
-    const target = Resolve.RecursiveRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return Functions.CreateFunction(nextStack, context, target, value);
+    const target = stack.RecursiveRef(schema) ?? false;
+    return Functions.CreateFunction(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRecursiveRef(stack, context, schema, value) {
-    const target = Resolve.RecursiveRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, 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 = Resolve.RecursiveRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
+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 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRef, value: string): string;
-export declare function CheckRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
-export declare function ErrorRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;
+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,7 +1,6 @@
 // deno-fmt-ignore-file
 import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
-import { Resolve } from '../resolve/index.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
@@ -22,35 +21,32 @@ function BuildRefFast(stack, context, target, value) {
     return Functions.CreateFunction(stack, context, target, value);
 }
 export function BuildRef(stack, context, schema, value) {
-    const result = Resolve.Ref(stack, schema);
-    const target = result.schema ?? false;
+    const target = stack.Ref(schema) ?? false;
     return context.UseUnevaluated()
-        ? BuildRefStandard(result.stack, context, target, value)
-        : BuildRefFast(result.stack, context, target, value);
+        ? BuildRefStandard(stack, context, target, value)
+        : BuildRefFast(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRef(stack, context, schema, value) {
-    const result = Resolve.Ref(stack, schema);
-    const target = result.schema ?? false;
+    const target = stack.Ref(schema) ?? false;
     const nextContext = new CheckContext();
-    const valid = (Schema.IsSchema(target) && CheckSchema(result.stack, nextContext, target, value));
-    if (valid)
+    const result = (Schema.IsSchema(target) && CheckSchema(stack, nextContext, target, value));
+    if (result)
         context.Merge([nextContext]);
-    return valid;
+    return result;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
-    const result = Resolve.Ref(stack, schema);
-    const target = result.schema ?? false;
+export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
+    const target = stack.Ref(schema) ?? false;
     const nextContext = new ErrorContext();
-    const valid = (Schema.IsSchema(target) && ErrorSchema(result.stack, nextContext, schemaPath, instancePath, target, value));
-    if (valid)
+    const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
+    if (result)
         context.Merge([nextContext]);
-    if (!valid)
-        context.AddErrors(nextContext.GetErrors());
-    return valid;
+    if (!result)
+        nextContext.GetErrors().forEach(error => context.AddError(error));
+    return result;
 }

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

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

@@ -23,6 +23,10 @@ export function ErrorRequired(_stack, context, schemaPath, instancePath, schema,
             requiredProperties.push(key);
         return hasKey;
     });
-    return isRequired ||
-        context.AddError('required', schemaPath, instancePath, { requiredProperties });
+    return isRequired || context.AddError({
+        keyword: 'required',
+        schemaPath,
+        instancePath,
+        params: { requiredProperties }
+    });
 }

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

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