@coinlist-co/react 0.0.1 → 0.1.0

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

@@ -1,14 +1,55 @@
-import { a as CoinListClient } from '../../coinlist-client-fkB3J-2a.js';
-import '../../oauth-session-g0OPJNKn.js';
+export { C as CompleteCoinListOAuthFailureReason, U as UseCompleteCoinListOAuthOptions, u as useCoinList, a as useCompleteCoinListOAuth } from '../../useCompleteCoinListOAuth-wkCa45w3.js';
+import { O as OfferId, a as Offer } from '../../offer-CkZxbS45.js';
+import { d as OfferDetail } from '../../coinlist-client-CN48gVhi.js';
+import '../../oauth-session-DnKDI5ou.js';
+import '../../newtype-yKTvFdg_.js';
 
-interface UseCoinListResult {
-    /**
-     * Indicates whether the CoinList client has been initialized and ready to use.
-     * While isReady is false, then the current user state will be `unknown`.
-     */
-    isReady: boolean;
-    coinlist: CoinListClient;
+type LoadOfferDetailsReason = 'not-authenticated' | 'generic-error';
+type LoadOfferDetailsState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadOfferDetailsReason;
+} | {
+    type: 'CONTENT';
+    offerDetail: OfferDetail;
+};
+interface UseCoinListOfferDetailsResult {
+    offerDetailsState: LoadOfferDetailsState;
 }
-declare function useCoinList(): UseCoinListResult;
+/**
+ * Loads CoinList offer details for a given offer id and exposes a UI-friendly state.
+ *
+ * Returns `LOADING` while CoinList is initializing or while details are being fetched.
+ * Returns `CONTENT` with the offer when `fetchOfferDetails()` succeeds.
+ * Returns `ERROR` with:
+ * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
+ * - `generic-error` for any other failure
+ */
+declare function useCoinListOfferDetails(offerId: OfferId): UseCoinListOfferDetailsResult;
 
-export { useCoinList };
+type LoadOffersReason = 'not-authenticated' | 'generic-error';
+type LoadOffersState = {
+    type: 'LOADING';
+} | {
+    type: 'ERROR';
+    reason: LoadOffersReason;
+} | {
+    type: 'CONTENT';
+    offers: Offer[];
+};
+interface UseCoinListOffersResult {
+    offersState: LoadOffersState;
+}
+/**
+ * Loads all CoinList offers for the current user and exposes a UI-friendly state.
+ *
+ * Returns `LOADING` while CoinList is initializing or while offers are being fetched.
+ * Returns `CONTENT` with all offers when `fetchAllOffers()` succeeds.
+ * Returns `ERROR` with:
+ * - `not-authenticated` when fetching fails with {@link NotAuthenticatedError}
+ * - `generic-error` for any other failure
+ */
+declare function useCoinListOffers(): UseCoinListOffersResult;
+
+export { useCoinListOfferDetails, useCoinListOffers };

package/dist/client/hooks/index.js

@@ -1,9 +1,17 @@
 import {
-  useCoinList
-} from "../../chunk-F56RBKNS.js";
-import "../../chunk-OETRTIQ4.js";
-import "../../chunk-NLJMUHOG.js";
+  useCoinListOfferDetails,
+  useCoinListOffers
+} from "../../chunk-Y5AHTOZO.js";
+import {
+  useCoinList,
+  useCompleteCoinListOAuth
+} from "../../chunk-EPWEY23P.js";
+import "../../chunk-74NFAQYP.js";
+import "../../chunk-GRVV7NLV.js";
 export {
-  useCoinList
+  useCoinList,
+  useCoinListOfferDetails,
+  useCoinListOffers,
+  useCompleteCoinListOAuth
 };
 //# sourceMappingURL=index.js.map

package/dist/client/index.cjs

@@ -33,7 +33,8 @@ __export(client_exports, {
   UserEmail: () => UserEmail,
   UserId: () => UserId,
   createCoinListClient: () => createCoinListClient,
-  useCoinList: () => useCoinList
+  useCoinList: () => useCoinList,
+  useCompleteCoinListOAuth: () => useCompleteCoinListOAuth
 });
 module.exports = __toCommonJS(client_exports);
 
@@ -127,7 +128,10 @@ async function makeRequest(request) {
   if (request.method === "POST" && request.body !== void 0) {
     init.body = JSON.stringify(request.body);
   }
-  const response = await fetch(request.url, init);
+  const response = await fetch(
+    buildUrlWithQueryParams(request.url, request.queryParams),
+    init
+  );
   const responseHeaders = headersToRecord(response.headers);
   if (response.status === 204 || response.status === 205) {
     return {
@@ -152,6 +156,32 @@ async function makeRequest(request) {
     headers: responseHeaders
   };
 }
+function buildUrlWithQueryParams(url, queryParams) {
+  if (!queryParams) {
+    return url;
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null) {
+          continue;
+        }
+        searchParams.append(key, String(item));
+      }
+      continue;
+    }
+    searchParams.append(key, String(value));
+  }
+  const queryString = searchParams.toString();
+  if (!queryString) {
+    return url;
+  }
+  return url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+}
 function headersToRecord(headers) {
   const record = {};
   headers.forEach((value, key) => {
@@ -241,6 +271,13 @@ function getUUIDv4() {
   }
   return `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
 }
+function notBlankStringOrNull(value) {
+  if (value?.trim()) {
+    return value;
+  } else {
+    return null;
+  }
+}
 
 // src/client/core/api/middleware/device-id.ts
 var DEVICE_ID_KEY = "coinlist.device_id";
@@ -254,12 +291,12 @@ function getDeviceId() {
 }
 
 // src/shared/api/frontline.ts
-var BASE_URL = "https://mobile-api.coinlist.co";
+var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
 var HEADER_API_VERSION = "X-API-Version";
 var HEADER_USER_AGENT = "User-Agent";
 var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
 var API_VERSION = "2025-10-17";
-var COINLIST_OAUTH_URL = "https://coinlist.co/oauth/authorize";
+var COINLIST_OAUTH_PAGE_URL = "https://coinlist.co/oauth/authorize";
 
 // src/client/core/api/middleware/user-agent.ts
 var userAgentMiddleware = async (request) => {
@@ -434,6 +471,51 @@ var ApiClient = class {
   }
 };
 
+// src/shared/api/pagination.ts
+var Cursor = (value) => value;
+async function fetchAllPages(fetchPage) {
+  const items = [];
+  let cursor = null;
+  do {
+    const page = await fetchPage({
+      after: cursor ?? void 0
+    });
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
+}
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => ({
+    data: dto.data.map(itemMapper),
+    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
+    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
+  })
+};
+var PaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = {};
+    if (params.after) {
+      queryParams.starting_after = params.after;
+    }
+    if (params.before) {
+      queryParams.starting_before = params.before;
+    }
+    if (params.limit) {
+      queryParams.limit = params.limit;
+    }
+    return queryParams;
+  }
+};
+
+// src/shared/types/errors.ts
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+
 // src/shared/types/oauth.ts
 var AuthorizationCode = (value) => value;
 var CodeVerifier = (value) => value;
@@ -442,6 +524,115 @@ var RedirectUri = (value) => value;
 var ClientId = (value) => value;
 var ClientSecret = (value) => value;
 
+// src/shared/types/offer.ts
+var OfferId = (value) => value;
+var OfferSlug = (value) => value;
+var Offer = {
+  fromDto: (dto) => ({
+    id: OfferId(dto.id),
+    slug: OfferSlug(dto.slug),
+    tagline: notBlankStringOrNull(dto.tagline),
+    bannerUrl: notBlankStringOrNull(dto.banner_url),
+    logoUrl: notBlankStringOrNull(dto.logo_url),
+    startsAt: new Date(dto.starts_at),
+    endsAt: new Date(dto.ends_at)
+  })
+};
+
+// src/shared/types/asset.ts
+var AssetId = (value) => value;
+var AssetCode = (value) => value;
+var Asset = {
+  fromDto: (dto) => ({
+    id: AssetId(dto.id),
+    code: AssetCode(dto.code),
+    name: dto.name,
+    fractionalDigits: dto.fractional_digits
+  })
+};
+
+// src/shared/types/offer-detail.ts
+var OfferOptionId = (value) => value;
+var OfferOptionSlug = (value) => value;
+var OfferDetail = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.funding_assets)) {
+      throw new Error(`funding_assets must be an array`);
+    }
+    if (!Array.isArray(dto.options)) {
+      throw new Error(`options must be an array`);
+    }
+    if (!Array.isArray(dto.terms)) {
+      throw new Error(`terms must be an array`);
+    }
+    if (!Array.isArray(dto.links)) {
+      throw new Error(`links must be an array`);
+    }
+    if (!Array.isArray(dto.faqs)) {
+      throw new Error(`faqs must be an array`);
+    }
+    if (!Array.isArray(dto.milestones)) {
+      throw new Error(`milestones must be an array`);
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      name: dto.name,
+      asset: Asset.fromDto(dto.asset),
+      fundingAssets: dto.funding_assets.map(Asset.fromDto),
+      about: notBlankStringOrNull(dto.about),
+      tagline: notBlankStringOrNull(dto.tagline),
+      bannerUrl: notBlankStringOrNull(dto.banner_url),
+      logoUrl: notBlankStringOrNull(dto.logo_url),
+      category: notBlankStringOrNull(dto.category),
+      startsAt: new Date(dto.starts_at),
+      endsAt: new Date(dto.ends_at),
+      faqs: dto.faqs.map(FaqItem.fromDto),
+      links: dto.links.map(Link.fromDto),
+      milestones: dto.milestones.map(Milestone.fromDto),
+      options: dto.options.map(OfferOption.fromDto),
+      terms: dto.terms.map(TermItem.fromDto)
+    };
+  }
+};
+var OfferOption = {
+  fromDto: (dto) => ({
+    id: OfferOptionId(dto.id),
+    slug: OfferOptionSlug(dto.slug),
+    bidIncrement: dto.bid_increment,
+    floorPriceUsd: dto.floor_price_usd,
+    minimumPurchaseUsd: dto.minimum_purchase_usd,
+    priceUsd: dto.price_usd,
+    saleAgreementUrl: notBlankStringOrNull(dto.sale_agreement_url),
+    totalTokenSupply: dto.total_token_supply
+  })
+};
+var FaqItem = {
+  fromDto: (dto) => ({
+    question: notBlankStringOrNull(dto.question),
+    answer: notBlankStringOrNull(dto.answer)
+  })
+};
+var Link = {
+  fromDto: (dto) => ({
+    label: notBlankStringOrNull(dto.label),
+    url: notBlankStringOrNull(dto.url)
+  })
+};
+var TermItem = {
+  fromDto: (dto) => ({
+    key: notBlankStringOrNull(dto.key),
+    value: notBlankStringOrNull(dto.value)
+  })
+};
+var Milestone = {
+  fromDto: (dto) => ({
+    name: notBlankStringOrNull(dto.name),
+    schedule: notBlankStringOrNull(dto.schedule),
+    status: dto.status
+  })
+};
+
 // src/client/core/coinlist-client.ts
 var OAUTH_STATE_KEY = "coinlist.oauth_state";
 var OAUTH_CODE_VERIFIER_KEY = "coinlist.oauth_code_verifier";
@@ -450,9 +641,9 @@ var CoinListClientImpl = class {
     this._config = _config;
     /** Cached access token: undefined = loading, null = no token, AccessToken = logged in */
     this._accessToken = void 0;
-    this._api = new ApiClient(
+    this.api = new ApiClient(
       {
-        baseUrl: _config.baseUrl || BASE_URL,
+        baseUrl: _config.baseUrl || PUBLIC_API_BASE_URL,
         xApiVersion: API_VERSION
       },
       this.fetchAccessToken.bind(this)
@@ -494,11 +685,16 @@ var CoinListClientImpl = class {
       code_challenge_method: "S256",
       state
     });
-    const url = `${COINLIST_OAUTH_URL}?${params.toString()}`;
+    const oauthPageUrl = this._config.authorizationPageUrl ?? COINLIST_OAUTH_PAGE_URL;
+    const url = `${oauthPageUrl}?${params.toString()}`;
     window.location.href = url;
   }
   completeOAuth() {
     const params = new URLSearchParams(window.location.search);
+    const coinlistError = params.get("error");
+    if (coinlistError) {
+      return { type: "error", reason: "user_canceled" };
+    }
     const stateParam = params.get("state");
     if (!stateParam) {
       return { type: "error", reason: "missing_state" };
@@ -524,6 +720,34 @@ var CoinListClientImpl = class {
   logout() {
     this._accessToken = null;
   }
+  async fetchAllOffers() {
+    this.ensureAuthenticated();
+    return await fetchAllPages(this.fetchOffersPage.bind(this));
+  }
+  async fetchOffersPage(params) {
+    this.ensureAuthenticated();
+    const pageDto = await this.api.send({
+      method: "GET",
+      url: "/v1/offers",
+      queryParams: PaginationParams.toQueryParams(params),
+      attributes: Attributes.protected()
+    });
+    return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+  }
+  async fetchOfferDetails(id) {
+    this.ensureAuthenticated();
+    const offerDetailDto = await this.api.send({
+      method: "GET",
+      url: `/v1/offers/${id}`,
+      attributes: Attributes.protected()
+    });
+    return OfferDetail.fromDto(offerDetailDto);
+  }
+  ensureAuthenticated() {
+    if (this.getAuthState() !== "logged-in") {
+      throw new NotAuthenticatedError();
+    }
+  }
 };
 function createCoinListClient(config) {
   return new CoinListClientImpl(config);
@@ -577,6 +801,60 @@ var CoinListClientInitializationError = class extends Error {
   }
 };
 
+// src/client/hooks/useCompleteCoinListOAuth.ts
+var import_react3 = 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);
+  postOAuthCompleteRef.current = options.postOAuthComplete;
+  onFailureRef.current = options.onFailure;
+  onSuccessRef.current = options.onSuccess;
+  const hasStartedExchangeRef = (0, import_react3.useRef)(false);
+  (0, import_react3.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const params = new URLSearchParams(window.location.search);
+    if (!params.has("code") && !params.has("error")) return;
+    if (hasStartedExchangeRef.current) return;
+    const oauthResult = coinlist.completeOAuth();
+    if (oauthResult.type === "error") {
+      void Promise.resolve(onFailureRef.current(oauthResult.reason)).catch(
+        () => {
+        }
+      );
+      return;
+    }
+    hasStartedExchangeRef.current = true;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const ok = await postOAuthCompleteRef.current({
+          code: oauthResult.code,
+          codeVerifier: oauthResult.codeVerifier
+        });
+        if (cancelled) return;
+        if (!ok) {
+          hasStartedExchangeRef.current = false;
+          await onFailureRef.current("complete_request_failed");
+          return;
+        }
+        await coinlist.init();
+        if (cancelled) return;
+        await onSuccessRef.current();
+      } catch {
+        if (cancelled) return;
+        hasStartedExchangeRef.current = false;
+        await onFailureRef.current("complete_request_failed");
+      }
+    })();
+    return () => {
+      cancelled = true;
+      hasStartedExchangeRef.current = false;
+    };
+  }, [coinlist]);
+}
+
 // src/shared/types/oauth-session.ts
 var OAuthRefreshToken = (value) => value;
 var OAuthSession = {
@@ -616,6 +894,7 @@ var User = {
   UserEmail,
   UserId,
   createCoinListClient,
-  useCoinList
+  useCoinList,
+  useCompleteCoinListOAuth
 });
 //# sourceMappingURL=index.cjs.map