@coinlist-co/react 0.12.1-rc.df659d8 → 0.12.1-rc.e183ffd

package/dist/{chunk-3EOK47CQ.js → chunk-ONLH57LF.js}

@@ -19,7 +19,7 @@ import {
   generateSecureRandomBase64Url,
   internalLogger,
   sha256
-} from "./chunk-VSYGGTI6.js";
+} from "./chunk-MOE5S6CE.js";
 
 // src/universal/types/oauth.ts
 var AuthorizationCode = (value) => value;
@@ -354,4 +354,4 @@ export {
   UserEmail,
   User
 };
-//# sourceMappingURL=chunk-3EOK47CQ.js.map
+//# sourceMappingURL=chunk-ONLH57LF.js.map

package/dist/client/index.cjs

@@ -1317,8 +1317,15 @@ async function fetchAllPages(fetchPage, baseParams) {
 // src/universal/types/pagination.ts
 var Cursor = (value) => value;
 var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => ({
-    data: dto.data.map(itemMapper),
+  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
+  /**
+   * For a mapper that decides the page as a whole - one that drops items it
+   * cannot map, such as `Offer.listFromDto` - rather than item by item. The
+   * cursors are the wire's either way: dropping an item changes what the
+   * page holds, not where the next page starts.
+   */
+  fromDtoPage: (dto, pageMapper) => ({
+    data: pageMapper(dto.data),
     startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
     startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
   })
@@ -1351,6 +1358,40 @@ var Asset = {
   })
 };
 
+// src/universal/core/shared/utils/wire.ts
+function unknownTypeError(dto, model) {
+  const type = dto.type;
+  throw new ValidationError(
+    `${model}.type: unknown type ${JSON.stringify(type)}`
+  );
+}
+function requiredString(value, field) {
+  const text = notBlankStringOrNull(value);
+  if (text === null) {
+    throw new ValidationError(
+      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
+    );
+  }
+  return text;
+}
+function requiredDate(value, field) {
+  const date = typeof value === "string" ? new Date(value) : null;
+  if (date === null || Number.isNaN(date.getTime())) {
+    throw new ValidationError(
+      `${field}: expected a date, got ${JSON.stringify(value)}`
+    );
+  }
+  return date;
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(
+      `${field}: expected an array, got ${typeof value}`
+    );
+  }
+  return value;
+}
+
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -1444,25 +1485,69 @@ var Bps = (value) => value;
 // src/universal/types/offer.ts
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
+var OFFER_TYPES = {
+  "coinlist::token_sale": true,
+  "superstate::swap": true,
+  "ondo::swap": true
+};
+var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
+var OfferEditorial = {
+  /**
+   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+   * the same three checks name the payload that failed them.
+   */
+  fromDto: (dto, model) => ({
+    tagline: requiredString(dto.tagline, `${model}.tagline`),
+    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
+    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
+  })
+};
 var Offer = {
   fromDto: (dto) => {
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    return {
+    const tokens = requiredArray(dto.tokens, "Offer.tokens");
+    const base2 = {
       id: OfferId(dto.id),
       slug: OfferSlug(dto.slug),
-      type: dto.type,
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
-      startsAt: new Date(dto.starts_at),
       endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      tokens: OfferToken.listFromDto(dto.tokens)
+      tokens: OfferToken.listFromDto(tokens)
     };
-  }
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire: copying them would hand every consumer a `startsAt` that
+      // is 1970 for one variant and a date for the others.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      default:
+        return unknownTypeError(dto, "Offer");
+    }
+  },
+  /**
+   * Maps a page of offers, dropping every offer whose `type` this SDK does not
+   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+   * reject the whole page, so one offer of an unknown type would blank the
+   * grid for every offer beside it. A single offer fetched by id still
+   * throws, because there is nothing beside it to keep.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
 };
 var OfferToken = {
   fromDto: (dto) => ({
@@ -1499,76 +1584,69 @@ var OfferSwapContract = {
 };
 var OfferDetail = {
   fromDto: (dto) => {
-    if (!Array.isArray(dto.funding_assets)) {
-      throw new ValidationError(
-        `OfferDetail.funding_assets: expected an array, got ${typeof dto.funding_assets}`
-      );
-    }
-    if (!Array.isArray(dto.options)) {
-      throw new ValidationError(
-        `OfferDetail.options: expected an array, got ${typeof dto.options}`
-      );
-    }
-    if (!Array.isArray(dto.terms)) {
-      throw new ValidationError(
-        `OfferDetail.terms: expected an array, got ${typeof dto.terms}`
-      );
-    }
-    if (!Array.isArray(dto.links)) {
-      throw new ValidationError(
-        `OfferDetail.links: expected an array, got ${typeof dto.links}`
-      );
-    }
-    if (!Array.isArray(dto.faqs)) {
-      throw new ValidationError(
-        `OfferDetail.faqs: expected an array, got ${typeof dto.faqs}`
-      );
-    }
-    if (!Array.isArray(dto.milestones)) {
-      throw new ValidationError(
-        `OfferDetail.milestones: expected an array, got ${typeof dto.milestones}`
-      );
-    }
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `OfferDetail.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    const swapContracts = dto.swap_contracts === void 0 ? [] : dto.swap_contracts;
-    if (!Array.isArray(swapContracts)) {
-      throw new ValidationError(
-        `OfferDetail.swap_contracts: expected an array, got ${typeof swapContracts}`
-      );
-    }
+    const fundingAssets = requiredArray(
+      dto.funding_assets,
+      "OfferDetail.funding_assets"
+    );
+    const options = requiredArray(dto.options, "OfferDetail.options");
+    const terms = requiredArray(dto.terms, "OfferDetail.terms");
+    const links = requiredArray(dto.links, "OfferDetail.links");
+    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
+    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
+    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
     const isin = notBlankStringOrNull(dto.isin);
     const ticker = notBlankStringOrNull(dto.ticker);
-    return {
+    const base2 = {
       id: OfferId(dto.id),
       slug: OfferSlug(dto.slug),
-      type: dto.type,
       name: dto.name,
       asset: Asset.fromDto(dto.asset),
-      fundingAssets: dto.funding_assets.map(Asset.fromDto),
-      tokens: OfferToken.listFromDto(dto.tokens),
-      swapContracts: swapContracts.map(OfferSwapContract.fromDto),
+      fundingAssets: fundingAssets.map(Asset.fromDto),
+      tokens: OfferToken.listFromDto(tokens),
       about: notBlankStringOrNull(dto.about),
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
       category: dto.category,
       issuer: notBlankStringOrNull(dto.issuer),
       isin: isin === null ? null : Isin(isin),
       ticker: ticker === null ? null : Ticker(ticker),
       instrumentType: notBlankStringOrNull(dto.instrument_type),
       listingVenue: notBlankStringOrNull(dto.listing_venue),
-      startsAt: new Date(dto.starts_at),
       endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      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)
+      faqs: faqs.map(FaqItem.fromDto),
+      links: links.map(Link.fromDto),
+      milestones: milestones.map(Milestone.fromDto),
+      options: options.map(OfferOption.fromDto),
+      terms: terms.map(TermItem.fromDto)
     };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire, as in `Offer.fromDto`.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          swapContracts: requiredArray(
+            dto.swap_contracts,
+            "OfferDetail.swap_contracts"
+          ).map(OfferSwapContract.fromDto)
+        };
+      default:
+        return unknownTypeError(dto, "OfferDetail");
+    }
   }
 };
 var OfferOption = {
@@ -3495,7 +3573,7 @@ async function fetchOffersPage(api, params, clientCreds) {
       Attributes.clientCredentials(clientCreds)
     )
   });
-  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
 }
 async function fetchOfferDetails(api, id, clientCreds) {
   const dto = await api.send({
@@ -7465,7 +7543,7 @@ function stablecoinIconUrl(symbol) {
   }
 }
 function offerIconUrl(offer) {
-  return offer.logoUrl === "" ? null : AssetIconUrl(offer.logoUrl);
+  return offer.logoUrl ? AssetIconUrl(offer.logoUrl) : null;
 }
 function tokenLogoUrl(logo, minWidth = 40) {
   switch (logo.kind) {
@@ -12973,11 +13051,11 @@ function CheckoutContainer({
   enabled = true,
   className
 }) {
-  return renderOffer(offer.type, {
-    ondo: () => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
+  return renderOffer(offer, {
+    ondo: (ondoOffer) => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
       OndoCheckoutContainer,
       {
-        offer,
+        offer: ondoOffer,
         chain,
         wallets,
         config: config["ondo::swap"],
@@ -12985,10 +13063,10 @@ function CheckoutContainer({
         className
       }
     ),
-    superstate: () => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
+    superstate: (superstateOffer) => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
       SuperstateSwapCheckoutContainer,
       {
-        offer,
+        offer: superstateOffer,
         chain,
         wallets,
         enabled,
@@ -12996,7 +13074,7 @@ function CheckoutContainer({
         className
       }
     ),
-    tokenSale: () => config["coinlist::token_sale"].render(offer)
+    tokenSale: (tokenSaleOffer) => config["coinlist::token_sale"].render(tokenSaleOffer)
   });
 }
 function OndoCheckoutContainer({
@@ -13036,16 +13114,16 @@ function OndoCheckoutContainer({
     )
   });
 }
-function renderOffer(type, branches) {
-  switch (type) {
+function renderOffer(offer, branches) {
+  switch (offer.type) {
     case "ondo::swap":
-      return branches.ondo();
+      return branches.ondo(offer);
     case "superstate::swap":
-      return branches.superstate();
+      return branches.superstate(offer);
     case "coinlist::token_sale":
-      return branches.tokenSale();
+      return branches.tokenSale(offer);
     default: {
-      const exhaustive = type;
+      const exhaustive = offer;
       return exhaustive;
     }
   }
@@ -13530,20 +13608,31 @@ function useOffers(options = {}) {
 var OfferSaleCardUi = {
   fromOffer: (offer) => ({
     id: offer.id,
-    tagline: offer.tagline,
+    ...saleWindow(offer),
     logoUrl: offer.logoUrl,
-    startsAt: offer.startsAt,
     endsAt: offer.endsAt
   }),
   fromDetail: (detail) => ({
     id: detail.id,
     name: detail.name,
-    tagline: detail.tagline,
+    ...saleWindow(detail),
     logoUrl: detail.logoUrl,
-    startsAt: detail.startsAt,
     endsAt: detail.endsAt
   })
 };
+function saleWindow(offer) {
+  switch (offer.type) {
+    case "coinlist::token_sale":
+    case "superstate::swap":
+      return { tagline: offer.tagline, startsAt: offer.startsAt };
+    case "ondo::swap":
+      return { tagline: null, startsAt: null };
+    default: {
+      const exhaustive = offer;
+      return exhaustive;
+    }
+  }
+}
 
 // src/client/hooks/offers/grid/useOffersGridViewModel.ts
 var NOT_AUTHENTICATED_MESSAGE = "Sign in to view available offers.";