@fitzzero/quickdraw-core 5.1.2 → 5.1.3

package/dist/{chunk-7QCUX4TK.js → chunk-NZHA4TZD.js}

@@ -10,23 +10,18 @@ import {
   createBinding,
   createInvalidationCoordinator,
   createMutationTrace,
-  createQuickdrawConnection,
   entityScopes,
   entryQuery,
   feedKey,
   invalidateWith,
-  isTimeLimit,
   isWatchedQuery,
   liveDataOf,
   loopGuardOf,
   newItem,
-  notifyEach,
   overlaysOf,
   reconnectJitter,
   refetchOnAccessChanges,
   registerQuery,
-  reloadOncePerSession,
-  retryAfterOf,
   searchCall,
   searchTargetOf,
   serverStateOf,
@@ -43,167 +38,45 @@ import {
   useQuickdrawContext,
   userOf,
   viewPredicate
-} from "./chunk-GSIPUNJL.js";
+} from "./chunk-64I6MYBC.js";
 import {
-  CLIENT_EVENTS,
-  SERVICE_TOPIC,
-  collectionTopic
-} from "./chunk-753VJIUP.js";
+  call,
+  callData,
+  channelRoomOf,
+  isNotModified,
+  isUnknownOutcome,
+  shouldRetry,
+  streamRoomOf
+} from "./chunk-NX2V6SIL.js";
 import {
-  isScopedStream
-} from "./chunk-5CGO426C.js";
+  createQuickdrawConnection,
+  hostLinksOf,
+  hostsOf,
+  mayConnect,
+  reloadOncePerSession
+} from "./chunk-STH5DLQP.js";
 import {
   buildCaller,
   collectionKey,
   entityKey,
   methodKey,
   methodKeyPrefix
-} from "./chunk-X5CWPX7H.js";
+} from "./chunk-IIQ3WMJK.js";
+import {
+  CLIENT_EVENTS,
+  SERVICE_TOPIC,
+  collectionTopic
+} from "./chunk-X4ZU4QH5.js";
+import {
+  isHostServed,
+  isScopedStream
+} from "./chunk-GYLWEJHW.js";
+import {
+  QuickdrawError
+} from "./chunk-Q4OGQM5I.js";
 import {
-  QuickdrawError,
-  fromWire,
   isRecord
-} from "./chunk-4YO5H5ON.js";
-
-// src/client/call.ts
-var UNSENT_TIMEOUT = "operation has timed out";
-function isNotModified(result) {
-  return result.nm === true;
-}
-function cancelledError() {
-  return new QuickdrawError("CANCELLED", "The call was cancelled");
-}
-function internalError(message) {
-  return new QuickdrawError("INTERNAL", message);
-}
-var lostInFlight = /* @__PURE__ */ new WeakSet();
-function isUnknownOutcome(error) {
-  return error instanceof QuickdrawError && (error.code === "TIMEOUT" || lostInFlight.has(error));
-}
-function lostError() {
-  const error = internalError("No answer: the connection to the server is down");
-  lostInFlight.add(error);
-  return error;
-}
-function refusedBeforeSending(connection, kind, signal) {
-  if (signal?.aborted === true) {
-    return cancelledError();
-  }
-  const { socket } = connection;
-  if (!socket.connected && !socket.active) {
-    return internalError("Not connected to the server");
-  }
-  const remaining = connection.backoffRemaining(kind);
-  if (remaining > 0) {
-    return new QuickdrawError(
-      "RATE_LIMITED",
-      `Waiting before more ${kind} calls: the server answered RATE_LIMITED`,
-      { retryAfterMs: Math.ceil(remaining) }
-    );
-  }
-  return void 0;
-}
-function envelopeOf(id, request) {
-  return {
-    id,
-    s: request.service,
-    m: request.method,
-    ...request.input === void 0 ? {} : { i: request.input },
-    ...request.v === void 0 ? {} : { v: request.v }
-  };
-}
-function readReply(connection, kind, reply) {
-  if (isRecord(reply) && reply.ok === true) {
-    const versioned = typeof reply.v === "string" || typeof reply.v === "number";
-    if (reply.nm === true && !versioned) {
-      return internalError("The server answered not modified without a version");
-    }
-    return reply;
-  }
-  if (isRecord(reply) && reply.ok === false) {
-    const error = fromWire(reply.e);
-    if (error.code === "RATE_LIMITED") {
-      connection.reportRateLimited(kind, retryAfterOf(error));
-    }
-    return error;
-  }
-  return internalError("The server's reply is not a call reply");
-}
-function isQueuedCall(data, id) {
-  return Array.isArray(data) && data[0] === CLIENT_EVENTS.call && isRecord(data[1]) && data[1].id === id;
-}
-function cancelCall(socket, id) {
-  const queued = socket.sendBuffer.findIndex((packet) => isQueuedCall(packet.data, id));
-  if (queued >= 0) {
-    socket.sendBuffer.splice(queued, 1);
-  } else if (socket.connected) {
-    socket.emit(CLIENT_EVENTS.cancel, { id });
-  }
-}
-function call(connection, request) {
-  const kind = request.kind ?? "query";
-  const { signal } = request;
-  const refused = refusedBeforeSending(connection, kind, signal);
-  if (refused !== void 0) {
-    return Promise.reject(refused);
-  }
-  const { socket } = connection;
-  const timeoutMs = request.timeoutMs ?? connection.timeoutMs;
-  if (!isTimeLimit(timeoutMs)) {
-    return Promise.reject(
-      new TypeError(
-        "call: timeoutMs must be a number of milliseconds, above 0 and at most 2^31 - 1"
-      )
-    );
-  }
-  const id = connection.nextCallId();
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const settle = (outcome) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      signal?.removeEventListener("abort", onAbort);
-      if (outcome instanceof QuickdrawError) {
-        reject(outcome);
-      } else {
-        notifyEach([request.onReply], (onReply) => {
-          onReply?.(outcome);
-        });
-        resolve(outcome);
-      }
-    };
-    function onAbort() {
-      cancelCall(socket, id);
-      settle(cancelledError());
-    }
-    socket.timeout(timeoutMs).emit(CLIENT_EVENTS.call, envelopeOf(id, request), (error, reply) => {
-      if (error === null) {
-        settle(readReply(connection, kind, reply));
-      } else if (error instanceof QuickdrawError) {
-        settle(error);
-      } else if (socket.connected) {
-        settle(new QuickdrawError("TIMEOUT", `No answer within ${timeoutMs} ms`));
-      } else if (error.message === UNSENT_TIMEOUT) {
-        settle(internalError("No answer: the connection to the server is down"));
-      } else {
-        settle(lostError());
-      }
-    });
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function callData(connection, request) {
-  const result = await call(connection, request);
-  if (isNotModified(result)) {
-    throw internalError("The server answered not modified to a call that sent no version");
-  }
-  return result.d;
-}
-function shouldRetry(failureCount, error) {
-  return failureCount < 1 && (!(error instanceof QuickdrawError) || error.code === "INTERNAL");
-}
+} from "./chunk-QSU47XEX.js";
 
 // src/client/live/useSearch.ts
 import { useQuery as useQuery2 } from "@tanstack/react-query";
@@ -310,7 +183,7 @@ async function fetchVersioned(connection, queryClient, query, signal) {
   return fetchFresh(connection, query, signal);
 }
 async function helloKnown(connection, signal) {
-  const ready = () => connection.getState().hello !== null || !connection.socket.active || signal?.aborted === true;
+  const ready = () => connection.getState().hello !== null || !mayConnect(connection) || signal?.aborted === true;
   if (ready()) {
     return;
   }
@@ -356,7 +229,9 @@ async function fetchMethodQuery(connection, queryClient, query, signal) {
 }
 
 // src/client/queryHooks.ts
-import { hashKey } from "@tanstack/react-query";
+import {
+  hashKey
+} from "@tanstack/react-query";
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 function watchedModelsOf(target) {
   const { watch } = target;
@@ -465,6 +340,19 @@ function useOverlaySelect(queryClient, target, select) {
     };
   }, [shape, view, select]);
 }
+function placeholderFromCache(queryClient, placeholderData) {
+  if (typeof placeholderData !== "function") {
+    return placeholderData;
+  }
+  const asked = placeholderData;
+  const fromCache = (previousData, previousQuery) => previousQuery === void 0 || queryClient.getQueryCache().get(previousQuery.queryHash) === previousQuery ? asked(previousData, previousQuery) : void 0;
+  return fromCache;
+}
+function placeholderOption(queryClient, queryKey, options) {
+  const keyDefaults = queryClient.getQueryDefaults(queryKey);
+  const given = "placeholderData" in options ? options.placeholderData : Object.hasOwn(keyDefaults, "placeholderData") ? keyDefaults.placeholderData : queryClient.getDefaultOptions().queries?.placeholderData;
+  return placeholderFromCache(queryClient, given);
+}
 function hiddenResult(result) {
   return {
     ...result,
@@ -725,6 +613,7 @@ function useMethodQuery(target, input, options = {}) {
     enabled: live ? enabled ?? true : false,
     retry: retry ?? shouldRetry,
     structuralSharing: shareKeepingVersion(structuralSharing),
+    placeholderData: placeholderOption(queryClient, queryKey, options),
     ...shown2 === void 0 ? {} : { select: shown2 }
   });
   return awaiting ? hiddenResult(result) : result;
@@ -939,17 +828,25 @@ function clientAdminNamespace(contract, methods) {
 
 // src/client/live/useChannel.ts
 import { useCallback, useMemo as useMemo4 } from "react";
-function useChannel(service, channel) {
+function useChannel(service, channel, def) {
   const { connection } = useQuickdrawContext(`${service}.${channel}.useChannel`);
   const state = useConnectionState(connection);
   const send = useCallback(
     (payload) => {
       const { socket } = connection;
-      if (socket.connected) {
-        socket.volatile.emit(CLIENT_EVENTS.channel, [service, channel, payload]);
+      if (!socket.connected) {
+        return;
+      }
+      if (def !== void 0 && isHostServed(def)) {
+        const room = channelRoomOf(def, payload, hostsOf(connection).rooms.keys());
+        if (room !== void 0) {
+          hostLinksOf(connection).send(room, service, channel, payload);
+        }
+        return;
       }
+      socket.volatile.emit(CLIENT_EVENTS.channel, [service, channel, payload]);
     },
-    [connection, service, channel]
+    [connection, service, channel, def]
   );
   const isReady = state.status === "connected" && state.hello !== null;
   return useMemo4(() => ({ send, isReady }), [send, isReady]);
@@ -1016,13 +913,16 @@ function streamMember(target) {
 }
 function realtimeMembers(contract) {
   const service = contract.name;
-  const streams = Object.entries(contract.streams).map(([stream, def]) => [
-    stream,
-    streamMember(Object.freeze({ service, stream, scoped: isScopedStream(def) }))
-  ]);
-  const channels = Object.keys(contract.channels).map((channel) => [
+  const streams = Object.entries(contract.streams).map(([stream, def]) => {
+    const host = isHostServed(def) ? { host: (scope) => streamRoomOf(def, scope) } : {};
+    return [
+      stream,
+      streamMember(Object.freeze({ service, stream, scoped: isScopedStream(def), ...host }))
+    ];
+  });
+  const channels = Object.entries(contract.channels).map(([channel, def]) => [
     channel,
-    Object.freeze({ useChannel: () => useChannel(service, channel) })
+    Object.freeze({ useChannel: () => useChannel(service, channel, def) })
   ]);
   const events = Object.keys(contract.events).map((event) => [
     event,
@@ -1244,9 +1144,11 @@ function searchMember(target, definition, contract) {
 var RESERVED_KEYS = ["invalidate"];
 function queryMember(binding, target, extra) {
   const key = (input) => methodKey(target.service, target.method, input);
+  const defaults = target.queryDefaults;
   const member = Object.freeze({
     ...extra,
-    useQuery: (input, options) => useMethodQuery(target, input, options),
+    // The caller's options over the method's defaults (the admin kit's reads of rows: `staleTime: 0`).
+    useQuery: (input, options) => useMethodQuery(target, input, defaults === void 0 ? options : { ...defaults, ...options }),
     call: async (input, options) => await callData(connectionOf(binding, target, "call"), {
       ...target,
       input,
@@ -1399,15 +1301,10 @@ function useQuickdraw() {
 }
 
 export {
-  isNotModified,
-  isUnknownOutcome,
-  call,
-  callData,
-  shouldRetry,
   useLiveData,
   SEARCH_DEBOUNCE_MS,
   createQuickdrawClient,
   QuickdrawProvider,
   useQuickdraw
 };
-//# sourceMappingURL=chunk-7QCUX4TK.js.map
+//# sourceMappingURL=chunk-NZHA4TZD.js.map