@coinlist-co/react 0.1.2 → 0.3.0

package/dist/client/hooks/index.d.ts

@@ -1,7 +1,8 @@
-export { C as CompleteCoinListOAuthFailureReason, U as UseCompleteCoinListOAuthOptions, u as useCoinList, a as useCompleteCoinListOAuth } from '../../useCompleteCoinListOAuth-C3G1Vsf8.js';
-import { a as OfferId } from '../../offer-DnFEFJw9.js';
-import { d as OfferDetail } from '../../coinlist-client-BiA8a2yU.js';
-export { u as useCoinListOffers } from '../../useCoinListOffers-DIdOb5hB.js';
+export { C as CompleteCoinListOAuthFailureReason, U as UseCompleteCoinListOAuthOptions, u as useCoinList, a as useCompleteCoinListOAuth } from '../../useCompleteCoinListOAuth-DEZpHjd6.js';
+import { a as OfferDetail, b as OfferId } from '../../requirement-fJsQ3f9_.js';
+export { u as useCoinListOffers } from '../../useCoinListOffers-C5lBlzcC.js';
+export { L as LoadRequirementsReason, a as LoadRequirementsState, U as UseCoinListRequirementsResult, u as useCoinListRequirements } from '../../useCoinListRequirements-BECx1cIw.js';
+import '../../coinlist-client-B_dJkbwB.js';
 import '../../oauth-session-DnKDI5ou.js';
 import '../../newtype-yKTvFdg_.js';
 
@@ -29,4 +30,4 @@ interface UseCoinListOfferDetailsResult {
  */
 declare function useCoinListOfferDetails(offerId: OfferId): UseCoinListOfferDetailsResult;
 
-export { useCoinListOfferDetails };
+export { type LoadOfferDetailsReason, type LoadOfferDetailsState, type UseCoinListOfferDetailsResult, useCoinListOfferDetails };

package/dist/client/hooks/index.js

@@ -1,17 +1,19 @@
 import {
   useCoinListOfferDetails,
   useCoinListOffers
-} from "../../chunk-WFA6X7E2.js";
+} from "../../chunk-IADBIDY6.js";
 import {
   useCoinList,
+  useCoinListRequirements,
   useCompleteCoinListOAuth
-} from "../../chunk-DLEKT4T4.js";
-import "../../chunk-6CG7JT7Q.js";
+} from "../../chunk-V5M7SA3C.js";
+import "../../chunk-P4DTIPEX.js";
 import "../../chunk-GRVV7NLV.js";
 export {
   useCoinList,
   useCoinListOfferDetails,
   useCoinListOffers,
+  useCoinListRequirements,
   useCompleteCoinListOAuth
 };
 //# sourceMappingURL=index.js.map

package/dist/client/index.cjs

@@ -21,11 +21,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var client_exports = {};
 __export(client_exports, {
   AuthorizationCode: () => AuthorizationCode,
+  Blockchain: () => Blockchain,
+  ChecklistStatus: () => ChecklistStatus,
   ClientId: () => ClientId,
   ClientSecret: () => ClientSecret,
   CodeChallenge: () => CodeChallenge,
   CodeVerifier: () => CodeVerifier,
   CoinListProvider: () => CoinListProvider,
+  CreateParticipationParams: () => CreateParticipationParams,
   Cursor: () => Cursor,
   FaqItem: () => FaqItem,
   Link: () => Link,
@@ -41,14 +44,24 @@ __export(client_exports, {
   OfferSlug: () => OfferSlug,
   PaginatedResponse: () => PaginatedResponse,
   PaginationParams: () => PaginationParams,
+  Participation: () => Participation,
+  ParticipationId: () => ParticipationId,
+  ParticipationsPaginationParams: () => ParticipationsPaginationParams,
   RedirectUri: () => RedirectUri,
+  Requirement: () => Requirement,
+  RequirementId: () => RequirementId,
+  RequirementStatus: () => RequirementStatus,
+  RequirementStatusInfo: () => RequirementStatusInfo,
+  RequirementVariant: () => RequirementVariant,
   TermItem: () => TermItem,
   User: () => User,
   UserEmail: () => UserEmail,
   UserId: () => UserId,
+  WalletAddress: () => WalletAddress,
   createCoinListClient: () => createCoinListClient,
   fetchAllPages: () => fetchAllPages,
   useCoinList: () => useCoinList,
+  useCoinListRequirements: () => useCoinListRequirements,
   useCompleteCoinListOAuth: () => useCompleteCoinListOAuth
 });
 module.exports = __toCommonJS(client_exports);
@@ -488,13 +501,15 @@ var ApiClient = class {
 
 // src/shared/api/pagination.ts
 var Cursor = (value) => value;
-async function fetchAllPages(fetchPage) {
+async function fetchAllPages(fetchPage, baseParams) {
   const items = [];
   let cursor = null;
   do {
-    const page = await fetchPage({
+    const params = {
+      ...baseParams ?? {},
       after: cursor ?? void 0
-    });
+    };
+    const page = await fetchPage(params);
     items.push(...page.data);
     cursor = page.startingAfter;
   } while (cursor);
@@ -648,6 +663,69 @@ var Milestone = {
   })
 };
 
+// src/shared/types/participation.ts
+var ParticipationId = (value) => value;
+var Blockchain = (value) => value;
+var WalletAddress = (value) => value;
+var ParticipationsPaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (params.offerId) {
+      queryParams["filters[0][field]"] = "offer_id";
+      queryParams["filters[0][op]"] = "==";
+      queryParams["filters[0][value]"] = params.offerId;
+    }
+    return queryParams;
+  }
+};
+var Participation = {
+  /** Maps API DTO shape into the SDK participation domain model. */
+  fromDto: (dto) => {
+    const walletAddress = notBlankStringOrNull(dto.wallet_address);
+    return {
+      id: ParticipationId(dto.id),
+      offerId: OfferId(dto.offer_id),
+      offerOptionId: OfferOptionId(dto.offer_option_id),
+      status: dto.status,
+      amount: dto.amount,
+      displayAmount: dto.amount_string,
+      asset: Asset.fromDto(dto.asset),
+      chain: Blockchain(dto.chain),
+      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
+      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
+      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
+    };
+  }
+};
+var CreateParticipationParams = {
+  /** Maps participation creation params into API DTO payload. */
+  toDto: (params) => ({
+    offer_id: params.offerId,
+    offer_option_id: params.offerOptionId,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount,
+    asset_id: params.assetId,
+    approval_transaction_hash: params.approvalTransactionHash
+  })
+};
+
+// src/shared/types/requirement.ts
+var RequirementId = (value) => value;
+var Requirement = {
+  fromDto: (dto) => ({
+    id: RequirementId(dto.id),
+    type: dto.type,
+    details: dto.details
+  })
+};
+var RequirementStatusInfo = {
+  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(([id, status]) => ({
+    id: RequirementId(id),
+    status
+  }))
+};
+
 // src/client/core/coinlist-client.ts
 var OAUTH_STATE_KEY = "coinlist.oauth_state";
 var OAUTH_CODE_VERIFIER_KEY = "coinlist.oauth_code_verifier";
@@ -741,10 +819,14 @@ var CoinListClientImpl = class {
   }
   async fetchOffersPage(params) {
     this.ensureAuthenticated();
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (this._config.sandbox) {
+      queryParams.sandbox = true;
+    }
     const pageDto = await this.api.send({
       method: "GET",
       url: "/v1/offers",
-      queryParams: PaginationParams.toQueryParams(params),
+      queryParams,
       attributes: Attributes.protected()
     });
     return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
@@ -758,6 +840,67 @@ var CoinListClientImpl = class {
     });
     return OfferDetail.fromDto(offerDetailDto);
   }
+  async fetchAllParticipations(offerId) {
+    this.ensureAuthenticated();
+    return await fetchAllPages(
+      this.fetchParticipationsPage.bind(this),
+      { offerId }
+    );
+  }
+  async fetchParticipationsPage(params) {
+    this.ensureAuthenticated();
+    const pageDto = await this.api.send(
+      {
+        method: "GET",
+        url: "/v1/participations",
+        queryParams: ParticipationsPaginationParams.toQueryParams(params),
+        attributes: Attributes.protected()
+      }
+    );
+    return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
+  }
+  async fetchParticipation(id) {
+    this.ensureAuthenticated();
+    const participationDto = await this.api.send({
+      method: "GET",
+      url: `/v1/participations/${id}`,
+      attributes: Attributes.protected()
+    });
+    return Participation.fromDto(participationDto);
+  }
+  async createParticipation(params) {
+    this.ensureAuthenticated();
+    const participationDto = await this.api.send({
+      method: "POST",
+      url: "/v1/participations",
+      body: CreateParticipationParams.toDto(params),
+      attributes: Attributes.protected()
+    });
+    return Participation.fromDto(participationDto);
+  }
+  async fetchOfferRequirements(offerId) {
+    this.ensureAuthenticated();
+    const response = await this.api.send({
+      method: "GET",
+      url: `/v1/offers/${offerId}/requirements`,
+      attributes: Attributes.protected()
+    });
+    return Object.fromEntries(
+      Object.entries(response.options).map(([optionId, list]) => [
+        optionId,
+        list.data.map(Requirement.fromDto)
+      ])
+    );
+  }
+  async fetchRequirementStatuses(offerId) {
+    this.ensureAuthenticated();
+    const response = await this.api.send({
+      method: "GET",
+      url: `/v1/offers/${offerId}/requirements/statuses`,
+      attributes: Attributes.protected()
+    });
+    return RequirementStatusInfo.fromStatusesDto(response);
+  }
   ensureAuthenticated() {
     if (this.getAuthState() !== "logged-in") {
       throw new NotAuthenticatedError();
@@ -797,6 +940,43 @@ function CoinListProvider({ config, children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListContext.Provider, { value, children });
 }
 
+// src/client/components/requirements/RequirementItem.tsx
+var import_lucide_react = require("lucide-react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var RequirementVariant = {
+  fromType(type) {
+    switch (type) {
+      case "external_wallet":
+      case "whitelisted_wallet":
+        return "wallet";
+      default:
+        return "verification";
+    }
+  }
+};
+var RequirementStatus = {
+  fromStatusValue(status) {
+    switch (status) {
+      case "not_started":
+      case "action_needed":
+        return "required";
+      case "in_progress":
+        return "pending";
+      case "completed":
+        return "completed";
+      case "rejected":
+        return "rejected";
+    }
+  }
+};
+var ChecklistStatus = {
+  derive(statuses) {
+    if (statuses.some((s) => s.status === "rejected")) return "ineligible";
+    if (statuses.every((s) => s.status === "completed")) return "eligible";
+    return "inProgress";
+  }
+};
+
 // src/client/hooks/useCoinList.ts
 var import_react2 = require("react");
 function useCoinList() {
@@ -816,18 +996,59 @@ var CoinListClientInitializationError = class extends Error {
   }
 };
 
-// src/client/hooks/useCompleteCoinListOAuth.ts
+// src/client/hooks/useCoinListRequirements.ts
 var import_react3 = require("react");
+var LOADING_STATE = { type: "LOADING" };
+function useCoinListRequirements(offerId) {
+  const { coinlist, isReady } = useCoinList();
+  const [requirementsState, setRequirementsState] = (0, import_react3.useState)(LOADING_STATE);
+  const [fetchKey, setFetchKey] = (0, import_react3.useState)(0);
+  const refetch = (0, import_react3.useCallback)(() => setFetchKey((k) => k + 1), []);
+  (0, import_react3.useEffect)(() => {
+    let isCancelled = false;
+    if (!isReady) {
+      setRequirementsState(LOADING_STATE);
+      return () => {
+        isCancelled = true;
+      };
+    }
+    setRequirementsState(LOADING_STATE);
+    Promise.all([
+      coinlist.fetchOfferRequirements(offerId),
+      coinlist.fetchRequirementStatuses(offerId)
+    ]).then(([requirementsByOptionId, statuses]) => {
+      if (!isCancelled) {
+        setRequirementsState({
+          type: "CONTENT",
+          requirementsByOptionId,
+          statuses
+        });
+      }
+    }).catch((error) => {
+      if (!isCancelled) {
+        const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        setRequirementsState({ type: "ERROR", reason });
+      }
+    });
+    return () => {
+      isCancelled = true;
+    };
+  }, [coinlist, isReady, offerId, fetchKey]);
+  return { requirementsState, refetch };
+}
+
+// src/client/hooks/useCompleteCoinListOAuth.ts
+var import_react4 = require("react");
 function useCompleteCoinListOAuth(options) {
   const { coinlist } = useCoinList();
-  const postOAuthCompleteRef = (0, import_react3.useRef)(options.postOAuthComplete);
-  const onFailureRef = (0, import_react3.useRef)(options.onFailure);
-  const onSuccessRef = (0, import_react3.useRef)(options.onSuccess);
+  const postOAuthCompleteRef = (0, import_react4.useRef)(options.postOAuthComplete);
+  const onFailureRef = (0, import_react4.useRef)(options.onFailure);
+  const onSuccessRef = (0, import_react4.useRef)(options.onSuccess);
   postOAuthCompleteRef.current = options.postOAuthComplete;
   onFailureRef.current = options.onFailure;
   onSuccessRef.current = options.onSuccess;
-  const hasStartedExchangeRef = (0, import_react3.useRef)(false);
-  (0, import_react3.useEffect)(() => {
+  const hasStartedExchangeRef = (0, import_react4.useRef)(false);
+  (0, import_react4.useEffect)(() => {
     if (typeof window === "undefined") return;
     const params = new URLSearchParams(window.location.search);
     if (!params.has("code") && !params.has("error")) return;
@@ -897,11 +1118,14 @@ var User = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthorizationCode,
+  Blockchain,
+  ChecklistStatus,
   ClientId,
   ClientSecret,
   CodeChallenge,
   CodeVerifier,
   CoinListProvider,
+  CreateParticipationParams,
   Cursor,
   FaqItem,
   Link,
@@ -917,14 +1141,24 @@ var User = {
   OfferSlug,
   PaginatedResponse,
   PaginationParams,
+  Participation,
+  ParticipationId,
+  ParticipationsPaginationParams,
   RedirectUri,
+  Requirement,
+  RequirementId,
+  RequirementStatus,
+  RequirementStatusInfo,
+  RequirementVariant,
   TermItem,
   User,
   UserEmail,
   UserId,
+  WalletAddress,
   createCoinListClient,
   fetchAllPages,
   useCoinList,
+  useCoinListRequirements,
   useCompleteCoinListOAuth
 });
 //# sourceMappingURL=index.cjs.map