@dxos/plugin-search 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/src/components/SearchMain.stories.tsx

@@ -0,0 +1,90 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Decorator, type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Obj } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { corePlugins } from '@dxos/plugin-testing';
+import { faker } from '@dxos/random';
+import { useSpaces } from '@dxos/react-client/echo';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { withMosaic } from '@dxos/react-ui-mosaic/testing';
+
+import { SearchContextProvider } from '../hooks';
+import { translations } from '../translations';
+
+import { SearchMain } from './SearchMain';
+
+faker.seed(1234);
+
+const withSearchContext = (): Decorator => {
+  return (Story) => (
+    <SearchContextProvider>
+      <Story />
+    </SearchContextProvider>
+  );
+};
+
+const DefaultStory = () => {
+  const spaces = useSpaces();
+  const space = spaces[spaces.length - 1];
+  return <SearchMain space={space} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-search/SearchMain',
+  component: SearchMain,
+  render: DefaultStory,
+  decorators: [
+    withTheme,
+    withLayout({ layout: 'column' }),
+    withMosaic(),
+    withSearchContext(),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [TestSchema.Task, TestSchema.Organization, TestSchema.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* Effect.promise(() => client.halo.createIdentity());
+              yield* Effect.promise(() => client.spaces.waitUntilReady());
+              const space = yield* Effect.promise(() => client.spaces.create({ name: 'Test Space' }));
+              yield* Effect.promise(() => space.waitUntilReady());
+              // Create some test data to search.
+              space.db.add(
+                Obj.make(TestSchema.Task, { title: 'Project Proposal', description: 'A proposal for a new project' }),
+              );
+              space.db.add(
+                Obj.make(TestSchema.Task, { title: 'Meeting Notes', description: 'Notes from the team meeting' }),
+              );
+              space.db.add(
+                Obj.make(TestSchema.Task, { title: 'Budget Report', description: 'Q3 financial budget report' }),
+              );
+              space.db.add(Obj.make(TestSchema.Person, { name: 'Alice Smith', email: 'alice@example.com' }));
+              space.db.add(Obj.make(TestSchema.Person, { name: 'Bob Jones', email: 'bob@example.com' }));
+              space.db.add(Obj.make(TestSchema.Organization, { name: 'Composer Project' }));
+            }),
+        }),
+        PreviewPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof SearchMain>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/components/SearchMain.tsx

@@ -2,67 +2,82 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { type FC, useState } from 'react';
+import React, { useCallback, useMemo, useState } from 'react';
 
-import { log } from '@dxos/log';
-import { useClient } from '@dxos/react-client';
+import { Surface } from '@dxos/app-framework/react';
+import { Entity, Query } from '@dxos/echo';
 import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
-import { type ThemedClassName, useTranslation } from '@dxos/react-ui';
-import { activeSurface, mx } from '@dxos/react-ui-theme';
+import { Toolbar, useTranslation } from '@dxos/react-ui';
+import { Card, Mosaic, type StackTileComponent } from '@dxos/react-ui-mosaic';
+import { Layout } from '@dxos/react-ui-mosaic';
+import { SearchList } from '@dxos/react-ui-searchlist';
+import { Text } from '@dxos/schema';
 
-import { useGlobalSearch, useGlobalSearchResults } from '../hooks';
-import { useWebSearch } from '../hooks/useWebSearch';
+import { useGlobalSearch, useGlobalSearchResults, useWebSearch } from '../hooks';
 import { meta } from '../meta';
+import { type SearchResult } from '../types';
 
-import { Searchbar } from './Searchbar';
-import { SearchResults } from './SearchResults';
-
-export const SearchMain: FC<ThemedClassName<{ space: Space }>> = ({ classNames, space }) => {
+export const SearchMain = ({ space }: { space?: Space }) => {
   const { t } = useTranslation(meta.id);
-  const client = useClient();
   const { setMatch } = useGlobalSearch();
   const [query, setQuery] = useState<string>();
-  // TODO(burdon): UX to select all spaces.
-  const allSpaces = false;
+  // TODO(burdon): Option to search across spaces.
+  const objects = useQuery(
+    space?.db,
+    query === undefined
+      ? Query.select(Filter.nothing())
+      : // TODO(dmaretskyi): Final version would walk the ancestry of the object until we find a non-system type.
+        Query.all(
+          Query.select(Filter.text(query, { type: 'full-text' })).select(Filter.not(Filter.type(Text.Text))),
+          Query.select(Filter.text(query, { type: 'full-text' }))
+            .select(Filter.type(Text.Text))
+            .referencedBy('dxos.org/type/Document', 'content'),
+        ),
+  );
 
-  // TODO(burdon): Returns ALL objects (e.g., incl. Text objects that are fields of parent objects).
-  const objects = useQuery(allSpaces ? client.spaces : space, Filter.everything());
   const results = useGlobalSearchResults(objects);
+  const { results: webResults } = useWebSearch({ query });
+  const allResults = useMemo(
+    () => [...results, ...webResults].filter(({ object }) => object && Entity.getLabel(object)),
+    [results, webResults],
+  );
 
-  const {
-    runSearch,
-    results: webResults,
-    isLoading,
-  } = useWebSearch({
-    query,
-  });
-
-  const [selected, setSelected] = useState<string>();
-
-  // TODO(burdon): Activate and/or filter current main (set context).
-  const handleSelect = (id: string) => {
-    setSelected((selected) => (selected === id ? undefined : id));
-  };
+  const handleSearch = useCallback(
+    (text: string) => {
+      setQuery(text);
+      setMatch?.(text);
+    },
+    [setMatch],
+  );
 
-  const allResults = [...results, ...webResults];
-  log.info('results', { results, webResults });
+  return (
+    <Layout.Main toolbar>
+      <SearchList.Root onSearch={handleSearch}>
+        <Toolbar.Root>
+          <SearchList.Input placeholder={t('search placeholder')} />
+        </Toolbar.Root>
+        <SearchList.Content>
+          <Mosaic.Container asChild>
+            <Mosaic.Viewport>
+              <Mosaic.Stack items={allResults} getId={(result) => result.object!.id} Tile={SearchResultTile} />
+            </Mosaic.Viewport>
+          </Mosaic.Container>
+          {allResults.length === 0 && <SearchList.Empty>{t('empty results message')}</SearchList.Empty>}
+        </SearchList.Content>
+      </SearchList.Root>
+    </Layout.Main>
+  );
+};
 
+const SearchResultTile: StackTileComponent<SearchResult> = ({ data }) => {
   return (
-    <div className={mx('flex flex-col grow h-full overflow-hidden', classNames)}>
-      <Searchbar
-        placeholder={t('search placeholder')}
-        onChange={(text) => {
-          setQuery(text);
-          setMatch?.(text);
-        }}
-        onSubmit={runSearch}
-      />
-      {isLoading && <div className={mx('flex flex-col grow overflow-hidden', activeSurface)}>Loading...</div>}
-      {allResults.length > 0 && (
-        <div className={mx('flex flex-col grow overflow-hidden', activeSurface)}>
-          <SearchResults items={allResults} selected={selected} onSelect={handleSelect} />
-        </div>
-      )}
-    </div>
+    <Card.Root key={data.id}>
+      <Card.Toolbar>
+        <Card.DragHandle />
+        <Card.Title>{data.label ?? (data.object && Entity.getLabel(data.object))}</Card.Title>
+        <Card.Menu />
+      </Card.Toolbar>
+      <Surface role='card--content' data={{ subject: data.object }} limit={1} />
+    </Card.Root>
   );
 };

package/src/components/SpaceMain.tsx

@@ -0,0 +1,169 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { Common } from '@dxos/app-framework';
+import { useAppGraph, useCapabilities, useOperationInvoker } from '@dxos/app-framework/react';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { Graph, Node, useActionRunner, useConnections } from '@dxos/plugin-graph';
+import { type Space, useQuery } from '@dxos/react-client/echo';
+import { Toolbar, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { Card, Mosaic, type StackTileComponent } from '@dxos/react-ui-mosaic';
+import { Layout } from '@dxos/react-ui-mosaic';
+import { SearchList } from '@dxos/react-ui-searchlist';
+import { Text } from '@dxos/schema';
+import { getStyles } from '@dxos/ui-theme';
+
+import { meta } from '../meta';
+
+/**
+ *
+ */
+export const SpaceMain = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const { items, handleSearch } = useSpaceItems(space);
+
+  return (
+    <Layout.Main toolbar>
+      <SearchList.Root onSearch={handleSearch}>
+        <Toolbar.Root>
+          <SearchList.Input placeholder={t('search placeholder')} />
+        </Toolbar.Root>
+        <SearchList.Content>
+          <Mosaic.Container asChild>
+            <Mosaic.Viewport padding>
+              <Mosaic.Stack items={items} getId={(node) => node.id} Tile={NodeTile} />
+            </Mosaic.Viewport>
+          </Mosaic.Container>
+        </SearchList.Content>
+      </SearchList.Root>
+    </Layout.Main>
+  );
+};
+
+const NodeTile: StackTileComponent<Node.Node> = ({ data: node }) => {
+  const { t } = useTranslation(meta.id);
+  const { graph } = useAppGraph();
+  const { invokeSync } = useOperationInvoker();
+  const runAction = useActionRunner();
+
+  const label = toLocalizedString(node.properties.label, t);
+  const icon = node.properties.icon ?? 'ph--placeholder--regular';
+  const iconHue = node.properties.iconHue;
+  const styles = iconHue ? getStyles(iconHue) : undefined;
+
+  const handleClick = () => {
+    if (Node.isAction(node)) {
+      // Run action if this is an action node.
+      const [parent] = Graph.getConnections(graph, node.id, 'inbound');
+      if (parent) {
+        void runAction(node, { parent });
+      }
+    } else {
+      // Navigate to the node.
+      invokeSync(Common.LayoutOperation.Open, { subject: [node.id] });
+    }
+  };
+
+  return (
+    <Card.Root fullWidth>
+      <Card.Toolbar>
+        <Card.ToolbarIconButton variant='ghost' label={label} icon={icon} iconOnly iconClassNames={styles?.icon} />
+        <Card.Title onClick={handleClick}>{label}</Card.Title>
+        <Card.Menu />
+      </Card.Toolbar>
+    </Card.Root>
+  );
+};
+
+/**
+ * Hook to resolve metadata (icon, iconHue, etc.) for objects based on their typename.
+ */
+// TODO(wittjosiah): Factor out.
+const useMetadataResolver = () => {
+  const allMetadata = useCapabilities(Common.Capability.Metadata);
+  return useCallback((typename: string) => allMetadata.find((m) => m.id === typename)?.metadata ?? {}, [allMetadata]);
+};
+
+/**
+ * Hook to get space items with search/filter support.
+ * Returns direct children when no query, or full-text search results when searching.
+ */
+const useSpaceItems = (space: Space) => {
+  const { graph } = useAppGraph();
+  const [query, setQuery] = useState<string>();
+  const resolveMetadata = useMetadataResolver();
+
+  // Expand the space node to load its children (needed when navigating directly to a space URL).
+  useEffect(() => {
+    const frame = requestAnimationFrame(() => {
+      Graph.expand(graph, space.id, 'outbound');
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [graph, space.id]);
+
+  // Get direct children of the space node for the default view.
+  const children = useConnections(graph, space.id, 'outbound');
+
+  const handleSearch = useCallback((text: string) => {
+    setQuery(text);
+  }, []);
+
+  // TODO(dmaretskyi): Switch back to QueryEditor once query builder is ready for production.
+  // Query results using full-text search.
+  const results = useQuery(
+    space.db,
+    query === undefined
+      ? Query.select(Filter.nothing())
+      : Query.all(
+          Query.select(Filter.text(query, { type: 'full-text' })).select(Filter.not(Filter.type(Text.Text))),
+          Query.select(Filter.text(query, { type: 'full-text' }))
+            .select(Filter.type(Text.Text))
+            .referencedBy('dxos.org/type/Document', 'content'),
+        ),
+  );
+
+  // Determine if query is empty (show default view).
+  const isQueryEmpty = !query?.trim();
+
+  // Filter children to those which are objects or actions with disposition 'item'.
+  const filteredChildren = useMemo(
+    () =>
+      children.filter((node) => {
+        // Include regular objects.
+        if (Obj.isObject(node.data)) {
+          return true;
+        }
+        // Include actions with disposition 'item'.
+        return Node.isAction(node) && node.properties.disposition === 'item';
+      }),
+    [children],
+  );
+
+  // When showing default view, use nodes (which may include actions).
+  // When showing search results, wrap objects in a compatible shape with resolved metadata.
+  const items = useMemo(() => {
+    if (isQueryEmpty) {
+      return filteredChildren;
+    }
+    // Wrap query results as pseudo-nodes for consistent rendering.
+    return results.map((obj) => {
+      const typename = Obj.getTypename(obj);
+      const metadata = typename ? resolveMetadata(typename) : {};
+      return {
+        id: obj.id,
+        type: 'search-result',
+        data: obj,
+        properties: {
+          label: Obj.getLabel(obj) ?? obj.id,
+          icon: metadata.icon ?? 'ph--placeholder--regular',
+          iconHue: metadata.iconHue,
+        },
+      } as Node.Node;
+    });
+  }, [isQueryEmpty, filteredChildren, results, resolveMetadata]);
+
+  return { items, handleSearch };
+};

package/src/components/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './Searchbar';
 export * from './SearchMain';
 export * from './SearchDialog';
+export * from './SpaceMain';

package/src/hooks/index.ts

@@ -3,5 +3,7 @@
 //
 
 export * from './sync';
+
 export * from './useGlobalSearch';
 export * from './useSearchResults';
+export * from './useWebSearch';

package/src/hooks/sync.test.ts

@@ -5,7 +5,8 @@
 import { describe, expect, test } from 'vitest';
 
 import { Client } from '@dxos/client';
-import { Filter, Obj, Type } from '@dxos/echo';
+import { Filter, Obj } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
 import { faker } from '@dxos/random';
 
 import { filterObjectsSync } from './sync';
@@ -15,7 +16,8 @@ faker.seed(1);
 // TODO(burdon): Reconcile with agent/minisearch.
 
 describe('Search', () => {
-  test('Prefix text search', async () => {
+  // TODO(mykola): Fix FTS index to filter by fields.
+  test.skip('Prefix text search', async () => {
     const client = new Client();
     await client.initialize();
     await client.halo.createIdentity();
@@ -25,10 +27,10 @@ describe('Search', () => {
     Array.from({ length: 20 }).map((_, i) => {
       const content =
         i === 10 ? faker.lorem.sentence() + ` ${match}}. ` + faker.lorem.sentence() : faker.lorem.sentences();
-      return space.db.add(Obj.make(Type.Expando, { title: faker.lorem.sentence(), content }));
+      return space.db.add(Obj.make(TestSchema.Expando, { title: faker.lorem.sentence(), content }));
     });
 
-    const { objects } = await space.db.query(Filter.everything()).run();
+    const objects = await space.db.query(Filter.everything()).run();
     const results = filterObjectsSync(objects, new RegExp(match, 'i'));
     expect(results).to.have.length(1);
   });

package/src/hooks/sync.ts

@@ -5,8 +5,8 @@
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Obj } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
+import { type Entity, Obj } from '@dxos/echo';
+import { Text } from '@dxos/schema';
 
 import { type SearchResult } from '../types';
 
@@ -39,39 +39,34 @@ const getIcon = (schema: Schema.Schema.AnyNoContext | undefined): string | undef
 export type TextFields = Record<string, string>;
 
 // TODO(thure): This returns `SearchResult[]` which is not just a narrower set of objects as the name implies.
-export const filterObjectsSync = <T extends Record<string, any>>(objects: T[], match?: RegExp): SearchResult[] => {
+export const filterObjectsSync = <T extends Entity.Unknown>(objects: T[], match?: RegExp): SearchResult<T>[] => {
   if (!match) {
     return [];
   }
 
-  return objects.reduce<SearchResult[]>((results, object) => {
+  return objects.reduce<SearchResult<T>[]>((results, object) => {
     // TODO(burdon): Hack to ignore Text objects.
-    if (object instanceof DataType.Text) {
+    if (object instanceof Text.Text) {
       return results;
     }
 
     const fields = mapObjectToTextFields(object);
     Object.entries(fields).some(([, value]) => {
-      const result = value.match(match);
-      if (result) {
-        // TODO(burdon): Use schema.
-        const label = getStringProperty(object, ['label', 'name', 'title']);
-
-        results.push({
-          id: object.id,
-          type: getIcon(Obj.getSchema(object)),
-          label,
-          match,
-          // TODO(burdon): Truncate.
-          // TODO(burdon): Issue with sketch documents.
-          snippet: value !== label ? value : (fields.content ?? fields.description ?? undefined),
-          object,
-        });
-
-        return true;
-      }
+      // TODO(burdon): Use schema.
+      const label = Obj.getLabel(object as any);
+
+      results.push({
+        id: object.id,
+        type: getIcon(Obj.getSchema(object)),
+        label,
+        match,
+        // TODO(burdon): Truncate.
+        // TODO(burdon): Issue with sketch documents.
+        snippet: value !== label ? value : (fields.content ?? fields.description ?? undefined),
+        object,
+      });
 
-      return false;
+      return true;
     });
 
     return results;
@@ -95,13 +90,13 @@ export const getStringProperty = (object: any, keys: string[]): string | undefin
 };
 
 // TODO(burdon): Filter system fields.
-const getKeys = (object: Record<string, unknown>): string[] => {
+const getKeys = <T extends Entity.Unknown>(object: T): string[] => {
   try {
     const obj = JSON.parse(JSON.stringify(object));
     return Object.keys(obj).filter(
       (key) => key !== 'id' && key !== 'identityKey' && key[0] !== '_' && key[0] !== '@',
     ) as string[];
-  } catch (err) {
+  } catch {
     // TODO(burdon): Error with TLDraw sketch.
     //  Uncaught Error: Type with the name content has already been defined with a different constructor
     return [];
@@ -109,13 +104,13 @@ const getKeys = (object: Record<string, unknown>): string[] => {
 };
 
 // TODO(burdon): Use ECHO schema.
-export const mapObjectToTextFields = <T extends Record<string, unknown>>(object: T): TextFields => {
+export const mapObjectToTextFields = <T extends Entity.Unknown>(object: T): TextFields => {
   return getKeys(object).reduce<TextFields>((fields, key) => {
-    const value = object[key] as any;
-    if (typeof value === 'string' || value instanceof DataType.Text) {
+    const value = (object as any)[key];
+    if (typeof value === 'string' || value instanceof Text.Text) {
       try {
         fields[key] = String(value);
-      } catch (err) {
+      } catch {
         // TODO(burdon): Exception when parsing sketch document.
       }
     }

package/src/hooks/useGlobalSearch.tsx

@@ -2,14 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { type PropsWithChildren, createContext, useContext, useMemo, useState } from 'react';
+import React, { type PropsWithChildren, createContext, useCallback, useContext, useState } from 'react';
 
 import { raise } from '@dxos/debug';
+import { type Entity } from '@dxos/echo';
+import { GlobalFilterProvider } from '@dxos/react-ui-searchlist';
 
 import { type SearchResult } from '../types';
 
 import { filterObjectsSync, queryStringToMatch } from './sync';
 
+// Re-export for backward compatibility.
+export { useGlobalFilteredObjects, GlobalFilterProvider } from '@dxos/react-ui-searchlist';
+
 type SearchContextType = {
   match?: RegExp;
   setMatch?: (text?: string) => void;
@@ -17,26 +22,40 @@ type SearchContextType = {
 
 const SearchContext = createContext<SearchContextType>({});
 
+/**
+ * Provider for global search context.
+ * Also provides the GlobalFilterProvider for useGlobalFilteredObjects to work.
+ */
 export const SearchContextProvider = ({ children }: PropsWithChildren) => {
   const [match, setMatch] = useState<RegExp>();
   const handleMatch = (text?: string) => setMatch(queryStringToMatch(text));
-  return <SearchContext.Provider value={{ match, setMatch: handleMatch }}>{children}</SearchContext.Provider>;
+
+  // Provide a filter function for useGlobalFilteredObjects.
+  const filterFn = useCallback(
+    <T extends Entity.Any>(objects: T[]): T[] => {
+      if (!match) {
+        return objects;
+      }
+
+      return filterObjectsSync(objects, match)
+        .filter((result) => result.object)
+        .map((result) => result.object!);
+    },
+    [match],
+  );
+
+  return (
+    <SearchContext.Provider value={{ match, setMatch: handleMatch }}>
+      <GlobalFilterProvider filter={filterFn}>{children}</GlobalFilterProvider>
+    </SearchContext.Provider>
+  );
 };
 
 export const useGlobalSearch = () => {
   return useContext(SearchContext) ?? raise(new Error('Missing SearchContext.'));
 };
 
-export const useGlobalSearchResults = <T extends Record<string, any>>(objects?: T[]): SearchResult[] => {
+export const useGlobalSearchResults = <T extends Entity.Unknown>(objects?: T[]): SearchResult<T>[] => {
   const { match } = useGlobalSearch();
   return objects && match ? filterObjectsSync(objects, match) : [];
 };
-
-export const useGlobalFilteredObjects = <T extends Record<string, any>>(objects?: T[]): T[] => {
-  const { match } = useGlobalSearch();
-  if (!match || !objects) {
-    return objects ?? [];
-  }
-
-  return useMemo(() => filterObjectsSync(objects, match).map((result) => result.object), [objects, match]);
-};

package/src/hooks/useSearchResults.ts

@@ -5,12 +5,13 @@
 import { yieldOrContinue } from 'main-thread-scheduling';
 import { useEffect, useState } from 'react';
 
-import { DataType } from '@dxos/schema';
+import { type Entity } from '@dxos/echo';
+import { Text } from '@dxos/schema';
 
 // TODO(thure): Deprecate search-sync, move still-relevant utilities elsewhere (here, probably).
 import { mapObjectToTextFields, queryStringToMatch } from './sync';
 
-export const filterObjects = async <T extends Record<string, any>>(
+export const filterObjects = async <T extends Entity.Unknown>(
   objects: T[],
   match?: RegExp,
 ): Promise<Map<T, string[][]>> => {
@@ -18,9 +19,10 @@ export const filterObjects = async <T extends Record<string, any>>(
   if (!match) {
     return result;
   }
+
   await Promise.all(
     objects
-      .filter((object) => !(object instanceof DataType.Text))
+      .filter((object) => !(object instanceof Text.Text))
       .map(async (object) => {
         await yieldOrContinue('interactive');
         const fields = mapObjectToTextFields<T>(object);
@@ -34,10 +36,11 @@ export const filterObjects = async <T extends Record<string, any>>(
           });
       }),
   );
+
   return result;
 };
 
-export const useSearchResults = <T extends Record<string, any>>(
+export const useSearchResults = <T extends Entity.Unknown>(
   queryString?: string,
   objects?: T[],
   delay: number = 400,