@coinlist-co/react 0.0.2 → 0.1.1

package/dist/client/index.cjs

@@ -26,14 +26,30 @@ __export(client_exports, {
   CodeChallenge: () => CodeChallenge,
   CodeVerifier: () => CodeVerifier,
   CoinListProvider: () => CoinListProvider,
+  Cursor: () => Cursor,
+  FaqItem: () => FaqItem,
+  Link: () => Link,
+  Milestone: () => Milestone,
   OAuthRefreshToken: () => OAuthRefreshToken,
   OAuthSession: () => OAuthSession,
+  Offer: () => Offer,
+  OfferDetail: () => OfferDetail,
+  OfferId: () => OfferId,
+  OfferOption: () => OfferOption,
+  OfferOptionId: () => OfferOptionId,
+  OfferOptionSlug: () => OfferOptionSlug,
+  OfferSlug: () => OfferSlug,
+  PaginatedResponse: () => PaginatedResponse,
+  PaginationParams: () => PaginationParams,
   RedirectUri: () => RedirectUri,
+  TermItem: () => TermItem,
   User: () => User,
   UserEmail: () => UserEmail,
   UserId: () => UserId,
   createCoinListClient: () => createCoinListClient,
-  useCoinList: () => useCoinList
+  fetchAllPages: () => fetchAllPages,
+  useCoinList: () => useCoinList,
+  useCompleteCoinListOAuth: () => useCompleteCoinListOAuth
 });
 module.exports = __toCommonJS(client_exports);
 
@@ -127,7 +143,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 +171,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 +286,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";
@@ -259,7 +311,7 @@ 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 +486,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 +539,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,7 +656,7 @@ 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 || PUBLIC_API_BASE_URL,
         xApiVersion: API_VERSION
@@ -494,11 +700,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 +735,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 +816,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 = {
@@ -609,13 +902,29 @@ var User = {
   CodeChallenge,
   CodeVerifier,
   CoinListProvider,
+  Cursor,
+  FaqItem,
+  Link,
+  Milestone,
   OAuthRefreshToken,
   OAuthSession,
+  Offer,
+  OfferDetail,
+  OfferId,
+  OfferOption,
+  OfferOptionId,
+  OfferOptionSlug,
+  OfferSlug,
+  PaginatedResponse,
+  PaginationParams,
   RedirectUri,
+  TermItem,
   User,
   UserEmail,
   UserId,
   createCoinListClient,
-  useCoinList
+  fetchAllPages,
+  useCoinList,
+  useCompleteCoinListOAuth
 });
 //# sourceMappingURL=index.cjs.map