@wener/utils 1.1.26 → 1.1.27

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","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":["ExpressionErrors","expression"],"mappings":"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"}

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

@@ -0,0 +1,241 @@
+import { Hash } from '@sinclair/typebox/value';
+
+class ExpressionEvaluatorExpressionError extends Error {
+  constructor(expression) {
+    super("Unknown Expression Detected");
+    this.expression = expression;
+  }
+}
+var ExpressionEvaluator;
+((ExpressionEvaluator2) => {
+  function And(expression, value) {
+    return expression.expr.every((expression2) => Visit(expression2, 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 = /* @__PURE__ */ 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 === void 0;
+  }
+  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((expression2) => Visit(expression2, 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 !== void 0)
+      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();
+      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();
+      case "TypeOf":
+        return TypeOf(expression, value);
+      default:
+        throw new ExpressionEvaluatorExpressionError(expression);
+    }
+  }
+  const reference_map = /* @__PURE__ */ new Map();
+  function Evaluate(expression, references, value) {
+    reference_map.clear();
+    for (const reference of references) {
+      if (reference.$id === void 0)
+        continue;
+      reference_map.set(reference.$id, reference);
+    }
+    return Visit(expression, value);
+  }
+  ExpressionEvaluator2.Evaluate = Evaluate;
+})(ExpressionEvaluator || (ExpressionEvaluator = {}));
+
+export { ExpressionEvaluator, ExpressionEvaluatorExpressionError };
+//# sourceMappingURL=evaluator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","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":["ExpressionEvaluator","expression"],"mappings":"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"}

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

@@ -0,0 +1,200 @@
+var Expression;
+((Expression2) => {
+  function And(expressions, options = {}) {
+    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];
+    if (expr.length === 0)
+      return Expression2.False();
+    if (expr.length === 1)
+      return expr[0];
+    return { ...options, type: "And", expr };
+  }
+  Expression2.And = And;
+  function Call(target, parameters, expression, options = {}) {
+    return { ...options, type: "Call", target, parameters, expr: expression };
+  }
+  Expression2.Call = Call;
+  function Equals(value, options = {}) {
+    return { ...options, type: "Equals", value };
+  }
+  Expression2.Equals = Equals;
+  function Function(callback, options = {}) {
+    return { ...options, type: "Function", callback };
+  }
+  Expression2.Function = Function;
+  function ElementsDistinct(options = {}) {
+    return { ...options, type: "ElementsDistinct" };
+  }
+  Expression2.ElementsDistinct = ElementsDistinct;
+  function Elements(expression, options = {}) {
+    return { ...options, type: "Elements", expr: expression };
+  }
+  Expression2.Elements = Elements;
+  function False(options = {}) {
+    return { ...options, type: "False" };
+  }
+  Expression2.False = False;
+  function GreaterThanEqual(value, options = {}) {
+    return { ...options, type: "GreaterThanEqual", value };
+  }
+  Expression2.GreaterThanEqual = GreaterThanEqual;
+  function GreaterThan(value, options = {}) {
+    return { ...options, type: "GreaterThan", value };
+  }
+  Expression2.GreaterThan = GreaterThan;
+  function IfThenElse($if, $then, $else, options = {}) {
+    return { ...options, type: "IfThenElse", if: $if, then: $then, else: $else };
+  }
+  Expression2.IfThenElse = IfThenElse;
+  function Index(index, expression, options = {}) {
+    return { ...options, type: "Index", index, expr: expression };
+  }
+  Expression2.Index = Index;
+  function InstanceOf(value, options = {}) {
+    return { ...options, type: "InstanceOf", value };
+  }
+  Expression2.InstanceOf = InstanceOf;
+  function IsArray(options = {}) {
+    return { ...options, type: "IsArray" };
+  }
+  Expression2.IsArray = IsArray;
+  function IsNaN(options = {}) {
+    return { ...options, type: "IsNaN" };
+  }
+  Expression2.IsNaN = IsNaN;
+  function IsInteger(options = {}) {
+    return { ...options, type: "IsInteger" };
+  }
+  Expression2.IsInteger = IsInteger;
+  function IsObject(options = {}) {
+    return Expression2.TypeOf("object", options);
+  }
+  Expression2.IsObject = IsObject;
+  function IsBigInt(options = {}) {
+    return Expression2.TypeOf("bigint", options);
+  }
+  Expression2.IsBigInt = IsBigInt;
+  function IsBoolean(options = {}) {
+    return Expression2.TypeOf("boolean", options);
+  }
+  Expression2.IsBoolean = IsBoolean;
+  function IsFinite(options = {}) {
+    return { ...options, type: "IsFinite" };
+  }
+  Expression2.IsFinite = IsFinite;
+  function IsFunction(options = {}) {
+    return Expression2.TypeOf("function", options);
+  }
+  Expression2.IsFunction = IsFunction;
+  function IsNumber(options = {}) {
+    return Expression2.TypeOf("number", options);
+  }
+  Expression2.IsNumber = IsNumber;
+  function IsSafeInteger(options = {}) {
+    return { ...options, type: "IsSafeInteger" };
+  }
+  Expression2.IsSafeInteger = IsSafeInteger;
+  function IsString(options = {}) {
+    return Expression2.TypeOf("string", options);
+  }
+  Expression2.IsString = IsString;
+  function IsSymbol(options = {}) {
+    return Expression2.TypeOf("symbol", options);
+  }
+  Expression2.IsSymbol = IsSymbol;
+  function IsUndefined(options = {}) {
+    return { ...options, type: "IsUndefined" };
+  }
+  Expression2.IsUndefined = IsUndefined;
+  function IsNull(options = {}) {
+    return Expression2.Equals(null, options);
+  }
+  Expression2.IsNull = IsNull;
+  function IsPattern(pattern, options = {}) {
+    return { ...options, type: "IsPattern", pattern };
+  }
+  Expression2.IsPattern = IsPattern;
+  function KeyIn(value, options = {}) {
+    return { ...options, type: "KeyIn", value };
+  }
+  Expression2.KeyIn = KeyIn;
+  function LessThanEqual(value, options = {}) {
+    return { ...options, type: "LessThanEqual", value };
+  }
+  Expression2.LessThanEqual = LessThanEqual;
+  function LessThan(value, options = {}) {
+    return { ...options, type: "LessThan", value };
+  }
+  Expression2.LessThan = LessThan;
+  function MultipleOf(value, options = {}) {
+    return { ...options, type: "MultipleOf", value };
+  }
+  Expression2.MultipleOf = MultipleOf;
+  function Not(expression, options = {}) {
+    return { ...options, type: "Not", expr: expression };
+  }
+  Expression2.Not = Not;
+  function Or(expressions, options = {}) {
+    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];
+    if (expr.length === 0)
+      return Expression2.False();
+    if (expr.length === 1)
+      return expr[0];
+    return { ...options, type: "Or", expr };
+  }
+  Expression2.Or = Or;
+  function PropertiesExcludePattern(pattern, expression, options = {}) {
+    return { ...options, type: "PropertiesExcludePattern", expr: expression, pattern };
+  }
+  Expression2.PropertiesExcludePattern = PropertiesExcludePattern;
+  function PropertiesExclude(keys, expression, options = {}) {
+    return { ...options, type: "PropertiesExclude", expr: expression, keys };
+  }
+  Expression2.PropertiesExclude = PropertiesExclude;
+  function PropertiesIncludePattern(pattern, expression, options = {}) {
+    return { ...options, type: "PropertiesIncludePattern", expr: expression, pattern };
+  }
+  Expression2.PropertiesIncludePattern = PropertiesIncludePattern;
+  function PropertiesInclude(keys, expression, options = {}) {
+    return { ...options, type: "PropertiesInclude", expr: expression, keys };
+  }
+  Expression2.PropertiesInclude = PropertiesInclude;
+  function PropertiesLength(value, options = {}) {
+    return { ...options, type: "PropertiesLength", value };
+  }
+  Expression2.PropertiesLength = PropertiesLength;
+  function PropertiesMaximum(value, options = {}) {
+    return { ...options, type: "PropertiesMaximum", value };
+  }
+  Expression2.PropertiesMaximum = PropertiesMaximum;
+  function PropertiesMinimum(value, options = {}) {
+    return { ...options, type: "PropertiesMinimum", value };
+  }
+  Expression2.PropertiesMinimum = PropertiesMinimum;
+  function Properties(expression, options = {}) {
+    return { ...options, type: "Properties", expr: expression };
+  }
+  Expression2.Properties = Properties;
+  function PropertyKeys(keys, options = {}) {
+    return { ...options, type: "PropertyKeys", keys };
+  }
+  Expression2.PropertyKeys = PropertyKeys;
+  function Property(key, expression, options = {}) {
+    return { ...options, type: "Property", key, expr: expression };
+  }
+  Expression2.Property = Property;
+  function Ref(value, options = {}) {
+    return { ...options, type: "Ref", $ref: value };
+  }
+  Expression2.Ref = Ref;
+  function True(options = {}) {
+    return { ...options, type: "True" };
+  }
+  Expression2.True = True;
+  function TypeOf(value, options = {}) {
+    return { ...options, type: "TypeOf", value };
+  }
+  Expression2.TypeOf = TypeOf;
+})(Expression || (Expression = {}));
+
+export { Expression };
+//# sourceMappingURL=expression.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","sources":["../../../../../../src/schema/typebox/gen/codegen/expression/expression.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---------------------------------------------------------------------------*/\n\n// -------------------------------------------------------------------------\n// Expression: Error\n// -------------------------------------------------------------------------\nexport interface ExpressionError {\n  expression: Expression;\n  path: string;\n  value: unknown;\n}\n\n// -------------------------------------------------------------------------\n// Expression: Tree\n// -------------------------------------------------------------------------\n\nexport type Equatable = string | number | boolean | null | undefined;\nexport type Compariable = number | bigint;\nexport type TypeOf = 'undefined' | 'symbol' | 'function' | 'string' | 'number' | 'boolean' | 'bigint' | 'object';\n\nexport interface ExpressionOptions {\n  $id?: string;\n  [key: string]: any;\n}\nexport interface AndExpression extends ExpressionOptions {\n  type: 'And';\n  expr: Expression[];\n}\nexport interface CallExpression<\n  E extends Expression = Expression,\n  T extends string = string,\n  A extends unknown[] = unknown[],\n> extends ExpressionOptions {\n  type: 'Call';\n  target: T;\n  parameters: [...A];\n  expr: E;\n}\n\nexport interface ElementsDistinctExpression extends ExpressionOptions {\n  type: 'ElementsDistinct';\n}\nexport interface ElementsExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Elements';\n  expr: E;\n}\nexport interface EqualsExpression<T extends Equatable = Equatable> extends ExpressionOptions {\n  type: 'Equals';\n  value: T;\n}\nexport type FunctionExpressionCallback = (value: unknown) => boolean;\n\nexport interface FunctionExpression<F extends FunctionExpressionCallback = FunctionExpressionCallback>\n  extends ExpressionOptions {\n  type: 'Function';\n  callback: F;\n}\nexport interface GreaterThanEqualExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'GreaterThanEqual';\n  value: T;\n}\nexport interface GreaterThanExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'GreaterThan';\n  value: T;\n}\nexport interface FalseExpression extends ExpressionOptions {\n  type: 'False';\n}\nexport interface IfThenElseExpression extends ExpressionOptions {\n  type: 'IfThenElse';\n  if: Expression;\n  then: Expression;\n  else: Expression;\n}\nexport interface InstanceOfExpression<T extends string = string> extends ExpressionOptions {\n  type: 'InstanceOf';\n  value: T;\n}\nexport interface IndexExpression<E extends Expression = Expression, I extends number = number>\n  extends ExpressionOptions {\n  type: 'Index';\n  index: I;\n  expr: E;\n}\n\nexport interface IsArrayExpression extends ExpressionOptions {\n  type: 'IsArray';\n}\nexport interface IsBigIntExpression extends TypeOfExpression<'bigint'> {}\nexport interface IsBooleanExpression extends TypeOfExpression<'boolean'> {}\nexport interface IsFiniteExpression extends ExpressionOptions {\n  type: 'IsFinite';\n}\nexport interface IsFunctionExpression extends TypeOfExpression<'function'> {}\nexport interface IsIntegerExpression extends ExpressionOptions {\n  type: 'IsInteger';\n}\nexport interface IsNaNExpression extends ExpressionOptions {\n  type: 'IsNaN';\n}\nexport interface IsNullExpression extends EqualsExpression<null> {}\nexport interface IsNumberExpression extends TypeOfExpression<'number'> {}\nexport interface IsSafeIntegerExpression extends ExpressionOptions {\n  type: 'IsSafeInteger';\n}\nexport interface IsObjectExpression extends TypeOfExpression<'object'> {}\nexport interface IsStringExpression extends TypeOfExpression<'string'> {}\nexport interface IsSymbolExpression extends TypeOfExpression<'symbol'> {}\nexport interface IsUndefinedExpression extends ExpressionOptions {\n  type: 'IsUndefined';\n}\nexport interface KeyInExpression<T extends string = string> extends ExpressionOptions {\n  type: 'KeyIn';\n  value: T;\n}\nexport interface OrExpression extends ExpressionOptions {\n  type: 'Or';\n  expr: Expression[];\n}\nexport interface NotExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Not';\n  expr: E;\n}\nexport interface LessThanEqualExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'LessThanEqual';\n  value: T;\n}\nexport interface LessThanExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'LessThan';\n  value: T;\n}\nexport interface MultipleOfExpression<T extends number = number> extends ExpressionOptions {\n  type: 'MultipleOf';\n  value: T;\n}\nexport interface PropertiesIncludePatternExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'PropertiesIncludePattern';\n  pattern: string;\n  expr: E;\n}\nexport interface PropertiesIncludeExpression<E extends Expression = Expression, K extends string[] = string[]>\n  extends ExpressionOptions {\n  type: 'PropertiesInclude';\n  keys: K;\n  expr: E;\n}\nexport interface PropertiesExcludePatternExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'PropertiesExcludePattern';\n  pattern: string;\n  expr: E;\n}\nexport interface PropertiesExcludeExpression<E extends Expression = Expression, K extends string[] = string[]>\n  extends ExpressionOptions {\n  type: 'PropertiesExclude';\n  keys: K;\n  expr: E;\n}\nexport interface PropertiesLengthExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesLength';\n  value: T;\n}\nexport interface PropertiesMaximumExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesMaximum';\n  value: T;\n}\nexport interface PropertiesMinimumExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesMinimum';\n  value: T;\n}\nexport interface PropertiesExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Properties';\n  expr: E;\n}\nexport interface PropertyKeysExpression<T extends readonly string[] = string[]> extends ExpressionOptions {\n  type: 'PropertyKeys';\n  keys: [...T];\n}\nexport interface PropertyExpression<E extends Expression = Expression, K extends string = string>\n  extends ExpressionOptions {\n  type: 'Property';\n  key: K;\n  expr: E;\n}\nexport interface RefExpression<T extends string = string> extends ExpressionOptions {\n  type: 'Ref';\n  $ref: T;\n}\nexport interface IsPatternExpression extends ExpressionOptions {\n  type: 'IsPattern';\n  pattern: string;\n}\nexport interface TrueExpression extends ExpressionOptions {\n  type: 'True';\n}\nexport interface TypeOfExpression<T extends TypeOf = TypeOf> extends ExpressionOptions {\n  type: 'TypeOf';\n  value: T;\n}\nexport type Expression =\n  | AndExpression\n  | CallExpression\n  | FalseExpression\n  | FunctionExpression\n  | ElementsDistinctExpression\n  | ElementsExpression\n  | EqualsExpression\n  | GreaterThanExpression\n  | GreaterThanEqualExpression\n  | IfThenElseExpression\n  | IndexExpression\n  | InstanceOfExpression\n  | IsArrayExpression\n  | IsIntegerExpression\n  | IsNaNExpression\n  | IsObjectExpression\n  | IsBigIntExpression\n  | IsBooleanExpression\n  | IsFiniteExpression\n  | IsFunctionExpression\n  | IsNullExpression\n  | IsNumberExpression\n  | IsSafeIntegerExpression\n  | IsStringExpression\n  | IsSymbolExpression\n  | IsUndefinedExpression\n  | KeyInExpression\n  | LessThanEqualExpression\n  | LessThanExpression\n  | MultipleOfExpression\n  | NotExpression\n  | OrExpression\n  | PropertiesIncludeExpression\n  | PropertiesIncludePatternExpression\n  | PropertiesExcludeExpression\n  | PropertiesExcludePatternExpression\n  | PropertiesLengthExpression\n  | PropertiesMaximumExpression\n  | PropertiesMinimumExpression\n  | PropertiesExpression\n  | PropertyKeysExpression\n  | PropertyExpression\n  | RefExpression\n  | IsPatternExpression\n  | TrueExpression\n  | TypeOfExpression;\n\n// ---------------------------------------------------------------\n// Expression: Builder\n// ---------------------------------------------------------------\n\n/** Type Expressions builder used to assert JavaScript values */\nexport namespace Expression {\n  /** Creates a `And` expression where each sub expression is evaluated in sequence */\n  export function And<E extends Expression>(\n    expressions: (() => Generator<E>) | Array<E>,\n    options: ExpressionOptions = {},\n  ): Expression {\n    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];\n    if (expr.length === 0) return Expression.False();\n    if (expr.length === 1) return expr[0];\n    return { ...options, type: 'And', expr };\n  }\n  /** Creates a `Call` expression that will invoke the object target and check the return for the given sub expression */\n  export function Call<E extends Expression, T extends string, P extends unknown[]>(\n    target: T,\n    parameters: P,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): CallExpression<E, T, P> {\n    return { ...options, type: 'Call', target, parameters, expr: expression };\n  }\n  /** Creates a `Equals` expression that will compare for value equality */\n  export function Equals<T extends Equatable>(value: T, options: ExpressionOptions = {}): EqualsExpression<T> {\n    return { ...options, type: 'Equals', value };\n  }\n  /** Creates a `Function` expression which invokes the given callback to check a value */\n  export function Function<F extends (value: unknown) => boolean>(\n    callback: F,\n    options: ExpressionOptions = {},\n  ): FunctionExpression<F> {\n    return { ...options, type: 'Function', callback };\n  }\n  /** Creates a `ElementsDistinct` expression which will check an arrays elements are structurally distinct  */\n  export function ElementsDistinct(options: ExpressionOptions = {}): ElementsDistinctExpression {\n    return { ...options, type: 'ElementsDistinct' };\n  }\n  /** Creates a `Elements` expression that will check an arrays elements for the given sub expression */\n  export function Elements<E extends Expression>(\n    expression: E,\n    options: ExpressionOptions = {},\n  ): ElementsExpression<E> {\n    return { ...options, type: 'Elements', expr: expression };\n  }\n  /** Creates a `False` expression that evaluates `false` */\n  export function False(options: ExpressionOptions = {}): FalseExpression {\n    return { ...options, type: 'False' };\n  }\n  /** Creates a `GreaterThanEqual` comparison expression */\n  export function GreaterThanEqual<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): GreaterThanEqualExpression<T> {\n    return { ...options, type: 'GreaterThanEqual', value };\n  }\n  /** Creates a `GreaterThan` comparison expression */\n  export function GreaterThan<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): GreaterThanExpression<T> {\n    return { ...options, type: 'GreaterThan', value };\n  }\n  /** Creates a `IfThenElse` expression that will evaluate the `$if` expression followed by either the `$then` of `$else` expressions */\n  export function IfThenElse(\n    $if: Expression,\n    $then: Expression,\n    $else: Expression,\n    options: ExpressionOptions = {},\n  ): IfThenElseExpression {\n    return { ...options, type: 'IfThenElse', if: $if, then: $then, else: $else };\n  }\n  /** Creates a `Index` expression that will evaluate an array element by the given sub expression */\n  export function Index<E extends Expression, I extends number>(\n    index: I,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): IndexExpression<E, I> {\n    return { ...options, type: 'Index', index, expr: expression };\n  }\n  /** Creates a `InstanceOf` expression that will apply the `instanceof` operator */\n  export function InstanceOf<T extends string>(value: T, options: ExpressionOptions = {}): InstanceOfExpression<T> {\n    return { ...options, type: 'InstanceOf', value };\n  }\n  /** Creates a `IsArray` expression that will check a value as an array */\n  export function IsArray(options: ExpressionOptions = {}): IsArrayExpression {\n    return { ...options, type: 'IsArray' };\n  }\n  /** Creates a `IsNaN` expression that will check for NaN */\n  export function IsNaN(options: ExpressionOptions = {}): IsNaNExpression {\n    return { ...options, type: 'IsNaN' };\n  }\n  /** Creates a `IsInteger` expression that will check for numeric integer values */\n  export function IsInteger(options: ExpressionOptions = {}): IsIntegerExpression {\n    return { ...options, type: 'IsInteger' };\n  }\n  /** Creates a `IsObject` expression that will check a value as an object */\n  export function IsObject(options: ExpressionOptions = {}): IsObjectExpression {\n    return Expression.TypeOf('object', options);\n  }\n  /** Creates a `IsBigInt` expression that will check a value as a bigint */\n  export function IsBigInt(options: ExpressionOptions = {}): IsBigIntExpression {\n    return Expression.TypeOf('bigint', options);\n  }\n  /** Creates a `IsBoolean` expression that will check a value as a boolean */\n  export function IsBoolean(options: ExpressionOptions = {}): IsBooleanExpression {\n    return Expression.TypeOf('boolean', options);\n  }\n  /** Creates a `IsFinite` expression that will check a numeric value if finite */\n  export function IsFinite(options: ExpressionOptions = {}): IsFiniteExpression {\n    return { ...options, type: 'IsFinite' };\n  }\n  /** Creates a `IsFunction` expression that will check a value as a function */\n  export function IsFunction(options: ExpressionOptions = {}): IsFunctionExpression {\n    return Expression.TypeOf('function', options);\n  }\n  /** Creates a `IsNumber` expression that will check a value as a number */\n  export function IsNumber(options: ExpressionOptions = {}): IsNumberExpression {\n    return Expression.TypeOf('number', options);\n  }\n  /** Creates a `IsSafeInteger` expression that will check a numeric value if finite */\n  export function IsSafeInteger(options: ExpressionOptions = {}): IsSafeIntegerExpression {\n    return { ...options, type: 'IsSafeInteger' };\n  }\n  /** Creates a `IsString` expression that will check a value as a string */\n  export function IsString(options: ExpressionOptions = {}): IsStringExpression {\n    return Expression.TypeOf('string', options);\n  }\n  /** Creates a `IsSymbol` expression that will check a value as a symbol */\n  export function IsSymbol(options: ExpressionOptions = {}): IsSymbolExpression {\n    return Expression.TypeOf('symbol', options);\n  }\n  /** Creates a `IsUndefined` expression that will check a value is undefined */\n  export function IsUndefined(options: ExpressionOptions = {}): IsUndefinedExpression {\n    return { ...options, type: 'IsUndefined' };\n  }\n  /** Creates a `IsNull` expression that will check a value is null */\n  export function IsNull(options: ExpressionOptions = {}): IsNullExpression {\n    return Expression.Equals(null, options);\n  }\n  /** Creates a `IsPattern` expression that will check a string with a regular expression */\n  export function IsPattern(pattern: string, options: ExpressionOptions = {}): IsPatternExpression {\n    return { ...options, type: 'IsPattern', pattern };\n  }\n  /** Creates a KeyIn expression that will check if a key exists on this value */\n  export function KeyIn<T extends string>(value: T, options: ExpressionOptions = {}): KeyInExpression<T> {\n    return { ...options, type: 'KeyIn', value };\n  }\n  /** Creates a `LessThanEqual` comparison expression */\n  export function LessThanEqual<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): LessThanEqualExpression<T> {\n    return { ...options, type: 'LessThanEqual', value };\n  }\n  /** Creates a `LessThan` comparison expression */\n  export function LessThan<T extends Compariable>(value: T, options: ExpressionOptions = {}): LessThanExpression<T> {\n    return { ...options, type: 'LessThan', value };\n  }\n  /** Creates a `MultipleOf` modulus expression that is true if the result is zero */\n  export function MultipleOf<T extends number>(value: T, options: ExpressionOptions = {}): MultipleOfExpression<T> {\n    return { ...options, type: 'MultipleOf', value };\n  }\n  /** Creates a `Not` expression where the result of the sub expression is inverted */\n  export function Not<E extends Expression>(expression: E, options: ExpressionOptions = {}): NotExpression<E> {\n    return { ...options, type: 'Not', expr: expression };\n  }\n  /** Creates a `Or` expression where each sub expression is evaluated in sequence */\n  export function Or<E extends Expression>(\n    expressions: (() => Generator<E>) | Array<E>,\n    options: ExpressionOptions = {},\n  ): Expression {\n    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];\n    if (expr.length === 0) return Expression.False();\n    if (expr.length === 1) return expr[0];\n    return { ...options, type: 'Or', expr };\n  }\n  /** Creates a `PropertiesExcludePattern` expression that will enumerate each key matching the given regular expression */\n  export function PropertiesExcludePattern<E extends Expression>(\n    pattern: string,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExcludePatternExpression<E> {\n    return { ...options, type: 'PropertiesExcludePattern', expr: expression, pattern };\n  }\n  /** Creates a `PropertiesExclude` expression that will enumerate the unselected keys and check each for the sub expression */\n  export function PropertiesExclude<E extends Expression, K extends string[]>(\n    keys: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExcludeExpression<E, K> {\n    return { ...options, type: 'PropertiesExclude', expr: expression, keys };\n  }\n  /** Creates a `PropertiesIncludePattern` expression that will enumerate each key matching the given regular expression */\n  export function PropertiesIncludePattern<E extends Expression>(\n    pattern: string,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesIncludePatternExpression<E> {\n    return { ...options, type: 'PropertiesIncludePattern', expr: expression, pattern };\n  }\n  /** Creates a `PropertiesInclude` expression that will enumerate the selected keys and check each for the sub expression */\n  export function PropertiesInclude<E extends Expression, K extends string[]>(\n    keys: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesIncludeExpression<E, K> {\n    return { ...options, type: 'PropertiesInclude', expr: expression, keys };\n  }\n  /** Creates a `PropertiesLength` expression that checks an object a property length that equals the given value */\n  export function PropertiesLength<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesLengthExpression<T> {\n    return { ...options, type: 'PropertiesLength', value };\n  }\n  /** Creates a `PropertiesMaximum` expression that will check an object has a property length less or equal the given value */\n  export function PropertiesMaximum<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesMaximumExpression<T> {\n    return { ...options, type: 'PropertiesMaximum', value };\n  }\n  /** Creates a `PropertiesMinimum` expression that will check an object has a property length greater or equal the given value */\n  export function PropertiesMinimum<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesMinimumExpression<T> {\n    return { ...options, type: 'PropertiesMinimum', value };\n  }\n  /** Creates a `Properties` expression that will enumerate all object properties and check for the given sub expression */\n  export function Properties<E extends Expression>(\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExpression<E> {\n    return { ...options, type: 'Properties', expr: expression };\n  }\n  /** Creates a `PropertyKeys` expression that will check an object has the specified keys */\n  export function PropertyKeys<T extends string[]>(\n    keys: T,\n    options: ExpressionOptions = {},\n  ): PropertyKeysExpression<T> {\n    return { ...options, type: 'PropertyKeys', keys };\n  }\n  /** Creates a `Property` expression that will evaluate the property value by the given sub expression */\n  export function Property<E extends Expression, K extends string>(\n    key: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertyExpression<E, K> {\n    return { ...options, type: 'Property', key, expr: expression };\n  }\n  /** Creates a `Ref` that will reference another part of the expression tree via $id */\n  export function Ref<T extends string>(value: T, options: ExpressionOptions = {}): RefExpression<T> {\n    return { ...options, type: 'Ref', $ref: value };\n  }\n  /** Creates a `True` expression that evaluates `true` */\n  export function True(options: ExpressionOptions = {}): TrueExpression {\n    return { ...options, type: 'True' };\n  }\n  /** Creates a `TypeOf` expression that will apply `typeof` operator for the evaluated value */\n  export function TypeOf<E extends TypeOf>(value: E, options: ExpressionOptions = {}): TypeOfExpression<E> {\n    return { ...options, type: 'TypeOf', value };\n  }\n}\n"],"names":["Expression"],"mappings":"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"}

package/lib/schema/typebox/gen/codegen/index.js

@@ -0,0 +1,19 @@
+export { MemberExpressionEncoder, PropertyEncoder } from './common/encoder.js';
+export { Formatter } from './common/formatter.js';
+export { JsDoc } from './common/jsdoc.js';
+export { ModelToArkType } from './model/model-to-arktype.js';
+export { ModelToExpr, TypeBoxToExpression, TypeTransformUnknownSchemaError } from './model/model-to-expression.js';
+export { ModelToGRPC } from './model/model-to-grpc.js';
+export { ModelToIoTs } from './model/model-to-io-ts.js';
+export { ModelToJavaScript } from './model/model-to-javascript.js';
+export { ModelToJsonSchema } from './model/model-to-json-schema.js';
+export { ModelToTypeBox } from './model/model-to-typebox.js';
+export { ModelToTypeScript } from './model/model-to-typescript.js';
+export { ModelToValibot } from './model/model-to-valibot.js';
+export { ModelToValue } from './model/model-to-value.js';
+export { ModelToYrel } from './model/model-to-yrel.js';
+export { ModelToYup } from './model/model-to-yup.js';
+export { ModelToZod } from './model/model-to-zod.js';
+export { TypeScriptToModel } from './typescript/typescript-to-model.js';
+export { TypeScriptToTypeBox, TypeScriptToTypeBoxError } from './typescript/typescript-to-typebox.js';
+//# sourceMappingURL=index.js.map

package/lib/schema/typebox/gen/codegen/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}