@xylex-group/athena 1.4.1 → 1.5.0

package/dist/react.js

@@ -1,4 +1,5 @@
-import { useState, useMemo, useCallback } from 'react';
+import { createContext, useState, useMemo, useCallback, createElement, useContext, useRef, useEffect } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
 
 // src/gateway/use-athena-gateway.ts
 
@@ -534,6 +535,963 @@ function useAthenaGateway(config) {
   };
 }
 
-export { AthenaGatewayError, isAthenaGatewayError, useAthenaGateway };
+// src/react/utils.ts
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value == null || ["string", "number", "boolean"].includes(typeof value);
+}
+function encodePrimitive(value) {
+  if (value === null) return "null:0:";
+  if (value === void 0) return "undefined:0:";
+  if (typeof value === "string") return `str:${value.length}:${value}`;
+  if (typeof value === "number") {
+    const serialized2 = Number.isFinite(value) ? String(value) : "nan";
+    return `num:${serialized2.length}:${serialized2}`;
+  }
+  const serialized = value ? "1" : "0";
+  return `bool:${serialized.length}:${serialized}`;
+}
+function stableSerialize(value, seen) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return `"${value}"`;
+  if (valueType === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (valueType === "boolean") return value ? "true" : "false";
+  if (valueType === "bigint") return `${String(value)}n`;
+  if (valueType === "symbol") return `symbol:${String(value)}`;
+  if (valueType === "function") {
+    const namedFunction = value;
+    return `function:${namedFunction.name || "anonymous"}`;
+  }
+  if (value instanceof Date) return `date:${value.toISOString()}`;
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (valueType === "object") {
+    const objectValue = value;
+    if (seen.has(objectValue)) return "[circular]";
+    seen.add(objectValue);
+    const keys = Object.keys(objectValue).sort();
+    const serialized = `{${keys.map((key) => `${key}:${stableSerialize(objectValue[key], seen)}`).join(",")}}`;
+    seen.delete(objectValue);
+    return serialized;
+  }
+  return String(value);
+}
+function safeSerializeQueryKey(queryKey) {
+  try {
+    if (typeof queryKey === "string") {
+      return `key:${queryKey}`;
+    }
+    if (Array.isArray(queryKey) && queryKey.every(isPrimitive)) {
+      return `arr:${queryKey.map((item) => encodePrimitive(item)).join("|")}`;
+    }
+    return `ser:${stableSerialize(queryKey, /* @__PURE__ */ new WeakSet())}`;
+  } catch {
+    try {
+      return `fallback:${String(queryKey)}`;
+    } catch {
+      return "fallback:[unserializable-query-key]";
+    }
+  }
+}
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function resolveRetryCount(retry) {
+  if (retry === false || retry == null) return 0;
+  if (!Number.isFinite(retry)) return 0;
+  return Math.max(0, Math.trunc(retry));
+}
+function resolveRetryDelay(retryDelay, attempt) {
+  if (typeof retryDelay === "function") {
+    const resolved = retryDelay(attempt);
+    if (!Number.isFinite(resolved)) return 0;
+    return Math.max(0, resolved);
+  }
+  if (typeof retryDelay === "number") {
+    if (!Number.isFinite(retryDelay)) return 0;
+    return Math.max(0, retryDelay);
+  }
+  return 0;
+}
+async function runWithRetry(execute, options) {
+  const retries = resolveRetryCount(options?.retry);
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    try {
+      return await execute(attempt);
+    } catch (error) {
+      if (attempt > retries) {
+        throw error;
+      }
+      const delay = resolveRetryDelay(options?.retryDelay, attempt);
+      await sleep(delay);
+    }
+  }
+}
+function errorMessageFromUnknown(error) {
+  if (typeof error === "string" && error.trim()) return error.trim();
+  if (error instanceof Error && error.message.trim()) return error.message.trim();
+  if (isRecord2(error)) {
+    const messageCandidate = error.message ?? error.error;
+    if (typeof messageCandidate === "string" && messageCandidate.trim()) {
+      return messageCandidate.trim();
+    }
+  }
+  return "Athena request failed";
+}
+function normalizeAthenaError(error, source) {
+  if (isRecord2(error) && typeof error.message === "string" && (error.status === void 0 || typeof error.status === "number") && (error.code === void 0 || typeof error.code === "string")) {
+    return {
+      message: error.message,
+      status: typeof error.status === "number" ? error.status : void 0,
+      code: typeof error.code === "string" ? error.code : void 0,
+      details: error.details,
+      raw: error.raw ?? source ?? error
+    };
+  }
+  if (isAthenaGatewayError(error)) {
+    const details = error.toDetails();
+    return {
+      message: details.message,
+      status: details.status,
+      code: details.code,
+      details,
+      raw: source ?? error
+    };
+  }
+  if (isRecord2(source) && source.errorDetails && isRecord2(source.errorDetails)) {
+    const details = source.errorDetails;
+    return {
+      message: errorMessageFromUnknown(error ?? source.error),
+      status: typeof source.status === "number" ? source.status : void 0,
+      code: typeof details.code === "string" ? details.code : void 0,
+      details,
+      raw: source
+    };
+  }
+  if (isRecord2(source) && typeof source.status === "number") {
+    return {
+      message: errorMessageFromUnknown(error),
+      status: source.status,
+      details: source,
+      raw: source
+    };
+  }
+  return {
+    message: errorMessageFromUnknown(error),
+    raw: source ?? error
+  };
+}
+function isAthenaResponseLike(value) {
+  if (!isRecord2(value)) return false;
+  if ("error" in value || "errorDetails" in value) return true;
+  if ("status" in value && typeof value.status === "number") {
+    return "data" in value || "raw" in value;
+  }
+  return "data" in value && ("raw" in value || "status" in value);
+}
+function normalizeAthenaResult(value, select) {
+  if (isAthenaResponseLike(value)) {
+    const status = typeof value.status === "number" ? value.status : value.error != null ? 500 : 200;
+    if (value.error != null) {
+      return {
+        data: void 0,
+        error: normalizeAthenaError(value.error, value),
+        status,
+        raw: value.raw ?? value
+      };
+    }
+    const hasData = "data" in value;
+    const sourceData2 = hasData ? value.data : void 0;
+    const selectedData2 = sourceData2 === void 0 ? void 0 : sourceData2 === null ? null : select ? select(sourceData2) : sourceData2;
+    return {
+      data: selectedData2,
+      error: null,
+      status,
+      raw: value.raw ?? value
+    };
+  }
+  const sourceData = value;
+  const selectedData = select ? select(sourceData) : sourceData;
+  return {
+    data: selectedData,
+    error: null,
+    status: 200,
+    raw: value
+  };
+}
+
+// src/react/query-client.ts
+function createInitialQueryState(initialData) {
+  return {
+    status: initialData === void 0 ? "idle" : "success",
+    isFetching: false,
+    data: initialData,
+    error: null,
+    updatedAt: initialData === void 0 ? void 0 : Date.now()
+  };
+}
+function createInitialMutationState() {
+  return {
+    status: "idle",
+    data: void 0,
+    error: null,
+    isLoading: false,
+    lastVariables: void 0,
+    lastResponse: void 0,
+    updatedAt: void 0
+  };
+}
+function shouldUseMemoryCache(config) {
+  return config.cache?.mode === "memory";
+}
+var AthenaQueryClient = class {
+  queryEntries = /* @__PURE__ */ new Map();
+  mutationEntries = /* @__PURE__ */ new Map();
+  inflightQueries = /* @__PURE__ */ new Map();
+  eventSubscribers = /* @__PURE__ */ new Set();
+  adapters = /* @__PURE__ */ new Set();
+  requestCounter = 0;
+  config;
+  defaultQueryOptions;
+  defaultMutationOptions;
+  constructor(config = {}) {
+    this.config = {
+      cache: {
+        mode: config.cache?.mode ?? "none",
+        staleTime: config.cache?.staleTime,
+        gcTime: config.cache?.gcTime
+      },
+      defaultQueryOptions: config.defaultQueryOptions,
+      defaultMutationOptions: config.defaultMutationOptions
+    };
+    this.defaultQueryOptions = {
+      retry: config.defaultQueryOptions?.retry ?? 0,
+      retryDelay: config.defaultQueryOptions?.retryDelay,
+      refetchOnMount: config.defaultQueryOptions?.refetchOnMount ?? true,
+      refetchOnWindowFocus: config.defaultQueryOptions?.refetchOnWindowFocus ?? false,
+      refetchOnReconnect: config.defaultQueryOptions?.refetchOnReconnect ?? false
+    };
+    this.defaultMutationOptions = {
+      retry: config.defaultMutationOptions?.retry ?? 0,
+      retryDelay: config.defaultMutationOptions?.retryDelay
+    };
+  }
+  getQueryKeyToken(queryKey) {
+    return safeSerializeQueryKey(queryKey);
+  }
+  getMutationKeyToken(mutationKey) {
+    if (mutationKey == null) {
+      return "__mutation__default__";
+    }
+    return safeSerializeQueryKey(mutationKey);
+  }
+  getQueryState(key) {
+    const entry = this.ensureQueryEntry(key);
+    return entry.state;
+  }
+  getMutationState(key) {
+    const entry = this.ensureMutationEntry(key);
+    return entry.state;
+  }
+  subscribeQuery(key, listener) {
+    const entry = this.ensureQueryEntry(key);
+    if (entry.gcTimer) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = void 0;
+    }
+    entry.listeners.add(listener);
+    return () => {
+      const current = this.queryEntries.get(key);
+      if (!current) return;
+      current.listeners.delete(listener);
+      if (current.listeners.size === 0) {
+        this.scheduleQueryGc(current);
+      }
+    };
+  }
+  subscribeMutation(key, listener) {
+    const entry = this.ensureMutationEntry(key);
+    if (entry.gcTimer) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = void 0;
+    }
+    entry.listeners.add(listener);
+    return () => {
+      const current = this.mutationEntries.get(key);
+      if (!current) return;
+      current.listeners.delete(listener);
+      if (current.listeners.size === 0) {
+        this.scheduleMutationGc(current);
+      }
+    };
+  }
+  subscribeEvents(listener) {
+    this.eventSubscribers.add(listener);
+    return () => {
+      this.eventSubscribers.delete(listener);
+    };
+  }
+  attachAdapter(adapter) {
+    this.adapters.add(adapter);
+    return () => {
+      this.adapters.delete(adapter);
+    };
+  }
+  resetQuery(queryKey) {
+    const key = this.getQueryKeyToken(queryKey);
+    const entry = this.ensureQueryEntry(key);
+    entry.activeRequestId = ++this.requestCounter;
+    this.setQueryState(entry, createInitialQueryState(), "query_reset");
+    this.inflightQueries.delete(key);
+  }
+  resetMutation(mutationKey) {
+    const key = this.getMutationKeyToken(mutationKey);
+    const entry = this.ensureMutationEntry(key);
+    entry.activeRequestId = ++this.requestCounter;
+    this.setMutationState(entry, createInitialMutationState(), "mutation_reset");
+  }
+  async executeQuery(input) {
+    const entry = this.ensureQueryEntry(input.queryKeyToken);
+    if (input.dedupe !== false) {
+      const existing = this.inflightQueries.get(input.queryKeyToken);
+      if (existing) {
+        return existing;
+      }
+    }
+    if (!input.force && shouldUseMemoryCache(this.config)) {
+      const staleTime = this.config.cache?.staleTime ?? 0;
+      const hasFreshData = entry.state.status === "success" && entry.state.data !== void 0 && entry.state.updatedAt !== void 0 && Date.now() - entry.state.updatedAt <= staleTime;
+      if (hasFreshData) {
+        return {
+          data: entry.state.data,
+          error: null,
+          status: 200,
+          raw: entry.state.lastResponse ?? entry.state.data,
+          __applied: true
+        };
+      }
+    }
+    const requestId = ++this.requestCounter;
+    entry.activeRequestId = requestId;
+    const startRequestLog = {
+      requestId,
+      queryKey: input.queryKey,
+      queryKeyToken: input.queryKeyToken,
+      attempt: 1,
+      startedAt: Date.now()
+    };
+    const loadingStatus = entry.state.data === void 0 ? "loading" : entry.state.status;
+    this.setQueryState(
+      entry,
+      {
+        ...entry.state,
+        status: loadingStatus,
+        isFetching: true,
+        error: null,
+        lastRequest: startRequestLog
+      },
+      "query_updated"
+    );
+    const executionPromise = runWithRetry(
+      async (attempt) => {
+        const attemptRequestLog = {
+          ...startRequestLog,
+          attempt
+        };
+        if (entry.activeRequestId === requestId) {
+          this.setQueryState(
+            entry,
+            {
+              ...entry.state,
+              lastRequest: attemptRequestLog,
+              isFetching: true
+            },
+            "query_updated"
+          );
+        }
+        const rawResult = await input.queryFn();
+        const normalized = normalizeAthenaResult(rawResult, input.select);
+        if (normalized.error) {
+          throw {
+            __athenaNormalizedError: normalized.error,
+            __athenaStatus: normalized.status,
+            __athenaRaw: normalized.raw,
+            __athenaResponse: rawResult
+          };
+        }
+        return {
+          normalized,
+          response: rawResult,
+          attempt
+        };
+      },
+      {
+        retry: input.retry,
+        retryDelay: input.retryDelay
+      }
+    ).then((result) => {
+      const applied = entry.activeRequestId === requestId;
+      if (applied) {
+        const finishedAt = Date.now();
+        const doneRequestLog = {
+          ...startRequestLog,
+          attempt: result.attempt,
+          endedAt: finishedAt
+        };
+        this.setQueryState(
+          entry,
+          {
+            ...entry.state,
+            status: "success",
+            isFetching: false,
+            error: null,
+            data: result.normalized.data,
+            lastRequest: doneRequestLog,
+            lastResponse: result.response,
+            updatedAt: finishedAt
+          },
+          "query_updated"
+        );
+      }
+      return {
+        ...result.normalized,
+        __applied: applied
+      };
+    }).catch((error) => {
+      const wrapped = typeof error === "object" && error !== null ? error : void 0;
+      const normalizedError = wrapped?.__athenaNormalizedError ? wrapped.__athenaNormalizedError : normalizeAthenaError(error);
+      const status = typeof wrapped?.__athenaStatus === "number" ? wrapped.__athenaStatus : normalizedError.status ?? 500;
+      const raw = wrapped?.__athenaRaw ?? normalizedError.raw ?? null;
+      const response = wrapped?.__athenaResponse ?? raw;
+      const applied = entry.activeRequestId === requestId;
+      if (applied) {
+        const finishedAt = Date.now();
+        const doneRequestLog = {
+          ...startRequestLog,
+          endedAt: finishedAt,
+          attempt: entry.state.lastRequest?.requestId === requestId ? entry.state.lastRequest.attempt : startRequestLog.attempt
+        };
+        this.setQueryState(
+          entry,
+          {
+            ...entry.state,
+            status: "error",
+            isFetching: false,
+            error: normalizedError,
+            lastRequest: doneRequestLog,
+            lastResponse: response,
+            updatedAt: finishedAt
+          },
+          "query_updated"
+        );
+      }
+      return {
+        data: void 0,
+        error: normalizedError,
+        status,
+        raw,
+        __applied: applied
+      };
+    }).finally(() => {
+      const inflight = this.inflightQueries.get(input.queryKeyToken);
+      if (inflight === executionPromise) {
+        this.inflightQueries.delete(input.queryKeyToken);
+      }
+    });
+    this.inflightQueries.set(input.queryKeyToken, executionPromise);
+    return executionPromise;
+  }
+  async executeMutation(input) {
+    const entry = this.ensureMutationEntry(input.mutationKeyToken);
+    const requestId = ++this.requestCounter;
+    entry.activeRequestId = requestId;
+    const startRequestLog = {
+      requestId,
+      mutationKey: input.mutationKey,
+      mutationKeyToken: input.mutationKeyToken,
+      attempt: 1,
+      startedAt: Date.now(),
+      variables: input.variables
+    };
+    this.setMutationState(
+      entry,
+      {
+        ...entry.state,
+        status: "loading",
+        isLoading: true,
+        error: null,
+        lastVariables: input.variables,
+        lastRequest: startRequestLog
+      },
+      "mutation_updated"
+    );
+    try {
+      const result = await runWithRetry(
+        async (attempt) => {
+          const attemptRequestLog = {
+            ...startRequestLog,
+            attempt
+          };
+          if (entry.activeRequestId === requestId) {
+            this.setMutationState(
+              entry,
+              {
+                ...entry.state,
+                lastRequest: attemptRequestLog,
+                isLoading: true
+              },
+              "mutation_updated"
+            );
+          }
+          const rawResult = await input.mutationFn(input.variables);
+          const normalized = normalizeAthenaResult(rawResult, input.select);
+          if (normalized.error) {
+            throw {
+              __athenaNormalizedError: normalized.error,
+              __athenaStatus: normalized.status,
+              __athenaRaw: normalized.raw,
+              __athenaResponse: rawResult
+            };
+          }
+          return {
+            normalized,
+            response: rawResult,
+            attempt
+          };
+        },
+        {
+          retry: input.retry,
+          retryDelay: input.retryDelay
+        }
+      );
+      if (entry.activeRequestId === requestId) {
+        const finishedAt = Date.now();
+        const doneRequestLog = {
+          ...startRequestLog,
+          attempt: result.attempt,
+          endedAt: finishedAt
+        };
+        this.setMutationState(
+          entry,
+          {
+            ...entry.state,
+            status: "success",
+            isLoading: false,
+            data: result.normalized.data,
+            error: null,
+            lastVariables: input.variables,
+            lastRequest: doneRequestLog,
+            lastResponse: result.response,
+            updatedAt: finishedAt
+          },
+          "mutation_updated"
+        );
+      }
+      return result.normalized;
+    } catch (error) {
+      const wrapped = typeof error === "object" && error !== null ? error : void 0;
+      const normalizedError = wrapped?.__athenaNormalizedError ? wrapped.__athenaNormalizedError : normalizeAthenaError(error);
+      const status = typeof wrapped?.__athenaStatus === "number" ? wrapped.__athenaStatus : normalizedError.status ?? 500;
+      const raw = wrapped?.__athenaRaw ?? normalizedError.raw ?? null;
+      const response = wrapped?.__athenaResponse ?? raw;
+      if (entry.activeRequestId === requestId) {
+        const finishedAt = Date.now();
+        const doneRequestLog = {
+          ...startRequestLog,
+          endedAt: finishedAt,
+          attempt: entry.state.lastRequest?.requestId === requestId ? entry.state.lastRequest.attempt : startRequestLog.attempt
+        };
+        this.setMutationState(
+          entry,
+          {
+            ...entry.state,
+            status: "error",
+            isLoading: false,
+            error: normalizedError,
+            lastVariables: input.variables,
+            lastRequest: doneRequestLog,
+            lastResponse: response,
+            updatedAt: finishedAt
+          },
+          "mutation_updated"
+        );
+      }
+      return {
+        data: void 0,
+        error: normalizedError,
+        status,
+        raw
+      };
+    }
+  }
+  ensureQueryEntry(key) {
+    let entry = this.queryEntries.get(key);
+    if (entry) return entry;
+    entry = {
+      key,
+      state: createInitialQueryState(),
+      listeners: /* @__PURE__ */ new Set(),
+      activeRequestId: 0
+    };
+    this.queryEntries.set(key, entry);
+    return entry;
+  }
+  ensureMutationEntry(key) {
+    let entry = this.mutationEntries.get(key);
+    if (entry) return entry;
+    entry = {
+      key,
+      state: createInitialMutationState(),
+      listeners: /* @__PURE__ */ new Set(),
+      activeRequestId: 0
+    };
+    this.mutationEntries.set(key, entry);
+    return entry;
+  }
+  scheduleQueryGc(entry) {
+    const gcTime = shouldUseMemoryCache(this.config) ? Math.max(0, this.config.cache?.gcTime ?? 3e5) : Math.max(0, this.config.cache?.gcTime ?? 0);
+    entry.gcTimer = setTimeout(() => {
+      const current = this.queryEntries.get(entry.key);
+      if (!current || current.listeners.size > 0) return;
+      this.queryEntries.delete(entry.key);
+      this.inflightQueries.delete(entry.key);
+      this.emitEvent({
+        type: "query_gc",
+        key: entry.key,
+        state: current.state,
+        timestamp: Date.now()
+      });
+    }, gcTime);
+  }
+  scheduleMutationGc(entry) {
+    const gcTime = shouldUseMemoryCache(this.config) ? Math.max(0, this.config.cache?.gcTime ?? 3e5) : Math.max(0, this.config.cache?.gcTime ?? 0);
+    entry.gcTimer = setTimeout(() => {
+      const current = this.mutationEntries.get(entry.key);
+      if (!current || current.listeners.size > 0) return;
+      this.mutationEntries.delete(entry.key);
+    }, gcTime);
+  }
+  setQueryState(entry, state, eventType) {
+    entry.state = state;
+    for (const listener of entry.listeners) {
+      listener();
+    }
+    this.emitEvent({
+      type: eventType,
+      key: entry.key,
+      state,
+      timestamp: Date.now()
+    });
+  }
+  setMutationState(entry, state, eventType) {
+    entry.state = state;
+    for (const listener of entry.listeners) {
+      listener();
+    }
+    this.emitEvent({
+      type: eventType,
+      key: entry.key,
+      state,
+      timestamp: Date.now()
+    });
+  }
+  emitEvent(event) {
+    for (const listener of this.eventSubscribers) {
+      listener(event);
+    }
+    for (const adapter of this.adapters) {
+      adapter.onEvent?.(event);
+      if (event.type === "query_updated" || event.type === "query_reset" || event.type === "query_gc") {
+        adapter.onQueryUpdated?.(event);
+      }
+      if (event.type === "mutation_updated" || event.type === "mutation_reset") {
+        adapter.onMutationUpdated?.(event);
+      }
+    }
+  }
+};
+function createAthenaQueryClient(config) {
+  return new AthenaQueryClient(config);
+}
+function attachStateAdapter(client, adapter) {
+  return client.attachAdapter(adapter);
+}
+var AthenaQueryClientContext = createContext(null);
+function AthenaQueryClientProvider(props) {
+  const memoizedClient = useMemo(() => {
+    if (props.client) {
+      return props.client;
+    }
+    return createAthenaQueryClient(props.config);
+  }, [props.client, props.config]);
+  return createElement(
+    AthenaQueryClientContext.Provider,
+    { value: memoizedClient },
+    props.children
+  );
+}
+function useAthenaQueryClient() {
+  const client = useContext(AthenaQueryClientContext);
+  if (!client) {
+    throw new Error(
+      "No AthenaQueryClient found. Wrap your component tree with AthenaQueryClientProvider."
+    );
+  }
+  return client;
+}
+function getBrowserTarget() {
+  const maybeGlobal = globalThis;
+  const hasListeners = (value) => Boolean(value) && typeof value === "object" && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+  if (hasListeners(maybeGlobal.window)) {
+    return maybeGlobal.window;
+  }
+  if (hasListeners(maybeGlobal)) {
+    return maybeGlobal;
+  }
+  return null;
+}
+function useQuery(options) {
+  const client = useAthenaQueryClient();
+  const queryKeyRef = useRef(options.queryKey);
+  queryKeyRef.current = options.queryKey;
+  const queryFnRef = useRef(options.queryFn);
+  queryFnRef.current = options.queryFn;
+  const selectRef = useRef(options.select);
+  selectRef.current = options.select;
+  const onSuccessRef = useRef(options.onSuccess);
+  onSuccessRef.current = options.onSuccess;
+  const onErrorRef = useRef(options.onError);
+  onErrorRef.current = options.onError;
+  const onSettledRef = useRef(options.onSettled);
+  onSettledRef.current = options.onSettled;
+  const enabledRef = useRef(options.enabled ?? true);
+  enabledRef.current = options.enabled ?? true;
+  const retryRef = useRef(options.retry);
+  retryRef.current = options.retry;
+  const retryDelayRef = useRef(options.retryDelay);
+  retryDelayRef.current = options.retryDelay;
+  const initialDataRef = useRef(options.initialData);
+  initialDataRef.current = options.initialData;
+  const refetchOnMountRef = useRef(options.refetchOnMount);
+  refetchOnMountRef.current = options.refetchOnMount;
+  const refetchOnWindowFocusRef = useRef(options.refetchOnWindowFocus);
+  refetchOnWindowFocusRef.current = options.refetchOnWindowFocus;
+  const refetchOnReconnectRef = useRef(options.refetchOnReconnect);
+  refetchOnReconnectRef.current = options.refetchOnReconnect;
+  const queryKeyToken = useMemo(
+    () => client.getQueryKeyToken(options.queryKey),
+    [client, options.queryKey]
+  );
+  const activeQueryKeyTokenRef = useRef(queryKeyToken);
+  activeQueryKeyTokenRef.current = queryKeyToken;
+  const subscribe = useCallback(
+    (listener) => client.subscribeQuery(queryKeyToken, listener),
+    [client, queryKeyToken]
+  );
+  const getSnapshot = useCallback(
+    () => client.getQueryState(queryKeyToken),
+    [client, queryKeyToken]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const effectiveSnapshot = useMemo(() => {
+    if (snapshot.status === "idle" && snapshot.data === void 0 && initialDataRef.current !== void 0) {
+      return {
+        ...snapshot,
+        status: "success",
+        data: initialDataRef.current,
+        error: null
+      };
+    }
+    return snapshot;
+  }, [snapshot]);
+  const runQuery = useCallback(
+    async (force = false) => {
+      const result = await client.executeQuery({
+        queryKey: queryKeyRef.current,
+        queryKeyToken,
+        queryFn: () => queryFnRef.current(),
+        select: selectRef.current,
+        retry: retryRef.current ?? client.defaultQueryOptions.retry ?? 0,
+        retryDelay: retryDelayRef.current ?? client.defaultQueryOptions.retryDelay,
+        dedupe: true,
+        force
+      });
+      const internalResult = result;
+      if (activeQueryKeyTokenRef.current !== queryKeyToken || internalResult.__applied === false) {
+        return result;
+      }
+      if (result.error) {
+        onErrorRef.current?.(result.error);
+        onSettledRef.current?.(result.data, result.error);
+        return result;
+      }
+      onSuccessRef.current?.(result.data);
+      onSettledRef.current?.(result.data, null);
+      return result;
+    },
+    [client, queryKeyToken]
+  );
+  const lastAutoKeyRef = useRef(null);
+  useEffect(() => {
+    const refetchOnMount = refetchOnMountRef.current ?? client.defaultQueryOptions.refetchOnMount ?? true;
+    const isFirstRenderForKey = lastAutoKeyRef.current !== queryKeyToken;
+    lastAutoKeyRef.current = queryKeyToken;
+    if (!enabledRef.current) {
+      return;
+    }
+    const state = client.getQueryState(queryKeyToken);
+    const shouldFetch = state.status === "idle" || isFirstRenderForKey && refetchOnMount;
+    if (shouldFetch) {
+      void runQuery(false);
+    }
+  }, [client, queryKeyToken, runQuery]);
+  useEffect(() => {
+    const browser = getBrowserTarget();
+    if (!browser || !enabledRef.current) {
+      return void 0;
+    }
+    const refetchOnWindowFocus = refetchOnWindowFocusRef.current ?? client.defaultQueryOptions.refetchOnWindowFocus ?? false;
+    if (!refetchOnWindowFocus) {
+      return void 0;
+    }
+    const onFocus = () => {
+      if (!enabledRef.current) return;
+      void runQuery(true);
+    };
+    browser.addEventListener("focus", onFocus);
+    return () => {
+      browser.removeEventListener("focus", onFocus);
+    };
+  }, [client, runQuery]);
+  useEffect(() => {
+    const browser = getBrowserTarget();
+    if (!browser || !enabledRef.current) {
+      return void 0;
+    }
+    const refetchOnReconnect = refetchOnReconnectRef.current ?? client.defaultQueryOptions.refetchOnReconnect ?? false;
+    if (!refetchOnReconnect) {
+      return void 0;
+    }
+    const onReconnect = () => {
+      if (!enabledRef.current) return;
+      void runQuery(true);
+    };
+    browser.addEventListener("online", onReconnect);
+    return () => {
+      browser.removeEventListener("online", onReconnect);
+    };
+  }, [client, runQuery]);
+  const refetch = useCallback(() => runQuery(true), [runQuery]);
+  const reset = useCallback(() => {
+    client.resetQuery(queryKeyRef.current);
+  }, [client]);
+  return {
+    data: effectiveSnapshot.data,
+    error: effectiveSnapshot.error,
+    isLoading: effectiveSnapshot.status === "loading" && effectiveSnapshot.data === void 0,
+    isFetching: effectiveSnapshot.isFetching,
+    isSuccess: effectiveSnapshot.status === "success",
+    isError: effectiveSnapshot.status === "error",
+    status: effectiveSnapshot.status,
+    refetch,
+    reset,
+    lastResponse: effectiveSnapshot.lastResponse,
+    lastRequest: effectiveSnapshot.lastRequest
+  };
+}
+function useMutation(options) {
+  const client = useAthenaQueryClient();
+  const mutationKeyRef = useRef(options.mutationKey);
+  mutationKeyRef.current = options.mutationKey;
+  const mutationFnRef = useRef(options.mutationFn);
+  mutationFnRef.current = options.mutationFn;
+  const selectRef = useRef(options.select);
+  selectRef.current = options.select;
+  const retryRef = useRef(options.retry);
+  retryRef.current = options.retry;
+  const retryDelayRef = useRef(options.retryDelay);
+  retryDelayRef.current = options.retryDelay;
+  const onMutateRef = useRef(options.onMutate);
+  onMutateRef.current = options.onMutate;
+  const onSuccessRef = useRef(options.onSuccess);
+  onSuccessRef.current = options.onSuccess;
+  const onErrorRef = useRef(options.onError);
+  onErrorRef.current = options.onError;
+  const onSettledRef = useRef(options.onSettled);
+  onSettledRef.current = options.onSettled;
+  const mutationKeyToken = useMemo(
+    () => client.getMutationKeyToken(options.mutationKey),
+    [client, options.mutationKey]
+  );
+  const subscribe = useCallback(
+    (listener) => client.subscribeMutation(mutationKeyToken, listener),
+    [client, mutationKeyToken]
+  );
+  const getSnapshot = useCallback(
+    () => client.getMutationState(mutationKeyToken),
+    [client, mutationKeyToken]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const mutateAsync = useCallback(
+    async (variables) => {
+      await onMutateRef.current?.(variables);
+      const result = await client.executeMutation({
+        mutationKey: mutationKeyRef.current,
+        mutationKeyToken,
+        variables,
+        mutationFn: (currentVariables) => mutationFnRef.current(currentVariables),
+        select: selectRef.current,
+        retry: retryRef.current ?? client.defaultMutationOptions.retry ?? 0,
+        retryDelay: retryDelayRef.current ?? client.defaultMutationOptions.retryDelay
+      });
+      if (result.error) {
+        onErrorRef.current?.(result.error, variables);
+        onSettledRef.current?.(result.data, result.error, variables);
+        throw result.error;
+      }
+      const data = result.data;
+      onSuccessRef.current?.(data, variables);
+      onSettledRef.current?.(data, null, variables);
+      return data;
+    },
+    [client, mutationKeyToken]
+  );
+  const mutate = useCallback(
+    (variables) => {
+      void mutateAsync(variables).catch(() => void 0);
+    },
+    [mutateAsync]
+  );
+  const reset = useCallback(() => {
+    client.resetMutation(mutationKeyRef.current);
+  }, [client]);
+  return {
+    mutate,
+    mutateAsync,
+    data: snapshot.data,
+    error: snapshot.error,
+    isIdle: snapshot.status === "idle",
+    isLoading: snapshot.status === "loading",
+    isSuccess: snapshot.status === "success",
+    isError: snapshot.status === "error",
+    status: snapshot.status,
+    reset,
+    lastResponse: snapshot.lastResponse,
+    lastVariables: snapshot.lastVariables,
+    lastRequest: snapshot.lastRequest
+  };
+}
+
+export { AthenaGatewayError, AthenaQueryClient, AthenaQueryClientProvider, attachStateAdapter, createAthenaQueryClient, isAthenaGatewayError, useAthenaGateway, useAthenaQueryClient, useMutation, useQuery };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map