@dxos/echo-react 0.10.0 → 0.11.0

package/src/usePagination.ts

@@ -0,0 +1,276 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useMemo, useRef, useSyncExternalStore } from 'react';
+
+import { type Database, type Entity, Query } from '@dxos/echo';
+
+const EMPTY_ARRAY: never[] = [];
+
+export type UsePaginationOptions = {
+  /**
+   * Max loaded items before the newest end is evicted (the window's start advances instead of
+   * growing further). Defaults to 10x the query's page size.
+   */
+  maxWindowSize?: number;
+};
+
+export type PaginationResult<T> = {
+  /** Loaded window, in query order (newest first for `Order.natural('desc')`). */
+  items: T[];
+  /** Extends toward older items by one page. Single-flight; no-op while loading or exhausted. */
+  getNext: () => void;
+  /**
+   * Extends back toward the head by one page (the inverse of `getNext`). Single-flight; no-op
+   * while loading or already at the head.
+   */
+  getPrevious: () => void;
+  /** Whether older items remain beyond what is currently loaded. Inferred from the last page's size. */
+  hasMore: boolean;
+  /** True until the current range delivers its first result, even an empty one. */
+  isLoading: boolean;
+  /** False once eviction has detached the window from the live head (i.e. skip > 0). */
+  atHead: boolean;
+  /** Resets to the newest page and resumes live updates. */
+  jumpToHead: () => void;
+};
+
+/** Reactive snapshot handed to React by `useSyncExternalStore`; a fresh object only on real change. */
+type Snapshot<O> = { items: O[]; skip: number; limit: number; isLoading: boolean };
+
+/**
+ * The element type a paginated query yields: the flat record for an aggregate query (branded with
+ * {@link Query.AggregateResult}), otherwise the query's entity type. Mirrors `useQuery`'s overloads.
+ */
+type PaginationElement<Q extends Query.Any> =
+  Query.Type<Q> extends Query.AggregateResult ? Query.Type<Q> : Entity.Entity<Query.Type<Q>>;
+
+/**
+ * Builds the external store backing `usePagination` for one query identity (filter/order/page
+ * size/resource). Mirrors `useQuery`'s own `useMemo`-built `{ getObjects, subscribe }` pair as
+ * closely as the added pagination state allows: nothing is queried and `.results` is never read
+ * until `subscribe()` is called (i.e. from `useSyncExternalStore`'s commit-safe effect, never
+ * during render). `getSnapshot` returns the last *delivered* results (`displayItems`), which are
+ * only replaced once a newly-pointed range actually produces a result -- so the previous page stays
+ * visible (rather than flashing empty) while an async range loads. `QueryResultImpl` still owns
+ * recompute/dedup; we only retain the most recent delivered array.
+ *
+ * `skip`/`limit` live as plain closure state rather than React state: pagination is internal
+ * bookkeeping for *which range this same identity is currently showing*, not a prop the rest of
+ * the component tree needs to read independently. `getNext`/`getPrevious` re-point the query at
+ * a new range by opening a fresh `QueryResult` for it, without discarding the previous one's
+ * results until the new one delivers its own -- that's what keeps the previous page visible while
+ * the new one loads (see the hook's own doc comment for why that matters).
+ */
+const createPaginationStore = <Q extends Query.Any, O>(
+  resource: Database.Queryable | undefined,
+  innerAst: Parameters<typeof Query.fromAst>[0],
+  pageSize: number,
+  initialMaxWindowSize: number,
+  // Seed for the visible page, handed over when a query-identity change rebuilds the store, so the
+  // view refreshes in place instead of flashing empty + loading (see the hook's `previousItemsRef`).
+  initialItems: O[],
+) => {
+  let maxWindowSize = initialMaxWindowSize;
+  let skip = 0;
+  let limit = pageSize;
+  // Single-flight latch coalescing a burst of synchronous `getNext`/`getPrevious` calls (a
+  // virtualizer's `onChange` fires once per rendered row) into one range change.
+  let rangeChangePending = false;
+  let innerUnsubscribe: (() => void) | undefined;
+  // Held across a range change (and seeded across an identity change) until the new range delivers,
+  // so the list never flickers to empty while a new (possibly async) range loads.
+  let displayItems: O[] = initialItems.length > 0 ? initialItems : EMPTY_ARRAY;
+  // Cleared on the range's first delivery, never on a timer, so it can't stick true on an empty feed.
+  // False when seeded: a page is already shown, so this is a background refresh, not a first load.
+  let isLoading = resource !== undefined && displayItems.length === 0;
+  let snapshot: Snapshot<O> = { items: displayItems, skip, limit, isLoading };
+  const listeners = new Set<() => void>();
+
+  const notify = () => {
+    snapshot = { items: displayItems, skip, limit, isLoading };
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+
+  // (Re)points the query at the current skip/limit. `markLoading` is true for a range the user
+  // navigated to (initial load, `getNext`/`getPrevious`, `jumpToHead`); a seeded background refresh
+  // passes false so the previous page stays visible and consumers don't blank on it.
+  //
+  // TODO(wittjosiah): For feeds, this re-fetches/decodes the whole feed on every range change --
+  // only what's rendered is bounded, not what's fetched. Needs index-backed keyset pagination to
+  // fix properly.
+  const pointAtRange = (markLoading: boolean) => {
+    innerUnsubscribe?.();
+    innerUnsubscribe = undefined;
+
+    if (!resource) {
+      displayItems = EMPTY_ARRAY;
+      isLoading = false;
+      notify();
+      return;
+    }
+
+    // `Query.fromAst` necessarily erases the entity type to `Query.Any`; the cast restores it,
+    // which is sound because only `skip`/`limit` were layered on top of the caller's own query's
+    // selection/filter/type -- the entity type this query selects is unchanged from `Q`.
+    const effectiveQuery = Query.fromAst(innerAst).skip(skip).limit(limit) as Q;
+    const nextQueryResult = resource.query(effectiveQuery);
+    if (markLoading) {
+      isLoading = true;
+    }
+
+    // Publish results and clear `isLoading` only on delivery -- deferred for an async source (a feed
+    // served by the index) until its first response, which arrives even when that response is empty.
+    innerUnsubscribe = nextQueryResult.subscribe(
+      () => {
+        displayItems = nextQueryResult.results as O[];
+        isLoading = false;
+        notify();
+      },
+      { fire: true },
+    );
+
+    notify();
+    // The re-entrancy latch only needs to survive one tick, not the query's actual delivery.
+    queueMicrotask(() => {
+      rangeChangePending = false;
+    });
+  };
+
+  return {
+    subscribe: (onStoreChange: () => void) => {
+      listeners.add(onStoreChange);
+      if (listeners.size === 1) {
+        // Seeded (background identity refresh) → don't surface loading; otherwise it's a first load.
+        pointAtRange(displayItems.length === 0);
+      }
+      return () => {
+        listeners.delete(onStoreChange);
+        if (listeners.size === 0) {
+          innerUnsubscribe?.();
+          innerUnsubscribe = undefined;
+        }
+      };
+    },
+    getSnapshot: (): Snapshot<O> => snapshot,
+    setMaxWindowSize: (value: number) => {
+      maxWindowSize = value;
+    },
+    getNext: () => {
+      if (isLoading || rangeChangePending || snapshot.items.length < limit) {
+        return;
+      }
+      rangeChangePending = true;
+      const nextLimit = limit + pageSize;
+      if (nextLimit <= maxWindowSize) {
+        limit = nextLimit;
+      } else {
+        limit = maxWindowSize;
+        skip += pageSize;
+      }
+      pointAtRange(true);
+    },
+    getPrevious: () => {
+      if (isLoading || rangeChangePending || skip === 0) {
+        return;
+      }
+      rangeChangePending = true;
+      // Slides the window toward the head at constant size (limit unchanged) -- decreasing skip
+      // while holding limit fixed both reveals newer items at the front and drops an equal count
+      // of the oldest loaded items, mirroring getNext's own "slide" branch (taken once it hits
+      // maxWindowSize) in the opposite direction.
+      skip = Math.max(0, skip - pageSize);
+      pointAtRange(true);
+    },
+    jumpToHead: () => {
+      rangeChangePending = false;
+      skip = 0;
+      limit = pageSize;
+      pointAtRange(true);
+    },
+  };
+};
+
+/**
+ * Wraps a query with page management for paginated reads. The query's own `.limit(n)` clause is
+ * the page size -- the hook manages which page is loaded by rewriting `skip`/`limit` on top of
+ * it; the query must not carry its own `.skip()`.
+ *
+ * The query's `.orderBy(...)` is otherwise untouched, and applies to any query the underlying
+ * `Database.Queryable` supports -- e.g. `Order.natural('desc')` for feed insertion order.
+ *
+ * Keeps showing the previous page while a new one loads -- across both a `skip`/`limit` move and a
+ * query-identity change (filter/order/page-size/resource). The latter rebuilds the internal store;
+ * the last page is handed to the new store as its seed so the view refreshes in place instead of
+ * flashing empty, and `isLoading` stays put (a background refresh isn't a load the user asked for).
+ *
+ * @example
+ * ```tsx
+ * const { items, getNext, hasMore, isLoading, atHead, jumpToHead } = usePagination(
+ *   db,
+ *   Query.select(Filter.type(Message.Message)).from(feed).orderBy(Order.natural('desc')).limit(50),
+ * );
+ * ```
+ */
+export const usePagination = <Q extends Query.Any>(
+  resource: Database.Queryable | undefined,
+  query: Q,
+  options?: UsePaginationOptions,
+): PaginationResult<PaginationElement<Q>> => {
+  if (query.ast.type !== 'limit') {
+    throw new TypeError('usePagination requires the query to carry .limit(pageSize).');
+  }
+  if (query.ast.query.type === 'skip') {
+    throw new TypeError('usePagination manages .skip() internally -- do not include it in the query.');
+  }
+  const pageSize = query.ast.limit;
+  const innerAst = query.ast.query;
+  const innerAstKey = JSON.stringify(innerAst);
+  const maxWindowSize = options?.maxWindowSize ?? pageSize * 10;
+
+  // The page shown right now, carried across a store rebuild to seed the new store. Written just
+  // after the snapshot below, so the next render's `useMemo` sees the previously-displayed page.
+  const previousItemsRef = useRef<PaginationElement<Q>[]>(EMPTY_ARRAY);
+
+  // A new store is built when "what" is being shown changes: filter/order (`innerAstKey`), page
+  // size, or `resource` (matching `useQuery`, which likewise keys its memo on `resource` directly
+  // rather than just its truthiness). It is seeded from the previous store's page (see above).
+  const store = useMemo(
+    () =>
+      createPaginationStore<Q, PaginationElement<Q>>(
+        resource,
+        innerAst,
+        pageSize,
+        maxWindowSize,
+        previousItemsRef.current,
+      ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [resource, innerAstKey, pageSize],
+  );
+  // `maxWindowSize` deliberately isn't part of the store's `useMemo` deps above (a caller passing
+  // a literal default each render shouldn't reset the window), but a genuine change should still
+  // take effect immediately rather than only on the next unrelated identity change.
+  store.setMaxWindowSize(maxWindowSize);
+
+  const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot);
+  previousItemsRef.current = snapshot.items;
+
+  // Stable across renders that don't change `snapshot` (`store`'s own methods are already stable
+  // per store identity) -- callers can pass this straight through to a memoized child (e.g. a
+  // virtualizer's pagination callbacks) without re-destructuring and re-bundling it themselves.
+  return useMemo(
+    () => ({
+      items: snapshot.items,
+      getNext: store.getNext,
+      getPrevious: store.getPrevious,
+      hasMore: snapshot.items.length >= snapshot.limit,
+      isLoading: snapshot.isLoading,
+      atHead: snapshot.skip === 0,
+      jumpToHead: store.jumpToHead,
+    }),
+    [snapshot, store],
+  );
+};

package/src/useQuery.test.tsx

@@ -0,0 +1,106 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { renderHook, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+
+import { Aggregate, Filter, Obj, Query } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
+import { TestSchema } from '@dxos/echo/testing';
+
+import { useQuery } from './useQuery';
+
+describe('useQuery', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('returns entities for a plain query', async () => {
+    await using peer = await builder.createPeer({ types: [TestSchema.Person] });
+    const db = await peer.createDatabase();
+
+    db.add(Obj.make(TestSchema.Person, { name: 'Alice', username: 'alice', email: 'alice@example.com', tasks: [] }));
+    await db.flush();
+
+    const { result } = renderHook(() => useQuery(db, Query.select(Filter.type(TestSchema.Person))));
+
+    await waitFor(() => {
+      expect(result.current).toHaveLength(1);
+    });
+    expect(result.current[0].name).toBe('Alice');
+  });
+
+  test('returns grouped results for an aggregate query', async () => {
+    await using peer = await builder.createPeer({ types: [TestSchema.Expando] });
+    const db = await peer.createDatabase();
+
+    db.add(Obj.make(TestSchema.Expando, { category: 'a' }));
+    db.add(Obj.make(TestSchema.Expando, { category: 'a' }));
+    db.add(Obj.make(TestSchema.Expando, { category: 'b' }));
+    await db.flush();
+
+    const query = Query.select(Filter.everything()).aggregate({
+      category: Aggregate.group('category'),
+      count: Aggregate.count(),
+      items: Aggregate.items(),
+    });
+    const { result } = renderHook(() => useQuery(db, query));
+
+    await waitFor(() => {
+      expect(result.current).toHaveLength(2);
+    });
+
+    const byKey = new Map(result.current.map((group) => [group.category, group]));
+    expect(byKey.get('a')?.count).toBe(2);
+    expect(byKey.get('a')?.items).toHaveLength(2);
+    expect(byKey.get('b')?.count).toBe(1);
+  });
+
+  test('groups update reactively as objects are added', async () => {
+    await using peer = await builder.createPeer({ types: [TestSchema.Expando] });
+    const db = await peer.createDatabase();
+
+    db.add(Obj.make(TestSchema.Expando, { category: 'a' }));
+    await db.flush();
+
+    const query = Query.select(Filter.everything()).aggregate({ category: Aggregate.group('category') });
+    const { result } = renderHook(() => useQuery(db, query));
+
+    await waitFor(() => {
+      expect(result.current).toHaveLength(1);
+    });
+
+    db.add(Obj.make(TestSchema.Expando, { category: 'b' }));
+    await db.flush({ updates: true });
+
+    await waitFor(() => {
+      expect(result.current).toHaveLength(2);
+    });
+  });
+
+  test('stable snapshot identity when nothing changes', async () => {
+    await using peer = await builder.createPeer({ types: [TestSchema.Expando] });
+    const db = await peer.createDatabase();
+
+    db.add(Obj.make(TestSchema.Expando, { category: 'a' }));
+    await db.flush();
+
+    const query = Query.select(Filter.everything()).aggregate({ category: Aggregate.group('category') });
+    const { result, rerender } = renderHook(() => useQuery(db, query));
+
+    await waitFor(() => {
+      expect(result.current).toHaveLength(1);
+    });
+
+    const first = result.current;
+    rerender();
+    expect(result.current).toBe(first);
+  });
+});

package/src/useQuery.ts

@@ -11,6 +11,10 @@ const EMPTY_ARRAY: never[] = [];
 const noop = () => {};
 
 interface UseQueryFn {
+  // Aggregate queries produce flat records branded with `Query.AggregateResult`; return them as-is,
+  // never wrapped in `Entity.Entity` (they are not entities).
+  <R extends Query.AggregateResult>(resource: Database.Queryable | undefined, query: Query.Query<R>): R[];
+
   <Q extends Query.Any, O extends Entity.Entity<Query.Type<Q>> = Entity.Entity<Query.Type<Q>>>(
     resource: Database.Queryable | undefined,
     query: Q,
@@ -27,10 +31,14 @@ interface UseQueryFn {
  *
  * @param queryOrFilter - The query or filter to apply. Query is memoized based on the AST. No need to call useMemo.
  */
+// The overloaded public signature returns `O[]` (entities) or the flat record `R[]` (aggregate
+// queries) depending on the query shape; the implementation forwards whatever the query result
+// produces, so — as with any implementation of a multi-signature overloaded function type — it is
+// typed as `any[]` here rather than picking one of the mutually-incompatible overload return shapes.
 export const useQuery: UseQueryFn = (
   resource: Database.Queryable | undefined,
   queryOrFilter: Query.Any | Filter.Any,
-): Entity.Any[] => {
+): any[] => {
   const query = Filter.is(queryOrFilter) ? Query.select(queryOrFilter) : queryOrFilter;
 
   const { getObjects, subscribe } = useMemo(() => {
@@ -55,6 +63,6 @@ export const useQuery: UseQueryFn = (
 
   // https://beta.reactjs.org/reference/react/useSyncExternalStore
   // NOTE: This hook will resubscribe whenever the callback passed to the first argument changes; make sure it is stable.
-  const objects = useSyncExternalStore<Entity.Any[]>(subscribe, getObjects);
+  const objects = useSyncExternalStore<any[]>(subscribe, getObjects);
   return objects;
 };

package/dist/lib/neutral/index.mjs

@@ -1,194 +0,0 @@
-// src/useQuery.ts
-import { useMemo, useSyncExternalStore } from "react";
-import { Filter, Query } from "@dxos/echo";
-var EMPTY_ARRAY = [];
-var noop = () => {
-};
-var useQuery = (resource, queryOrFilter) => {
-  const query = Filter.is(queryOrFilter) ? Query.select(queryOrFilter) : queryOrFilter;
-  const { getObjects, subscribe } = useMemo(() => {
-    let queryResult = void 0;
-    if (resource) {
-      queryResult = resource.query(query);
-    }
-    let subscribed = false;
-    return {
-      getObjects: () => subscribed && queryResult ? queryResult.results : EMPTY_ARRAY,
-      subscribe: (cb) => {
-        subscribed = true;
-        const unsubscribe = queryResult?.subscribe(cb) ?? noop;
-        return () => {
-          unsubscribe?.();
-          subscribed = false;
-        };
-      }
-    };
-  }, [
-    resource,
-    JSON.stringify(query.ast)
-  ]);
-  const objects = useSyncExternalStore(subscribe, getObjects);
-  return objects;
-};
-
-// src/useType.ts
-import { useMemo as useMemo2, useSyncExternalStore as useSyncExternalStore2 } from "react";
-import { DXN, EID, Filter as Filter2, Query as Query2, Scope, Type } from "@dxos/echo";
-var useType = (db, typeUri) => {
-  const { subscribe, getType } = useMemo2(() => {
-    if (!typeUri || !db) {
-      return {
-        subscribe: () => () => {
-        },
-        getType: () => void 0
-      };
-    }
-    const searchEid = EID.isEID(typeUri) ? EID.tryParse(typeUri) : void 0;
-    const searchDxn = DXN.isDXN(typeUri) ? DXN.tryMake(typeUri) : void 0;
-    const queryResult = db.query(Query2.select(Filter2.type(Type.Type)).from(Scope.space(), Scope.registry()));
-    let subscribed = false;
-    const find = () => {
-      if (!subscribed) {
-        return void 0;
-      }
-      return queryResult.results.find((type) => {
-        const uri = Type.getURI(type);
-        if (uri === typeUri) {
-          return true;
-        }
-        if (searchEid && EID.isEID(uri)) {
-          const typeEid = EID.tryParse(uri);
-          return typeEid != null && EID.getEntityId(typeEid) === EID.getEntityId(searchEid);
-        }
-        if (searchDxn && DXN.isDXN(uri)) {
-          const typeDxn = DXN.tryMake(uri);
-          return typeDxn != null && DXN.getName(typeDxn) === DXN.getName(searchDxn);
-        }
-        return false;
-      });
-    };
-    return {
-      subscribe: (onStoreChange) => {
-        subscribed = true;
-        const unsubscribe = queryResult.subscribe(onStoreChange);
-        return () => {
-          unsubscribe();
-          subscribed = false;
-        };
-      },
-      getType: find
-    };
-  }, [
-    typeUri,
-    db
-  ]);
-  return useSyncExternalStore2(subscribe, getType);
-};
-
-// src/useObject.ts
-import { useAtomValue } from "@effect-atom/atom-react";
-import * as Atom from "@effect-atom/atom/Atom";
-import { useCallback, useMemo as useMemo3 } from "react";
-import { Obj, Ref } from "@dxos/echo";
-var useObject = (objOrRef, property) => {
-  const isRef = Ref.isRef(objOrRef);
-  const liveObj = isRef ? objOrRef?.target : objOrRef;
-  const callback = useCallback((updateOrValue) => {
-    const obj = isRef ? objOrRef?.target : liveObj;
-    if (obj === void 0) {
-      return;
-    }
-    Obj.update(obj, (obj2) => {
-      if (typeof updateOrValue === "function") {
-        const returnValue = updateOrValue(property !== void 0 ? obj2[property] : obj2);
-        if (returnValue !== void 0) {
-          if (property === void 0) {
-            throw new Error("Cannot re-assign the entire object");
-          }
-          obj2[property] = returnValue;
-        }
-      } else {
-        if (property === void 0) {
-          throw new Error("Cannot re-assign the entire object");
-        }
-        obj2[property] = updateOrValue;
-      }
-    });
-  }, [
-    objOrRef,
-    property,
-    isRef,
-    liveObj
-  ]);
-  if (property !== void 0) {
-    useRefLoad(objOrRef);
-    return [
-      useObjectProperty(liveObj, property),
-      callback
-    ];
-  } else {
-    return [
-      useObjectValue(objOrRef),
-      callback
-    ];
-  }
-};
-var useObjectValue = (objOrRef) => {
-  const atom = useMemo3(() => {
-    if (objOrRef == null) {
-      return Atom.make(() => void 0);
-    }
-    if (Ref.isRef(objOrRef)) {
-      return Obj.atom(objOrRef);
-    }
-    return Obj.atom(objOrRef);
-  }, [
-    objOrRef
-  ]);
-  return useAtomValue(atom);
-};
-var useRefLoad = (objOrRef) => {
-  const atom = useMemo3(() => {
-    if (objOrRef == null || !Ref.isRef(objOrRef)) {
-      return Atom.make(() => void 0);
-    }
-    return objOrRef.atom;
-  }, [
-    objOrRef
-  ]);
-  useAtomValue(atom);
-};
-var useObjectProperty = (obj, property) => {
-  const atom = useMemo3(() => {
-    if (obj == null) {
-      return Atom.make(() => void 0);
-    }
-    return Obj.atomProperty(obj, property);
-  }, [
-    obj,
-    property
-  ]);
-  return useAtomValue(atom);
-};
-var useObjects = (refs) => {
-  const atom = useMemo3(() => Atom.make((get) => {
-    const results = [];
-    for (const ref of refs) {
-      const value = get(Obj.atom(ref));
-      if (value !== void 0) {
-        results.push(value);
-      }
-    }
-    return results;
-  }), [
-    refs
-  ]);
-  return useAtomValue(atom);
-};
-export {
-  useObject,
-  useObjects,
-  useQuery,
-  useType
-};
-//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/useQuery.ts", "../../../src/useType.ts", "../../../src/useObject.ts"],
-  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nimport { useMemo, useSyncExternalStore } from 'react';\n\nimport { type Database, type Entity, Filter, Query } from '@dxos/echo';\n\nconst EMPTY_ARRAY: never[] = [];\n\nconst noop = () => {};\n\ninterface UseQueryFn {\n  <Q extends Query.Any, O extends Entity.Entity<Query.Type<Q>> = Entity.Entity<Query.Type<Q>>>(\n    resource: Database.Queryable | undefined,\n    query: Q,\n  ): O[];\n\n  <F extends Filter.Any, O extends Entity.Entity<Filter.Type<F>> = Entity.Entity<Filter.Type<F>>>(\n    resource: Database.Queryable | undefined,\n    filter: F,\n  ): O[];\n}\n\n/**\n * Create subscription.\n *\n * @param queryOrFilter - The query or filter to apply. Query is memoized based on the AST. No need to call useMemo.\n */\nexport const useQuery: UseQueryFn = (\n  resource: Database.Queryable | undefined,\n  queryOrFilter: Query.Any | Filter.Any,\n): Entity.Any[] => {\n  const query = Filter.is(queryOrFilter) ? Query.select(queryOrFilter) : queryOrFilter;\n\n  const { getObjects, subscribe } = useMemo(() => {\n    let queryResult = undefined;\n    if (resource) {\n      queryResult = resource.query(query);\n    }\n\n    let subscribed = false;\n    return {\n      getObjects: () => (subscribed && queryResult ? queryResult.results : EMPTY_ARRAY),\n      subscribe: (cb: () => void) => {\n        subscribed = true;\n        const unsubscribe = queryResult?.subscribe(cb) ?? noop;\n        return () => {\n          unsubscribe?.();\n          subscribed = false;\n        };\n      },\n    };\n  }, [resource, JSON.stringify(query.ast)]);\n\n  // https://beta.reactjs.org/reference/react/useSyncExternalStore\n  // NOTE: This hook will resubscribe whenever the callback passed to the first argument changes; make sure it is stable.\n  const objects = useSyncExternalStore<Entity.Any[]>(subscribe, getObjects);\n  return objects;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { useMemo, useSyncExternalStore } from 'react';\n\nimport { type Database, DXN, EID, Filter, Query, Scope, Type, URI } from '@dxos/echo';\n\n/**\n * Subscribe to and retrieve a type by its URI from a space: a static schema's typename DXN, or a\n * persisted (database) schema's `echo:` EID (what `Type.getURI` / `getTypeURIFromQuery` produce).\n *\n * Fans across the owning space db (persisted custom types) and the shared\n * registry (static/runtime plugin types). Persisted types live only in the db,\n * so a registry-only lookup misses them.\n *\n * DXN matching is version-agnostic: `dxn:com.example/Foo` matches `dxn:com.example/Foo:0.1.0`.\n * This lets callers pass a bare typename DXN (no version) from e.g. a `ReferenceAnnotation`.\n */\nexport const useType = <T extends Type.AnyEntity = Type.AnyEntity>(\n  db?: Database.Database,\n  typeUri?: URI.URI,\n): T | undefined => {\n  const { subscribe, getType } = useMemo(() => {\n    if (!typeUri || !db) {\n      return {\n        subscribe: () => () => {},\n        getType: (): T | undefined => undefined,\n      };\n    }\n\n    const searchEid = EID.isEID(typeUri) ? EID.tryParse(typeUri) : undefined;\n    const searchDxn = DXN.isDXN(typeUri) ? DXN.tryMake(typeUri) : undefined;\n\n    const queryResult = db.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()));\n    let subscribed = false;\n    const find = (): T | undefined => {\n      if (!subscribed) {\n        return undefined;\n      }\n      return queryResult.results.find((type) => {\n        const uri = Type.getURI(type);\n        if (uri === typeUri) {\n          return true;\n        }\n        // EID matching is space-agnostic: echo:/<id> matches echo://<space>/<id>.\n        if (searchEid && EID.isEID(uri)) {\n          const typeEid = EID.tryParse(uri);\n          return typeEid != null && EID.getEntityId(typeEid) === EID.getEntityId(searchEid);\n        }\n        // DXN matching is version-agnostic so callers may pass an unversioned DXN.\n        if (searchDxn && DXN.isDXN(uri)) {\n          const typeDxn = DXN.tryMake(uri);\n          return typeDxn != null && DXN.getName(typeDxn) === DXN.getName(searchDxn);\n        }\n        return false;\n      }) as T | undefined;\n    };\n\n    return {\n      subscribe: (onStoreChange: () => void) => {\n        subscribed = true;\n        const unsubscribe = queryResult.subscribe(onStoreChange);\n        return () => {\n          unsubscribe();\n          subscribed = false;\n        };\n      },\n      getType: find,\n    };\n  }, [typeUri, db]);\n\n  return useSyncExternalStore(subscribe, getType);\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { useAtomValue } from '@effect-atom/atom-react';\nimport * as Atom from '@effect-atom/atom/Atom';\nimport { useCallback, useMemo } from 'react';\n\nimport { Obj, Ref } from '@dxos/echo';\n\nexport interface ObjectUpdateCallback<T> {\n  (update: (obj: Obj.Mutable<T>) => void): void;\n  (update: (obj: Obj.Mutable<T>) => Obj.Mutable<T>): void;\n}\n\nexport interface ObjectPropUpdateCallback<T> {\n  (update: (value: Obj.Mutable<T>) => void): void;\n  (update: (value: Obj.Mutable<T>) => Obj.Mutable<T>): void;\n  (newValue: T): void;\n}\n\nexport const useObject: {\n  /**\n   * Hook to subscribe to a Ref's target object.\n   * Automatically dereferences the ref and handles async loading.\n   * Returns a snapshot (undefined if the ref hasn't loaded yet).\n   * Re-renders the component when the ref resolves or the target object changes.\n   *\n   * @param ref - The Ref to dereference and subscribe to\n   * @returns The current target snapshot (or undefined if not loaded) and update callback\n   *\n   * @idiom org.dxos.echo-react.useObjectReactive\n   *   applies: Reading a ref's target (or a specific property) inside a React component — establishes a reactive subscription so the component re-renders when the ref resolves or the value changes\n   *   instead-of: `ref.target` — synchronous and not reactive; returns `undefined` when the target isn't loaded yet and never triggers a re-render when it becomes available\n   *   uses: {@link useObject}\n   *   related: org.dxos.echo.objAtomReactive, org.dxos.echo.refLoad\n   */\n  <T extends Obj.Unknown>(ref: Ref.Ref<T>): [Obj.Snapshot<T> | undefined, ObjectUpdateCallback<T>];\n\n  /**\n   * Hook to subscribe to a Ref's target object that may be undefined.\n   * Returns a snapshot (undefined if the ref is undefined or hasn't loaded yet).\n   *\n   * @param ref - The Ref to dereference and subscribe to (can be undefined)\n   * @returns The current target snapshot (or undefined) and update callback\n   */\n  <T extends Obj.Unknown>(ref: Ref.Ref<T> | undefined): [Obj.Snapshot<T> | undefined, ObjectUpdateCallback<T>];\n\n  /**\n   * Hook to subscribe to an entire Echo object.\n   * Returns a snapshot of the current object value and automatically re-renders when the object changes.\n   *\n   * @param obj - The Echo object to subscribe to (objects only, not relations)\n   * @returns The current object snapshot and update callback\n   */\n  <T extends Obj.Unknown>(obj: T): [Obj.Snapshot<T>, ObjectUpdateCallback<T>];\n\n  /**\n   * Hook to subscribe to an entire Echo object that may be undefined.\n   * Returns a snapshot (undefined if the object is undefined).\n   *\n   * @param obj - The Echo object to subscribe to (can be undefined, objects only)\n   * @returns The current object snapshot (or undefined) and update callback\n   */\n  <T extends Obj.Unknown>(obj: T | undefined): [Obj.Snapshot<T> | undefined, ObjectUpdateCallback<T>];\n\n  /**\n   * Hook to subscribe to an Echo object or Ref.\n   * Handles both cases - if passed a Ref, dereferences it and subscribes to the target.\n   * Returns a snapshot (undefined if ref hasn't loaded).\n   *\n   * @param objOrRef - The Echo object or Ref to subscribe to\n   * @returns The current object snapshot (or undefined) and update callback\n   */\n  <T extends Obj.Unknown>(objOrRef: T | Ref.Ref<T> | undefined): [Obj.Snapshot<T> | undefined, ObjectUpdateCallback<T>];\n\n  /**\n   * Hook to subscribe to a specific property of an Echo object.\n   * Returns the current property value and automatically re-renders when the property changes.\n   *\n   * @param obj - The Echo object to subscribe to (objects only, not relations)\n   * @param property - Property key to subscribe to\n   * @returns The current property value and update callback\n   */\n  <T extends Obj.Unknown, K extends keyof T>(obj: T, property: K): [T[K], ObjectPropUpdateCallback<T[K]>];\n\n  /**\n   * Hook to subscribe to a specific property of an Echo object that may be undefined.\n   * Returns undefined if the object is undefined.\n   *\n   * @param obj - The Echo object to subscribe to (can be undefined, objects only)\n   * @param property - Property key to subscribe to\n   * @returns The current property value (or undefined) and update callback\n   */\n  <T extends Obj.Unknown, K extends keyof T>(\n    obj: T | undefined,\n    property: K,\n  ): [T[K] | undefined, ObjectPropUpdateCallback<T[K]>];\n\n  /**\n   * Hook to subscribe to a specific property of a Ref's target object.\n   * Automatically dereferences the ref and handles async loading.\n   * Returns undefined if the ref hasn't loaded yet.\n   *\n   * @param ref - The Ref to dereference and subscribe to\n   * @param property - Property key to subscribe to\n   * @returns The current property value (or undefined if not loaded) and update callback\n   */\n  <T, K extends keyof T>(ref: Ref.Ref<T>, property: K): [T[K] | undefined, ObjectPropUpdateCallback<T[K]>];\n\n  /**\n   * Hook to subscribe to a specific property of a Ref's target object that may be undefined.\n   * Returns undefined if the ref is undefined or hasn't loaded yet.\n   *\n   * @param ref - The Ref to dereference and subscribe to (can be undefined)\n   * @param property - Property key to subscribe to\n   * @returns The current property value (or undefined) and update callback\n   */\n  <T, K extends keyof T>(ref: Ref.Ref<T> | undefined, property: K): [T[K] | undefined, ObjectPropUpdateCallback<T[K]>];\n} = (<T extends Obj.Unknown, K extends keyof T>(objOrRef: T | Ref.Ref<T> | undefined, property?: K): any => {\n  // Get the live object for the callback (refs need to dereference).\n  const isRef = Ref.isRef(objOrRef);\n  const liveObj = isRef ? (objOrRef as Ref.Ref<T>)?.target : (objOrRef as T | undefined);\n\n  const callback: ObjectPropUpdateCallback<unknown> = useCallback(\n    (updateOrValue: unknown | ((obj: unknown) => unknown)) => {\n      // Get current target for refs (may have loaded since render).\n      const obj = isRef ? (objOrRef as Ref.Ref<T>)?.target : liveObj;\n      if (obj === undefined) {\n        return;\n      }\n      Obj.update(obj, (obj: any) => {\n        if (typeof updateOrValue === 'function') {\n          const returnValue = updateOrValue(property !== undefined ? obj[property] : obj);\n          if (returnValue !== undefined) {\n            if (property === undefined) {\n              throw new Error('Cannot re-assign the entire object');\n            }\n            obj[property] = returnValue;\n          }\n        } else {\n          if (property === undefined) {\n            throw new Error('Cannot re-assign the entire object');\n          }\n          obj[property] = updateOrValue;\n        }\n      });\n    },\n    [objOrRef, property, isRef, liveObj],\n  );\n\n  if (property !== undefined) {\n    // For refs, subscribe to load event only (not full mutation tracking).\n    // Property-level updates are handled by useObjectProperty once the ref loads.\n    useRefLoad(objOrRef);\n    return [useObjectProperty(liveObj, property as any), callback];\n  } else {\n    return [useObjectValue(objOrRef), callback];\n  }\n}) as any;\n\n/**\n * Internal hook for subscribing to an Echo object or Ref.\n */\nconst useObjectValue = <T extends Obj.Unknown>(objOrRef: T | Ref.Ref<T> | undefined): Obj.Snapshot<T> | undefined => {\n  const atom = useMemo(() => {\n    if (objOrRef == null) {\n      return Atom.make<Obj.Snapshot<T> | undefined>(() => undefined);\n    }\n    if (Ref.isRef(objOrRef)) {\n      return Obj.atom(objOrRef);\n    }\n    return Obj.atom(objOrRef);\n  }, [objOrRef]);\n  return useAtomValue(atom) as Obj.Snapshot<T> | undefined;\n};\n\n/**\n * Internal hook for subscribing to ref resolution only (load-once).\n * Triggers a re-render when the ref target first becomes available,\n * without subscribing to subsequent target mutations.\n * For non-refs, this is a no-op.\n */\nconst useRefLoad = <T extends Obj.Unknown>(objOrRef: T | Ref.Ref<T> | undefined): void => {\n  const atom = useMemo(() => {\n    if (objOrRef == null || !Ref.isRef(objOrRef)) {\n      return Atom.make<T | undefined>(() => undefined);\n    }\n    return objOrRef.atom;\n  }, [objOrRef]);\n  useAtomValue(atom);\n};\n\n/**\n * Internal hook for subscribing to a specific property of an Echo object.\n */\nconst useObjectProperty = <T extends Obj.Unknown, K extends keyof T>(\n  obj: T | undefined,\n  property: K,\n): T[K] | undefined => {\n  const atom = useMemo(() => {\n    if (obj == null) {\n      return Atom.make<T[K] | undefined>(() => undefined);\n    }\n    return Obj.atomProperty(obj, property);\n  }, [obj, property]);\n  return useAtomValue(atom);\n};\n\n/**\n * Hook to subscribe to multiple Refs' target objects.\n * Automatically dereferences each ref and handles async loading.\n * Returns an array of loaded snapshots (filtering out undefined values).\n *\n * This hook is useful for aggregate computations like counts or filtering\n * across multiple refs without using .target directly.\n *\n * @deprecated Subscribes the component to the whole list, re-rendering on any element's change. Prefer pushing\n * the subscription down — derive the aggregate in an atom (reading each `Obj.atom(ref)`) and read it where it is\n * needed, or subscribe to the individual ref/property closest to the consumer — to keep subscriptions granular.\n *\n * @param refs - Array of Refs to dereference and subscribe to\n * @returns Array of loaded target snapshots (excludes unloaded refs)\n */\nexport const useObjects = <T extends Obj.Unknown>(refs: readonly Ref.Ref<T>[]): Obj.Snapshot<T>[] => {\n  const atom = useMemo(\n    () =>\n      Atom.make((get) => {\n        const results: Obj.Snapshot<T>[] = [];\n        for (const ref of refs) {\n          const value = get(Obj.atom(ref));\n          if (value !== undefined) {\n            results.push(value as Obj.Snapshot<T>);\n          }\n        }\n        return results;\n      }),\n    [refs],\n  );\n  return useAtomValue(atom);\n};\n"],
-  "mappings": "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",
-  "names": ["useMemo", "useSyncExternalStore", "Filter", "Query", "EMPTY_ARRAY", "noop", "useQuery", "resource", "queryOrFilter", "query", "is", "select", "getObjects", "subscribe", "queryResult", "undefined", "subscribed", "results", "cb", "unsubscribe", "JSON", "stringify", "ast", "objects", "useMemo", "useSyncExternalStore", "DXN", "EID", "Filter", "Query", "Scope", "Type", "useType", "db", "typeUri", "subscribe", "getType", "undefined", "searchEid", "isEID", "tryParse", "searchDxn", "isDXN", "tryMake", "queryResult", "query", "select", "type", "from", "space", "registry", "subscribed", "find", "results", "uri", "getURI", "typeEid", "getEntityId", "typeDxn", "getName", "onStoreChange", "unsubscribe", "useAtomValue", "Atom", "useCallback", "useMemo", "Obj", "Ref", "useObject", "objOrRef", "property", "isRef", "liveObj", "target", "callback", "updateOrValue", "obj", "undefined", "update", "returnValue", "Error", "useRefLoad", "useObjectProperty", "useObjectValue", "atom", "make", "atomProperty", "useObjects", "refs", "get", "results", "ref", "value", "push"]
-}

package/dist/lib/neutral/meta.json

@@ -1 +0,0 @@
-{"inputs":{"src/useQuery.ts":{"bytes":5393,"imports":[{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true}],"format":"esm"},"src/useType.ts":{"bytes":8807,"imports":[{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true}],"format":"esm"},"src/useObject.ts":{"bytes":21031,"imports":[{"path":"@effect-atom/atom-react","kind":"import-statement","external":true},{"path":"@effect-atom/atom/Atom","kind":"import-statement","external":true},{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":552,"imports":[{"path":"src/useQuery.ts","kind":"import-statement","original":"./useQuery"},{"path":"src/useType.ts","kind":"import-statement","original":"./useType"},{"path":"src/useObject.ts","kind":"import-statement","original":"./useObject"}],"format":"esm"}},"outputs":{"dist/lib/neutral/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":19633},"dist/lib/neutral/index.mjs":{"imports":[{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@effect-atom/atom-react","kind":"import-statement","external":true},{"path":"@effect-atom/atom/Atom","kind":"import-statement","external":true},{"path":"react","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true}],"exports":["useObject","useObjects","useQuery","useType"],"entryPoint":"src/index.ts","inputs":{"src/useQuery.ts":{"bytesInOutput":921},"src/index.ts":{"bytesInOutput":0},"src/useType.ts":{"bytesInOutput":1686},"src/useObject.ts":{"bytesInOutput":2437}},"bytes":5199}}}