sprintify-ui 0.10.61 → 0.10.63

package/dist/types/components/BaseDataTable.vue.d.ts

@@ -1778,6 +1778,13 @@ declare const __VLS_self: import("vue").DefineComponent<import("vue").ExtractPro
         type: StringConstructor;
         default(): string;
     };
+    /**
+     * Function to search local data
+     */
+    search: {
+        default: undefined;
+        type: PropType<(items: Collection, search: string | null) => Collection>;
+    };
 }>, {
     t: typeof t;
     BaseDataIterator: typeof BaseDataIterator;
@@ -2066,11 +2073,19 @@ declare const __VLS_self: import("vue").DefineComponent<import("vue").ExtractPro
         type: StringConstructor;
         default(): string;
     };
+    /**
+     * Function to search local data
+     */
+    search: {
+        default: undefined;
+        type: PropType<(items: Collection, search: string | null) => Collection>;
+    };
 }>> & Readonly<{
     onDelete?: ((...args: any[]) => any) | undefined;
     "onUpdate:checked-rows"?: ((...args: any[]) => any) | undefined;
     onFetch?: ((...args: any[]) => any) | undefined;
 }>, {
+    search: (items: Collection, search: string | null) => Collection;
     size: "xs" | "sm" | "md" | "lg" | "xl";
     items: CollectionItem[] | undefined;
     actions: ActionItem[];
@@ -2360,6 +2375,13 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         type: StringConstructor;
         default(): string;
     };
+    /**
+     * Function to search local data
+     */
+    search: {
+        default: undefined;
+        type: PropType<(items: Collection, search: string | null) => Collection>;
+    };
 }>, {
     fetch: typeof fetch;
     fetchWithoutLoading: typeof fetchWithoutLoading;
@@ -2620,11 +2642,19 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
         type: StringConstructor;
         default(): string;
     };
+    /**
+     * Function to search local data
+     */
+    search: {
+        default: undefined;
+        type: PropType<(items: Collection, search: string | null) => Collection>;
+    };
 }>> & Readonly<{
     onDelete?: ((...args: any[]) => any) | undefined;
     "onUpdate:checked-rows"?: ((...args: any[]) => any) | undefined;
     onFetch?: ((...args: any[]) => any) | undefined;
 }>, {
+    search: (items: Collection, search: string | null) => Collection;
     size: "xs" | "sm" | "md" | "lg" | "xl";
     items: CollectionItem[] | undefined;
     actions: ActionItem[];

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.61",
+  "version": "0.10.63",
   "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,20 +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);
-      }
-      return false;
-    });
-  });
+  return items.filter((it) => deepIncludes(it, searchKeywords.value));
 }
 
 function sortItems(items: Collection | undefined) {

package/src/components/BaseDataTable.vue

@@ -14,6 +14,7 @@
     :sections="sectionsInternal"
     :scroll-top-on-fetch="maxHeight ? false : scrollTopOnFetch"
     :filters-position="filtersPosition"
+    :search="search"
     @fetch="onFetch"
     @will-scroll-top="onWillScrollTop"
   >
@@ -562,6 +563,14 @@ const props = defineProps({
       return window.location.pathname;
     },
   },
+
+  /**
+   * Function to search local data
+   */
+  search: {
+    default: undefined,
+    type: Function as PropType<(items: Collection, search: string | null) => Collection>,
+  }
 });
 
 const sizeInternal = useInputSize(props.size);

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);
+}