@fractalshq/sync 0.1.0 → 0.1.2

package/dist/v1/react/index.js

@@ -0,0 +1,552 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/v1/react/index.tsx
+var react_exports = {};
+__export(react_exports, {
+  SyncProvider: () => SyncProvider,
+  useClaimFlow: () => useClaimFlow,
+  useClaimHistory: () => useClaimHistory,
+  useClaimTransaction: () => useClaimTransaction,
+  useClaimableDistributions: () => useClaimableDistributions,
+  useCommitClaim: () => useCommitClaim,
+  useCommitDistribution: () => useCommitDistribution,
+  useDistribution: () => useDistribution,
+  useDistributionFlow: () => useDistributionFlow,
+  useDistributionTransaction: () => useDistributionTransaction,
+  useDistributions: () => useDistributions,
+  useRecipientComposer: () => useRecipientComposer,
+  useSyncClient: () => useSyncClient
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+var import_react_query = require("@tanstack/react-query");
+
+// src/v1/core/constants.ts
+var DEFAULT_RPC_ENDPOINT = process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+
+// src/v1/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/v1/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/v1/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/v1/react/index.tsx
+var SyncContext = (0, import_react.createContext)({ basePath: DEFAULT_BASE_PATH });
+function SyncProvider({ basePath, fetcher, children }) {
+  const value = (0, import_react.useMemo)(
+    () => ({
+      basePath: sanitizeBasePath(basePath || DEFAULT_BASE_PATH),
+      fetcher
+    }),
+    [basePath, fetcher]
+  );
+  return (0, import_react.createElement)(SyncContext.Provider, { value }, children);
+}
+function useSyncClient() {
+  const requestConfig = useSyncRequestConfig();
+  return (0, import_react.useMemo)(() => {
+    const request = (path, init) => requestJSON(requestConfig, path, init);
+    return {
+      basePath: requestConfig.basePath,
+      request,
+      get: (path, init) => request(path, __spreadProps(__spreadValues({}, init), { method: "GET" })),
+      post: (path, body, init) => {
+        const finalInit = __spreadProps(__spreadValues({}, init), { method: ((init == null ? void 0 : init.method) || "POST").toUpperCase() });
+        if (body !== void 0) {
+          finalInit.body = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        return request(path, finalInit);
+      }
+    };
+  }, [requestConfig]);
+}
+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", (_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) {
+  var _a2;
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : "";
+  return (0, import_react_query.useQuery)(__spreadProps(__spreadValues({
+    queryKey: ["sync", "distribution", id],
+    queryFn: () => client.get(`/distributions/me/${id}`)
+  }, 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({
+    queryKey: ["sync", "claims", "me"],
+    queryFn: () => client.get("/claims/me")
+  }, options));
+}
+function useClaimHistory(options) {
+  const client = useSyncClient();
+  return (0, import_react_query.useQuery)(__spreadValues({
+    queryKey: ["sync", "claims", "history"],
+    queryFn: () => client.get("/claims/history")
+  }, options));
+}
+function useClaimTransaction(distributionId, options) {
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : null;
+  return (0, import_react_query.useMutation)(__spreadValues({
+    mutationFn: async (input = {}) => {
+      if (!id) throw new SyncReactError(400, "distribution_id_required");
+      return client.post(`/claims/${id}/create-transaction`, input);
+    }
+  }, options));
+}
+function useCommitClaim(distributionId, options) {
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : null;
+  return (0, import_react_query.useMutation)(__spreadValues({
+    mutationFn: async (input) => {
+      if (!id) throw new SyncReactError(400, "distribution_id_required");
+      if (!input || !input.signature && !input.transaction && !input.signedTransactionBase64) {
+        throw new SyncReactError(400, "transaction_or_signature_required");
+      }
+      return client.post(`/claims/${id}/commit`, input);
+    }
+  }, options));
+}
+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 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 cloneDistributionInput(input) {
+  return __spreadProps(__spreadValues({}, input), {
+    recipients: input.recipients.map((recipient) => __spreadValues({}, recipient))
+  });
+}
+function resolveDistributionsArgs(paramsOrOptions, optionsMaybe) {
+  if (isDistributionsParams(paramsOrOptions)) {
+    return { params: paramsOrOptions, options: optionsMaybe };
+  }
+  return { params: void 0, options: paramsOrOptions };
+}
+function isDistributionsParams(arg) {
+  if (!arg || typeof arg !== "object") return false;
+  return "role" in arg || "status" in arg;
+}
+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";
+}
+function createRecipientRowId() {
+  return `recipient-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function hydrateRecipientRow(partial) {
+  var _a2, _b2;
+  return {
+    id: createRecipientRowId(),
+    address: (_a2 = partial == null ? void 0 : partial.address) != null ? _a2 : "",
+    amount: (_b2 = partial == null ? void 0 : partial.amount) != null ? _b2 : ""
+  };
+}
+function useRecipientComposer(initial = []) {
+  const [rows, setRows] = (0, import_react.useState)(() => {
+    if (initial.length === 0) return [hydrateRecipientRow()];
+    return initial.map((row) => hydrateRecipientRow(row));
+  });
+  const addRow = (0, import_react.useCallback)(() => {
+    setRows((current) => [...current, hydrateRecipientRow()]);
+  }, []);
+  const removeRow = (0, import_react.useCallback)((id) => {
+    setRows((current) => {
+      if (current.length <= 1) return [hydrateRecipientRow()];
+      return current.filter((row) => row.id !== id);
+    });
+  }, []);
+  const updateRow = (0, import_react.useCallback)((id, patch) => {
+    setRows((current) => current.map((row) => row.id === id ? __spreadValues(__spreadValues({}, row), patch) : row));
+  }, []);
+  const replaceRows = (0, import_react.useCallback)((incoming) => {
+    if (!incoming.length) {
+      setRows([hydrateRecipientRow()]);
+      return;
+    }
+    setRows(incoming.map((row) => hydrateRecipientRow(row)));
+  }, []);
+  const clearRows = (0, import_react.useCallback)(() => {
+    setRows([hydrateRecipientRow()]);
+  }, []);
+  const totals = (0, import_react.useMemo)(() => {
+    const normalized = rows.map((row) => ({
+      id: row.id,
+      address: row.address.trim(),
+      amountUi: Number(row.amount) || 0,
+      amountRaw: row.amount
+    }));
+    const totalAmountUi = normalized.reduce((sum, row) => sum + Math.max(0, row.amountUi), 0);
+    return {
+      count: rows.length,
+      totalAmountUi,
+      normalized
+    };
+  }, [rows]);
+  return {
+    state: { rows, totals },
+    addRow,
+    removeRow,
+    updateRow,
+    replaceRows,
+    clearRows
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SyncProvider,
+  useClaimFlow,
+  useClaimHistory,
+  useClaimTransaction,
+  useClaimableDistributions,
+  useCommitClaim,
+  useCommitDistribution,
+  useDistribution,
+  useDistributionFlow,
+  useDistributionTransaction,
+  useDistributions,
+  useRecipientComposer,
+  useSyncClient
+});