sprintify-ui 0.10.62 → 0.10.64

package/dist/types/utils/deepIncludes.d.ts

@@ -0,0 +1,14 @@
+export interface SearchOpts {
+    maxDepth?: number;
+    maxCharsPerItem?: number;
+    maxArray?: number;
+    cache?: WeakMap<object, string>;
+}
+/**
+ * Recursively searches an item (object, array, primitive) for a case-insensitive match of the query string.
+ * Limits can be set to avoid excessive CPU usage on large/deep items.
+ * @param item The item to search within.
+ * @param queryRaw The query string to search for.
+ * @param opts Optional search options.
+ */
+export declare function deepIncludes(item: any, queryRaw: string, opts?: SearchOpts): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprintify-ui",
-  "version": "0.10.62",
+  "version": "0.10.64",
   "type": "module",
   "scripts": {
     "build": "rimraf dist && vue-tsc && vite build",

package/src/components/BaseDataIterator.vue

@@ -188,6 +188,7 @@ type Direction = 'asc' | 'desc';
 import { Size } from '@/utils/sizes';
 import BaseInput from './BaseInput.vue';
 import { useInputSize } from '@/composables/inputSize';
+import { deepIncludes } from '@/utils/deepIncludes';
 
 const DEFAULT_QUERY = {
   page: 1,
@@ -785,22 +786,11 @@ function searchItems(items: Collection | undefined) {
     return [];
   }
 
-  const searchWords = searchKeywords.value.toLowerCase();
-
   if (props.search) {
     return props.search(items, searchKeywords.value);
   }
 
-  return items?.filter((item) => {
-    return Object.values(item).some((value) => {
-      if (typeof value === 'string') {
-        return value.toLowerCase().includes(searchWords);
-      }
-      if (typeof value === 'object') {
-        return JSON.stringify(value).toLowerCase().includes(searchWords);
-      }
-    });
-  });
+  return items.filter((it) => deepIncludes(it, searchKeywords.value));
 }
 
 function sortItems(items: Collection | undefined) {

package/src/components/BaseInput.vue

@@ -345,7 +345,7 @@ const decorationWrapClasses = computed(() => {
 });
 
 const decorationClasses = computed(() => {
-  const base = `flex items-center justify-center rounded-md`;
+  const base = `flex items-center justify-center rounded-md whitespace-pre`;
   const textColor = hasErrorInternal.value ? 'text-red-800' : 'text-slate-500';
   const padding = {
     xs: 'p-1',

package/src/utils/deepIncludes.ts

@@ -0,0 +1,77 @@
+export interface SearchOpts {
+    maxDepth?: number;          // stop descending after this depth
+    maxCharsPerItem?: number;   // stop scanning item after reading this many chars
+    maxArray?: number;          // cap how many array items to inspect per array
+    cache?: WeakMap<object, string>; // optional: lazy per-item cache of a “search blob”
+}
+
+/**
+ * Recursively searches an item (object, array, primitive) for a case-insensitive match of the query string.
+ * Limits can be set to avoid excessive CPU usage on large/deep items.
+ * @param item The item to search within.
+ * @param queryRaw The query string to search for.
+ * @param opts Optional search options.
+ */
+export function deepIncludes(item: any, queryRaw: string, opts: SearchOpts = {}): boolean {
+    const q = queryRaw.toLowerCase();
+    const {
+        maxDepth = 3,
+        maxCharsPerItem = 3000,
+        maxArray = 64,
+        cache,
+    } = opts;
+
+    let consumed = 0;
+    const seen = new WeakSet<object>();
+
+    const feed = (s: string): boolean => {
+        // consume without allocating new strings repeatedly
+        consumed += s.length;
+        return s.toLowerCase().includes(q) || consumed >= maxCharsPerItem;
+    };
+
+    const visit = (val: any, depth: number): boolean => {
+        if (val == null) return false;
+        if (consumed >= maxCharsPerItem) return false;
+
+        const t = typeof val;
+
+        if (t === 'string') return feed(val);
+        if (t === 'number' || t === 'boolean') return feed(String(val));
+        if (t === 'bigint') return feed(val.toString());
+        if (t === 'symbol' || t === 'function') return false;
+
+        // objects & arrays
+        if (t === 'object') {
+            if (seen.has(val)) return false;
+            seen.add(val);
+
+            // Optional lazy cache: build once per object identity
+            if (cache && cache.has(val)) {
+                return feed(cache.get(val)!); // already lowercased when stored? not necessary since feed lowercases
+            }
+
+            if (depth >= maxDepth) return false;
+
+            if (Array.isArray(val)) {
+                const len = Math.min(val.length, maxArray);
+                for (let i = 0; i < len; i++) {
+                    if (visit(val[i], depth + 1)) return true;
+                }
+                return false;
+            }
+
+            // plain object: iterate own enumerable keys only
+            for (const k in val) {
+                // match on key names too (often helpful if values are IDs)
+                if (feed(k)) return true;
+                if (visit(val[k], depth + 1)) return true;
+            }
+            return false;
+        }
+
+        return false;
+    };
+
+    return visit(item, 0);
+}