@wener/utils 1.1.48 → 1.1.50

package/lib/schema/typebox/gen/codegen/expression/errors.js

@@ -1,259 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-expression
-
-The MIT License (MIT)
-
-Copyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/ import { Hash } from '@sinclair/typebox/value';
-// ---------------------------------------------------------------------
-// ExpressionErrorsEvaluator
-// ---------------------------------------------------------------------
-export class ExpressionErrorsUnknownExpressionError extends Error {
-    expression;
-    constructor(expression){
-        super('Unknown Expression Detected');
-        this.expression = expression;
-    }
-}
-export var ExpressionErrors;
-(function(ExpressionErrors) {
-    function And(expression, path, value) {
-        return expression.expr.every((expression)=>Visit(expression, path, value));
-    }
-    function Call(expression, path, value) {
-        const func = value[expression.target].bind(value);
-        return typeof func === 'function' && Visit(expression.expr, path, func(...expression.parameters));
-    }
-    function ElementsDistinct(expression, path, value) {
-        const set = new Set();
-        for (const element of value){
-            const hash = Hash(element);
-            if (set.has(hash)) return false;
-            set.add(hash);
-        }
-        return true;
-    }
-    function Elements(expression, path, value) {
-        return value.every((element)=>Visit(expression.expr, path, element));
-    }
-    function Equals(expression, path, value) {
-        return value === expression.value;
-    }
-    function False(expression, path, value) {
-        return false;
-    }
-    function Function(expression, path, value) {
-        return expression.callback(value);
-    }
-    function GreaterThanEqual(expression, path, value) {
-        return value >= expression.value;
-    }
-    function GreaterThan(expression, path, value) {
-        return value > expression.value;
-    }
-    function IfThenElse(expression, path, value) {
-        return Visit(expression.if, path, value) ? Visit(expression.then, path, value) : Visit(expression.else, path, value);
-    }
-    function InstanceOf(expression, path, value) {
-        return value instanceof expression.value;
-    }
-    function IsArray(expression, path, value) {
-        return globalThis.Array.isArray(value);
-    }
-    function IsInteger(expression, path, value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsNaN(expression, path, value) {
-        return globalThis.Number.isNaN(value);
-    }
-    function IsFinite(expression, path, value) {
-        return globalThis.Number.isFinite(value);
-    }
-    function IsPattern(expression, path, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return regexp.test(value);
-    }
-    function IsSafeInteger(expression, path, value) {
-        return globalThis.Number.isSafeInteger(value);
-    }
-    function IsUndefined(expression, path, value) {
-        return value === undefined;
-    }
-    function LessThan(expression, path, value) {
-        return value < expression.value;
-    }
-    function LessThanEqual(expression, path, value) {
-        return value <= expression.value;
-    }
-    function MultipleOf(expression, path, value) {
-        return value % expression.value === 0;
-    }
-    function Property(expression, path, value) {
-        return Visit(expression.expr, path, value[expression.key]);
-    }
-    function Index(expression, path, value) {
-        return Visit(expression.expr, path, value[expression.index]);
-    }
-    function Or(expression, path, value) {
-        return expression.expr.some((expression)=>Visit(expression, path, value));
-    }
-    function Not(expression, path, value) {
-        return !Visit(expression.expr, path, value);
-    }
-    function PropertiesExcludePattern(expression, path, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return Object.getOwnPropertyNames(value).every((key)=>!regexp.test(key) ? Visit(expression.expr, path, value[key]) : true);
-    }
-    function PropertiesExclude(expression, path, value) {
-        return Object.getOwnPropertyNames(value).every((key)=>!expression.keys.includes(key) ? Visit(expression.expr, path, value[key]) : true);
-    }
-    function PropertiesIncludePattern(expression, path, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return Object.getOwnPropertyNames(value).every((key)=>regexp.test(key) ? Visit(expression.expr, path, value[key]) : true);
-    }
-    function PropertiesInclude(expression, path, value) {
-        return Object.getOwnPropertyNames(value).every((key)=>expression.keys.includes(key) ? Visit(expression.expr, path, value[key]) : true);
-    }
-    function PropertiesLength(expression, path, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length === expression.value;
-    }
-    function PropertiesMaximum(expression, path, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length <= expression.value;
-    }
-    function PropertiesMinimum(expression, path, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length >= expression.value;
-    }
-    function Properties(expression, path, value) {
-        return globalThis.Object.getOwnPropertyNames(value).every((key)=>Visit(expression.expr, path, value[key]));
-    }
-    function PropertyKeys(expression, path, value) {
-        const keys = globalThis.Object.getOwnPropertyNames(value);
-        return expression.keys.every((key)=>keys.includes(key));
-    }
-    function Ref(expression, path, value) {
-        if (!reference_map.has(expression.$ref)) return false;
-        const referenced_expression = reference_map.get(expression.$ref);
-        return Visit(referenced_expression, path, value);
-    }
-    function True(expression, path, value) {
-        return true;
-    }
-    function TypeOf(expression, path, value) {
-        return typeof value === expression.value;
-    }
-    function Visit(expression, path, value) {
-        if (expression.$id !== undefined) reference_map.set(expression.$id, expression);
-        switch(expression.type){
-            case 'And':
-                return And(expression, path, value);
-            case 'Call':
-                return Call(expression, path, value);
-            case 'ElementsDistinct':
-                return ElementsDistinct(expression, path, value);
-            case 'Elements':
-                return Elements(expression, path, value);
-            case 'Equals':
-                return Equals(expression, path, value);
-            case 'False':
-                return False(expression, path, value);
-            case 'Function':
-                return Function(expression, path, value);
-            case 'GreaterThanEqual':
-                return GreaterThanEqual(expression, path, value);
-            case 'GreaterThan':
-                return GreaterThan(expression, path, value);
-            case 'LessThanEqual':
-                return LessThanEqual(expression, path, value);
-            case 'LessThan':
-                return LessThan(expression, path, value);
-            case 'MultipleOf':
-                return MultipleOf(expression, path, value);
-            case 'IfThenElse':
-                return IfThenElse(expression, path, value);
-            case 'InstanceOf':
-                return InstanceOf(expression, path, value);
-            case 'Index':
-                return Index(expression, path, value);
-            case 'IsArray':
-                return IsArray(expression, path, value);
-            case 'IsFinite':
-                return IsFinite(expression, path, value);
-            case 'IsInteger':
-                return IsInteger(expression, path, value);
-            case 'IsNaN':
-                return IsNaN(expression, path, value);
-            case 'IsPattern':
-                return IsPattern(expression, path, value);
-            case 'IsSafeInteger':
-                return IsSafeInteger(expression, path, value);
-            case 'IsUndefined':
-                return IsUndefined(expression, path, value);
-            case 'Not':
-                return Not(expression, path, value);
-            case 'Or':
-                return Or(expression, path, value);
-            case 'PropertiesInclude':
-                return PropertiesInclude(expression, path, value);
-            case 'PropertiesIncludePattern':
-                return PropertiesIncludePattern(expression, path, value);
-            case 'PropertiesExclude':
-                return PropertiesExclude(expression, path, value);
-            case 'PropertiesExcludePattern':
-                return PropertiesExcludePattern(expression, path, value);
-            case 'PropertiesLength':
-                return PropertiesLength(expression, path, value);
-            case 'PropertiesMaximum':
-                return PropertiesMaximum(expression, path, value);
-            case 'PropertiesMinimum':
-                return PropertiesMinimum(expression, path, value);
-            case 'Properties':
-                return Properties(expression, path, value);
-            case 'PropertyKeys':
-                return PropertyKeys(expression, path, value);
-            case 'Property':
-                return Property(expression, path, value);
-            case 'Ref':
-                return Ref(expression, path, value);
-            case 'True':
-                return True(expression, path, value);
-            case 'TypeOf':
-                return TypeOf(expression, path, value);
-            default:
-                throw 1;
-        }
-    }
-    const reference_map = new Map();
-    const error_map = new Map();
-    function Evaluate(expression, references, value) {
-        reference_map.clear();
-        error_map.clear();
-        for (const reference of references){
-            if (reference.$id === undefined) continue;
-            reference_map.set(reference.$id, reference);
-        }
-        return Visit(expression, '', value);
-    }
-    /** Evaluates an expression against a value and returns an `ExpressionResult<T>` which contains a `path` and `ok` property  */ ExpressionErrors.Evaluate = Evaluate;
-})(ExpressionErrors || (ExpressionErrors = {}));
-
-//# sourceMappingURL=errors.js.map

package/lib/schema/typebox/gen/codegen/expression/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/expression/errors.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-expression\n\nThe MIT License (MIT)\n\nCopyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\nimport { Hash } from '@sinclair/typebox/value';\nimport * as Expr from './expression';\n\n// ---------------------------------------------------------------------\n// ExpressionErrorsEvaluator\n// ---------------------------------------------------------------------\n\nexport class ExpressionErrorsUnknownExpressionError extends Error {\n  constructor(public readonly expression: unknown) {\n    super('Unknown Expression Detected');\n  }\n}\n\nexport namespace ExpressionErrors {\n  function And(expression: Expr.AndExpression, path: string, value: unknown): boolean {\n    return expression.expr.every((expression) => Visit(expression, path, value));\n  }\n  function Call(expression: Expr.CallExpression, path: string, value: Record<string, Function>): boolean {\n    const func = value[expression.target].bind(value);\n    return typeof func === 'function' && Visit(expression.expr, path, func(...expression.parameters));\n  }\n  function ElementsDistinct(expression: Expr.ElementsDistinctExpression, path: string, value: unknown[]): boolean {\n    const set = new Set();\n    for (const element of value) {\n      const hash = Hash(element);\n      if (set.has(hash)) return false;\n      set.add(hash);\n    }\n    return true;\n  }\n  function Elements(expression: Expr.ElementsExpression, path: string, value: unknown[]): boolean {\n    return value.every((element) => Visit(expression.expr, path, element));\n  }\n  function Equals(expression: Expr.EqualsExpression, path: string, value: unknown): boolean {\n    return value === expression.value;\n  }\n  function False(expression: Expr.FalseExpression, path: string, value: unknown): boolean {\n    return false;\n  }\n  function Function(expression: Expr.FunctionExpression, path: string, value: unknown): boolean {\n    return expression.callback(value);\n  }\n  function GreaterThanEqual(expression: Expr.GreaterThanEqualExpression, path: string, value: number): boolean {\n    return value >= expression.value;\n  }\n  function GreaterThan(expression: Expr.GreaterThanExpression, path: string, value: number): boolean {\n    return value > expression.value;\n  }\n  function IfThenElse(expression: Expr.IfThenElseExpression, path: string, value: unknown): boolean {\n    return Visit(expression.if, path, value)\n      ? Visit(expression.then, path, value)\n      : Visit(expression.else, path, value);\n  }\n  function InstanceOf(expression: Expr.InstanceOfExpression, path: string, value: unknown): boolean {\n    return value instanceof (expression.value as any);\n  }\n  function IsArray(expression: Expr.IsArrayExpression, path: string, value: unknown[]): boolean {\n    return globalThis.Array.isArray(value);\n  }\n  function IsInteger(expression: Expr.IsIntegerExpression, path: string, value: number): boolean {\n    return globalThis.Number.isInteger(value);\n  }\n  function IsNaN(expression: Expr.IsNaNExpression, path: string, value: number): boolean {\n    return globalThis.Number.isNaN(value);\n  }\n  function IsFinite(expression: Expr.IsFiniteExpression, path: string, value: number): boolean {\n    return globalThis.Number.isFinite(value);\n  }\n  function IsPattern(expression: Expr.IsPatternExpression, path: string, value: string): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return regexp.test(value);\n  }\n  function IsSafeInteger(expression: Expr.IsSafeIntegerExpression, path: string, value: number): boolean {\n    return globalThis.Number.isSafeInteger(value);\n  }\n  function IsUndefined(expression: Expr.IsUndefinedExpression, path: string, value: number): boolean {\n    return value === undefined;\n  }\n  function LessThan(expression: Expr.LessThanExpression, path: string, value: number): boolean {\n    return value < expression.value;\n  }\n  function LessThanEqual(expression: Expr.LessThanEqualExpression, path: string, value: number): boolean {\n    return value <= expression.value;\n  }\n  function MultipleOf(expression: Expr.MultipleOfExpression, path: string, value: number): boolean {\n    return value % expression.value === 0;\n  }\n  function Property(expression: Expr.PropertyExpression, path: string, value: Record<string, unknown>): boolean {\n    return Visit(expression.expr, path, value[expression.key]);\n  }\n  function Index(expression: Expr.IndexExpression, path: string, value: unknown[]): boolean {\n    return Visit(expression.expr, path, value[expression.index]);\n  }\n  function Or(expression: Expr.OrExpression, path: string, value: unknown): boolean {\n    return expression.expr.some((expression) => Visit(expression, path, value));\n  }\n  function Not(expression: Expr.NotExpression, path: string, value: unknown): boolean {\n    return !Visit(expression.expr, path, value);\n  }\n  function PropertiesExcludePattern(\n    expression: Expr.PropertiesExcludePatternExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return Object.getOwnPropertyNames(value).every((key) =>\n      !regexp.test(key) ? Visit(expression.expr, path, value[key]) : true,\n    );\n  }\n  function PropertiesExclude(\n    expression: Expr.PropertiesExcludeExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    return Object.getOwnPropertyNames(value).every((key) =>\n      !expression.keys.includes(key) ? Visit(expression.expr, path, value[key]) : true,\n    );\n  }\n  function PropertiesIncludePattern(\n    expression: Expr.PropertiesIncludePatternExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return Object.getOwnPropertyNames(value).every((key) =>\n      regexp.test(key) ? Visit(expression.expr, path, value[key]) : true,\n    );\n  }\n  function PropertiesInclude(\n    expression: Expr.PropertiesIncludeExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    return Object.getOwnPropertyNames(value).every((key) =>\n      expression.keys.includes(key) ? Visit(expression.expr, path, value[key]) : true,\n    );\n  }\n  function PropertiesLength(\n    expression: Expr.PropertiesLengthExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length === expression.value;\n  }\n  function PropertiesMaximum(\n    expression: Expr.PropertiesMaximumExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length <= expression.value;\n  }\n  function PropertiesMinimum(\n    expression: Expr.PropertiesMinimumExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length >= expression.value;\n  }\n  function Properties(expression: Expr.PropertiesExpression, path: string, value: Record<string, unknown>): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).every((key) => Visit(expression.expr, path, value[key]));\n  }\n  function PropertyKeys(\n    expression: Expr.PropertyKeysExpression,\n    path: string,\n    value: Record<string, unknown>,\n  ): boolean {\n    const keys = globalThis.Object.getOwnPropertyNames(value);\n    return expression.keys.every((key) => keys.includes(key));\n  }\n  function Ref(expression: Expr.RefExpression, path: string, value: unknown): boolean {\n    if (!reference_map.has(expression.$ref)) return false;\n    const referenced_expression = reference_map.get(expression.$ref)!;\n    return Visit(referenced_expression, path, value);\n  }\n  function True(expression: Expr.TrueExpression, path: string, value: unknown): boolean {\n    return true;\n  }\n  function TypeOf(expression: Expr.TypeOfExpression, path: string, value: unknown): boolean {\n    return typeof value === expression.value;\n  }\n  function Visit(expression: Expr.Expression, path: string, value: any): boolean {\n    if (expression.$id !== undefined) reference_map.set(expression.$id, expression);\n    switch (expression.type) {\n      case 'And':\n        return And(expression, path, value);\n      case 'Call':\n        return Call(expression, path, value);\n      case 'ElementsDistinct':\n        return ElementsDistinct(expression, path, value);\n      case 'Elements':\n        return Elements(expression, path, value);\n      case 'Equals':\n        return Equals(expression, path, value);\n      case 'False':\n        return False(expression, path, value);\n      case 'Function':\n        return Function(expression, path, value);\n      case 'GreaterThanEqual':\n        return GreaterThanEqual(expression, path, value);\n      case 'GreaterThan':\n        return GreaterThan(expression, path, value);\n      case 'LessThanEqual':\n        return LessThanEqual(expression, path, value);\n      case 'LessThan':\n        return LessThan(expression, path, value);\n      case 'MultipleOf':\n        return MultipleOf(expression, path, value);\n      case 'IfThenElse':\n        return IfThenElse(expression, path, value);\n      case 'InstanceOf':\n        return InstanceOf(expression, path, value);\n      case 'Index':\n        return Index(expression, path, value);\n      case 'IsArray':\n        return IsArray(expression, path, value);\n      case 'IsFinite':\n        return IsFinite(expression, path, value);\n      case 'IsInteger':\n        return IsInteger(expression, path, value);\n      case 'IsNaN':\n        return IsNaN(expression, path, value);\n      case 'IsPattern':\n        return IsPattern(expression, path, value);\n      case 'IsSafeInteger':\n        return IsSafeInteger(expression, path, value);\n      case 'IsUndefined':\n        return IsUndefined(expression, path, value);\n      case 'Not':\n        return Not(expression, path, value);\n      case 'Or':\n        return Or(expression, path, value);\n      case 'PropertiesInclude':\n        return PropertiesInclude(expression, path, value);\n      case 'PropertiesIncludePattern':\n        return PropertiesIncludePattern(expression, path, value);\n      case 'PropertiesExclude':\n        return PropertiesExclude(expression, path, value);\n      case 'PropertiesExcludePattern':\n        return PropertiesExcludePattern(expression, path, value);\n      case 'PropertiesLength':\n        return PropertiesLength(expression, path, value);\n      case 'PropertiesMaximum':\n        return PropertiesMaximum(expression, path, value);\n      case 'PropertiesMinimum':\n        return PropertiesMinimum(expression, path, value);\n      case 'Properties':\n        return Properties(expression, path, value);\n      case 'PropertyKeys':\n        return PropertyKeys(expression, path, value);\n      case 'Property':\n        return Property(expression, path, value);\n      case 'Ref':\n        return Ref(expression, path, value);\n      case 'True':\n        return True(expression, path, value);\n      case 'TypeOf':\n        return TypeOf(expression, path, value);\n      default:\n        throw 1;\n    }\n  }\n  const reference_map = new Map<string, Expr.Expression>();\n  const error_map = new Map<string, string>();\n\n  /** Evaluates an expression against a value and returns an `ExpressionResult<T>` which contains a `path` and `ok` property  */\n  export function Evaluate(expression: Expr.Expression, references: Expr.Expression[], value: unknown) {\n    reference_map.clear();\n    error_map.clear();\n    for (const reference of references) {\n      if (reference.$id === undefined) continue;\n      reference_map.set(reference.$id, reference);\n    }\n    return Visit(expression, '', value);\n  }\n}\n"],"names":["Hash","ExpressionErrorsUnknownExpressionError","Error","constructor","expression","ExpressionErrors","And","path","value","expr","every","Visit","Call","func","target","bind","parameters","ElementsDistinct","set","Set","element","hash","has","add","Elements","Equals","False","Function","callback","GreaterThanEqual","GreaterThan","IfThenElse","if","then","else","InstanceOf","IsArray","globalThis","Array","isArray","IsInteger","Number","isInteger","IsNaN","isNaN","IsFinite","isFinite","IsPattern","regexp","RegExp","pattern","test","IsSafeInteger","isSafeInteger","IsUndefined","undefined","LessThan","LessThanEqual","MultipleOf","Property","key","Index","index","Or","some","Not","PropertiesExcludePattern","Object","getOwnPropertyNames","PropertiesExclude","keys","includes","PropertiesIncludePattern","PropertiesInclude","PropertiesLength","length","PropertiesMaximum","PropertiesMinimum","Properties","PropertyKeys","Ref","reference_map","$ref","referenced_expression","get","True","TypeOf","$id","type","Map","error_map","Evaluate","references","clear","reference"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/schema/typebox/gen/codegen/expression/evaluator.js

@@ -1,254 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-expression
-
-The MIT License (MIT)
-
-Copyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/ import { Hash } from '@sinclair/typebox/value';
-export class ExpressionEvaluatorExpressionError extends Error {
-    expression;
-    constructor(expression){
-        super('Unknown Expression Detected');
-        this.expression = expression;
-    }
-}
-export var ExpressionEvaluator;
-(function(ExpressionEvaluator) {
-    function And(expression, value) {
-        return expression.expr.every((expression)=>Visit(expression, value));
-    }
-    function Call(expression, value) {
-        const func = value[expression.target].bind(value);
-        return typeof func === 'function' && Visit(expression.expr, func(...expression.parameters));
-    }
-    function ElementsDistinct(expression, value) {
-        const set = new Set();
-        for (const element of value){
-            const hash = Hash(element);
-            if (set.has(hash)) return false;
-            set.add(hash);
-        }
-        return true;
-    }
-    function Elements(expression, value) {
-        return value.every((element)=>Visit(expression.expr, element));
-    }
-    function Equals(expression, value) {
-        return value === expression.value;
-    }
-    function False(expression, value) {
-        return false;
-    }
-    function Function(expression, value) {
-        return expression.callback(value);
-    }
-    function GreaterThanEqual(expression, value) {
-        return value >= expression.value;
-    }
-    function GreaterThan(expression, value) {
-        return value > expression.value;
-    }
-    function IfThenElse(expression, value) {
-        return Visit(expression.if, value) ? Visit(expression.then, value) : Visit(expression.else, value);
-    }
-    function InstanceOf(expression, value) {
-        return value instanceof globalThis[expression.value];
-    }
-    function IsArray(expression, value) {
-        return globalThis.Array.isArray(value);
-    }
-    function IsInteger(expression, value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsNaN(expression, value) {
-        return globalThis.Number.isNaN(value);
-    }
-    function IsFinite(expression, value) {
-        return globalThis.Number.isFinite(value);
-    }
-    function IsPattern(expression, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return regexp.test(value);
-    }
-    function IsSafeInteger(expression, value) {
-        return globalThis.Number.isSafeInteger(value);
-    }
-    function IsUndefined(expression, value) {
-        return value === undefined;
-    }
-    function LessThan(expression, value) {
-        return value < expression.value;
-    }
-    function LessThanEqual(expression, value) {
-        return value <= expression.value;
-    }
-    function MultipleOf(expression, value) {
-        return value % expression.value === 0;
-    }
-    function Property(expression, value) {
-        return Visit(expression.expr, value[expression.key]);
-    }
-    function Index(expression, value) {
-        return Visit(expression.expr, value[expression.index]);
-    }
-    function Or(expression, value) {
-        return expression.expr.some((expression)=>Visit(expression, value));
-    }
-    function Not(expression, value) {
-        return !Visit(expression.expr, value);
-    }
-    function PropertiesExcludePattern(expression, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return Object.getOwnPropertyNames(value).every((key)=>!regexp.test(key) ? Visit(expression.expr, value[key]) : true);
-    }
-    function PropertiesExclude(expression, value) {
-        return Object.getOwnPropertyNames(value).every((key)=>!expression.keys.includes(key) ? Visit(expression.expr, value[key]) : true);
-    }
-    function PropertiesIncludePattern(expression, value) {
-        const regexp = new globalThis.RegExp(expression.pattern);
-        return Object.getOwnPropertyNames(value).every((key)=>regexp.test(key) ? Visit(expression.expr, value[key]) : true);
-    }
-    function PropertiesInclude(expression, value) {
-        return Object.getOwnPropertyNames(value).every((key)=>expression.keys.includes(key) ? Visit(expression.expr, value[key]) : true);
-    }
-    function PropertiesLength(expression, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length === expression.value;
-    }
-    function PropertiesMaximum(expression, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length <= expression.value;
-    }
-    function PropertiesMinimum(expression, value) {
-        return globalThis.Object.getOwnPropertyNames(value).length >= expression.value;
-    }
-    function Properties(expression, value) {
-        return globalThis.Object.getOwnPropertyNames(value).every((key)=>Visit(expression.expr, value[key]));
-    }
-    function PropertyKeys(expression, value) {
-        const keys = globalThis.Object.getOwnPropertyNames(value);
-        return expression.keys.every((key)=>keys.includes(key));
-    }
-    function Ref(expression, value) {
-        if (!reference_map.has(expression.$ref)) return false;
-        const referenced_expression = reference_map.get(expression.$ref);
-        return Visit(referenced_expression, value);
-    }
-    function True(expression, value) {
-        return true;
-    }
-    function TypeOf(expression, value) {
-        return typeof value === expression.value;
-    }
-    function Visit(expression, value) {
-        if (expression.$id !== undefined) reference_map.set(expression.$id, expression);
-        switch(expression.type){
-            case 'And':
-                return And(expression, value);
-            case 'Call':
-                return Call(expression, value);
-            case 'ElementsDistinct':
-                return ElementsDistinct(expression, value);
-            case 'Elements':
-                return Elements(expression, value);
-            case 'Equals':
-                return Equals(expression, value);
-            case 'False':
-                return False(expression, value);
-            case 'Function':
-                return Function(expression, value);
-            case 'GreaterThanEqual':
-                return GreaterThanEqual(expression, value);
-            case 'GreaterThan':
-                return GreaterThan(expression, value);
-            case 'LessThanEqual':
-                return LessThanEqual(expression, value);
-            case 'LessThan':
-                return LessThan(expression, value);
-            case 'MultipleOf':
-                return MultipleOf(expression, value);
-            case 'IfThenElse':
-                return IfThenElse(expression, value);
-            case 'InstanceOf':
-                return InstanceOf(expression, value);
-            case 'Index':
-                return Index(expression, value);
-            case 'IsArray':
-                return IsArray(expression, value);
-            case 'IsFinite':
-                return IsFinite(expression, value);
-            case 'IsInteger':
-                return IsInteger(expression, value);
-            case 'IsNaN':
-                return IsNaN(expression, value);
-            case 'IsPattern':
-                return IsPattern(expression, value);
-            case 'IsSafeInteger':
-                return IsSafeInteger(expression, value);
-            case 'IsUndefined':
-                return IsUndefined(expression, value);
-            case 'Not':
-                return Not(expression, value);
-            case 'Or':
-                return Or(expression, value);
-            case 'PropertiesInclude':
-                return PropertiesInclude(expression, value);
-            case 'PropertiesIncludePattern':
-                return PropertiesIncludePattern(expression, value);
-            case 'PropertiesExclude':
-                return PropertiesExclude(expression, value);
-            case 'PropertiesExcludePattern':
-                return PropertiesExcludePattern(expression, value);
-            case 'PropertiesLength':
-                return PropertiesLength(expression, value);
-            case 'PropertiesMaximum':
-                return PropertiesMaximum(expression, value);
-            case 'PropertiesMinimum':
-                return PropertiesMinimum(expression, value);
-            case 'Properties':
-                return Properties(expression, value);
-            case 'PropertyKeys':
-                return PropertyKeys(expression, value);
-            case 'Property':
-                return Property(expression, value);
-            case 'Ref':
-                return Ref(expression, value);
-            case 'True':
-                return True(expression, value);
-            case 'TypeOf':
-                return TypeOf(expression, value);
-            default:
-                throw new ExpressionEvaluatorExpressionError(expression);
-        }
-    }
-    const reference_map = new Map();
-    function Evaluate(expression, references, value) {
-        reference_map.clear();
-        for (const reference of references){
-            if (reference.$id === undefined) continue;
-            reference_map.set(reference.$id, reference);
-        }
-        return Visit(expression, value);
-    }
-    /** Evaluates the given expression */ ExpressionEvaluator.Evaluate = Evaluate;
-})(ExpressionEvaluator || (ExpressionEvaluator = {}));
-
-//# sourceMappingURL=evaluator.js.map

package/lib/schema/typebox/gen/codegen/expression/evaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/expression/evaluator.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-expression\n\nThe MIT License (MIT)\n\nCopyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\nimport { Hash } from '@sinclair/typebox/value';\nimport * as Expr from './expression';\n\nexport class ExpressionEvaluatorExpressionError extends Error {\n  constructor(public readonly expression: unknown) {\n    super('Unknown Expression Detected');\n  }\n}\n\nexport namespace ExpressionEvaluator {\n  function And(expression: Expr.AndExpression, value: unknown): boolean {\n    return expression.expr.every((expression) => Visit(expression, value));\n  }\n  function Call(expression: Expr.CallExpression, value: Record<string, Function>): boolean {\n    const func = value[expression.target].bind(value);\n    return typeof func === 'function' && Visit(expression.expr, func(...expression.parameters));\n  }\n  function ElementsDistinct(expression: Expr.ElementsDistinctExpression, value: unknown[]): boolean {\n    const set = new Set();\n    for (const element of value) {\n      const hash = Hash(element);\n      if (set.has(hash)) return false;\n      set.add(hash);\n    }\n    return true;\n  }\n  function Elements(expression: Expr.ElementsExpression, value: unknown[]): boolean {\n    return value.every((element) => Visit(expression.expr, element));\n  }\n  function Equals(expression: Expr.EqualsExpression, value: unknown): boolean {\n    return value === expression.value;\n  }\n  function False(expression: Expr.FalseExpression, value: unknown): boolean {\n    return false;\n  }\n  function Function(expression: Expr.FunctionExpression, value: unknown): boolean {\n    return expression.callback(value);\n  }\n  function GreaterThanEqual(expression: Expr.GreaterThanEqualExpression, value: number): boolean {\n    return value >= expression.value;\n  }\n  function GreaterThan(expression: Expr.GreaterThanExpression, value: number): boolean {\n    return value > expression.value;\n  }\n  function IfThenElse(expression: Expr.IfThenElseExpression, value: unknown): boolean {\n    return Visit(expression.if, value) ? Visit(expression.then, value) : Visit(expression.else, value);\n  }\n  function InstanceOf(expression: Expr.InstanceOfExpression, value: unknown): boolean {\n    return value instanceof (globalThis as any)[expression.value];\n  }\n  function IsArray(expression: Expr.IsArrayExpression, value: unknown[]): boolean {\n    return globalThis.Array.isArray(value);\n  }\n  function IsInteger(expression: Expr.IsIntegerExpression, value: number): boolean {\n    return globalThis.Number.isInteger(value);\n  }\n  function IsNaN(expression: Expr.IsNaNExpression, value: number): boolean {\n    return globalThis.Number.isNaN(value);\n  }\n  function IsFinite(expression: Expr.IsFiniteExpression, value: number): boolean {\n    return globalThis.Number.isFinite(value);\n  }\n  function IsPattern(expression: Expr.IsPatternExpression, value: string): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return regexp.test(value);\n  }\n  function IsSafeInteger(expression: Expr.IsSafeIntegerExpression, value: number): boolean {\n    return globalThis.Number.isSafeInteger(value);\n  }\n  function IsUndefined(expression: Expr.IsUndefinedExpression, value: number): boolean {\n    return value === undefined;\n  }\n  function LessThan(expression: Expr.LessThanExpression, value: number): boolean {\n    return value < expression.value;\n  }\n  function LessThanEqual(expression: Expr.LessThanEqualExpression, value: number): boolean {\n    return value <= expression.value;\n  }\n  function MultipleOf(expression: Expr.MultipleOfExpression, value: number): boolean {\n    return value % expression.value === 0;\n  }\n  function Property(expression: Expr.PropertyExpression, value: Record<string, unknown>): boolean {\n    return Visit(expression.expr, value[expression.key]);\n  }\n  function Index(expression: Expr.IndexExpression, value: unknown[]): boolean {\n    return Visit(expression.expr, value[expression.index]);\n  }\n  function Or(expression: Expr.OrExpression, value: unknown): boolean {\n    return expression.expr.some((expression) => Visit(expression, value));\n  }\n  function Not(expression: Expr.NotExpression, value: unknown): boolean {\n    return !Visit(expression.expr, value);\n  }\n  function PropertiesExcludePattern(\n    expression: Expr.PropertiesExcludePatternExpression,\n    value: Record<string, unknown>,\n  ): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return Object.getOwnPropertyNames(value).every((key) =>\n      !regexp.test(key) ? Visit(expression.expr, value[key]) : true,\n    );\n  }\n  function PropertiesExclude(expression: Expr.PropertiesExcludeExpression, value: Record<string, unknown>): boolean {\n    return Object.getOwnPropertyNames(value).every((key) =>\n      !expression.keys.includes(key) ? Visit(expression.expr, value[key]) : true,\n    );\n  }\n  function PropertiesIncludePattern(\n    expression: Expr.PropertiesIncludePatternExpression,\n    value: Record<string, unknown>,\n  ): boolean {\n    const regexp = new globalThis.RegExp(expression.pattern);\n    return Object.getOwnPropertyNames(value).every((key) =>\n      regexp.test(key) ? Visit(expression.expr, value[key]) : true,\n    );\n  }\n  function PropertiesInclude(expression: Expr.PropertiesIncludeExpression, value: Record<string, unknown>): boolean {\n    return Object.getOwnPropertyNames(value).every((key) =>\n      expression.keys.includes(key) ? Visit(expression.expr, value[key]) : true,\n    );\n  }\n  function PropertiesLength(expression: Expr.PropertiesLengthExpression, value: Record<string, unknown>): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length === expression.value;\n  }\n  function PropertiesMaximum(expression: Expr.PropertiesMaximumExpression, value: Record<string, unknown>): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length <= expression.value;\n  }\n  function PropertiesMinimum(expression: Expr.PropertiesMinimumExpression, value: Record<string, unknown>): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).length >= expression.value;\n  }\n  function Properties(expression: Expr.PropertiesExpression, value: Record<string, unknown>): boolean {\n    return globalThis.Object.getOwnPropertyNames(value).every((key) => Visit(expression.expr, value[key]));\n  }\n  function PropertyKeys(expression: Expr.PropertyKeysExpression, value: Record<string, unknown>): boolean {\n    const keys = globalThis.Object.getOwnPropertyNames(value);\n    return expression.keys.every((key) => keys.includes(key));\n  }\n\n  function Ref(expression: Expr.RefExpression, value: unknown): boolean {\n    if (!reference_map.has(expression.$ref)) return false;\n    const referenced_expression = reference_map.get(expression.$ref)!;\n    return Visit(referenced_expression, value);\n  }\n  function True(expression: Expr.TrueExpression, value: unknown): boolean {\n    return true;\n  }\n  function TypeOf(expression: Expr.TypeOfExpression, value: unknown): boolean {\n    return typeof value === expression.value;\n  }\n  function Visit(expression: Expr.Expression, value: any): boolean {\n    if (expression.$id !== undefined) reference_map.set(expression.$id, expression);\n    switch (expression.type) {\n      case 'And':\n        return And(expression, value);\n      case 'Call':\n        return Call(expression, value);\n      case 'ElementsDistinct':\n        return ElementsDistinct(expression, value);\n      case 'Elements':\n        return Elements(expression, value);\n      case 'Equals':\n        return Equals(expression, value);\n      case 'False':\n        return False(expression, value);\n      case 'Function':\n        return Function(expression, value);\n      case 'GreaterThanEqual':\n        return GreaterThanEqual(expression, value);\n      case 'GreaterThan':\n        return GreaterThan(expression, value);\n      case 'LessThanEqual':\n        return LessThanEqual(expression, value);\n      case 'LessThan':\n        return LessThan(expression, value);\n      case 'MultipleOf':\n        return MultipleOf(expression, value);\n      case 'IfThenElse':\n        return IfThenElse(expression, value);\n      case 'InstanceOf':\n        return InstanceOf(expression, value);\n      case 'Index':\n        return Index(expression, value);\n      case 'IsArray':\n        return IsArray(expression, value);\n      case 'IsFinite':\n        return IsFinite(expression, value);\n      case 'IsInteger':\n        return IsInteger(expression, value);\n      case 'IsNaN':\n        return IsNaN(expression, value);\n      case 'IsPattern':\n        return IsPattern(expression, value);\n      case 'IsSafeInteger':\n        return IsSafeInteger(expression, value);\n      case 'IsUndefined':\n        return IsUndefined(expression, value);\n      case 'Not':\n        return Not(expression, value);\n      case 'Or':\n        return Or(expression, value);\n      case 'PropertiesInclude':\n        return PropertiesInclude(expression, value);\n      case 'PropertiesIncludePattern':\n        return PropertiesIncludePattern(expression, value);\n      case 'PropertiesExclude':\n        return PropertiesExclude(expression, value);\n      case 'PropertiesExcludePattern':\n        return PropertiesExcludePattern(expression, value);\n      case 'PropertiesLength':\n        return PropertiesLength(expression, value);\n      case 'PropertiesMaximum':\n        return PropertiesMaximum(expression, value);\n      case 'PropertiesMinimum':\n        return PropertiesMinimum(expression, value);\n      case 'Properties':\n        return Properties(expression, value);\n      case 'PropertyKeys':\n        return PropertyKeys(expression, value);\n      case 'Property':\n        return Property(expression, value);\n      case 'Ref':\n        return Ref(expression, value);\n      case 'True':\n        return True(expression, value);\n      case 'TypeOf':\n        return TypeOf(expression, value);\n      default:\n        throw new ExpressionEvaluatorExpressionError(expression);\n    }\n  }\n  const reference_map = new Map<string, Expr.Expression>();\n  /** Evaluates the given expression */\n  export function Evaluate(expression: Expr.Expression, references: Expr.Expression[], value: unknown): boolean {\n    reference_map.clear();\n    for (const reference of references) {\n      if (reference.$id === undefined) continue;\n      reference_map.set(reference.$id, reference);\n    }\n    return Visit(expression, value);\n  }\n}\n"],"names":["Hash","ExpressionEvaluatorExpressionError","Error","constructor","expression","ExpressionEvaluator","And","value","expr","every","Visit","Call","func","target","bind","parameters","ElementsDistinct","set","Set","element","hash","has","add","Elements","Equals","False","Function","callback","GreaterThanEqual","GreaterThan","IfThenElse","if","then","else","InstanceOf","globalThis","IsArray","Array","isArray","IsInteger","Number","isInteger","IsNaN","isNaN","IsFinite","isFinite","IsPattern","regexp","RegExp","pattern","test","IsSafeInteger","isSafeInteger","IsUndefined","undefined","LessThan","LessThanEqual","MultipleOf","Property","key","Index","index","Or","some","Not","PropertiesExcludePattern","Object","getOwnPropertyNames","PropertiesExclude","keys","includes","PropertiesIncludePattern","PropertiesInclude","PropertiesLength","length","PropertiesMaximum","PropertiesMinimum","Properties","PropertyKeys","Ref","reference_map","$ref","referenced_expression","get","True","TypeOf","$id","type","Map","Evaluate","references","clear","reference"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}