@kosdev-code/kos-ui-sdk 0.1.0-next.808 → 0.1.0-next.810

package/index.js

@@ -6362,8 +6362,38 @@ const getMessageBody = (payload, skipParse) => {
     return payload.body || payload;
   }
 };
+const TRANSPORT_NOT_READY = "TRANSPORT_NOT_READY";
+class TransportNotReadyError extends Error {
+  /** Stable discriminator; see {@link TRANSPORT_NOT_READY}. */
+  code = TRANSPORT_NOT_READY;
+  /**
+   * The budget, in milliseconds, that expired while waiting. `undefined` when
+   * the wait was cut short by a caller-supplied timeout signal rather than by
+   * the request's own budget.
+   */
+  timeout;
+  /** The URL of the request that was never sent. */
+  url;
+  constructor(details = {}) {
+    super(
+      `Transport not ready${details.timeout === void 0 ? "" : ` after ${details.timeout}ms`}${details.url ? ` - url: ${details.url}` : ""}`
+    );
+    this.name = "TransportNotReadyError";
+    this.timeout = details.timeout;
+    this.url = details.url;
+  }
+}
+const isTransportNotReadyError = (error) => !!error && error.code === TRANSPORT_NOT_READY;
 const log$D = KosLog.createLogger({ name: "kos-fetch" });
-const WS_TIMEOUT = process.env.KOS_WS_TIMEOUT ? parseInt(process.env.KOS_WS_TIMEOUT) : 3e4;
+const DEFAULT_WS_TIMEOUT = 3e4;
+const WS_TIMEOUT = (() => {
+  const configured = process.env.KOS_WS_TIMEOUT ? parseInt(process.env.KOS_WS_TIMEOUT) : DEFAULT_WS_TIMEOUT;
+  return Number.isNaN(configured) ? DEFAULT_WS_TIMEOUT : configured;
+})();
+const resolveTimeoutBudget = (timeout) => {
+  const budget = timeout ?? WS_TIMEOUT;
+  return Number.isFinite(budget) && budget > 0 ? budget : void 0;
+};
 const delay = () => new Promise((resolve) => {
   setTimeout(() => {
     resolve(true);
@@ -6397,6 +6427,14 @@ const combineSignals = (signals) => {
   }
   return controller.signal;
 };
+const createRequestSignal = (budget, callerSignal) => {
+  const timeoutSignal = budget ? createTimeoutSignal(budget) : void 0;
+  if (timeoutSignal && callerSignal) {
+    return combineSignals([callerSignal, timeoutSignal]);
+  }
+  return timeoutSignal ?? callerSignal ?? new AbortController().signal;
+};
+const isTimeoutReason = (reason) => reason?.name === "TimeoutError";
 const fetchMessageFactory = (options) => {
   if (options?.studio) {
     return createStudioMessage;
@@ -6408,15 +6446,25 @@ const fetchMessageFactory = (options) => {
 };
 const kosFetchWs = async (url, options) => {
   const transport = KosCore.getInstance().transport;
-  await transport.whenReady();
   const requestId = uuid();
   const urlObj = new URL(url);
   const path = `${urlObj.pathname}${urlObj.search}`;
   log$D.debug(`path: ${path}`);
-  const TIMEOUT = options?.timeout || WS_TIMEOUT;
+  const budget = resolveTimeoutBudget(options?.timeout);
   const messageFactory = fetchMessageFactory(options);
-  const timeoutSignal = createTimeoutSignal(TIMEOUT);
-  const signal = options?.signal ? combineSignals([options.signal, timeoutSignal]) : timeoutSignal;
+  const signal = createRequestSignal(budget, options?.signal);
+  try {
+    await transport.whenReady({ signal });
+  } catch (error) {
+    if (isTimeoutReason(error)) {
+      log$D.error(
+        `Transport not ready${budget === void 0 ? "" : ` after ${budget}ms`} - request not sent - url: ${url}`
+      );
+      throw new TransportNotReadyError({ timeout: budget, url });
+    }
+    log$D.debug(`Request aborted while waiting for transport - url: ${url}`);
+    throw error;
+  }
   const processedBody = await processRequestBody(options?.body);
   const additionalHeaders = {};
   if (processedBody.contentType) {
@@ -6579,6 +6627,7 @@ const resolveBaseUrl = () => {
 };
 const log$C = KosLog.createLogger({ name: "kos-service-request" });
 const ERROR_UNKNOWN = "errUnknown";
+const ERROR_TRANSPORT_NOT_READY = "Transport not ready";
 const MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 const RETRY_DEFAULTS = {
   maxAttempts: 3,
@@ -6628,6 +6677,10 @@ async function executeFetch(fullUrl, fetchOptions) {
     const payload = await response.json();
     return [null, payload.data ?? payload];
   } catch (error) {
+    if (isTransportNotReadyError(error)) {
+      log$C.error(`Transport not ready, request not sent: ${fullUrl}`);
+      return [ERROR_TRANSPORT_NOT_READY, null];
+    }
     if (error instanceof DOMException) {
       if (error.name === "TimeoutError") {
         log$C.error(`Request timed out: ${fullUrl}`);
@@ -6671,6 +6724,10 @@ async function executeFetchWithRetry(fullUrl, fetchOptions, config2) {
         await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
     } catch (error) {
+      if (isTransportNotReadyError(error)) {
+        log$C.error(`Transport not ready, request not sent: ${fullUrl}`);
+        return [ERROR_TRANSPORT_NOT_READY, null];
+      }
       if (error instanceof DOMException) {
         if (error.name === "TimeoutError") {
           log$C.error(`Request timed out: ${fullUrl}`);
@@ -7482,6 +7539,38 @@ class FlowControlManager {
     return { ...this.stats };
   }
 }
+const abortReason = (signal) => signal.reason ?? new DOMException("Aborted", "AbortError");
+const abortableWhen = async (predicate, signal) => {
+  if (predicate()) {
+    return;
+  }
+  if (!signal) {
+    await when(predicate);
+    return;
+  }
+  if (signal.aborted) {
+    throw abortReason(signal);
+  }
+  const pending = when(predicate);
+  let onAbort;
+  try {
+    await Promise.race([
+      // `cancel()` below rejects this promise with MobX's WHEN_CANCELLED
+      // sentinel. That rejection *is* the cancellation, never a real failure,
+      // so it is swallowed here; the abort branch supplies the thrown reason.
+      pending.catch(() => void 0),
+      new Promise((_, reject) => {
+        onAbort = () => reject(abortReason(signal));
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort) {
+      signal.removeEventListener("abort", onAbort);
+    }
+    pending.cancel();
+  }
+};
 class WebSocketBridgeTransport extends WebSocket {
   constructor(address) {
     super(address);
@@ -8114,15 +8203,26 @@ ${dstAddr}topics:${topic}
       }
     };
   }
-  async whenReady() {
-    const that = this;
+  /**
+   * Resolves once the transport can carry requests: the socket (and the FOS
+   * socket, when used) is connected and the connection is authorized.
+   *
+   * Pass `options.signal` to bound the wait. `connectionEstablished` flips back
+   * to `false` on socket close, so an unbounded wait parks indefinitely while
+   * the transport is down — callers with a deadline must supply a signal.
+   *
+   * @param options - See {@link KosTransportReadyOptions}.
+   * @throws The signal's abort reason if it aborts before the transport is ready.
+   */
+  async whenReady(options) {
     if (!this.webSocketSupported) {
       return {
         status: `not supported`
       };
     }
-    await when(
-      () => !!that.socket?.connectionEstablished && (!that.useFosTransport || !!that.fosSocket?.connectionEstablished) && that.authorized
+    await abortableWhen(
+      () => !!this.socket?.connectionEstablished && (!this.useFosTransport || !!this.fosSocket?.connectionEstablished) && this.authorized,
+      options?.signal
     );
     return {
       status: `success`
@@ -26945,6 +27045,7 @@ export {
   Device,
   index$6 as DeviceServices,
   DomIntersectionStrategy,
+  ERROR_TRANSPORT_NOT_READY,
   EVENT_KOS_MODEL_READY,
   EVENT_TROUBLE_ADDED,
   EVENT_TROUBLE_REMOVED,
@@ -27127,6 +27228,7 @@ export {
   TIMER_END,
   TIMER_EVENT,
   TOPIC_TIMER_TICK_EVENT,
+  TRANSPORT_NOT_READY,
   TimerManager,
   TokenContext,
   TokenProvider,
@@ -27139,6 +27241,7 @@ export {
   TranslationContainerContext,
   TranslationContext,
   TransportFactory,
+  TransportNotReadyError,
   Trouble,
   TroubleAwareSetup,
   TroubleContainer,
@@ -27277,6 +27380,7 @@ export {
   isLocalRefId,
   isNumber,
   isPrintable,
+  isTransportNotReadyError,
   isTroubleAware,
   isValidDate,
   kosAction,