@axi-engine/expressions 0.2.5 → 0.3.0

package/dist/index.js

@@ -42,25 +42,25 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/guards.ts
-var import_utils = require("@axi-engine/utils");
+var import_ensure = require("@axijs/ensure");
 function isValueOperand(val) {
-  return !(0, import_utils.isNullOrUndefined)(val) && typeof val === "object" && "value" in val;
+  return !(0, import_ensure.isNullOrUndefined)(val) && typeof val === "object" && "value" in val;
 }
 function isReferenceOperand(val) {
-  return !(0, import_utils.isNullOrUndefined)(val) && typeof val === "object" && "path" in val;
+  return !(0, import_ensure.isNullOrUndefined)(val) && typeof val === "object" && "path" in val;
 }
 function isArithmeticOperand(val) {
-  return !(0, import_utils.isNullOrUndefined)(val) && typeof val === "object" && "arithmetic" in val;
+  return !(0, import_ensure.isNullOrUndefined)(val) && typeof val === "object" && "arithmetic" in val;
 }
 function isOperand(val) {
   return isValueOperand(val) || isReferenceOperand(val) || isArithmeticOperand(val);
 }
 
 // src/resolve-math.ts
-var import_utils2 = require("@axi-engine/utils");
+var import_ensure2 = require("@axijs/ensure");
 function resolveMath(op, left, right) {
-  (0, import_utils2.throwIf)(
-    !(0, import_utils2.isNumber)(left) || !(0, import_utils2.isNumber)(right),
+  (0, import_ensure2.throwIf)(
+    !(0, import_ensure2.isNumber)(left) || !(0, import_ensure2.isNumber)(right),
     `Require number operands, but got ${typeof left} and ${typeof right}.`
   );
   switch (op) {
@@ -73,12 +73,13 @@ function resolveMath(op, left, right) {
     case "/":
       return Number(left) / Number(right);
     default:
-      return (0, import_utils2.throwError)(`Unknown arithmetic operator: ${op}`);
+      return (0, import_ensure2.throwError)(`Unknown arithmetic operator: ${op}`);
   }
 }
 
 // src/resolve-operand.ts
-var import_utils3 = require("@axi-engine/utils");
+var import_utils = require("@axi-engine/utils");
+var import_ensure3 = require("@axijs/ensure");
 function resolveOperand(op, source) {
   if (isValueOperand(op)) {
     return op.value;
@@ -91,22 +92,22 @@ function resolveOperand(op, source) {
     const rightVal = resolveOperand(op.arithmetic.right, source);
     return resolveMath(op.arithmetic.op, leftVal, rightVal);
   }
-  return (0, import_utils3.throwError)(`Unknown operand type: ${JSON.stringify(op)}`);
+  return (0, import_ensure3.throwError)(`Unknown operand type: ${JSON.stringify(op)}`);
 }
 function resolveOperandAsScalar(op, source) {
   const value = resolveOperand(op, source);
-  (0, import_utils3.throwIf)(
-    !(0, import_utils3.isScalar)(value),
+  (0, import_ensure3.throwIf)(
+    !(0, import_utils.isScalar)(value),
     `Expected a scalar value (string, number, boolean), but got ${typeof value}.`
   );
   return value;
 }
 
 // src/core-expression-evaluator.ts
-var import_utils4 = require("@axi-engine/utils");
+var import_utils2 = require("@axi-engine/utils");
 var CoreExpressionEvaluator = class {
   /** @internal A map of registered expression handlers. */
-  handlers = new import_utils4.Registry();
+  handlers = new import_utils2.Registry();
   /**
    * Registers a new `ExpressionHandler` with the evaluator.
    * This is the primary mechanism for extending the expression language with
@@ -133,7 +134,7 @@ var CoreExpressionEvaluator = class {
    * evaluation result.
    */
   async resolve(expression, data) {
-    const key = (0, import_utils4.firstKeyOf)(expression);
+    const key = (0, import_utils2.firstKeyOf)(expression);
     const handler = this.handlers.getOrThrow(key);
     const context = {
       resolve: (expression2) => this.resolve(expression2, data),
@@ -156,7 +157,8 @@ var AndExpressionHandler = class {
 };
 
 // src/handlers/chance-expression-handler.ts
-var import_utils5 = require("@axi-engine/utils");
+var import_utils3 = require("@axi-engine/utils");
+var import_ensure4 = require("@axijs/ensure");
 var ChanceExpressionHandler = class {
   type = "chance";
   /**
@@ -177,16 +179,16 @@ var ChanceExpressionHandler = class {
   async resolve(exp, context) {
     const resolvedValue = resolveOperandAsScalar(exp.chance, context.source());
     let numericValue;
-    if ((0, import_utils5.isNumber)(resolvedValue)) {
+    if ((0, import_ensure4.isNumber)(resolvedValue)) {
       numericValue = resolvedValue;
-    } else if ((0, import_utils5.isString)(resolvedValue)) {
+    } else if ((0, import_ensure4.isString)(resolvedValue)) {
       const parsed = parseFloat(resolvedValue.replace("%", "").trim());
-      (0, import_utils5.throwIf)(isNaN(parsed), `Chance value as a string must be a valid number, but got '${resolvedValue}'.`);
+      (0, import_ensure4.throwIf)(isNaN(parsed), `Chance value as a string must be a valid number, but got '${resolvedValue}'.`);
       numericValue = parsed;
     } else {
-      (0, import_utils5.throwError)(`Chance value must be a number or a string, but got a boolean.`);
+      (0, import_ensure4.throwError)(`Chance value must be a number or a string, but got a boolean.`);
     }
-    const randomRoll = (0, import_utils5.randInt)(0, 100);
+    const randomRoll = (0, import_utils3.randInt)(0, 100);
     return randomRoll < numericValue;
   }
 };
@@ -223,7 +225,8 @@ var ExistsExpressionHandler = class {
 };
 
 // src/handlers/in-expression-handler.ts
-var import_utils6 = require("@axi-engine/utils");
+var import_utils4 = require("@axi-engine/utils");
+var import_ensure5 = require("@axijs/ensure");
 var InExpressionHandler = class {
   type = "in";
   /**
@@ -247,13 +250,13 @@ var InExpressionHandler = class {
   async resolve(exp, context) {
     const value = resolveOperandAsScalar(exp.in.value, context.source());
     const rawArray = Array.isArray(exp.in.array) ? exp.in.array : resolveOperand(exp.in.array, context.source());
-    (0, import_utils6.throwIf)(
+    (0, import_ensure5.throwIf)(
       !Array.isArray(rawArray),
       `The 'in' expression requires an array, but the provided source resolved to ${typeof rawArray}.`
     );
     const typedArray = rawArray;
     const resolvedArray = typedArray.map(
-      (item) => (0, import_utils6.isScalar)(item) ? item : resolveOperandAsScalar(item, context.source())
+      (item) => (0, import_utils4.isScalar)(item) ? item : resolveOperandAsScalar(item, context.source())
     );
     return resolvedArray.includes(value);
   }

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/guards.ts
-import { isNullOrUndefined } from "@axi-engine/utils";
+import { isNullOrUndefined } from "@axijs/ensure";
 function isValueOperand(val) {
   return !isNullOrUndefined(val) && typeof val === "object" && "value" in val;
 }
@@ -14,7 +14,7 @@ function isOperand(val) {
 }
 
 // src/resolve-math.ts
-import { isNumber, throwError, throwIf } from "@axi-engine/utils";
+import { isNumber, throwError, throwIf } from "@axijs/ensure";
 function resolveMath(op, left, right) {
   throwIf(
     !isNumber(left) || !isNumber(right),
@@ -35,7 +35,8 @@ function resolveMath(op, left, right) {
 }
 
 // src/resolve-operand.ts
-import { isScalar, throwError as throwError2, throwIf as throwIf2 } from "@axi-engine/utils";
+import { isScalar } from "@axi-engine/utils";
+import { throwError as throwError2, throwIf as throwIf2 } from "@axijs/ensure";
 function resolveOperand(op, source) {
   if (isValueOperand(op)) {
     return op.value;
@@ -116,7 +117,8 @@ var AndExpressionHandler = class {
 };
 
 // src/handlers/chance-expression-handler.ts
-import { isNumber as isNumber2, isString, randInt, throwError as throwError3, throwIf as throwIf3 } from "@axi-engine/utils";
+import { randInt } from "@axi-engine/utils";
+import { isString, isNumber as isNumber2, throwIf as throwIf3, throwError as throwError3 } from "@axijs/ensure";
 var ChanceExpressionHandler = class {
   type = "chance";
   /**
@@ -183,7 +185,8 @@ var ExistsExpressionHandler = class {
 };
 
 // src/handlers/in-expression-handler.ts
-import { isScalar as isScalar2, throwIf as throwIf4 } from "@axi-engine/utils";
+import { isScalar as isScalar2 } from "@axi-engine/utils";
+import { throwIf as throwIf4 } from "@axijs/ensure";
 var InExpressionHandler = class {
   type = "in";
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axi-engine/expressions",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "",
   "license": "MIT",
   "repository": {
@@ -32,10 +32,8 @@
   "files": [
     "dist"
   ],
-  "devDependencies": {
-    "@axi-engine/utils": "^0.2.10"
-  },
   "peerDependencies": {
-    "@axi-engine/utils": "^0.2.10"
+    "@axijs/ensure": "^1.0.1",
+    "@axi-engine/utils": "^0.3.0"
   }
 }