@namiml/expo-sdk 3.4.0-dev.202605060437

package/src/utils/actionHandler.ts

@@ -0,0 +1,281 @@
+import { Linking } from 'react-native';
+import {
+  NamiEventEmitter, PAYWALL_ACTION_EVENT, NamiPaywallAction,
+  namiBuySKU,
+  PaywallManagerEvents,
+  hasCapability,
+  Capabilities,
+  logger,
+  storageService,
+} from '@namiml/sdk-core';
+import type {
+  NamiSKU, NamiPaywallComponentChange,
+} from '@namiml/sdk-core';
+import type { PaywallContextValue } from '../context/PaywallContext';
+import { setVideoMuted, setVideoPlaying } from './videoControls';
+
+export const ACTION_CLOSE_PAYWALL = 'namiClosePaywall';
+export const ACTION_RESTORE_PURCHASES = 'namiRestorePurchases';
+export const ACTION_SIGN_IN = 'namiSignIn';
+export const ACTION_DEEP_LINK = 'namiDeeplink';
+export const ACTION_BUY_SKU = 'namiBuySKU';
+export const ACTION_NAVIGATE_TO_SCREEN = 'namiNavigateToScreen';
+export const ACTION_SET_STATE = 'setState';
+export const ACTION_SELECT_SKU = 'namiSelectSKU';
+export const ACTION_PURCHASE_SELECTED = 'namiPurchaseSelectedSKU';
+export const ACTION_RELOAD_PRODUCTS = 'namiReloadProducts';
+export const ACTION_PLAY_VIDEO = 'namiPlayVideo';
+export const ACTION_PAUSE_VIDEO = 'namiPauseVideo';
+export const ACTION_MUTE_VIDEO = 'namiMuteVideo';
+export const ACTION_UNMUTE_VIDEO = 'namiUnmuteVideo';
+
+type NamiTapAction = {
+  function: string;
+  parameters?: Record<string, unknown>;
+};
+
+type ProductOffer = {
+  offer_ref_id?: string;
+  offer_type?: string;
+  price?: number;
+};
+
+type ProductDetailsWithOffers = {
+  offers?: ProductOffer[];
+};
+
+type ActionSku = NamiSKU & {
+  id?: string;
+  skuId?: string;
+  sku_ref_id?: string;
+  promoId?: string;
+  productDetails?: ProductDetailsWithOffers;
+  product_details?: ProductDetailsWithOffers;
+};
+
+type SetStateActionParams = {
+  formId?: string;
+  value?: string;
+};
+
+interface HandleActionParams {
+  onTap?: NamiTapAction;
+  sku?: NamiSKU;
+  componentChange?: NamiPaywallComponentChange;
+  ctx: PaywallContextValue;
+  onClose?: () => void;
+}
+
+export function handleAction({ onTap, sku, componentChange, ctx, onClose }: HandleActionParams): void {
+  if (!onTap?.function) return;
+
+  const eventData = ctx.getPaywallActionEventData();
+
+  switch (onTap.function) {
+    case ACTION_CLOSE_PAYWALL:
+      emitAction(NamiPaywallAction.CLOSE_PAYWALL, { ...eventData, componentChange });
+      closePaywallHandler(onClose);
+      break;
+
+    case ACTION_RESTORE_PURCHASES:
+      emitAction(NamiPaywallAction.RESTORE_PURCHASES, { ...eventData, componentChange });
+      restorePurchase();
+      break;
+
+    case ACTION_SIGN_IN:
+      emitAction(NamiPaywallAction.SIGN_IN, { ...eventData, componentChange });
+      signIn();
+      break;
+
+    case ACTION_DEEP_LINK: {
+      const url = asOptionalString(onTap.parameters?.url);
+      emitAction(NamiPaywallAction.DEEPLINK, { ...eventData, deeplinkUrl: url, componentChange });
+      deepLink(url);
+      break;
+    }
+
+    case ACTION_BUY_SKU: {
+      if (!sku) break;
+      ctx.setPurchaseInProgress(true);
+      const nextSku = buySKU(ctx, onTap, sku);
+      emitAction(NamiPaywallAction.BUY_SKU, { ...eventData, sku: nextSku, componentChange });
+      break;
+    }
+
+    case ACTION_SELECT_SKU: {
+      if (!sku) break;
+      const skuId = getSkuIdentifier(sku as ActionSku);
+      if (!skuId) break;
+      const products = { ...ctx.state.selectedProducts, [ctx.state.currentGroupId]: skuId };
+      ctx.setSelectedProducts(products);
+      emitAction(NamiPaywallAction.SELECT_SKU, { ...eventData, sku, componentChange });
+      break;
+    }
+
+    case ACTION_NAVIGATE_TO_SCREEN: {
+      const screen = asOptionalString(onTap.parameters?.screen);
+      if (screen) {
+        ctx.setCurrentPage(screen);
+      }
+      emitAction(NamiPaywallAction.PAGE_CHANGE, { ...eventData, componentChange });
+      break;
+    }
+
+    case ACTION_SET_STATE: {
+      const params = onTap.parameters as SetStateActionParams | undefined;
+      if (params?.formId) {
+        ctx.setCurrentFormId(params.formId, params.value);
+      } else {
+        ctx.setCurrentGroupData(ctx.state.currentGroupId, (ctx.state as any).currentGroupName ?? '');
+      }
+      emitAction(NamiPaywallAction.TOGGLE_CHANGE, { ...eventData, componentChange });
+      break;
+    }
+
+    case ACTION_PURCHASE_SELECTED: {
+      if (sku) {
+        ctx.setPurchase(true, sku);
+      }
+      emitAction(NamiPaywallAction.PURCHASE_SELECTED_SKU, { ...eventData, sku, componentChange });
+      break;
+    }
+
+    case ACTION_RELOAD_PRODUCTS:
+      emitAction(NamiPaywallAction.UNKNOWN, eventData);
+      break;
+
+    case ACTION_PLAY_VIDEO:
+      setVideoPlaying(true);
+      emitAction(NamiPaywallAction.UNKNOWN, { ...eventData, componentChange });
+      break;
+
+    case ACTION_PAUSE_VIDEO:
+      setVideoPlaying(false);
+      emitAction(NamiPaywallAction.UNKNOWN, { ...eventData, componentChange });
+      break;
+
+    case ACTION_MUTE_VIDEO:
+      setVideoMuted(true);
+      emitAction(NamiPaywallAction.UNKNOWN, { ...eventData, componentChange });
+      break;
+
+    case ACTION_UNMUTE_VIDEO:
+      setVideoMuted(false);
+      emitAction(NamiPaywallAction.UNKNOWN, { ...eventData, componentChange });
+      break;
+
+    default:
+      break;
+  }
+}
+
+function emitAction(action: NamiPaywallAction, data: Record<string, any>): void {
+  NamiEventEmitter.getInstance().emit(PAYWALL_ACTION_EVENT, { ...data, action });
+}
+
+export function shouldHoist(onTap?: Pick<NamiTapAction, 'function'>): boolean {
+  if (!onTap) return false;
+  return [
+    ACTION_SIGN_IN, ACTION_DEEP_LINK, ACTION_RESTORE_PURCHASES,
+    ACTION_CLOSE_PAYWALL, ACTION_BUY_SKU, ACTION_SELECT_SKU,
+  ].includes(onTap.function);
+}
+
+function closePaywallHandler(onClose?: () => void): void {
+  storageService.clearLaunchId();
+  if (!invokeListener(PaywallManagerEvents.Close)) {
+    onClose?.();
+  }
+}
+
+function restorePurchase(): void {
+  const thirdPartyTransCap = hasCapability(Capabilities.THIRD_PARTY_TRANSACTIONS);
+  if (!invokeListener(PaywallManagerEvents.Restore) && !thirdPartyTransCap) {
+    logger.warn('NamiPaywallManager.registerRestoreHandler is not registered, so restore uses the default Expo behavior.');
+  }
+}
+
+function signIn(): void {
+  invokeListener(PaywallManagerEvents.SignIn);
+}
+
+function deepLink(url?: string): void {
+  if (!url) {
+    logger.debug('Paywall deep link action invoked, but no url present.');
+    return;
+  }
+
+  if (!invokeListener(PaywallManagerEvents.DeeplinkAction, url)) {
+    Linking.canOpenURL(url).then((canOpen: boolean) => {
+      if (canOpen) {
+        Linking.openURL(url);
+      }
+    }).catch(() => {});
+  }
+}
+
+function buySKU(
+  ctx: PaywallContextValue,
+  onTap: NamiTapAction,
+  sku: NamiSKU,
+): NamiSKU {
+  const nextSku = { ...sku } as ActionSku;
+  const promoId = onTap.parameters?.promo;
+
+  if (promoId) {
+    nextSku.promoId = String(promoId);
+  } else {
+    const product = nextSku.productDetails ?? nextSku.product_details;
+    const trialOffer = getFreeTrialOffer(product);
+    if (trialOffer?.offer_ref_id) {
+      nextSku.promoId = String(trialOffer.offer_ref_id);
+    } else {
+      const firstOffer = product?.offers?.[0];
+      if (firstOffer?.offer_ref_id) {
+        nextSku.promoId = String(firstOffer.offer_ref_id);
+      }
+    }
+  }
+
+  handleClickedSKU(ctx, nextSku);
+  return nextSku;
+}
+
+function handleClickedSKU(ctx: PaywallContextValue, sku: NamiSKU): void {
+  if (hasCapability(Capabilities.THIRD_PARTY_TRANSACTIONS)) {
+    storageService.setPurchaseImpression();
+
+    if (!invokeListener(PaywallManagerEvents.BuySku, sku)) {
+      logger.warn(
+        'In order for Nami to hand off the purchase, you must register a NamiBuySkuHandler with NamiPaywallManager.registerBuySkuHandler.',
+      );
+    }
+    return;
+  }
+
+  namiBuySKU(getSkuIdentifier(sku as ActionSku) ?? '');
+}
+
+function invokeListener(eventName: string, ...args: any[]): boolean {
+  const emitter = NamiEventEmitter.getInstance();
+  const hasListeners = emitter.listenerCount(eventName) > 0;
+  if (hasListeners) {
+    emitter.emit(eventName, ...args);
+  }
+  return hasListeners;
+}
+
+function getFreeTrialOffer(product?: ProductDetailsWithOffers): ProductOffer | undefined {
+  if (!product?.offers?.length) {
+    return undefined;
+  }
+  return product.offers.find((offer) => offer.offer_type === 'promo' && offer.price === 0);
+}
+
+function getSkuIdentifier(sku?: ActionSku): string | undefined {
+  return sku?.skuId ?? sku?.sku_ref_id ?? sku?.id;
+}
+
+function asOptionalString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/src/utils/fonts.ts

@@ -0,0 +1,359 @@
+import { Platform } from 'react-native';
+import { logger, type FontDetails, type IPaywall } from '@namiml/sdk-core';
+
+type FontModule = {
+  loadAsync(map: Record<string, string | { uri: string }>): Promise<void>;
+};
+
+type PreparedFont = FontDetails & {
+  alias: string;
+};
+type HostedFontsMap = Record<string, FontDetails | undefined>;
+
+type FontVariantKey = 'regular' | 'bold' | 'italic' | 'boldItalic';
+export type ResolvedFontDescriptor = {
+  family?: string;
+  isHosted: boolean;
+  variant?: FontVariantKey;
+};
+
+let fontModule: FontModule | null = null;
+try {
+  fontModule = require('expo-font');
+} catch {
+  try {
+    fontModule = require('@amazon-devices/expo-font');
+  } catch {
+    fontModule = null;
+  }
+}
+
+const knownFontFaces = new Set<string>();
+const loadedFonts = new Set<string>();
+const loadingFonts = new Map<string, Promise<void>>();
+let warnedMissingFontModule = false;
+const warnedFailedFontLoads = new Set<string>();
+const fontFamilyVariants = new Map<string, Map<FontVariantKey, string>>();
+const aliasToFamilyKey = new Map<string, string>();
+const KEPLER_VARIANT_COLLISION_FAMILY_KEYS = new Set<string>(['All-ProDisplayC']);
+
+export async function prepareAndLoadFonts(
+  fontsObject?: HostedFontsMap,
+): Promise<boolean> {
+  if (!fontsObject) return false;
+
+  if (!fontModule) {
+    if (!warnedMissingFontModule && Object.keys(fontsObject).length > 0) {
+      warnedMissingFontModule = true;
+      logger.warn(
+        '[NamiExpo][fonts] Paywall requested hosted fonts, but expo-font is unavailable in the current app runtime.',
+      );
+    }
+    return false;
+  }
+
+  const fonts = collectHostedFonts(fontsObject);
+
+  for (const font of fonts) {
+    registerFontMetadata(font);
+  }
+
+  const results = await Promise.all(fonts.map((font) => loadFont(font)));
+  return results.some(Boolean);
+}
+
+export function prewarmPaywallFonts(paywalls: Array<IPaywall | null | undefined>): void {
+  const uniqueCollections = new Set<HostedFontsMap>();
+
+  for (const paywall of paywalls) {
+    if (!paywall?.fonts) {
+      continue;
+    }
+    uniqueCollections.add(paywall.fonts);
+  }
+
+  for (const fonts of uniqueCollections) {
+    void prepareAndLoadFonts(fonts);
+  }
+}
+
+export async function prepareAndLoadFontsWithTimeout(
+  fontsObject?: HostedFontsMap,
+  timeoutMs = 1200,
+): Promise<'ready' | 'timeout' | 'failed' | 'none'> {
+  if (!fontsObject || Object.keys(fontsObject).length === 0) {
+    return 'none';
+  }
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const result: 'ready' | 'failed' | 'timeout' = await Promise.race([
+    ensureFontsReady(fontsObject).then((value) => (value === 'none' ? 'failed' : value)),
+    new Promise<'timeout'>((resolve) => {
+      timer = setTimeout(() => resolve('timeout'), timeoutMs);
+    }),
+  ]);
+
+  if (timer) {
+    clearTimeout(timer);
+  }
+
+  return result;
+}
+
+export async function ensureFontsReady(
+  fontsObject?: HostedFontsMap,
+): Promise<'ready' | 'failed' | 'none'> {
+  if (!fontsObject || Object.keys(fontsObject).length === 0) {
+    return 'none';
+  }
+
+  await prepareAndLoadFonts(fontsObject);
+
+  const fonts = collectHostedFonts(fontsObject);
+
+  const allReady = fonts.every((font) => loadedFonts.has(font.alias || buildFontFaceFamily(font)));
+  return allReady ? 'ready' : 'failed';
+}
+
+function collectHostedFonts(fontsObject?: HostedFontsMap): PreparedFont[] {
+  if (!fontsObject) {
+    return [];
+  }
+
+  return Object.entries(fontsObject)
+    .flatMap(([fontName, value]) => {
+      if (!value?.file) {
+        return [];
+      }
+
+      return [{
+        ...value,
+        alias: sanitizeFontName(fontName),
+      } satisfies PreparedFont];
+    });
+}
+
+async function loadFont(font: PreparedFont): Promise<boolean> {
+  if (!fontModule) return false;
+
+  if (shouldSkipHostedFontLoad(font)) {
+    return false;
+  }
+
+  const family = font.alias || buildFontFaceFamily(font);
+  knownFontFaces.add(family);
+  if (loadedFonts.has(family)) return false;
+
+  const existing = loadingFonts.get(family);
+  if (existing) {
+    await existing;
+    return false;
+  }
+
+  let loaded = false;
+  const promise = fontModule
+    .loadAsync({ [family]: { uri: font.file } })
+    .then(() => {
+      loadedFonts.add(family);
+      loaded = true;
+    })
+    .catch((error) => {
+      if (!warnedFailedFontLoads.has(family)) {
+        warnedFailedFontLoads.add(family);
+        logger.warn(
+          `[NamiExpo][fonts] Failed to load hosted font "${family}" from "${font.file}".`,
+          error,
+        );
+      }
+      // Keep the renderer resilient if a hosted font is unavailable.
+    })
+    .finally(() => {
+      loadingFonts.delete(family);
+    });
+
+  loadingFonts.set(family, promise);
+  await promise;
+  return loaded;
+}
+
+export function buildFontFaceFamily(font: FontDetails): string {
+  return sanitizeFontName(`${font.family}-${font.style}`);
+}
+
+export function sanitizeFontName(value: string): string {
+  return value.replace(/ /g, '');
+}
+
+export function resolveFontFamily(
+  fontName?: string,
+  options?: { italic?: boolean; bold?: boolean },
+): string | undefined {
+  return resolveFontDescriptor(fontName, options).family;
+}
+
+export function resolveFontDescriptor(
+  fontName?: string,
+  options?: { italic?: boolean; bold?: boolean },
+): ResolvedFontDescriptor {
+  if (!fontName) {
+    return {
+      family: undefined,
+      isHosted: false,
+    };
+  }
+
+  const sanitized = sanitizeFontName(fontName);
+  const familyKey = aliasToFamilyKey.get(sanitized) ?? sanitized;
+
+  const exact = getKnownFontFamily(sanitized);
+  if (exact) {
+    return {
+      family: exact,
+      isHosted: true,
+      variant: getRegisteredFontVariant(familyKey, exact),
+    };
+  }
+
+  if (options?.bold || options?.italic) {
+    const knownVariant = getKnownVariantFamily(familyKey, options);
+    if (knownVariant) {
+      return {
+        family: knownVariant,
+        isHosted: true,
+        variant: getRegisteredFontVariant(familyKey, knownVariant),
+      };
+    }
+  }
+
+  const knownBase = getKnownVariantFamily(familyKey);
+  if (knownBase) {
+    return {
+      family: knownBase,
+      isHosted: true,
+      variant: getRegisteredFontVariant(familyKey, knownBase),
+    };
+  }
+
+  return {
+    family: undefined,
+    isHosted: false,
+  };
+}
+
+function registerFontMetadata(font: PreparedFont): void {
+  const familyKey = sanitizeFontName(font.family);
+  aliasToFamilyKey.set(font.alias, familyKey);
+  const variant = normalizeFontVariant(font.style);
+  const variants = fontFamilyVariants.get(familyKey) ?? new Map<FontVariantKey, string>();
+  variants.set(variant, font.alias);
+  fontFamilyVariants.set(familyKey, variants);
+}
+
+function getKnownFontFamily(candidate: string): string | undefined {
+  if (loadedFonts.has(candidate)) {
+    return candidate;
+  }
+
+  return undefined;
+}
+
+function getKnownVariantFamily(
+  candidate: string,
+  options?: { italic?: boolean; bold?: boolean },
+): string | undefined {
+  const variants = fontFamilyVariants.get(candidate);
+  if (!variants) {
+    return undefined;
+  }
+
+  const desired = buildRequestedVariantKey(options);
+  const exact = variants.get(desired);
+  if (exact && getKnownFontFamily(exact)) {
+    return exact;
+  }
+
+  const regular = variants.get('regular');
+  if (regular && getKnownFontFamily(regular)) {
+    return regular;
+  }
+
+  if (!options?.bold && !options?.italic) {
+    const bold = variants.get('bold');
+    if (bold && getKnownFontFamily(bold)) {
+      return bold;
+    }
+
+    const italic = variants.get('italic');
+    if (italic && getKnownFontFamily(italic)) {
+      return italic;
+    }
+
+    const boldItalic = variants.get('boldItalic');
+    if (boldItalic && getKnownFontFamily(boldItalic)) {
+      return boldItalic;
+    }
+  }
+
+  return undefined;
+}
+
+function getRegisteredFontVariant(
+  familyKey: string,
+  alias: string,
+): FontVariantKey | undefined {
+  const variants = fontFamilyVariants.get(familyKey);
+  if (!variants) {
+    return undefined;
+  }
+
+  for (const [variant, family] of variants.entries()) {
+    if (family === alias) {
+      return variant;
+    }
+  }
+
+  return undefined;
+}
+
+function buildRequestedVariantKey(
+  options?: { italic?: boolean; bold?: boolean },
+): FontVariantKey {
+  if (options?.bold && options?.italic) return 'boldItalic';
+  if (options?.bold) return 'bold';
+  if (options?.italic) return 'italic';
+  return 'regular';
+}
+
+function normalizeFontVariant(style?: string): FontVariantKey {
+  const normalized = sanitizeFontName(style ?? '').toLowerCase();
+  const hasBold = normalized.includes('bold');
+  const hasItalic = normalized.includes('italic');
+
+  if (hasBold && hasItalic) return 'boldItalic';
+  if (hasBold) return 'bold';
+  if (hasItalic) return 'italic';
+  return 'regular';
+}
+
+function shouldSkipHostedFontLoad(font: PreparedFont): boolean {
+  const isTelevisionRuntime = Platform.isTV === true;
+  if (!isTelevisionRuntime) {
+    return false;
+  }
+
+  const familyKey = sanitizeFontName(font.family);
+  if (!KEPLER_VARIANT_COLLISION_FAMILY_KEYS.has(familyKey)) {
+    return false;
+  }
+
+  const variant = normalizeFontVariant(font.style);
+  return variant === 'italic' || variant === 'boldItalic';
+}
+
+export function inferFontNameVariant(fontName?: string): { italic: boolean; bold: boolean } {
+  const normalized = sanitizeFontName(fontName ?? '').toLowerCase();
+  return {
+    italic: normalized.includes('italic'),
+    bold: normalized.includes('bold'),
+  };
+}

package/src/utils/iconMap.ts

@@ -0,0 +1,67 @@
+const DEFAULT_ICON = 'CheckCircleOutlined';
+
+const iconPathMap: Record<string, string[]> = {
+  CheckCircleOutlined: [
+    'M699 353h-46.9c-10.2 0-19.9 4.9-25.9 13.3L469 584.3l-71.2-98.8c-6-8.3-15.6-13.3-25.9-13.3H325c-6.5 0-10.3 7.4-6.5 12.7l124.6 172.8a31.8 31.8 0 0051.7 0l210.6-292c3.9-5.3.1-12.7-6.4-12.7z',
+    'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z',
+  ],
+  CheckOutlined: [
+    'M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 00-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z',
+  ],
+  CloseOutlined: [
+    'M799.86 166.31c.02 0 .04.02.08.06l57.69 57.7c.04.03.05.05.06.08a.12.12 0 010 .06c0 .03-.02.05-.06.09L569.93 512l287.7 287.7c.04.04.05.06.06.09a.12.12 0 010 .07c0 .02-.02.04-.06.08l-57.7 57.69c-.03.04-.05.05-.07.06a.12.12 0 01-.07 0c-.03 0-.05-.02-.09-.06L512 569.93l-287.7 287.7c-.04.04-.06.05-.09.06a.12.12 0 01-.07 0c-.02 0-.04-.02-.08-.06l-57.69-57.7c-.04-.03-.05-.05-.06-.07a.12.12 0 010-.07c0-.03.02-.05.06-.09L454.07 512l-287.7-287.7c-.04-.04-.05-.06-.06-.09a.12.12 0 010-.07c0-.02.02-.04.06-.08l57.7-57.69c.03-.04.05-.05.07-.06a.12.12 0 01.07 0c.03 0 .05.02.09.06L512 454.07l287.7-287.7c.04-.04.06-.05.09-.06a.12.12 0 01.07 0z',
+  ],
+  LeftOutlined: [
+    'M724 218.3V141c0-6.7-7.7-10.4-12.9-6.3L260.3 486.8a31.86 31.86 0 000 50.3l450.8 352.1c5.3 4.1 12.9.4 12.9-6.3v-77.3c0-4.9-2.3-9.6-6.1-12.6l-360-281 360-281.1c3.8-3 6.1-7.7 6.1-12.6z',
+  ],
+  RightOutlined: [
+    'M765.7 486.8L314.9 134.7A7.97 7.97 0 00302 141v77.3c0 4.9 2.3 9.6 6.1 12.6l360 281.1-360 281.1c-3.9 3-6.1 7.7-6.1 12.6V883c0 6.7 7.7 10.4 12.9 6.3l450.8-352.1a31.96 31.96 0 000-50.4z',
+  ],
+  UpOutlined: [
+    'M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z',
+  ],
+  DownOutlined: [
+    'M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z',
+  ],
+  PlusOutlined: [
+    'M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z',
+    'M192 474h672q8 0 8 8v60q0 8-8 8H160q-8 0-8-8v-60q0-8 8-8z',
+  ],
+  CaretDownOutlined: [
+    'M840.4 300H183.6c-19.7 0-30.7 20.8-18.5 35l328.4 380.8c9.4 10.9 27.5 10.9 37 0L858.9 335c12.2-14.2 1.2-35-18.5-35z',
+  ],
+  CaretLeftOutlined: [
+    'M689 165.1L308.2 493.5c-10.9 9.4-10.9 27.5 0 37L689 858.9c14.2 12.2 35 1.2 35-18.5V183.6c0-19.7-20.8-30.7-35-18.5z',
+  ],
+  CaretRightOutlined: [
+    'M715.8 493.5L335 165.1c-14.2-12.2-35-1.2-35 18.5v656.8c0 19.7 20.8 30.7 35 18.5l380.8-328.4c10.9-9.4 10.9-27.6 0-37z',
+  ],
+  CaretUpOutlined: [
+    'M858.9 689L530.5 308.2c-9.4-10.9-27.5-10.9-37 0L165.1 689c-12.2 14.2-1.2 35 18.5 35h656.8c19.7 0 30.7-20.8 18.5-35z',
+  ],
+  InfoCircleOutlined: [
+    'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z',
+    'M464 336a48 48 0 1096 0 48 48 0 10-96 0zm72 112h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V456c0-4.4-3.6-8-8-8z',
+  ],
+  QuestionOutlined: [
+    'M764 280.9c-14-30.6-33.9-58.1-59.3-81.6C653.1 151.4 584.6 125 512 125s-141.1 26.4-192.7 74.2c-25.4 23.6-45.3 51-59.3 81.7-14.6 32-22 65.9-22 100.9v27c0 6.2 5 11.2 11.2 11.2h54c6.2 0 11.2-5 11.2-11.2v-27c0-99.5 88.6-180.4 197.6-180.4s197.6 80.9 197.6 180.4c0 40.8-14.5 79.2-42 111.2-27.2 31.7-65.6 54.4-108.1 64-24.3 5.5-46.2 19.2-61.7 38.8a110.85 110.85 0 00-23.9 68.6v31.4c0 6.2 5 11.2 11.2 11.2h54c6.2 0 11.2-5 11.2-11.2v-31.4c0-15.7 10.9-29.5 26-32.9 58.4-13.2 111.4-44.7 149.3-88.7 19.1-22.3 34-47.1 44.3-74 10.7-27.9 16.1-57.2 16.1-87 0-35-7.4-69-22-100.9zM512 787c-30.9 0-56 25.1-56 56s25.1 56 56 56 56-25.1 56-56-25.1-56-56-56z',
+  ],
+  PauseOutlined: [
+    'M304 176h80v672h-80zm408 0h-64c-4.4 0-8 3.6-8 8v656c0 4.4 3.6 8 8 8h64c4.4 0 8-3.6 8-8V184c0-4.4-3.6-8-8-8z',
+  ],
+  PlayCircleOutlined: [
+    'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z',
+    'M719.4 499.1l-296.1-215A15.9 15.9 0 0 0 398 297v430c0 13.1 14.8 20.5 25.3 12.9l296.1-215a15.9 15.9 0 0 0 0-25.8zm-257.6 134V390.9L628.5 512 461.8 633.1z',
+  ],
+  SoundOutlined: [
+    'M625.9 115c-5.9 0-11.9 1.6-17.4 5.3L254 352H90c-8.8 0-16 7.2-16 16v288c0 8.8 7.2 16 16 16h164l354.5 231.7c5.5 3.6 11.6 5.3 17.4 5.3 16.7 0 32.1-13.3 32.1-32.1V147.1c0-18.8-15.4-32.1-32.1-32.1zM586 803L293.4 611.7l-18-11.7H146V424h129.4l17.9-11.7L586 221v582zm348-327H806c-8.8 0-16 7.2-16 16v40c0 8.8 7.2 16 16 16h128c8.8 0 16-7.2 16-16v-40c0-8.8-7.2-16-16-16zm-41.9 261.8l-110.3-63.7a15.9 15.9 0 0 0-21.7 5.9l-19.9 34.5c-4.4 7.6-1.8 17.4 5.8 21.8L856.3 800a15.9 15.9 0 0 0 21.7-5.9l19.9-34.5c4.4-7.6 1.7-17.4-5.8-21.8zM760 344a15.9 15.9 0 0 0 21.7 5.9L892 286.2c7.6-4.4 10.2-14.2 5.8-21.8L878 230a15.9 15.9 0 0 0-21.7-5.9L746 287.8a15.99 15.99 0 0 0-5.8 21.8L760 344z',
+  ],
+  MutedOutlined: [
+    'M771.915 115c-5.863 0-11.877 1.644-17.42 5.267L400 351.966H236c-8.837 0-16 7.165-16 16.003V656.03c0 8.838 7.163 16.003 16 16.003h164l354.495 231.7c5.542 3.621 11.558 5.267 17.42 5.267C788.566 909 804 895.749 804 876.94V147.06c0-18.808-15.436-32.06-32.085-32.06M732 220.997v582.005L439.386 611.75l-17.948-11.73H292V423.98h129.438l17.948-11.73z',
+  ],
+};
+
+export function iconPathsByName(name?: string): string[] | undefined {
+  if (!name) return undefined;
+  return iconPathMap[name] ?? iconPathMap[DEFAULT_ICON];
+}