pacc 4.15.1 → 4.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "4.15.1",
+  "version": "4.16.1",
   "publishConfig": {
     "access": "public",
     "provenance": true

package/src/attributes.mjs

@@ -1,5 +1,10 @@
+
+
+export const baseTypes = new Set(["string", "number", "bigint", "boolean"]);
+
 const types = {
   base: { name: "base" },
+  
   string: { name: "string", extends: "base" },
   number: {
     name: "number",
@@ -7,6 +12,12 @@ const types = {
     convertValue: (value, attribute) =>
       typeof value === "string" ? parseFloat(value) : value
   },
+  boolean: {
+    name: "boolean",
+    extends: "base",
+    convertValue: (value, attribute) => (!value || value === "0" ? false : true)
+  },
+
   integer: {
     name: "integer",
     extends: "base",
@@ -14,11 +25,6 @@ const types = {
       typeof value === "string" ? parseInt(value) : value
   },
   "unsigned-integer": { name: "unsigned-integer", extends: "integer" },
-  boolean: {
-    name: "boolean",
-    extends: "base",
-    convertValue: (value, attribute) => (!value || value === "0" ? false : true)
-  },
   url: { name: "url", extends: "string" },
   object: { name: "object", extends: "base" }
 };

package/src/expression.mjs

@@ -19,6 +19,35 @@ import {
   EOF
 } from "./tokens.mjs";
 
+export function binop(op, left, right) {
+  switch (op) {
+    case DOUBLE_BAR:
+      return left || right;
+    case DOUBLE_AMPERSAND:
+      return left && right;
+    case EQUAL:
+      return left == right;
+    case NOT_EQUAL:
+      return left != right;
+    case GREATER:
+      return left > right;
+    case LESS:
+      return left < right;
+    case GREATER_EQUAL:
+      return left >= right;
+    case LESS_EQUAL:
+      return left <= right;
+    case PLUS:
+      return left + right;
+    case MINUS:
+      return left - right;
+    case STAR:
+      return left * right;
+    case DIVIDE:
+      return left / right;
+  }
+}
+
 export function parse(context) {
   let node, token;
 
@@ -65,9 +94,9 @@ export function parse(context) {
     switch (typeof token) {
       case "string":
         return { path: [token] };
-      case "boolean":
-      case "bigint":
       case "number":
+      case "bigint":
+      case "boolean":
         return token;
     }
 
@@ -80,35 +109,11 @@ export function parse(context) {
         const right = expression(token.precedence - 1);
         if (typeof left === typeof right) {
           switch (typeof left) {
-            case "bigint":
-            case "number":
             case "string":
-              switch (token) {
-                case GREATER:
-                  return left > right;
-                case GREATER_EQUAL:
-                  return left >= right;
-                case LESS:
-                  return left < right;
-                case LESS_EQUAL:
-                  return left <= right;
-                case EQUAL:
-                  return left == right;
-                case NOT_EQUAL:
-                  return left != right;
-              }
-              break;
+            case "number":
+            case "bigint":
             case "boolean":
-              switch (token) {
-                case DOUBLE_BAR:
-                  return left || right;
-                case DOUBLE_AMPERSAND:
-                  return left && right;
-                case EQUAL:
-                  return left == right;
-                case NOT_EQUAL:
-                  return left != right;
-              }
+              return binop(token, left, right);
           }
         }
         return {
@@ -122,19 +127,9 @@ export function parse(context) {
         const right = expression(token.precedence);
         if (typeof left === typeof right) {
           switch (typeof left) {
-            case "bigint":
             case "number":
-              switch (token) {
-                case PLUS:
-                  return left + right;
-                case MINUS:
-                  return left - right;
-                case STAR:
-                  return left * right;
-                case DIVIDE:
-                  return left / right;
-              }
-              break;
+            case "bigint":
+              return binop(token, left, right);
           }
         }
         if (token === DOT) {

package/src/filter.mjs

@@ -7,14 +7,15 @@ import {
   GREATER,
   GREATER_EQUAL
 } from "pacc";
+import { binop } from "./expression.mjs";
 
-function dateOp(value, against, op) {
-  return numberOp(value.getTime(), against.getTime(), op);
+function dateOp(op, value, against) {
+  return binop(op, value.getTime(), against.getTime());
 }
 
-function collectionOp(value, against, op) {
+function collectionOp(op, value, against) {
   for (const v of value) {
-    if (allOp(v, against, op)) {
+    if (allOp(op, v, against)) {
       return true;
     }
   }
@@ -22,7 +23,7 @@ function collectionOp(value, against, op) {
   return false;
 }
 
-function allOp(value, against, op) {
+function allOp(op, value, against) {
   switch (typeof value) {
     case "undefined":
       return false;
@@ -33,13 +34,13 @@ function allOp(value, against, op) {
       }
 
       if (value instanceof Map) {
-        return collectionOp(value.keys(), against, op);
+        return collectionOp(op, value.keys(), against);
       }
       if (value instanceof RegExp) {
         return value.test(against);
       }
       if (value[Symbol.iterator]) {
-        return collectionOp(value, against, op);
+        return collectionOp(op, value, against);
       }
 
       switch (typeof against) {
@@ -50,26 +51,29 @@ function allOp(value, against, op) {
               against[0] instanceof Date &&
               against[1] instanceof Date
             ) {
-              return dateOp(value, against[0], GREATER_EQUAL) && dateOp(value, against[1], LESS_EQUAL);
+              return (
+                dateOp(GREATER_EQUAL, value, against[0]) &&
+                dateOp(LESS_EQUAL, value, against[1])
+              );
             }
 
             if (against instanceof Date) {
-              return dateOp(value, against, op);
+              return dateOp(op, value, against);
             }
           }
 
           if (value[Symbol.toPrimitive] && against[Symbol.toPrimitive]) {
-            return numberOp(
+            return binop(
+              op,
               value[Symbol.toPrimitive]("number"),
-              against[Symbol.toPrimitive]("number"),
-              op
+              against[Symbol.toPrimitive]("number")
             );
           }
           break;
 
         case "bigint":
         case "number":
-          return allOp(value[Symbol.toPrimitive]("number"), against, op);
+          return allOp(op, value[Symbol.toPrimitive]("number"), against);
 
         case "string":
           if (against.length === 0) {
@@ -77,11 +81,11 @@ function allOp(value, against, op) {
           }
 
           if (value instanceof Date) {
-            return dateOp(value, new Date(against), op);
+            return dateOp(op, value, new Date(against));
           }
           break;
         case "boolean":
-          return numberOp(value ? true : false, against, op);
+          return binop(op, value ? true : false, against);
       }
 
       if (against instanceof RegExp) {
@@ -92,7 +96,7 @@ function allOp(value, against, op) {
     case "string":
       switch (typeof against) {
         case "boolean":
-          return numberOp(value.length !== 0, against, op);
+          return binop(op, value.length !== 0, against);
         case "string":
           if (
             op === EQUAL &&
@@ -106,14 +110,14 @@ function allOp(value, against, op) {
           }
         case "bigint":
         case "number":
-          return value.length ? numberOp(value, against, op) : true;
+          return value.length ? binop(op, value, against) : true;
         case "object":
           if (value.length === 0) {
             return false;
           }
 
           if (against instanceof Date) {
-            return dateOp(new Date(value), against, op);
+            return dateOp(op, new Date(value), against);
           }
 
           if (against instanceof RegExp) {
@@ -122,7 +126,7 @@ function allOp(value, against, op) {
 
           if (against instanceof Map) {
             for (const [k, v] of against) {
-              if (allOp(value, k, op) || allOp(value, v, op)) {
+              if (allOp(op, value, k) || allOp(op, value, v)) {
                 return true;
               }
             }
@@ -130,7 +134,7 @@ function allOp(value, against, op) {
 
           if (against[Symbol.iterator]) {
             for (const i of against) {
-              if (allOp(value, i, op)) {
+              if (allOp(op, value, i)) {
                 return true;
               }
             }
@@ -149,7 +153,7 @@ function allOp(value, against, op) {
 
           if (against instanceof Map) {
             for (const [k, v] of against) {
-              if (numberOp(value, k, op) || numberOp(value, v, op)) {
+              if (binop(op, value, k) || binop(op, value, v)) {
                 return true;
               }
             }
@@ -158,20 +162,20 @@ function allOp(value, against, op) {
 
           if (against[Symbol.iterator]) {
             for (const i of against) {
-              if (numberOp(value, i, op)) {
+              if (binop(op, value, i)) {
                 return true;
               }
             }
             return false;
           }
       }
-      return numberOp(value, against, op);
+      return binop(op, value, against);
     case "boolean":
       switch (typeof against) {
         case "object":
           if (against[Symbol.iterator]) {
             for (const i of against) {
-              if (allOp(value, i, op)) {
+              if (allOp(op, value, i)) {
                 return true;
               }
             }
@@ -185,23 +189,6 @@ function allOp(value, against, op) {
   return false;
 }
 
-function numberOp(value, against, op) {
-  switch (op) {
-    case NOT_EQUAL:
-      return value != against;
-    case EQUAL:
-      return value == against;
-    case GREATER:
-      return value > against;
-    case LESS:
-      return value < against;
-    case GREATER_EQUAL:
-      return value >= against;
-    case LESS_EQUAL:
-      return value <= against;
-  }
-}
-
 /**
  * Generate filter function.
  * @param {Object} [filterBy]
@@ -212,7 +199,7 @@ export function filter(filterBy) {
     const filters = Object.entries(filterBy).map(([key, against]) => {
       return a => {
         const [value, op] = getAttributeAndOperator(a, key);
-        return allOp(value, against, op);
+        return allOp(op, value, against);
       };
     });
 

package/types/attributes.d.mts

@@ -12,3 +12,4 @@ export function prepareAttributesDefinitions(newDefinitions: any, presentDefinit
  */
 export function attributeIterator(definition: any, path?: string[]): any;
 export function convertValue(value: any, attribute: any): any;
+export const baseTypes: Set<string>;

package/types/expression.d.mts

@@ -1 +1,2 @@
+export function binop(op: any, left: any, right: any): any;
 export function parse(context: any): any;