@rpcbase/client 0.340.0 → 0.342.0

package/dist/useQuery-C2L-Rgat.js

@@ -0,0 +1,788 @@
+import { useId, useState, useRef, useEffect, useMemo } from "react";
+const UNDERSCORE_PREFIX = "$_";
+const DEFAULT_FIND_LIMIT = 4096;
+let storeConfig = null;
+let pouchDbPromise = null;
+let lastAppliedPrefix = null;
+const collections = /* @__PURE__ */ new Map();
+const dbNamesByPrefix = /* @__PURE__ */ new Map();
+const unwrapDefault = (mod) => {
+  if (!mod || typeof mod !== "object") return mod;
+  const maybe = mod;
+  return maybe.default ?? mod;
+};
+const ensureBrowser$1 = () => {
+  if (typeof window === "undefined") {
+    throw new Error("RTS PouchDB store can only be used in the browser");
+  }
+};
+const computeBasePrefix = ({ tenantId, appName }) => {
+  let prefix = "rb/";
+  if (appName) prefix += `${appName}/`;
+  prefix += `${tenantId}/`;
+  return prefix;
+};
+const getDbNamesKey = (prefix) => `rb:rts:pouchDbs:${prefix}`;
+const getPrefixOverrideKey = ({ tenantId, appName }) => `rb:rts:pouchPrefix:${appName ?? ""}:${tenantId}`;
+const readPrefixOverride = ({ tenantId, appName }) => {
+  try {
+    const value = window.localStorage.getItem(getPrefixOverrideKey({ tenantId, appName }));
+    if (!value) return null;
+    if (!value.endsWith("/")) return `${value}/`;
+    return value;
+  } catch {
+    return null;
+  }
+};
+const getPrefix = () => {
+  if (!storeConfig) {
+    throw new Error("RTS PouchDB store is not configured");
+  }
+  if (storeConfig.prefix) return storeConfig.prefix;
+  const basePrefix = computeBasePrefix({ tenantId: storeConfig.tenantId, appName: storeConfig.appName });
+  const override = readPrefixOverride({ tenantId: storeConfig.tenantId, appName: storeConfig.appName });
+  return override ?? basePrefix;
+};
+const loadDbNames = (prefix) => {
+  const existing = dbNamesByPrefix.get(prefix);
+  if (existing) return existing;
+  const names = /* @__PURE__ */ new Set();
+  try {
+    const raw = window.localStorage.getItem(getDbNamesKey(prefix));
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        for (const value of parsed) {
+          if (typeof value === "string" && value) names.add(value);
+        }
+      }
+    }
+  } catch {
+    return names;
+  }
+  dbNamesByPrefix.set(prefix, names);
+  return names;
+};
+const persistDbNames = (prefix, names) => {
+  try {
+    if (!names.size) {
+      window.localStorage.removeItem(getDbNamesKey(prefix));
+      dbNamesByPrefix.delete(prefix);
+      return;
+    }
+    window.localStorage.setItem(getDbNamesKey(prefix), JSON.stringify(Array.from(names)));
+    dbNamesByPrefix.set(prefix, names);
+  } catch {
+    return;
+  }
+};
+const registerDbName = (prefix, dbName) => {
+  if (!prefix || !dbName) return;
+  const names = loadDbNames(prefix);
+  if (names.has(dbName)) return;
+  names.add(dbName);
+  persistDbNames(prefix, names);
+};
+const unregisterDbName = (prefix, dbName) => {
+  if (!prefix || !dbName) return;
+  const names = loadDbNames(prefix);
+  if (!names.delete(dbName)) return;
+  persistDbNames(prefix, names);
+};
+const getPouchDb = async () => {
+  ensureBrowser$1();
+  if (!pouchDbPromise) {
+    pouchDbPromise = (async () => {
+      const [core, indexedDbAdapter, findPlugin] = await Promise.all([
+        import("pouchdb-core"),
+        import("pouchdb-adapter-indexeddb"),
+        import("pouchdb-find")
+      ]);
+      const PouchDB = unwrapDefault(core);
+      PouchDB.plugin(unwrapDefault(indexedDbAdapter));
+      PouchDB.plugin(unwrapDefault(findPlugin));
+      return PouchDB;
+    })();
+  }
+  return pouchDbPromise;
+};
+const applyPrefix = (PouchDB) => {
+  const prefix = getPrefix();
+  if (prefix === lastAppliedPrefix) return;
+  PouchDB.prefix = prefix;
+  lastAppliedPrefix = prefix;
+};
+const configureRtsPouchStore = (config) => {
+  storeConfig = config;
+  lastAppliedPrefix = null;
+  collections.clear();
+};
+const getCollection = async (modelName, options) => {
+  const PouchDB = await getPouchDb();
+  applyPrefix(PouchDB);
+  const prefix = getPrefix();
+  const dbName = `${options.uid}/${modelName}`;
+  const dbKey = `${prefix}${dbName}`;
+  const existing = collections.get(dbKey);
+  if (existing) return existing;
+  registerDbName(prefix, dbName);
+  const db = new PouchDB(dbName, { adapter: "indexeddb", revs_limit: 1 });
+  collections.set(dbKey, db);
+  return db;
+};
+const replaceQueryKeys = (value, replaceKey) => {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => replaceQueryKeys(item, replaceKey));
+  }
+  const obj = value;
+  const next = Object.create(Object.getPrototypeOf(obj));
+  for (const key of Object.keys(obj)) {
+    if (/^\$/.test(key) || /\.\d+$/.test(key)) {
+      throw new Error(`replaceQueryKeys: Unexpected key format: ${key}`);
+    }
+    const newKey = replaceKey(key);
+    next[newKey] = replaceQueryKeys(obj[key], replaceKey);
+  }
+  return next;
+};
+const getKeys = (obj, parentKey = "") => {
+  const keys = [];
+  for (const key of Object.keys(obj)) {
+    const nextKey = parentKey ? `${parentKey}.${key}` : key;
+    const value = obj[key];
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      keys.push(...getKeys(value, nextKey));
+    } else {
+      keys.push(nextKey);
+    }
+  }
+  return keys;
+};
+const satisfiesProjection = (doc, projection) => {
+  const docKeys = new Set(getKeys(doc));
+  const projectionKeys = new Set(Object.keys(projection).filter((key) => projection[key] === 1));
+  if (!projectionKeys.has("_id")) {
+    docKeys.delete("_id");
+  }
+  if (projectionKeys.size > docKeys.size) return false;
+  for (const key of projectionKeys) {
+    if (!docKeys.has(key)) return false;
+  }
+  return true;
+};
+const remapDocFromStorage = (doc) => {
+  const next = {};
+  for (const [key, value] of Object.entries(doc)) {
+    const newKey = key.startsWith(UNDERSCORE_PREFIX) ? key.replace(/^\$_/, "") : key;
+    next[newKey] = value;
+  }
+  return next;
+};
+const runQuery = async ({
+  modelName,
+  query = {},
+  options
+}) => {
+  const collection = await getCollection(modelName, { uid: options.uid });
+  const replacedQuery = replaceQueryKeys(
+    query,
+    (key) => key.startsWith("_") && key !== "_id" ? `${UNDERSCORE_PREFIX}${key}` : key
+  );
+  const limit = typeof options.limit === "number" ? Math.abs(options.limit) : DEFAULT_FIND_LIMIT;
+  const { docs } = await collection.find({
+    selector: replacedQuery,
+    limit
+  });
+  let mappedDocs = docs.map(({ _rev: _revIgnored, ...rest }) => remapDocFromStorage(rest));
+  if (options.projection) {
+    mappedDocs = mappedDocs.filter((doc) => satisfiesProjection(doc, options.projection));
+  }
+  if (options.sort) {
+    mappedDocs = mappedDocs.sort((a, b) => {
+      for (const key of Object.keys(options.sort)) {
+        if (!Object.hasOwn(a, key) || !Object.hasOwn(b, key)) continue;
+        const dir = options.sort[key];
+        const aVal = a[key];
+        const bVal = b[key];
+        if (typeof aVal === "number" && typeof bVal === "number") {
+          if (aVal < bVal) return -1 * dir;
+          if (aVal > bVal) return 1 * dir;
+          continue;
+        }
+        if (typeof aVal === "string" && typeof bVal === "string") {
+          if (aVal < bVal) return -1 * dir;
+          if (aVal > bVal) return 1 * dir;
+          continue;
+        }
+      }
+      return 0;
+    });
+  }
+  return { data: mappedDocs, context: { source: "cache" } };
+};
+const updateDocs = async (modelName, data, uid) => {
+  const collection = await getCollection(modelName, { uid });
+  const allIds = data.map((doc) => doc._id).filter(Boolean);
+  if (!allIds.length) return;
+  const { docs: currentDocs } = await collection.find({
+    selector: { _id: { $in: allIds } },
+    fields: ["_id", "_rev"],
+    limit: allIds.length
+  });
+  const currentDocsById = currentDocs.reduce((acc, doc) => {
+    const id = String(doc._id ?? "");
+    if (id) acc[id] = doc;
+    return acc;
+  }, {});
+  const newDocs = data.map((mongoDoc) => {
+    const currentDoc = currentDocsById[mongoDoc._id] ?? { _id: mongoDoc._id };
+    const nextDoc = Object.entries(mongoDoc).reduce((acc, [key, value]) => {
+      const newKey = key !== "_id" && key.startsWith("_") ? `${UNDERSCORE_PREFIX}${key}` : key;
+      acc[newKey] = value;
+      return acc;
+    }, { ...currentDoc });
+    const rev = currentDoc._rev;
+    if (typeof rev === "string" && rev) {
+      nextDoc._rev = rev;
+    } else {
+      delete nextDoc._rev;
+    }
+    return nextDoc;
+  });
+  await collection.bulkDocs(newDocs);
+};
+const deleteDocs = async (modelName, ids, uid) => {
+  const collection = await getCollection(modelName, { uid });
+  const allIds = ids.map((id) => String(id ?? "")).filter(Boolean);
+  if (!allIds.length) return;
+  const { docs: currentDocs } = await collection.find({
+    selector: { _id: { $in: allIds } },
+    fields: ["_id", "_rev"],
+    limit: allIds.length
+  });
+  const deletions = currentDocs.map((doc) => ({
+    _id: String(doc?._id ?? ""),
+    _rev: doc?._rev,
+    _deleted: true
+  })).filter((doc) => doc._id && typeof doc._rev === "string" && doc._rev);
+  if (!deletions.length) return;
+  await collection.bulkDocs(deletions);
+};
+const destroyCollection = async (modelName, uid) => {
+  const collection = await getCollection(modelName, { uid });
+  const prefix = getPrefix();
+  const dbName = `${uid}/${modelName}`;
+  collections.delete(`${prefix}${dbName}`);
+  unregisterDbName(prefix, dbName);
+  await collection.destroy();
+};
+const resetRtsPouchStore = ({ tenantId, appName }) => {
+  ensureBrowser$1();
+  const basePrefix = computeBasePrefix({ tenantId, appName });
+  const oldPrefix = readPrefixOverride({ tenantId, appName }) ?? basePrefix;
+  const dbNames = Array.from(loadDbNames(oldPrefix));
+  const openDbs = Array.from(collections.entries()).filter(([key]) => key.startsWith(oldPrefix)).map(([, db]) => db);
+  void (async () => {
+    const remaining = new Set(dbNames);
+    await Promise.all(openDbs.map((db) => db.destroy().catch(() => {
+    })));
+    if (remaining.size) {
+      const PouchDB = await getPouchDb();
+      const PouchDBForPrefix = PouchDB.defaults?.({}) ?? PouchDB;
+      PouchDBForPrefix.prefix = oldPrefix;
+      await Promise.all(Array.from(remaining).map(async (name) => {
+        const db = new PouchDBForPrefix(name, { adapter: "indexeddb", revs_limit: 1 });
+        await db.destroy().then(() => {
+          remaining.delete(name);
+        }).catch(() => {
+        });
+      }));
+    }
+    if (remaining.size) {
+      persistDbNames(oldPrefix, remaining);
+    } else {
+      persistDbNames(oldPrefix, /* @__PURE__ */ new Set());
+    }
+  })();
+  const newPrefix = `${basePrefix}reset-${Date.now().toString(16)}/`;
+  try {
+    window.localStorage.setItem(getPrefixOverrideKey({ tenantId, appName }), newPrefix);
+  } catch {
+    return newPrefix;
+  }
+  lastAppliedPrefix = null;
+  collections.clear();
+  return newPrefix;
+};
+const destroyAllCollections = async () => {
+  const dbs = Array.from(collections.values());
+  await Promise.all(dbs.map((db) => db.destroy()));
+  collections.clear();
+};
+const TENANT_ID_QUERY_PARAM = "rb-tenant-id";
+const RTS_CHANGES_ROUTE = "/api/rb/rts/changes";
+const MAX_TXN_BUF = 2048;
+let socket = null;
+let connectPromise = null;
+let explicitDisconnect = false;
+let currentTenantId = null;
+let currentUid = null;
+let connectOptions = {};
+const localTxnBuf = [];
+const queryCallbacks = /* @__PURE__ */ new Map();
+const subscriptions = /* @__PURE__ */ new Map();
+const messageCallbacks = /* @__PURE__ */ new Map();
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+let syncPromise = null;
+let syncKey = null;
+const ensureBrowser = () => {
+  if (typeof window === "undefined") {
+    throw new Error("RTS websocket client can only be used in the browser");
+  }
+};
+const buildSocketUrl = (tenantId, _uid, options) => {
+  if (options.url) {
+    const url = new URL(options.url);
+    url.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
+    return url.toString();
+  }
+  const base = new URL(window.location.href);
+  base.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+  base.pathname = options.path ?? "/rts";
+  base.search = "";
+  base.hash = "";
+  base.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
+  return base.toString();
+};
+const computeQueryKey = (query, options) => {
+  const key = options.key ?? "";
+  const projection = options.projection ? JSON.stringify(options.projection) : "";
+  const sort = options.sort ? JSON.stringify(options.sort) : "";
+  const limit = typeof options.limit === "number" ? String(options.limit) : "";
+  return `${key}${JSON.stringify(query)}${projection}${sort}${limit}`;
+};
+const sendToServer = (message) => {
+  if (!socket) return;
+  if (socket.readyState !== WebSocket.OPEN) return;
+  socket.send(JSON.stringify(message));
+};
+const resubscribeAll = () => {
+  for (const sub of subscriptions.values()) {
+    sendToServer({
+      type: "register-query",
+      modelName: sub.modelName,
+      queryKey: sub.queryKey,
+      query: sub.query,
+      options: sub.options
+    });
+    sendToServer({
+      type: "run-query",
+      modelName: sub.modelName,
+      queryKey: sub.queryKey,
+      query: sub.query,
+      options: sub.options
+    });
+  }
+};
+const clearReconnectTimer = () => {
+  if (reconnectTimer === null) return;
+  if (typeof window !== "undefined") {
+    window.clearTimeout(reconnectTimer);
+  }
+  reconnectTimer = null;
+};
+const scheduleReconnect = () => {
+  clearReconnectTimer();
+  if (explicitDisconnect) return;
+  if (!currentTenantId || !currentUid) return;
+  const cfg = connectOptions.reconnect ?? {};
+  const maxAttempts = cfg.attempts ?? 128;
+  const delayMs = cfg.delayMs ?? 400;
+  const delayMaxMs = cfg.delayMaxMs ?? 1e4;
+  if (reconnectAttempts >= maxAttempts) return;
+  const delay = Math.min(delayMaxMs, delayMs * Math.pow(2, reconnectAttempts));
+  reconnectAttempts += 1;
+  reconnectTimer = window.setTimeout(() => {
+    void connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+  }, delay);
+};
+const handleQueryPayload = (payload) => {
+  const { modelName, queryKey, data, error, txnId } = payload;
+  const cbKey = `${modelName}.${queryKey}`;
+  const callbacks = queryCallbacks.get(cbKey);
+  if (!callbacks || !callbacks.size) return;
+  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
+  const context = { source: "network", isLocal, txnId };
+  if (error) {
+    for (const cb of callbacks) cb(error, void 0, context);
+    return;
+  }
+  for (const cb of callbacks) cb(null, data, context);
+  if (!currentUid) return;
+  const docs = Array.isArray(data) ? data.filter((doc) => {
+    if (!doc || typeof doc !== "object") return false;
+    return typeof doc._id === "string";
+  }) : [];
+  if (!docs.length) return;
+  void updateDocs(modelName, docs, currentUid).catch(() => {
+  });
+};
+const handleEvent = (payload) => {
+  const callbacks = messageCallbacks.get(payload.event);
+  if (!callbacks || !callbacks.size) return;
+  for (const cb of callbacks) cb(payload.payload);
+};
+const handleMessage = (event) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(typeof event.data === "string" ? event.data : String(event.data));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object") return;
+  const message = parsed;
+  if (message.type === "query-payload") {
+    handleQueryPayload(message);
+    return;
+  }
+  if (message.type === "event") {
+    handleEvent(message);
+  }
+};
+const addLocalTxn = (txnId) => {
+  if (!txnId) return;
+  localTxnBuf.push(txnId);
+  if (localTxnBuf.length > MAX_TXN_BUF) {
+    localTxnBuf.shift();
+  }
+};
+const getSyncStorageKey = ({ tenantId, uid, appName }) => `rb:rts:changesSeq:${appName ?? ""}:${tenantId}:${uid}`;
+const readStoredSeq = (key) => {
+  try {
+    const raw = window.localStorage.getItem(key);
+    const num = raw ? Number(raw) : 0;
+    return Number.isFinite(num) && num >= 0 ? Math.floor(num) : 0;
+  } catch {
+    return 0;
+  }
+};
+const writeStoredSeq = (key, value) => {
+  try {
+    window.localStorage.setItem(key, String(Math.max(0, Math.floor(value))));
+  } catch {
+    return;
+  }
+};
+const applyChangeBatch = async (changes, uid) => {
+  const resetModels = /* @__PURE__ */ new Set();
+  const deletesByModel = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const modelName = typeof change.modelName === "string" ? change.modelName : "";
+    if (!modelName) continue;
+    if (change.op === "reset_model") {
+      resetModels.add(modelName);
+      continue;
+    }
+    if (change.op === "delete") {
+      const docId = typeof change.docId === "string" ? change.docId : "";
+      if (!docId) continue;
+      const existing = deletesByModel.get(modelName) ?? [];
+      existing.push(docId);
+      deletesByModel.set(modelName, existing);
+    }
+  }
+  for (const modelName of resetModels) {
+    await destroyCollection(modelName, uid).catch(() => {
+    });
+  }
+  for (const [modelName, ids] of deletesByModel.entries()) {
+    if (resetModels.has(modelName)) continue;
+    await deleteDocs(modelName, ids, uid).catch(() => {
+    });
+  }
+};
+const syncRtsChanges = async (tenantId, uid, options = {}) => {
+  ensureBrowser();
+  if (!tenantId || !uid) return;
+  const storageKey = getSyncStorageKey({ tenantId, uid, appName: options.appName });
+  let sinceSeq = readStoredSeq(storageKey);
+  for (let i = 0; i < 32; i += 1) {
+    const url = `${RTS_CHANGES_ROUTE}?${TENANT_ID_QUERY_PARAM}=${encodeURIComponent(tenantId)}`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sinceSeq, limit: 2e3 })
+    });
+    if (!response.ok) return;
+    const payload = await response.json().catch(() => null);
+    if (!payload || typeof payload !== "object") return;
+    const ok = payload.ok;
+    if (ok !== true) return;
+    const latestSeq = Number(payload.latestSeq ?? 0);
+    const needsFullResync = Boolean(payload.needsFullResync);
+    if (needsFullResync) {
+      resetRtsPouchStore({ tenantId, appName: options.appName });
+      writeStoredSeq(storageKey, latestSeq);
+      return;
+    }
+    const changesRaw = payload.changes;
+    const changes = Array.isArray(changesRaw) ? changesRaw : [];
+    const normalized = changes.map((c) => {
+      if (!c || typeof c !== "object") return null;
+      const obj = c;
+      const seq = Number(obj.seq ?? 0);
+      const modelName = typeof obj.modelName === "string" ? obj.modelName : String(obj.modelName ?? "");
+      const op = obj.op === "reset_model" ? "reset_model" : "delete";
+      const docId = typeof obj.docId === "string" && obj.docId ? obj.docId : obj.docId ? String(obj.docId) : void 0;
+      return { seq, modelName, op, ...docId ? { docId } : {} };
+    }).filter((c) => c !== null).filter(
+      (c) => Number.isFinite(c.seq) && c.seq > 0 && c.modelName && (c.op === "reset_model" || !!c.docId)
+    );
+    if (!normalized.length) {
+      writeStoredSeq(storageKey, latestSeq);
+      return;
+    }
+    await applyChangeBatch(normalized, uid);
+    const lastSeq = normalized.reduce((max, c) => c.seq > max ? c.seq : max, sinceSeq);
+    sinceSeq = lastSeq;
+    writeStoredSeq(storageKey, sinceSeq);
+    if (latestSeq > 0 && sinceSeq >= latestSeq) {
+      return;
+    }
+  }
+};
+const ensureSynced = (tenantId, uid, options) => {
+  if (options.syncChanges === false) return;
+  const key = `${options.appName ?? ""}:${tenantId}:${uid}`;
+  if (syncPromise && syncKey === key) return;
+  syncKey = key;
+  syncPromise = syncRtsChanges(tenantId, uid, { appName: options.appName }).catch(() => {
+  }).finally(() => {
+    if (syncKey === key) {
+      syncPromise = null;
+    }
+  });
+};
+const connectInternal = (tenantId, uid, options, { resetReconnectAttempts }) => {
+  ensureBrowser();
+  if (!tenantId) return Promise.resolve();
+  if (!uid) throw new Error("Missing uid");
+  currentTenantId = tenantId;
+  currentUid = uid;
+  connectOptions = options;
+  if (options.configureStore !== false) {
+    configureRtsPouchStore({ tenantId, appName: options.appName });
+  }
+  ensureSynced(tenantId, uid, options);
+  if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
+    return connectPromise ?? Promise.resolve();
+  }
+  explicitDisconnect = false;
+  clearReconnectTimer();
+  const url = buildSocketUrl(tenantId, uid, options);
+  connectPromise = new Promise((resolve, reject) => {
+    if (resetReconnectAttempts) reconnectAttempts = 0;
+    let opened = false;
+    let settled = false;
+    socket = new WebSocket(url);
+    socket.addEventListener("open", () => {
+      opened = true;
+      settled = true;
+      reconnectAttempts = 0;
+      resubscribeAll();
+      resolve();
+    });
+    socket.addEventListener("message", handleMessage);
+    socket.addEventListener("close", (event) => {
+      if (!opened && !settled) {
+        settled = true;
+        reject(new Error(`RTS WebSocket closed before opening (code=${event.code})`));
+      }
+      socket = null;
+      connectPromise = null;
+      scheduleReconnect();
+    });
+    socket.addEventListener("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err instanceof Error ? err : new Error("RTS WebSocket error"));
+    });
+  });
+  return connectPromise;
+};
+const connect = (tenantId, uid, options = {}) => {
+  return connectInternal(tenantId, uid, options, { resetReconnectAttempts: true });
+};
+const disconnect = () => {
+  explicitDisconnect = true;
+  clearReconnectTimer();
+  if (socket) {
+    try {
+      socket.close();
+    } catch {
+    }
+  }
+  socket = null;
+  connectPromise = null;
+};
+const reconnect = (tenantId, uid, options = {}) => {
+  disconnect();
+  return connect(tenantId, uid, options);
+};
+const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe) => {
+  let options;
+  let callback;
+  if (typeof optionsOrCallback === "function") {
+    options = {};
+    callback = optionsOrCallback;
+  } else {
+    options = optionsOrCallback ?? {};
+    callback = callbackMaybe;
+  }
+  if (!callback) return void 0;
+  if (!modelName) return void 0;
+  const queryKey = computeQueryKey(query, options);
+  const cbKey = `${modelName}.${queryKey}`;
+  const set = queryCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
+  set.add(callback);
+  queryCallbacks.set(cbKey, set);
+  subscriptions.set(cbKey, { modelName, query, options, queryKey });
+  if (currentUid) {
+    void runQuery({
+      modelName,
+      query,
+      options: {
+        uid: currentUid,
+        projection: options.projection,
+        sort: options.sort,
+        limit: options.limit
+      }
+    }).then(({ data, context }) => {
+      callback?.(null, data, context);
+    }).catch(() => {
+    });
+  }
+  sendToServer({ type: "run-query", modelName, queryKey, query, options });
+  sendToServer({ type: "register-query", modelName, queryKey, query, options });
+  return () => {
+    sendToServer({ type: "remove-query", modelName, queryKey });
+    const callbacks = queryCallbacks.get(cbKey);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) {
+      queryCallbacks.delete(cbKey);
+      subscriptions.delete(cbKey);
+    }
+  };
+};
+const sendMessage = (event, payload) => {
+  sendToServer({ type: "event", event, payload });
+};
+const onMessage = (event, callback) => {
+  const set = messageCallbacks.get(event) ?? /* @__PURE__ */ new Set();
+  set.add(callback);
+  messageCallbacks.set(event, set);
+  return () => {
+    const callbacks = messageCallbacks.get(event);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) messageCallbacks.delete(event);
+  };
+};
+const useQuery = (modelName, query = {}, options = {}) => {
+  const id = useId();
+  const key = options.key ?? id;
+  const projectionJson = options.projection ? JSON.stringify(options.projection) : "";
+  const sortJson = options.sort ? JSON.stringify(options.sort) : "";
+  const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
+  const [data, setData] = useState(void 0);
+  const [source, setSource] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const [loading, setLoading] = useState(true);
+  const hasFirstReply = useRef(false);
+  const hasNetworkReply = useRef(false);
+  const lastDataJsonRef = useRef("");
+  useEffect(() => {
+    hasFirstReply.current = false;
+    hasNetworkReply.current = false;
+    lastDataJsonRef.current = "";
+    setLoading(true);
+    setError(void 0);
+  }, [modelName, key, JSON.stringify(query), projectionJson, sortJson, limitStr]);
+  useEffect(() => {
+    if (!modelName) return;
+    const unsubscribe = registerQuery(
+      modelName,
+      query,
+      {
+        key,
+        projection: options.projection,
+        sort: options.sort,
+        limit: options.limit
+      },
+      (err, result, context) => {
+        if (context.source === "cache" && hasNetworkReply.current) return;
+        if (context.source === "network") {
+          hasNetworkReply.current = true;
+        }
+        setLoading(false);
+        if (err) {
+          setError(err);
+          return;
+        }
+        if (!Array.isArray(result)) return;
+        if (context.source === "network" && context.isLocal && options.skipLocal && hasFirstReply.current) {
+          return;
+        }
+        hasFirstReply.current = true;
+        let nextJson = "";
+        try {
+          nextJson = JSON.stringify(result);
+        } catch {
+          nextJson = "";
+        }
+        if (nextJson && nextJson === lastDataJsonRef.current) {
+          setSource(context.source);
+          return;
+        }
+        lastDataJsonRef.current = nextJson;
+        setSource(context.source);
+        setData(result);
+      }
+    );
+    return () => {
+      unsubscribe?.();
+    };
+  }, [modelName, key, JSON.stringify(query), projectionJson, sortJson, limitStr]);
+  return useMemo(
+    () => ({
+      data,
+      source,
+      error,
+      loading
+    }),
+    [data, source, error, loading]
+  );
+};
+export {
+  destroyCollection as a,
+  deleteDocs as b,
+  configureRtsPouchStore as c,
+  destroyAllCollections as d,
+  runQuery as e,
+  addLocalTxn as f,
+  getCollection as g,
+  connect as h,
+  disconnect as i,
+  reconnect as j,
+  registerQuery as k,
+  syncRtsChanges as l,
+  useQuery as m,
+  onMessage as o,
+  resetRtsPouchStore as r,
+  sendMessage as s,
+  updateDocs as u
+};