pacc 3.3.0 → 3.4.1

package/README.md

@@ -38,11 +38,13 @@ const result = getAttribute({ a: [0,{ b: 4 }]}, "a[1].b");
     *   [Parameters](#parameters-2)
 *   [getAttributeAndOperator](#getattributeandoperator)
     *   [Parameters](#parameters-3)
+*   [filter](#filter)
+    *   [Parameters](#parameters-4)
 *   [lookup](#lookup)
 *   [Token](#token)
     *   [Properties](#properties-1)
 *   [createToken](#createtoken)
-    *   [Parameters](#parameters-4)
+    *   [Parameters](#parameters-5)
 *   [PLUS](#plus)
 *   [MINUS](#minus)
 *   [STAR](#star)
@@ -134,6 +136,16 @@ The name may be a property path like 'a.b.c <='.
 
 Returns **\[any, [Token](#token)]** value associated with the given property name
 
+## filter
+
+Generate filter function.
+
+### Parameters
+
+*   `filterBy` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?**&#x20;
+
+Returns **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)**&#x20;
+
 ## lookup
 
 Token lookup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "3.3.0",
+  "version": "3.4.1",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -34,14 +34,14 @@
   },
   "devDependencies": {
     "ava": "^6.2.0",
-    "browser-ava": "^2.3.9",
+    "browser-ava": "^2.3.17",
     "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",
@@ -59,5 +59,8 @@
       "arlac77/template-node-component",
       "arlac77/template-typescript"
     ]
+  },
+  "dependencies": {
+    "npm-pkgbuild": "^18.1.1"
   }
 }

package/src/attribute.mjs

@@ -33,6 +33,7 @@ import {
   STAR
 } from "./tokens.mjs";
 export * from "./tokens.mjs";
+export * from "./filter.mjs";
 
 /**
  * Set Object attribute.

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;