pacc 3.2.0 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -34,14 +34,14 @@
   },
   "devDependencies": {
     "ava": "^6.2.0",
-    "browser-ava": "^2.3.9",
+    "browser-ava": "^2.3.16",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
-    "semantic-release": "^24.2.1",
-    "typescript": "^5.7.3"
+    "semantic-release": "^24.2.3",
+    "typescript": "^5.8.3"
   },
   "engines": {
-    "node": ">=22.13.1"
+    "node": ">=22.14.0"
   },
   "repository": {
     "type": "git",

package/src/attribute.mjs

@@ -33,6 +33,7 @@ import {
   STAR
 } from "./tokens.mjs";
 export * from "./tokens.mjs";
+export * from "./filter.mjs";
 
 /**
  * Set Object attribute.
@@ -94,7 +95,11 @@ export function getAttribute(object, expression) {
 export function getAttributeAndOperator(object, expression) {
   switch (typeof object?.[expression]) {
     case "function":
-      return [object[expression](), EQUAL];
+      object = object[expression]();
+      if (typeof object[Symbol.iterator] === "function") {
+        object = [...object];
+      }
+      return [object, EQUAL];
     case "undefined":
       break;
     default:
@@ -141,6 +146,9 @@ export function getAttributeAndOperator(object, expression) {
           switch (typeof object[token]) {
             case "function":
               object = object[token]();
+              if (typeof object[Symbol.iterator] === "function") {
+                object = [...object];
+              }
               break;
             default:
               object = object[token];

package/src/filter.mjs

@@ -0,0 +1,228 @@
+import {
+  getAttributeAndOperator,
+  EQUAL,
+  NOT_EQUAL,
+  LESS,
+  LESS_EQUAL,
+  GREATER,
+  GREATER_EQUAL
+} from "pacc";
+
+function dateOp(value, against, op) {
+  return numberOp(value.getTime(), against.getTime(), op);
+}
+
+function collectionOp(value, against, op) {
+  for (const v of value) {
+    if (allOp(v, against, op)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function allOp(value, against, op) {
+  switch (typeof value) {
+    case "undefined":
+      return false;
+
+    case "object":
+      if (value === null) {
+        return false;
+      }
+
+      if (value instanceof Map) {
+        return collectionOp(value.keys(), against, op);
+      }
+      if (value instanceof RegExp) {
+        return value.test(against);
+      }
+      if (value[Symbol.iterator]) {
+        return collectionOp(value, against, op);
+      }
+
+      switch (typeof against) {
+        case "object":
+          if (value instanceof Date) {
+            if (
+              Array.isArray(against) &&
+              against[0] instanceof Date &&
+              against[1] instanceof Date
+            ) {
+              return dateOp(value, against[0], GREATER_EQUAL) && dateOp(value, against[1], LESS_EQUAL);
+            }
+
+            if (against instanceof Date) {
+              return dateOp(value, against, op);
+            }
+          }
+
+          if (value[Symbol.toPrimitive] && against[Symbol.toPrimitive]) {
+            return numberOp(
+              value[Symbol.toPrimitive]("number"),
+              against[Symbol.toPrimitive]("number"),
+              op
+            );
+          }
+          break;
+
+        case "bigint":
+        case "number":
+          return allOp(value[Symbol.toPrimitive]("number"), against, op);
+
+        case "string":
+          if (against.length === 0) {
+            return true;
+          }
+
+          if (value instanceof Date) {
+            return dateOp(value, new Date(against), op);
+          }
+          break;
+        case "boolean":
+          return numberOp(value ? true : false, against, op);
+      }
+
+      if (against instanceof RegExp) {
+        return against.test(value.toString());
+      }
+
+      return value.toString().match(against);
+    case "string":
+      switch (typeof against) {
+        case "boolean":
+          return numberOp(value.length !== 0, against, op);
+        case "string":
+          if (
+            op === EQUAL &&
+            (against.length === 0 || value.indexOf(against) >= 0)
+          ) {
+            return true;
+          }
+
+          if (!value.match(/^-?\d/)) {
+            break;
+          }
+        case "bigint":
+        case "number":
+          return value.length ? numberOp(value, against, op) : true;
+        case "object":
+          if (value.length === 0) {
+            return false;
+          }
+
+          if (against instanceof Date) {
+            return dateOp(new Date(value), against, op);
+          }
+
+          if (against instanceof RegExp) {
+            return against.test(value);
+          }
+
+          if (against instanceof Map) {
+            for (const [k, v] of against) {
+              if (allOp(value, k, op) || allOp(value, v, op)) {
+                return true;
+              }
+            }
+          }
+
+          if (against[Symbol.iterator]) {
+            for (const i of against) {
+              if (allOp(value, i, op)) {
+                return true;
+              }
+            }
+            return false;
+          }
+      }
+
+      return value.match(against);
+    case "bigint":
+    case "number":
+      switch (typeof against) {
+        case "object":
+          if (against instanceof RegExp) {
+            return against.test(String(value));
+          }
+
+          if (against instanceof Map) {
+            for (const [k, v] of against) {
+              if (numberOp(value, k, op) || numberOp(value, v, op)) {
+                return true;
+              }
+            }
+            return false;
+          }
+
+          if (against[Symbol.iterator]) {
+            for (const i of against) {
+              if (numberOp(value, i, op)) {
+                return true;
+              }
+            }
+            return false;
+          }
+      }
+      return numberOp(value, against, op);
+    case "boolean":
+      switch (typeof against) {
+        case "object":
+          if (against[Symbol.iterator]) {
+            for (const i of against) {
+              if (allOp(value, i, op)) {
+                return true;
+              }
+            }
+          }
+          break;
+      }
+
+      return value == against;
+  }
+
+  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]
+ * @returns {Function}
+ */
+export function filter(filterBy) {
+  if (filterBy) {
+    const filters = Object.entries(filterBy).map(([key, against]) => {
+      return a => {
+        const [value, op] = getAttributeAndOperator(a, key);
+        return allOp(value, against, op);
+      };
+    });
+
+    if (filters.length === 1) {
+      return filters[0];
+    }
+    if (filters.length > 1) {
+      return a => !filters.some(f => !f(a));
+    }
+  }
+
+  return () => true;
+}

package/types/attribute.d.mts

@@ -23,6 +23,7 @@ export function getAttribute(object: any, expression: string): any;
  */
 export function getAttributeAndOperator(object: any, expression: string): [any, Token];
 export * from "./tokens.mjs";
+export * from "./filter.mjs";
 export type AttributeDefinition = {
     type: string;
     isKey: boolean;

package/types/filter.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Generate filter function.
+ * @param {Object} [filterBy]
+ * @returns {Function}
+ */
+export function filter(filterBy?: any): Function;