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

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

@@ -1,118 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Arguments } from '../system/arguments/index.mjs';
-import { Environment } from '../system/environment/index.mjs';
-import { Hashing } from '../system/hashing/index.mjs';
-import { Guard } from '../guard/index.mjs';
-import { Format } from '../format/index.mjs';
-import * as Engine from './engine/index.mjs';
-// ------------------------------------------------------------------
-// CreateCode
-// ------------------------------------------------------------------
-function CreateCode(build) {
-    const functions = build.Functions().join(';\n');
-    const statements = build.UseUnevaluated()
-        ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
-        : [`return ${build.Entry()}`];
-    return `${functions}; return (value) => { ${statements.join('; ')} }`;
-}
-// ------------------------------------------------------------------
-// CreateEvaluatedCheck
-// ------------------------------------------------------------------
-function CreateEvaluatedCheck(build, code) {
-    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
-}
-// ------------------------------------------------------------------
-// CreateDynamicCheck
-// ------------------------------------------------------------------
-function CreateDynamicCheck(build) {
-    const stack = new Engine.Stack(build.Context(), build.Schema());
-    const context = new Engine.CheckContext();
-    return (value) => Engine.CheckSchema(stack, context, build.Schema(), value);
-}
-// ------------------------------------------------------------------
-// CreateCheck
-// ------------------------------------------------------------------
-function CreateCheck(build, code) {
-    return Environment.CanEvaluate()
-        ? CreateEvaluatedCheck(build, code)
-        : CreateDynamicCheck(build);
-}
-// ------------------------------------------------------------------
-// EvaluateResult
-// ------------------------------------------------------------------
-export class EvaluateResult {
-    constructor(isAccelerated, code, check) {
-        this.isAccelerated = isAccelerated;
-        this.code = code;
-        this.check = check;
-    }
-    IsAccelerated() {
-        return this.isAccelerated;
-    }
-    Code() {
-        return this.code;
-    }
-    Check(value) {
-        return this.check(value);
-    }
-}
-// ------------------------------------------------------------------
-// BuildResult
-// ------------------------------------------------------------------
-export class BuildResult {
-    constructor(context, schema, external, functions, entry, useUnevaluated) {
-        this.context = context;
-        this.schema = schema;
-        this.external = external;
-        this.functions = functions;
-        this.entry = entry;
-        this.useUnevaluated = useUnevaluated;
-    }
-    /** Returns the Context used for this build */
-    Context() {
-        return this.context;
-    }
-    /** Returns the Schema used for this build */
-    Schema() {
-        return this.schema;
-    }
-    /** Returns true if this build requires a Unevaluated context */
-    UseUnevaluated() {
-        return this.useUnevaluated;
-    }
-    /** Returns external variables */
-    External() {
-        return this.external;
-    }
-    /** Returns check functions */
-    Functions() {
-        return this.functions;
-    }
-    /** Return entry function call. */
-    Entry() {
-        return this.entry;
-    }
-    /** Evaluates the build into a validation function */
-    Evaluate() {
-        const code = CreateCode(this);
-        const check = CreateCheck(this, code);
-        return new EvaluateResult(Environment.CanEvaluate(), code, check);
-    }
-}
-/** Builds a schema into a optimized runtime validator */
-export function Build(...args) {
-    const [context, schema] = Arguments.Match(args, {
-        2: (context, schema) => [context, schema],
-        1: (schema) => [{}, schema]
-    });
-    Engine.ResetExternal();
-    Engine.ResetFunctions();
-    const stack = new Engine.Stack(context, schema);
-    const build = new Engine.BuildContext(Engine.HasUnevaluated(context, schema));
-    const call = Engine.CreateFunction(stack, build, schema, 'value');
-    const functions = Engine.GetFunctions();
-    const externals = Engine.GetExternal();
-    return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated());
-}

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

@@ -1,6 +0,0 @@
-import { type Static } from '../type/types/static.mjs';
-import * as Schema from './types/index.mjs';
-/** Checks a value against the provided schema */
-export declare function Check<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): value is Static<Schema>;
-/** Checks a value against the provided schema */
-export declare function Check<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): value is Static<Schema>;

package/node_modules/typebox/build/schema/check.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Arguments } from '../system/arguments/index.mjs';
-import * as Engine from './engine/index.mjs';
-/** Checks a value against the provided schema */
-export function Check(...args) {
-    const [context, schema, value] = Arguments.Match(args, {
-        3: (context, schema, value) => [context, schema, value],
-        2: (schema, value) => [{}, schema, value]
-    });
-    const stack = new Engine.Stack(context, schema);
-    const checkContext = new Engine.CheckContext();
-    return Engine.CheckSchema(stack, checkContext, schema, value);
-}

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

@@ -1,23 +0,0 @@
-import { type TLocalizedValidationError } from '../error/index.mjs';
-import { type Static } from '../type/types/static.mjs';
-import * as Schema from './types/index.mjs';
-export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly evaluateResult;
-    private readonly context;
-    private readonly schema;
-    constructor(context: Record<string, Schema.XSchema>, schema: Schema);
-    /** Returns true if this Validator is using JIT acceleration. */
-    IsAccelerated(): boolean;
-    /** Returns the underlying Schema used to construct this Validator. */
-    Schema(): Schema;
-    /** Performs a type-guard check on the provided value. */
-    Check(value: unknown): value is Value;
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value: unknown): Value;
-    /** Returns an array of validation errors for the given value. */
-    Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
-}
-/** Compiles this schema into a high performance Validator */
-export declare function Compile<const Schema extends Schema.XSchema>(schema: Schema): Validator<Schema>;
-/** Compiles this schema into a high performance Validator */
-export declare function Compile<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema): Validator<Schema>;

package/node_modules/typebox/build/schema/compile.mjs

@@ -1,46 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Arguments } from '../system/arguments/index.mjs';
-import * as Build from './build.mjs';
-import { Errors } from './errors.mjs';
-import { ThrowParseError } from './parse.mjs';
-// ------------------------------------------------------------------
-// Validator
-// ------------------------------------------------------------------
-export class Validator {
-    constructor(context, schema) {
-        this.evaluateResult = Build.Build(context, schema).Evaluate();
-        this.context = context;
-        this.schema = schema;
-    }
-    /** Returns true if this Validator is using JIT acceleration. */
-    IsAccelerated() {
-        return this.evaluateResult.IsAccelerated();
-    }
-    /** Returns the underlying Schema used to construct this Validator. */
-    Schema() {
-        return this.schema;
-    }
-    /** Performs a type-guard check on the provided value. */
-    Check(value) {
-        return this.evaluateResult.Check(value);
-    }
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value) {
-        if (this.evaluateResult.Check(value))
-            return value;
-        ThrowParseError(this.context, this.schema, value);
-    }
-    /** Returns an array of validation errors for the given value. */
-    Errors(value) {
-        return Errors(this.context, this.schema, value);
-    }
-}
-/** Compiles this schema into a high performance Validator */
-export function Compile(...args) {
-    const [context, schema] = Arguments.Match(args, {
-        2: (context, schema) => [context, schema],
-        1: (schema) => [{}, schema]
-    });
-    return new Validator(context, schema);
-}

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

@@ -1,30 +0,0 @@
-import type { TValidationError } from '../../error/index.mjs';
-export declare function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean;
-export declare class BuildContext {
-    private readonly hasUnevaluated;
-    constructor(hasUnevaluated: boolean);
-    UseUnevaluated(): boolean;
-    Push(): string;
-    Pop(): string;
-    AddIndex(index: string): string;
-    AddKey(key: string): string;
-    Merge(results: string): string;
-}
-export declare class CheckContext {
-    private readonly stack;
-    constructor();
-    Push(): true;
-    Pop(): true;
-    AddIndex(index: number): true;
-    AddKey(key: string): true;
-    GetIndices(): Set<number>;
-    GetKeys(): Set<string>;
-    Merge(results: CheckContext[]): true;
-}
-export declare class ErrorContext extends CheckContext {
-    private readonly errors;
-    constructor();
-    AtCapacity(): boolean;
-    AddError(error: TValidationError): false;
-    GetErrors(): TValidationError[];
-}

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

@@ -1,124 +0,0 @@
-// deno-fmt-ignore-file
-import { Settings } from '../../system/settings/index.mjs';
-import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// HasUnevaluated
-// ------------------------------------------------------------------
-function HasUnevaluatedFromObject(value) {
-    return (Schema.IsUnevaluatedItems(value)
-        || Schema.IsUnevaluatedProperties(value)
-        || G.Some(G.Keys(value), key => HasUnevaluatedFromUnknown(value[key])));
-}
-function HasUnevaluatedFromArray(value) {
-    return G.Some(value, value => HasUnevaluatedFromUnknown(value));
-}
-function HasUnevaluatedFromUnknown(value) {
-    return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
-        G.IsObject(value) ? HasUnevaluatedFromObject(value) :
-            false);
-}
-export function HasUnevaluated(context, schema) {
-    return HasUnevaluatedFromUnknown(schema) || G.Some(G.Keys(context), key => HasUnevaluatedFromUnknown(context[key]));
-}
-// ------------------------------------------------------------------
-// BuildContext
-// ------------------------------------------------------------------
-export class BuildContext {
-    constructor(hasUnevaluated) {
-        this.hasUnevaluated = hasUnevaluated;
-    }
-    UseUnevaluated() {
-        return this.hasUnevaluated;
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push() {
-        return E.Call(E.Member('context', 'Push'), []);
-    }
-    Pop() {
-        return E.Call(E.Member('context', 'Pop'), []);
-    }
-    // ----------------------------------------------------------------
-    // Top
-    // ----------------------------------------------------------------
-    AddIndex(index) {
-        return E.Call(E.Member('context', 'AddIndex'), [index]);
-    }
-    AddKey(key) {
-        return E.Call(E.Member('context', 'AddKey'), [key]);
-    }
-    Merge(results) {
-        return E.Call(E.Member('context', 'Merge'), [results]);
-    }
-}
-// ------------------------------------------------------------------
-// CheckContext
-// ------------------------------------------------------------------
-export class CheckContext {
-    constructor() {
-        const indices = new Set();
-        const keys = new Set();
-        this.stack = [{ indices, keys }];
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push() {
-        const indices = new Set();
-        const keys = new Set();
-        this.stack.push({ indices, keys });
-        return true;
-    }
-    Pop() {
-        this.stack.pop();
-        return true;
-    }
-    // ----------------------------------------------------------------
-    // Top
-    // ----------------------------------------------------------------
-    AddIndex(index) {
-        this.GetIndices().add(index);
-        return true;
-    }
-    AddKey(key) {
-        this.GetKeys().add(key);
-        return true;
-    }
-    GetIndices() {
-        const top = this.stack[this.stack.length - 1];
-        return top.indices;
-    }
-    GetKeys() {
-        const top = this.stack[this.stack.length - 1];
-        return top.keys;
-    }
-    Merge(results) {
-        for (const context of results) {
-            context.GetIndices().forEach(value => this.GetIndices().add(value));
-            context.GetKeys().forEach(value => this.GetKeys().add(value));
-        }
-        return true;
-    }
-}
-// ------------------------------------------------------------------
-// ErrorContext
-// ------------------------------------------------------------------
-export class ErrorContext extends CheckContext {
-    constructor() {
-        super();
-        this.errors = [];
-    }
-    AtCapacity() {
-        return this.errors.length >= Settings.Get().maxErrors;
-    }
-    AddError(error) {
-        if (!this.AtCapacity())
-            this.errors.push(error);
-        return false;
-    }
-    GetErrors() {
-        return this.errors;
-    }
-}

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

@@ -1,3 +0,0 @@
-export declare function IsExactOptional(required: string[], key: string): boolean;
-export declare function InexactOptionalBuild(value: string, key: string): string;
-export declare function InexactOptionalCheck(value: Record<PropertyKey, unknown>, key: string): boolean;

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

@@ -1,20 +0,0 @@
-import { Settings } from '../../system/settings/index.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// IsExactOptional
-// ------------------------------------------------------------------
-export function IsExactOptional(required, key) {
-    return required.includes(key) || Settings.Get().exactOptionalPropertyTypes;
-}
-// ------------------------------------------------------------------
-// ExactOptionalBuild
-// ------------------------------------------------------------------
-export function InexactOptionalBuild(value, key) {
-    return E.IsUndefined(E.Member(value, key));
-}
-// ------------------------------------------------------------------
-// ExactOptionalCheck
-// ------------------------------------------------------------------
-export function InexactOptionalCheck(value, key) {
-    return G.IsUndefined(value[key]);
-}

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

@@ -1,7 +0,0 @@
-export interface TExternal {
-    identifier: 'External';
-    variables: unknown[];
-}
-export declare function CreateVariable(value: unknown): string;
-export declare function ResetExternal(): void;
-export declare function GetExternal(): TExternal;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-const state = {
-    identifier: 'External',
-    variables: []
-};
-// ------------------------------------------------------------------
-// CreateVariable
-// ------------------------------------------------------------------
-export function CreateVariable(value) {
-    const call = `External[${state.variables.length}]`;
-    state.variables.push(value);
-    return call;
-}
-// ------------------------------------------------------------------
-// ResetExternal
-// ------------------------------------------------------------------
-export function ResetExternal() {
-    state.variables = [];
-}
-// ------------------------------------------------------------------
-// GetExternals
-// ------------------------------------------------------------------
-export function GetExternal() {
-    return { ...state };
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function ResetFunctions(): void;
-export declare function GetFunctions(): string[];
-export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;

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

@@ -1,65 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-const index = [0];
-const names = new Map;
-const funcs = new Map();
-// ------------------------------------------------------------------
-// CreateName
-// ------------------------------------------------------------------
-function NextName() {
-    return `${index[0]++}`;
-}
-function CreateName(schema, href) {
-    if (!names.has(schema))
-        names.set(schema, new Map());
-    const hrefs = names.get(schema);
-    if (hrefs.has(href))
-        return hrefs.get(href);
-    const name = NextName();
-    hrefs.set(href, name);
-    return name;
-}
-// ------------------------------------------------------------------
-// CreateCallExpression
-// ------------------------------------------------------------------
-function CreateCallExpression(context, _schema, name, value) {
-    return context.UseUnevaluated()
-        ? E.Call(`check_${name}`, ['context', value])
-        : E.Call(`check_${name}`, [value]);
-}
-// ------------------------------------------------------------------
-// CreateFunctionExpression
-// ------------------------------------------------------------------
-function CreateFunctionExpression(stack, context, schema, name) {
-    const expression = BuildSchema(stack, context, schema, 'value');
-    return context.UseUnevaluated()
-        ? E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['context', 'value'], expression))
-        : E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['value'], expression));
-}
-// ------------------------------------------------------------------
-// ResetFunctions
-// ------------------------------------------------------------------
-export function ResetFunctions() {
-    index[0] = 0;
-    names.clear();
-    funcs.clear();
-}
-// ------------------------------------------------------------------
-// GetFunctions
-// ------------------------------------------------------------------
-export function GetFunctions() {
-    return [...funcs.values()];
-}
-// ------------------------------------------------------------------
-// CreateFunction
-// ------------------------------------------------------------------
-export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.LexicalBaseURL());
-    const call = CreateCallExpression(context, schema, name, value);
-    if (funcs.has(name))
-        return call;
-    funcs.set(name, '');
-    funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
-    return call;
-}

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

@@ -1,4 +0,0 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function Reducer(stack: Stack, context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;

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

@@ -1,45 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Reducer
-//
-// This function is used to generate an reducer evaluation context 
-// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
-// is required from 2019-09 onwards to gather evaluated keys and indices
-// for the unevaluatedItems and unevaluatedProperties keywords.
-//
-// ------------------------------------------------------------------
-//
-// const context = new Context() // exterior
-//
-// (() => {
-//   const results = []
-//
-//   const context_0 = context.Clone()
-//   const context_1 = context.Clone()
-//   const context_2 = context.Clone()
-//   const context_3 = context.Clone()
-//   
-//   const condition_0 = ((context) => <subschema>)(context_0)
-//   const condition_1 = ((context) => <subschema>)(context_1)
-//   const condition_2 = ((context) => <subschema>)(context_2)
-//   const condition_3 = ((context) => <subschema>)(context_3)
-// 
-//   if(condition_0) results.push(context_0)
-//   if(condition_1) results.push(context_1)
-//   if(condition_2) results.push(context_2)
-//   if(condition_3) results.push(context_3)
-//
-//   return <check> && context.Merge(results)
-// })()
-//
-// ------------------------------------------------------------------
-export function Reducer(stack, context, schemas, value, check) {
-    const results = E.ConstDeclaration('results', '[]');
-    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, E.New('CheckContext', [])));
-    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(stack, context, schema, value)), [`context_${index}`])));
-    const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])));
-    const returns = E.Return(E.And(check, context.Merge('results')));
-    return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
-}

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

@@ -1,6 +0,0 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRefine(_stack: Stack, _context: BuildContext, schema: S.XRefine, value: string): string;
-export declare function CheckRefine(_stack: Stack, _context: CheckContext, schema: S.XRefine, value: unknown): boolean;
-export declare function ErrorRefine(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;

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

@@ -1,29 +0,0 @@
-// deno-fmt-ignore-file
-import * as V from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildRefine(_stack, _context, schema, value) {
-    const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRefine(_stack, _context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.check(value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) || context.AddError({
-            keyword: '~refine',
-            schemaPath,
-            instancePath,
-            params: { index, message: refinement.error(value) },
-        });
-    });
-}

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

@@ -1,2 +0,0 @@
-/** Standard RegExp with Unicode */
-export declare function UnicodeRegExp(pattern: string): RegExp;

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

@@ -1,4 +0,0 @@
-/** Standard RegExp with Unicode */
-export function UnicodeRegExp(pattern) {
-    return new RegExp(pattern, 'u');
-}

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

@@ -1,22 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare class Stack {
-    #private;
-    private readonly context;
-    private readonly schema;
-    private readonly ids;
-    private readonly resourceIds;
-    private readonly anchors;
-    private readonly recursiveAnchors;
-    private readonly dynamicAnchors;
-    private readonly retrievedResources;
-    private readonly retrievedFrames;
-    private readonly resolvedResources;
-    private pendingResource;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    LexicalBaseURL(): string;
-    Push(schema: Schema.XSchema): void;
-    Pop(schema: Schema.XSchema): void;
-    Ref(ref: Schema.XRef): Schema.XSchema | undefined;
-    RecursiveRef(recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-    DynamicRef(dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
-}