svelte-common 6.4.2 → 6.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-common",
-  "version": "6.4.2",
+  "version": "6.4.4",
   "publishConfig": {
     "access": "public"
   },
@@ -55,7 +55,7 @@
     "mf-styling": "^3.0.2",
     "npm-pkgbuild": "^11.10.1",
     "semantic-release": "^21.0.7",
-    "stylelint": "^15.10.1",
+    "stylelint": "^15.10.2",
     "stylelint-config-standard": "^34.0.0",
     "svelte": "^4.0.5",
     "testcafe": "^3.0.1",

package/src/attribute.mjs

@@ -210,6 +210,8 @@ export function getAttributeAndOperator(object, expression, getters = {}) {
         } else {
           if (object[token] !== undefined) {
             object = object[token];
+          } else {
+            return [undefined, op];
           }
         }
     }

package/src/filter.mjs

@@ -1,34 +1,93 @@
 import { getAttributeAndOperator } from "./attribute.mjs";
 
-function dateOp(a, b, op) {
-  return numberOp(a.getTime(), b.getTime(), op);
+function dateOp(value, against, op) {
+  return numberOp(value.getTime(), against.getTime(), op);
 }
 
-function collectionOp(a, b, op) {
-  for (const v of a) {
-    const r = numberOp(v, b, op);
-    if (r) {
-      return r;
+function collectionOp(value, against, op) {
+  for (const v of value) {
+    if (allOp(v, against, op)) {
+      return true;
     }
   }
 
   return false;
 }
 
-function numberOp(a, b, op) {
+function allOp(value, against, op) {
+  switch (typeof against) {
+    case "object":
+      if (against instanceof Date) {
+        switch (typeof value) {
+          case "object":
+            if (value instanceof Date) {
+              return dateOp(value, against, op);
+            }
+            break;
+          case "string":
+            return dateOp(new Date(value), against, op);
+        }
+      }
+  }
+
+  switch (typeof value) {
+    case "object":
+      if (value instanceof Date) {
+        switch (typeof against) {
+          case "string":
+            return dateOp(value, new Date(against), op);
+          case "object":
+            if (against instanceof Date) {
+              return dateOp(value, against, op);
+            }
+        }
+      }
+
+      if (Array.isArray(value) || value instanceof Set) {
+        return collectionOp(value, against, op);
+      }
+
+      return value.toString().match(against);
+    case "string":
+      switch (typeof against) {
+        case "bigint":
+        case "number":
+          return numberOp(value, against, op);
+        case "object":
+          if (against instanceof RegExp) {
+            return against.test(value);
+          }
+      }
+
+      return value.match(against);
+    case "bigint":
+    case "number":
+      if (against instanceof RegExp) {
+        return against.test(value);
+      }
+
+      return numberOp(value, against, op);
+    case "boolean":
+      return value == against;
+  }
+
+  return false;
+}
+
+function numberOp(value, against, op) {
   switch (op) {
     case "!=":
-      return a != b;
+      return value != against;
     case "=":
-      return a == b;
+      return value == against;
     case ">":
-      return a > b;
+      return value > against;
     case "<":
-      return a < b;
+      return value < against;
     case ">=":
-      return a >= b;
+      return value >= against;
     case "<=":
-      return a <= b;
+      return value <= against;
   }
 }
 
@@ -40,52 +99,10 @@ function numberOp(a, b, op) {
  */
 export function filter(filterBy, getters) {
   if (filterBy) {
-    const filters = Object.entries(filterBy).map(([key, value]) => {
+    const filters = Object.entries(filterBy).map(([key, against]) => {
       return a => {
-        const [av, op] = getAttributeAndOperator(a, key, getters);
-
-        switch (typeof value) {
-          case "bigint":
-          case "number":
-            return numberOp(av, value, op);
-          case "string":
-            if (av instanceof Date) {
-              return dateOp(av, new Date(value), op);
-            }
-            break;
-          case "object":
-            if (value instanceof RegExp) {
-              return value.test(av);
-            }
-            if (value instanceof Date) {
-              switch (typeof av) {
-                case "object":
-                  if (av instanceof Date) {
-                    return dateOp(av, value, op);
-                  }
-                  break;
-                case "string":
-                  return dateOp(new Date(av), value, op);
-              }
-            }
-        }
-
-        switch (typeof av) {
-          case "object":
-            if (Array.isArray(av) || av instanceof Set) {
-              return collectionOp(av, value, op);
-            }
-
-            return av.toString().match(value);
-          case "string":
-            return av.match(value);
-          case "bigint":
-          case "number":
-            return numberOp(av, value, op);
-          case "boolean":
-            return value == av;
-        }
-        return false;
+        const [value, op] = getAttributeAndOperator(a, key, getters);
+        return allOp(value, against, op);
       };
     });