@fractalshq/sync 0.0.3 → 0.0.5

package/dist/react/index.d.ts

@@ -1,9 +1,8 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { g as ListDistributionsResponse, a as Distribution, o as ClaimableResponse, q as ClaimHistoryResponse, B as BuildClaimTransactionRequest, l as BuildClaimTransactionResponse, m as CommitClaimRequest, n as CommitClaimResponse } from '../api-CQqyHbnT.js';
+import { F as Fetcher, g as ListDistributionsResponse, K as SyncReactError, a as Distribution, B as BuildDistributionTransactionRequest, k as DistributionTransactionPayload, q as CommitDistributionSignatureInput, p as CommitDistributionResponse, v as ClaimableResponse, x as ClaimHistoryResponse, r as BuildClaimTransactionRequest, s as BuildClaimTransactionResponse, t as CommitClaimRequest, u as CommitClaimResponse } from '../api-Cl-FACri.js';
 
-type Fetcher = typeof fetch;
 interface SyncContextValue {
     basePath: string;
     fetcher?: Fetcher;
@@ -21,20 +20,64 @@ interface SyncClient {
     post<T>(path: string, body?: unknown, init?: RequestInit): Promise<T>;
 }
 declare function useSyncClient(): SyncClient;
-declare class SyncReactError extends Error {
-    readonly status: number;
-    readonly code?: string | undefined;
-    readonly details?: unknown | undefined;
-    constructor(status: number, code?: string | undefined, details?: unknown | undefined);
-}
 type QueryOptions<T> = Omit<UseQueryOptions<T, SyncReactError, T>, "queryKey" | "queryFn">;
-declare function useDistributions<TResponse = ListDistributionsResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+interface DistributionsQueryParams {
+    role?: "claimant" | "creator";
+    status?: string | null;
+}
+declare function useDistributions<TResponse = ListDistributionsResponse>(paramsOrOptions?: DistributionsQueryParams | QueryOptions<TResponse>, optionsMaybe?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
 declare function useDistribution<TResponse = Distribution>(distributionId: string | null | undefined, options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+type DistributionTransactionInput = BuildDistributionTransactionRequest;
+declare function useDistributionTransaction(options?: UseMutationOptions<DistributionTransactionPayload, SyncReactError, DistributionTransactionInput>): UseMutationResult<DistributionTransactionPayload, SyncReactError, DistributionTransactionInput>;
+type DistributionCommitInput = CommitDistributionSignatureInput;
+declare function useCommitDistribution(options?: UseMutationOptions<CommitDistributionResponse, SyncReactError, DistributionCommitInput>): UseMutationResult<CommitDistributionResponse, SyncReactError, DistributionCommitInput>;
+interface DistributionFlowState {
+    latestPayload: DistributionTransactionPayload | null;
+    building: boolean;
+    committing: boolean;
+    error: SyncReactError | null;
+}
+type DistributionFlowSignerInput = Partial<Omit<CommitDistributionSignatureInput, "distributionId">> & {
+    [key: string]: unknown;
+};
+type DistributionFlowSigner = (payload: DistributionTransactionPayload) => Promise<DistributionFlowSignerInput> | DistributionFlowSignerInput;
+interface DistributionFlowCommitResult {
+    payload: DistributionTransactionPayload;
+    commit: CommitDistributionResponse;
+    signerInput: DistributionFlowSignerInput;
+}
+interface DistributionFlowResult {
+    state: DistributionFlowState;
+    build: (input: DistributionTransactionInput) => Promise<DistributionTransactionPayload>;
+    commit: (signer: DistributionFlowSigner, input?: DistributionTransactionInput) => Promise<DistributionFlowCommitResult>;
+    claim: (signer: DistributionFlowSigner, input?: DistributionTransactionInput) => Promise<DistributionFlowCommitResult>;
+    reset: () => void;
+}
+declare function useDistributionFlow(): DistributionFlowResult;
 declare function useClaimableDistributions<TResponse = ClaimableResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
 declare function useClaimHistory<TResponse = ClaimHistoryResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
 type ClaimTransactionInput = Partial<Omit<BuildClaimTransactionRequest, "distributionId" | "claimant">>;
 declare function useClaimTransaction(distributionId: string | null | undefined, options?: UseMutationOptions<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>): UseMutationResult<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>;
 type ClaimCommitInput = Omit<CommitClaimRequest, "distributionId">;
 declare function useCommitClaim(distributionId: string | null | undefined, options?: UseMutationOptions<CommitClaimResponse, SyncReactError, ClaimCommitInput>): UseMutationResult<CommitClaimResponse, SyncReactError, ClaimCommitInput>;
+interface ClaimFlowState {
+    latestPayload: BuildClaimTransactionResponse | null;
+    building: boolean;
+    claiming: boolean;
+    error: SyncReactError | null;
+}
+type ClaimFlowSigner = (payload: BuildClaimTransactionResponse) => Promise<ClaimCommitInput> | ClaimCommitInput;
+interface ClaimFlowClaimResult {
+    payload: BuildClaimTransactionResponse;
+    commit: CommitClaimResponse;
+    signerInput: ClaimCommitInput;
+}
+interface ClaimFlowResult {
+    state: ClaimFlowState;
+    build: (input?: ClaimTransactionInput) => Promise<BuildClaimTransactionResponse>;
+    claim: (signer: ClaimFlowSigner, input?: ClaimTransactionInput) => Promise<ClaimFlowClaimResult>;
+    reset: () => void;
+}
+declare function useClaimFlow(distributionId: string | null | undefined): ClaimFlowResult;
 
-export { type ClaimCommitInput, type ClaimTransactionInput, type SyncClient, SyncProvider, type SyncProviderProps, SyncReactError, useClaimHistory, useClaimTransaction, useClaimableDistributions, useCommitClaim, useDistribution, useDistributions, useSyncClient };
+export { type ClaimCommitInput, type ClaimFlowClaimResult, type ClaimFlowResult, type ClaimFlowSigner, type ClaimFlowState, type ClaimTransactionInput, type DistributionCommitInput, type DistributionFlowCommitResult, type DistributionFlowResult, type DistributionFlowSigner, type DistributionFlowSignerInput, type DistributionFlowState, type DistributionTransactionInput, type DistributionsQueryParams, type SyncClient, SyncProvider, type SyncProviderProps, useClaimFlow, useClaimHistory, useClaimTransaction, useClaimableDistributions, useCommitClaim, useCommitDistribution, useDistribution, useDistributionFlow, useDistributionTransaction, useDistributions, useSyncClient };

package/dist/react/index.js

@@ -20,6 +20,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -38,22 +50,191 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var react_exports = {};
 __export(react_exports, {
   SyncProvider: () => SyncProvider,
-  SyncReactError: () => SyncReactError,
+  useClaimFlow: () => useClaimFlow,
   useClaimHistory: () => useClaimHistory,
   useClaimTransaction: () => useClaimTransaction,
   useClaimableDistributions: () => useClaimableDistributions,
   useCommitClaim: () => useCommitClaim,
+  useCommitDistribution: () => useCommitDistribution,
   useDistribution: () => useDistribution,
+  useDistributionFlow: () => useDistributionFlow,
+  useDistributionTransaction: () => useDistributionTransaction,
   useDistributions: () => useDistributions,
   useSyncClient: () => useSyncClient
 });
 module.exports = __toCommonJS(react_exports);
 var import_react = require("react");
 var import_react_query = require("@tanstack/react-query");
+
+// src/core/constants.ts
+var DEFAULT_RPC_ENDPOINT = process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+
+// src/core/persistence.ts
+var STORAGE_PREFIX = "distribution:persistence-warning:";
+var PERSISTENCE_WARNING_EVENT = "distribution:persistence-warning";
+function isBrowser() {
+  return typeof window !== "undefined" && typeof localStorage !== "undefined";
+}
+function persistToStorage(record) {
+  if (!isBrowser()) return;
+  try {
+    localStorage.setItem(`${STORAGE_PREFIX}${record.id}`, JSON.stringify(record));
+  } catch (error) {
+    console.error("[sync:persistence-warning] Failed to write to localStorage", error);
+  }
+}
+function emitWarning(record) {
+  if (!isBrowser()) return;
+  try {
+    window.dispatchEvent(new CustomEvent(PERSISTENCE_WARNING_EVENT, { detail: record }));
+  } catch (error) {
+    console.error("[sync:persistence-warning] Failed to emit warning event", error);
+  }
+}
+function recordPersistenceWarning(input) {
+  var _a2;
+  if (!isBrowser()) return void 0;
+  const record = __spreadProps(__spreadValues({}, input), {
+    createdAt: (_a2 = input.createdAt) != null ? _a2 : Date.now()
+  });
+  persistToStorage(record);
+  emitWarning(record);
+  return record;
+}
+function handlePersistenceWarningResponse(response) {
+  var _a2;
+  if (!isBrowser() || !response || typeof response !== "object") return;
+  const warning = response.persistenceWarning;
+  if (!warning) return;
+  const distributionId = warning.distributionId || response.distributionId || "unknown";
+  const exportJson = (_a2 = response.exportJson) != null ? _a2 : warning.exportJson;
+  const reason = warning.reason || "persist_distribution_failed";
+  const message = warning.message || "We were unable to save your distribution draft. Download the JSON to avoid data loss.";
+  const key = warning.id || `${distributionId}:${reason}:${Date.now()}`;
+  recordPersistenceWarning({
+    id: key,
+    distributionId,
+    reason,
+    message,
+    detail: warning.detail,
+    exportJson
+  });
+}
+
+// src/core/http.ts
 var FALLBACK_BASE_PATH = "/api/v1/fractals-sync";
 var _a, _b;
 var ENV_BASE_PATH = typeof process !== "undefined" && (((_a = process.env) == null ? void 0 : _a.NEXT_PUBLIC_SYNC_PATH) || ((_b = process.env) == null ? void 0 : _b.NEXT_PUBLIC_FRACTALS_SYNC_PATH)) || void 0;
 var DEFAULT_BASE_PATH = sanitizeBasePath(ENV_BASE_PATH || FALLBACK_BASE_PATH);
+function resolveRequestConfig(options) {
+  return {
+    basePath: sanitizeBasePath((options == null ? void 0 : options.basePath) || DEFAULT_BASE_PATH),
+    fetcher: resolveFetcher(options == null ? void 0 : options.fetcher)
+  };
+}
+var SyncReactError = class extends Error {
+  constructor(status, code, details) {
+    super(code || `Sync request failed with status ${status}`);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "SyncReactError";
+  }
+};
+async function requestJSON(config, path, init) {
+  var _a2;
+  const url = buildUrl(config.basePath, path);
+  const requestInit = prepareInit(init);
+  requestInit.credentials = (_a2 = requestInit.credentials) != null ? _a2 : isRelativeUrl(url) ? "include" : void 0;
+  const response = await config.fetcher(url, requestInit);
+  const payload = await parseResponseBody(response);
+  if (!response.ok) {
+    const errorCode = typeof payload === "object" && payload && "error" in payload ? String(payload.error) : void 0;
+    throw new SyncReactError(response.status, errorCode, payload);
+  }
+  return payload;
+}
+function resolveFetcher(custom) {
+  if (custom) return custom;
+  if (typeof fetch === "function") return fetch.bind(globalThis);
+  throw new Error("Global fetch is not available. Provide a fetcher via Sync configuration.");
+}
+function sanitizeBasePath(path) {
+  if (!path) return FALLBACK_BASE_PATH;
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/") return "/";
+  return trimmed.replace(/\/+$/, "");
+}
+function buildUrl(basePath, path) {
+  if (path && isAbsoluteUrl(path)) return path;
+  const normalizedBase = sanitizeBasePath(basePath);
+  const suffix = path ? `/${path.replace(/^\/+/, "")}` : "";
+  if (!normalizedBase || normalizedBase === "/") {
+    return suffix ? suffix : normalizedBase;
+  }
+  return `${normalizedBase}${suffix}`;
+}
+function isAbsoluteUrl(path) {
+  return /^https?:\/\//i.test(path);
+}
+function isRelativeUrl(path) {
+  return !isAbsoluteUrl(path);
+}
+function prepareInit(init) {
+  const finalInit = __spreadValues({}, init);
+  if ((init == null ? void 0 : init.headers) instanceof Headers) {
+    const cloned = new Headers(init.headers);
+    if (!cloned.has("content-type")) cloned.set("content-type", "application/json");
+    finalInit.headers = cloned;
+    return finalInit;
+  }
+  const headers = new Headers(init == null ? void 0 : init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  finalInit.headers = headers;
+  return finalInit;
+}
+async function parseResponseBody(response) {
+  if (response.status === 204) return void 0;
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return text;
+  }
+}
+
+// src/core/api.ts
+async function buildDistributionTransaction(input, options) {
+  const config = resolveRequestConfig(options);
+  const path = (input == null ? void 0 : input.distributionId) ? `/distributions/${encodeURIComponent(input.distributionId)}/create-transaction` : "/distributions/create-transaction";
+  const payload = await requestJSON(config, path, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  handlePersistenceWarningResponse(payload);
+  return payload;
+}
+async function commitDistributionSignature(input, options) {
+  const distributionId = input == null ? void 0 : input.distributionId;
+  if (!distributionId) {
+    throw new SyncReactError(400, "distribution_id_required");
+  }
+  const config = resolveRequestConfig(options);
+  const _a2 = input, { distributionId: _unused } = _a2, body = __objRest(_a2, ["distributionId"]);
+  return requestJSON(
+    config,
+    `/distributions/${encodeURIComponent(distributionId)}/commit`,
+    {
+      method: "POST",
+      body: JSON.stringify(body)
+    }
+  );
+}
+
+// src/react/index.tsx
 var SyncContext = (0, import_react.createContext)({ basePath: DEFAULT_BASE_PATH });
 function SyncProvider({ basePath, fetcher, children }) {
   const value = (0, import_react.useMemo)(
@@ -66,13 +247,11 @@ function SyncProvider({ basePath, fetcher, children }) {
   return (0, import_react.createElement)(SyncContext.Provider, { value }, children);
 }
 function useSyncClient() {
-  const context = (0, import_react.useContext)(SyncContext);
-  const basePath = sanitizeBasePath((context == null ? void 0 : context.basePath) || DEFAULT_BASE_PATH);
-  const fetcher = resolveFetcher(context == null ? void 0 : context.fetcher);
+  const requestConfig = useSyncRequestConfig();
   return (0, import_react.useMemo)(() => {
-    const request = (path, init) => requestJSON({ basePath, fetcher }, path, init);
+    const request = (path, init) => requestJSON(requestConfig, path, init);
     return {
-      basePath,
+      basePath: requestConfig.basePath,
       request,
       get: (path, init) => request(path, __spreadProps(__spreadValues({}, init), { method: "GET" })),
       post: (path, body, init) => {
@@ -83,22 +262,16 @@ function useSyncClient() {
         return request(path, finalInit);
       }
     };
-  }, [basePath, fetcher]);
+  }, [requestConfig]);
 }
-var SyncReactError = class extends Error {
-  constructor(status, code, details) {
-    super(code || `Sync request failed with status ${status}`);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.name = "SyncReactError";
-  }
-};
-function useDistributions(options) {
+function useDistributions(paramsOrOptions, optionsMaybe) {
+  var _a2, _b2;
   const client = useSyncClient();
+  const { params, options } = resolveDistributionsArgs(paramsOrOptions, optionsMaybe);
+  const path = buildDistributionsPath(params);
   return (0, import_react_query.useQuery)(__spreadValues({
-    queryKey: ["sync", "distributions", "me"],
-    queryFn: () => client.get("/distributions/me")
+    queryKey: ["sync", "distributions", "me", (_a2 = params == null ? void 0 : params.role) != null ? _a2 : "claimant", (_b2 = params == null ? void 0 : params.status) != null ? _b2 : "all"],
+    queryFn: () => client.get(path)
   }, options));
 }
 function useDistribution(distributionId, options) {
@@ -112,6 +285,88 @@ function useDistribution(distributionId, options) {
     enabled: Boolean(id) && ((_a2 = options == null ? void 0 : options.enabled) != null ? _a2 : true)
   }));
 }
+function useDistributionTransaction(options) {
+  const requestConfig = useSyncRequestConfig();
+  return (0, import_react_query.useMutation)(__spreadValues({
+    mutationFn: async (input) => {
+      if (!input) throw new SyncReactError(400, "distribution_input_required");
+      return buildDistributionTransaction(input, requestConfig);
+    }
+  }, options));
+}
+function useCommitDistribution(options) {
+  const requestConfig = useSyncRequestConfig();
+  return (0, import_react_query.useMutation)(__spreadValues({
+    mutationFn: async (input) => {
+      if (!(input == null ? void 0 : input.distributionId)) throw new SyncReactError(400, "distribution_id_required");
+      return commitDistributionSignature(input, requestConfig);
+    }
+  }, options));
+}
+function useDistributionFlow() {
+  var _a2, _b2;
+  const buildMutation = useDistributionTransaction();
+  const commitMutation = useCommitDistribution();
+  const [latestPayload, setLatestPayload] = (0, import_react.useState)(null);
+  const [latestInput, setLatestInput] = (0, import_react.useState)(null);
+  const build = (0, import_react.useCallback)(
+    async (input) => {
+      const payload = await buildMutation.mutateAsync(input);
+      setLatestPayload(payload);
+      setLatestInput(cloneDistributionInput(input));
+      return payload;
+    },
+    [buildMutation]
+  );
+  const doCommit = (0, import_react.useCallback)(
+    async (signer, input) => {
+      let payload = null;
+      if (input) {
+        payload = await build(input);
+      } else if (latestInput) {
+        payload = await build(latestInput);
+      } else if (latestPayload) {
+        payload = latestPayload;
+      }
+      if (!payload) {
+        throw new SyncReactError(400, "distribution_payload_missing");
+      }
+      if (!payload.distributionId) {
+        throw new SyncReactError(400, "distribution_id_required");
+      }
+      const signerInput = await signer(payload);
+      if (!signerInput || !signerInput.signature && !signerInput.transaction && !signerInput.signedTransactionBase64) {
+        throw new SyncReactError(400, "distribution_signature_required");
+      }
+      const commitPayload = __spreadProps(__spreadValues({}, signerInput), {
+        distributionId: payload.distributionId
+      });
+      if (!commitPayload.exportJson && payload.exportJson) {
+        commitPayload.exportJson = payload.exportJson;
+      }
+      const commitResult = await commitMutation.mutateAsync(commitPayload);
+      return { payload, commit: commitResult, signerInput };
+    },
+    [build, latestInput, latestPayload, commitMutation]
+  );
+  const reset = (0, import_react.useCallback)(() => {
+    setLatestPayload(null);
+    setLatestInput(null);
+    buildMutation.reset();
+    commitMutation.reset();
+  }, [buildMutation, commitMutation]);
+  const error = (_b2 = (_a2 = buildMutation.error) != null ? _a2 : commitMutation.error) != null ? _b2 : null;
+  const state = (0, import_react.useMemo)(
+    () => ({
+      latestPayload,
+      building: buildMutation.isPending,
+      committing: commitMutation.isPending,
+      error
+    }),
+    [latestPayload, buildMutation.isPending, commitMutation.isPending, error]
+  );
+  return { state, build, commit: doCommit, claim: doCommit, reset };
+}
 function useClaimableDistributions(options) {
   const client = useSyncClient();
   return (0, import_react_query.useQuery)(__spreadValues({
@@ -149,79 +404,86 @@ function useCommitClaim(distributionId, options) {
     }
   }, options));
 }
-async function requestJSON(config, path, init) {
-  var _a2;
-  const url = buildUrl(config.basePath, path);
-  const requestInit = prepareInit(init);
-  requestInit.credentials = (_a2 = requestInit.credentials) != null ? _a2 : isRelativeUrl(url) ? "include" : void 0;
-  const response = await config.fetcher(url, requestInit);
-  const payload = await parseResponseBody(response);
-  if (!response.ok) {
-    const errorCode = typeof payload === "object" && payload && "error" in payload ? String(payload.error) : void 0;
-    throw new SyncReactError(response.status, errorCode, payload);
-  }
-  return payload;
-}
-function prepareInit(init) {
-  const finalInit = __spreadValues({}, init);
-  if ((init == null ? void 0 : init.headers) instanceof Headers) {
-    const cloned = new Headers(init.headers);
-    if (!cloned.has("content-type")) cloned.set("content-type", "application/json");
-    finalInit.headers = cloned;
-    return finalInit;
-  }
-  const headers = new Headers(init == null ? void 0 : init.headers);
-  if (!headers.has("content-type")) {
-    headers.set("content-type", "application/json");
-  }
-  finalInit.headers = headers;
-  return finalInit;
-}
-async function parseResponseBody(response) {
-  if (response.status === 204) return void 0;
-  const text = await response.text();
-  if (!text) return void 0;
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    return text;
-  }
+function useClaimFlow(distributionId) {
+  var _a2, _b2;
+  const buildMutation = useClaimTransaction(distributionId);
+  const commitMutation = useCommitClaim(distributionId);
+  const [latestPayload, setLatestPayload] = (0, import_react.useState)(null);
+  const build = (0, import_react.useCallback)(
+    async (input) => {
+      const payload = await buildMutation.mutateAsync(input != null ? input : {});
+      setLatestPayload(payload);
+      return payload;
+    },
+    [buildMutation]
+  );
+  const claim = (0, import_react.useCallback)(
+    async (signer, input) => {
+      const payload = await build(input);
+      const signerInput = await signer(payload);
+      if (!signerInput || !signerInput.signature && !signerInput.transaction && !signerInput.signedTransactionBase64) {
+        throw new SyncReactError(400, "claim_signature_required");
+      }
+      const commit = await commitMutation.mutateAsync(signerInput);
+      return { payload, commit, signerInput };
+    },
+    [build, commitMutation]
+  );
+  const reset = (0, import_react.useCallback)(() => {
+    setLatestPayload(null);
+  }, []);
+  const state = {
+    latestPayload,
+    building: buildMutation.isPending,
+    claiming: commitMutation.isPending,
+    error: (_b2 = (_a2 = buildMutation.error) != null ? _a2 : commitMutation.error) != null ? _b2 : null
+  };
+  return { state, build, claim, reset };
 }
-function resolveFetcher(custom) {
-  if (custom) return custom;
-  if (typeof fetch === "function") return fetch.bind(globalThis);
-  throw new Error("Global fetch is not available. Provide a fetcher via <SyncProvider fetcher={...}>.");
+function useSyncRequestConfig() {
+  const context = (0, import_react.useContext)(SyncContext);
+  const basePath = sanitizeBasePath((context == null ? void 0 : context.basePath) || DEFAULT_BASE_PATH);
+  const fetcher = resolveFetcher(context == null ? void 0 : context.fetcher);
+  return (0, import_react.useMemo)(() => ({ basePath, fetcher }), [basePath, fetcher]);
 }
-function sanitizeBasePath(path) {
-  if (!path) return FALLBACK_BASE_PATH;
-  const trimmed = path.trim();
-  if (!trimmed || trimmed === "/") return "/";
-  return trimmed.replace(/\/+$/, "");
+function cloneDistributionInput(input) {
+  return __spreadProps(__spreadValues({}, input), {
+    recipients: input.recipients.map((recipient) => __spreadValues({}, recipient))
+  });
 }
-function buildUrl(basePath, path) {
-  if (path && isAbsoluteUrl(path)) return path;
-  const normalizedBase = sanitizeBasePath(basePath);
-  const suffix = path ? `/${path.replace(/^\/+/, "")}` : "";
-  if (!normalizedBase || normalizedBase === "/") {
-    return suffix ? suffix : normalizedBase;
+function resolveDistributionsArgs(paramsOrOptions, optionsMaybe) {
+  if (isDistributionsParams(paramsOrOptions)) {
+    return { params: paramsOrOptions, options: optionsMaybe };
   }
-  return `${normalizedBase}${suffix}`;
+  return { params: void 0, options: paramsOrOptions };
 }
-function isAbsoluteUrl(path) {
-  return /^https?:\/\//i.test(path);
+function isDistributionsParams(arg) {
+  if (!arg || typeof arg !== "object") return false;
+  return "role" in arg || "status" in arg;
 }
-function isRelativeUrl(path) {
-  return !isAbsoluteUrl(path);
+function buildDistributionsPath(params) {
+  const search = new URLSearchParams();
+  if ((params == null ? void 0 : params.role) && params.role !== "claimant") {
+    search.set("role", params.role);
+  }
+  if (params == null ? void 0 : params.status) {
+    search.set("status", params.status);
+  }
+  const qs = search.toString();
+  return qs ? `/distributions/me?${qs}` : "/distributions/me";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SyncProvider,
-  SyncReactError,
+  useClaimFlow,
   useClaimHistory,
   useClaimTransaction,
   useClaimableDistributions,
   useCommitClaim,
+  useCommitDistribution,
   useDistribution,
+  useDistributionFlow,
+  useDistributionTransaction,
   useDistributions,
   useSyncClient
 });