@akta/algomd-rn 0.0.1-canary

package/src/hooks/useAlgomdData.ts

@@ -0,0 +1,445 @@
+/**
+ * AlgoMD self-fetching data hooks.
+ *
+ * Each hook reads directly from algod/indexer (via @akta/sdk typed clients
+ * where available) and maps to the algomd-rn display types.
+ */
+
+// These web APIs are available in Hermes / all modern JS engines but not in TS "esnext" lib
+declare const TextDecoder: { new (): { decode(input?: ArrayBuffer | Uint8Array): string } }
+declare function btoa(data: string): string
+
+import { useQuery } from '@tanstack/react-query'
+import { useAlgorandClient, useIndexerClient } from './useAlgorandClient'
+import { useAlgomd } from '../provider/context'
+import type { AlgorandClient } from '@algorandfoundation/algokit-utils'
+import type {
+  AlgorandAccount,
+  ASA as ASAType,
+  TransactionDetails as TransactionDetailsType,
+  NFDProfile as NFDProfileType,
+  Poll as PollType,
+  PollOption,
+  RaffleListing as RaffleListingType,
+  AuctionListing as AuctionListingType,
+  TradeOffer as TradeOfferType,
+  NFTListing as NFTListingType,
+} from '../types/algorand'
+
+// ---------------------------------------------------------------------------
+// Shared helper: fetch ASA details from algod
+// ---------------------------------------------------------------------------
+
+async function fetchASADetails(algorand: AlgorandClient, assetId: number | bigint): Promise<ASAType> {
+  try {
+    const info = await algorand.client.algod.getAssetByID(BigInt(assetId)).do()
+    const params = info.params
+    return {
+      id: Number(assetId),
+      name: params.name ?? `Asset #${assetId}`,
+      unitName: params.unitName ?? '',
+      total: Number(params.total),
+      decimals: Number(params.decimals),
+      defaultFrozen: params.defaultFrozen ?? false,
+      url: params.url,
+      creator: params.creator ?? '',
+      createdAt: new Date(),
+      verified: false,
+    }
+  } catch {
+    return {
+      id: Number(assetId),
+      name: `Asset #${assetId}`,
+      unitName: '???',
+      total: 0,
+      decimals: 0,
+      defaultFrozen: false,
+      creator: '',
+      createdAt: new Date(),
+      verified: false,
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// On-chain hooks (algod / indexer)
+// ---------------------------------------------------------------------------
+
+export function useAccountData(address: string | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'account', address],
+    queryFn: async (): Promise<AlgorandAccount> => {
+      if (!address) throw new Error('No address provided')
+      const info = await algorand.client.algod.accountInformation(address).do()
+      const assets: ASAType[] = (info.assets ?? []).map(
+        (a: { assetId: bigint; amount: bigint }) => ({
+          id: Number(a.assetId),
+          name: `Asset #${a.assetId}`,
+          unitName: '',
+          total: Number(a.amount),
+          decimals: 0,
+          defaultFrozen: false,
+          creator: '',
+          createdAt: new Date(),
+          verified: false,
+        }),
+      )
+      return {
+        id: address,
+        address,
+        balance: Number(info.amount),
+        assets,
+        apps: (info.appsLocalState ?? []).map(
+          (a: { id: bigint }) => ({
+            id: Number(a.id),
+            creator: '',
+            globalState: {},
+            localState: {},
+            params: {
+              globalNumUint: 0,
+              globalNumByteSlice: 0,
+              localNumUint: 0,
+              localNumByteSlice: 0,
+            },
+            createdAt: new Date(),
+          }),
+        ),
+        createdAt: new Date(),
+        isOnline: info.status === 'Online',
+        round: Number(info.round ?? 0),
+      }
+    },
+    enabled: !!address,
+    staleTime: 60_000,
+  })
+}
+
+export function useASAData(assetId: number | string | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'asa', assetId],
+    queryFn: async (): Promise<ASAType> => {
+      if (!assetId) throw new Error('No asset ID provided')
+      return fetchASADetails(algorand, Number(assetId))
+    },
+    enabled: assetId != null,
+    staleTime: 60_000,
+  })
+}
+
+export function useTransactionData(txId: string | undefined) {
+  const indexer = useIndexerClient()
+  return useQuery({
+    queryKey: ['algomd', 'transaction', txId],
+    queryFn: async (): Promise<TransactionDetailsType> => {
+      if (!txId) throw new Error('No transaction ID provided')
+      if (!indexer) throw new Error('Indexer not configured')
+      const result = await indexer.lookupTransactionByID(txId).do()
+      const txn = result.transaction
+
+      const typeMap: Record<string, TransactionDetailsType['type']> = {
+        pay: 'payment',
+        axfer: 'asset-transfer',
+        appl: 'application-call',
+        acfg: 'asset-config',
+        keyreg: 'key-registration',
+        afrz: 'asset-freeze',
+      }
+
+      // algosdk v3 indexer returns note as Uint8Array, not base64 string
+      let note: string | undefined
+      if (txn.note) {
+        try {
+          note = new TextDecoder().decode(txn.note)
+        } catch {
+          note = undefined
+        }
+      }
+
+      return {
+        id: txId,
+        type: typeMap[txn.txType ?? ''] ?? 'payment',
+        from: txn.sender,
+        to: txn.paymentTransaction?.receiver ?? txn.assetTransferTransaction?.receiver,
+        amount: Number(
+          txn.paymentTransaction?.amount ?? txn.assetTransferTransaction?.amount ?? 0,
+        ),
+        fee: Number(txn.fee),
+        round: Number(txn.confirmedRound),
+        timestamp: new Date((txn.roundTime ?? 0) * 1000),
+        confirmed: !!txn.confirmedRound,
+        signature: (() => {
+          const sig = txn.signature?.sig
+          if (!sig) return ''
+          if (typeof sig === 'string') return sig
+          // Convert Uint8Array to base64 without Node Buffer
+          return btoa(Array.from(sig as Uint8Array, (b: number) => String.fromCharCode(b)).join(''))
+        })(),
+        note,
+      }
+    },
+    enabled: !!txId && !!indexer,
+    staleTime: 120_000,
+  })
+}
+
+export function useNFDProfileData(name: string | undefined) {
+  const { config } = useAlgomd()
+  const nfdApiUrl = config.nfdApiUrl ?? 'https://api.nf.domains'
+  return useQuery({
+    queryKey: ['algomd', 'nfd', name],
+    queryFn: async (): Promise<NFDProfileType> => {
+      if (!name) throw new Error('No NFD name provided')
+      const response = await fetch(`${nfdApiUrl}/nfd/${encodeURIComponent(name)}`)
+      if (!response.ok) throw new Error(`NFD lookup failed: ${response.status}`)
+      const nfd = await response.json()
+      return {
+        id: nfd.appID?.toString() ?? name,
+        name: nfd.name ?? name,
+        address: nfd.depositAccount ?? nfd.caAlgo?.[0] ?? '',
+        avatar: nfd.properties?.userDefined?.avatar,
+        bio: nfd.properties?.userDefined?.bio,
+        properties: nfd.properties?.userDefined ?? {},
+        verified: nfd.properties?.verified?.caAlgo === nfd.caAlgo?.[0],
+        createdAt: new Date(nfd.timeCreated ?? Date.now()),
+      }
+    },
+    enabled: !!name,
+    staleTime: 120_000,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// On-chain contract hooks (via @akta/sdk typed clients)
+// ---------------------------------------------------------------------------
+
+export function usePollData(appId: number | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'poll', appId],
+    queryFn: async (): Promise<PollType> => {
+      if (!appId) throw new Error('No poll app ID provided')
+      const { PollSDK } = await import('@akta/sdk')
+      const sdk = new PollSDK({
+        algorand,
+        factoryParams: { appId: BigInt(appId) },
+      })
+      const state = await sdk.state()
+
+      const optionTexts = [state.question, state.optionOne, state.optionTwo, state.optionThree, state.optionFour, state.optionFive]
+      const optionVotes = [state.votesOne, state.votesTwo, state.votesThree, state.votesFour, state.votesFive]
+      const options: PollOption[] = []
+      const count = Number(state.optionCount)
+      for (let i = 0; i < count && i < 5; i++) {
+        options.push({
+          id: `${i + 1}`,
+          text: optionTexts[i + 1] || `Option ${i + 1}`,
+          votes: Number(optionVotes[i]),
+          votingPower: Number(optionVotes[i]),
+        })
+      }
+
+      const endTime = Number(state.endTime)
+      const now = Date.now() / 1000
+      const isExpired = endTime > 0 && endTime < now
+      const totalVotes = optionVotes.slice(0, count).reduce((sum, v) => sum + Number(v), 0)
+
+      return {
+        id: appId.toString(),
+        question: state.question,
+        options,
+        creator: '',
+        createdAt: new Date(),
+        expiresAt: endTime > 0 ? new Date(endTime * 1000) : undefined,
+        totalVotes,
+        status: isExpired ? 'ended' : 'active',
+        gating: Number(state.gateId) > 0
+          ? { type: 'asset-holding' as const, requirements: { assets: [{ assetId: Number(state.gateId), minimumBalance: 1 }] } }
+          : undefined,
+      }
+    },
+    enabled: appId != null,
+    staleTime: 30_000,
+  })
+}
+
+export function useRaffleData(appId: number | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'raffle', appId],
+    queryFn: async (): Promise<RaffleListingType> => {
+      if (!appId) throw new Error('No raffle app ID provided')
+      const { RaffleSDK } = await import('@akta/sdk')
+      const sdk = new RaffleSDK({
+        algorand,
+        factoryParams: { appId: BigInt(appId) },
+      })
+      const state = await sdk.state()
+
+      const [prizeAsset, entryAsset] = await Promise.all([
+        fetchASADetails(algorand, Number(state.prize)),
+        fetchASADetails(algorand, Number(state.ticketAsset)),
+      ])
+
+      const startTs = Number(state.startTimestamp)
+      const endTs = Number(state.endTimestamp)
+      const now = Date.now() / 1000
+      let status: RaffleListingType['status']
+      if (startTs > now) status = 'upcoming'
+      else if (endTs > now) status = 'active'
+      else status = 'ended'
+
+      return {
+        id: appId.toString(),
+        title: `Raffle #${appId}`,
+        description: `Win ${prizeAsset.name}! Entry costs ${entryAsset.unitName || 'tokens'}.`,
+        pricePerEntry: 1,
+        entryAsset,
+        startTime: new Date(startTs * 1000),
+        endTime: new Date(endTs * 1000),
+        prizes: [prizeAsset],
+        entryCount: Number(state.entryCount),
+        ticketCount: Number(state.maxTickets),
+        creator: state.seller ?? '',
+        status,
+      }
+    },
+    enabled: appId != null,
+    staleTime: 30_000,
+  })
+}
+
+export function useAuctionData(appId: number | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'auction', appId],
+    queryFn: async (): Promise<AuctionListingType> => {
+      if (!appId) throw new Error('No auction app ID provided')
+      const { AuctionSDK } = await import('@akta/sdk')
+      const sdk = new AuctionSDK({
+        algorand,
+        factoryParams: { appId: BigInt(appId) },
+      })
+      const state = await sdk.state()
+
+      const [prizeAsset, bidAsset] = await Promise.all([
+        fetchASADetails(algorand, Number(state.prize)),
+        fetchASADetails(algorand, Number(state.bidAsset)),
+      ])
+
+      const startTs = Number(state.startTimestamp)
+      const endTs = Number(state.endTimestamp)
+      const now = Date.now() / 1000
+      let status: AuctionListingType['status']
+      if (startTs > now) status = 'upcoming'
+      else if (endTs > now) status = 'active'
+      else status = 'ended'
+
+      const bidDecimals = bidAsset.decimals || 0
+      const divisor = Math.pow(10, bidDecimals)
+
+      return {
+        id: appId.toString(),
+        title: `Auction #${appId}`,
+        description: `Bid on ${prizeAsset.name} with ${bidAsset.unitName || 'tokens'}.`,
+        bidAsset,
+        currentHighestBid: Number(state.highestBid) / divisor,
+        minimumNextBid: (Number(state.highestBid) + Number(state.bidMinimumIncrease)) / divisor,
+        startTime: new Date(startTs * 1000),
+        endTime: new Date(endTs * 1000),
+        prizes: [prizeAsset],
+        bidFeePercentage: Number(state.bidFee) > 0 ? Number(state.bidFee) / 100 : undefined,
+        currentBidFeePool: 0,
+        bidCount: Number(state.bidID),
+        timeExtended: false,
+        creator: state.seller ?? '',
+        status,
+      }
+    },
+    enabled: appId != null,
+    staleTime: 30_000,
+  })
+}
+
+export function useNFTListingData(appId: number | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'nftlisting', appId],
+    queryFn: async (): Promise<NFTListingType> => {
+      if (!appId) throw new Error('No NFT listing app ID provided')
+      const { MarketplaceSDK } = await import('@akta/sdk')
+      const marketplace = new MarketplaceSDK({
+        algorand,
+        factoryParams: {},
+      })
+      const listing = marketplace.getListing({ appId: BigInt(appId) })
+      const state = await listing.state()
+
+      const [nftAsset, paymentAsset] = await Promise.all([
+        fetchASADetails(algorand, Number(state.prize)),
+        fetchASADetails(algorand, Number(state.paymentAsset)),
+      ])
+
+      const payDecimals = paymentAsset.decimals || 0
+      const divisor = Math.pow(10, payDecimals)
+
+      return {
+        id: appId.toString(),
+        nft: nftAsset,
+        price: Number(state.price) / divisor,
+        priceAsset: paymentAsset,
+        currency: paymentAsset.unitName || 'ALGO',
+        seller: state.seller ?? '',
+        authenticityBadge: false,
+        quantity: 1,
+        reservedFor: state.reservedFor && state.reservedFor !== 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ' ? state.reservedFor : undefined,
+        views: 0,
+        favorites: 0,
+        createdAt: new Date(),
+        listedAt: new Date(),
+        expiresAt: Number(state.expiration) > 0 ? new Date(Number(state.expiration) * 1000) : undefined,
+      }
+    },
+    enabled: appId != null,
+    staleTime: 60_000,
+  })
+}
+
+export function useTradeOfferData(appId: number | undefined, offerId: number | undefined) {
+  const algorand = useAlgorandClient()
+  return useQuery({
+    queryKey: ['algomd', 'trade', appId, offerId],
+    queryFn: async (): Promise<TradeOfferType> => {
+      if (appId == null || offerId == null) throw new Error('No trade offer ID provided')
+      const { HyperSwapSDK } = await import('@akta/sdk')
+      const sdk = new HyperSwapSDK({
+        algorand,
+        factoryParams: { appId: BigInt(appId) },
+      })
+      const offer = await sdk.getOffer({ id: BigInt(offerId) })
+
+      const stateMap: Record<number, TradeOfferType['status']> = {
+        10: 'pending',   // Offered
+        20: 'pending',   // Escrowing
+        30: 'pending',   // Disbursing
+        40: 'accepted',  // Completed
+        50: 'expired',   // Cancelled
+        60: 'expired',   // CancelCompleted
+      }
+
+      return {
+        id: offerId.toString(),
+        creator: '',
+        recipients: [],
+        offering: [],
+        requesting: [],
+        expiresAt: new Date(Number(offer.expiration) * 1000),
+        status: stateMap[offer.state] ?? 'pending',
+        createdAt: new Date(),
+      }
+    },
+    enabled: appId != null && offerId != null,
+    staleTime: 60_000,
+  })
+}

package/src/hooks/useAlgorandClient.ts

@@ -0,0 +1,39 @@
+import { useMemo } from 'react'
+import { AlgorandClient } from '@algorandfoundation/algokit-utils'
+import algosdk from 'algosdk'
+import { useAlgomd } from '../provider/context'
+import { NETWORK_DEFAULTS } from '../provider/networks'
+
+/**
+ * Creates a memoized AlgorandClient from provider config.
+ */
+export function useAlgorandClient(): AlgorandClient {
+  const { config } = useAlgomd()
+
+  return useMemo(() => {
+    const defaults = NETWORK_DEFAULTS[config.network]
+    const server = config.algodServer ?? defaults.algodServer
+    const port = config.algodPort ?? defaults.algodPort
+    const token = config.algodToken ?? defaults.algodToken ?? ''
+
+    return AlgorandClient.fromConfig({
+      algodConfig: { server, port, token },
+    })
+  }, [config.network, config.algodServer, config.algodPort, config.algodToken])
+}
+
+/**
+ * Creates a memoized Indexer client from provider config.
+ * Returns null if indexer is not configured.
+ */
+export function useIndexerClient(): algosdk.Indexer | null {
+  const { config } = useAlgomd()
+
+  return useMemo(() => {
+    const defaults = NETWORK_DEFAULTS[config.network]
+    const server = config.indexerServer ?? defaults.indexerServer
+    if (!server) return null
+    const token = config.indexerToken ?? defaults.indexerToken ?? ''
+    return new algosdk.Indexer(token, server, '')
+  }, [config.network, config.indexerServer, config.indexerToken])
+}

package/src/index.ts

@@ -0,0 +1,83 @@
+// Provider
+export { AlgomdProvider, useAlgomd, defaultResolveImageUrl, NETWORK_DEFAULTS } from './provider';
+export type { AlgomdConfig, AlgomdNetwork } from './provider';
+
+// Self-fetching Components
+export {
+  Account,
+  ASA,
+  NFTListing,
+  NFDProfile,
+  TransactionDetails,
+  Poll,
+  RaffleListing,
+  AuctionListing,
+  TradeOffer,
+  // Display-only (no self-fetch)
+  AccountDisplay,
+  ASADisplay,
+  NFTListingDisplay,
+  NFDProfileDisplay,
+  TransactionDetailsDisplay,
+  PollDisplay,
+  RaffleListingDisplay,
+  AuctionListingDisplay,
+  TradeOfferDisplay,
+  // Search
+  AccountSearch,
+  ASASearch,
+  NFTSearch,
+  NFDSearch,
+  TransactionSearch,
+  PollSearch,
+  TradeSearch,
+} from './components';
+
+// Hooks
+export {
+  useAlgorandClient,
+  useIndexerClient,
+  useAccountData,
+  useASAData,
+  useTransactionData,
+  useNFDProfileData,
+  usePollData,
+  useRaffleData,
+  useAuctionData,
+  useNFTListingData,
+  useTradeOfferData,
+} from './hooks';
+
+// Shared UI
+export { SizeContainer, CopyButton, StatusBadge, ProgressBar, SearchSheet } from './ui';
+export { LoadingSkeleton, ErrorState } from './ui/DataStates';
+
+// Types
+export type {
+  AlgorandAccount,
+  ASA as ASAType,
+  NFTListing as NFTListingType,
+  NFDProfile as NFDProfileType,
+  TransactionDetails as TransactionDetailsType,
+  RaffleListing as RaffleListingType,
+  AuctionListing as AuctionListingType,
+  TradeOffer as TradeOfferType,
+  Poll as PollType,
+  PollOption,
+  GatingInfo,
+  Application,
+  ComponentSize,
+  SearchResult,
+  SearchableEntity,
+} from './types';
+
+// Utilities
+export {
+  formatAddress,
+  formatNumber,
+  formatCurrency,
+  formatDate,
+  formatRelativeTime,
+  formatAssetAmount,
+  searchEntities,
+} from './utils';

package/src/provider/AlgomdProvider.tsx

@@ -0,0 +1,45 @@
+import React, { useMemo } from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { AlgomdContext, type AlgomdContextValue } from './context'
+import type { AlgomdConfig } from './types'
+import { defaultResolveImageUrl } from './imageResolver'
+
+interface AlgomdProviderProps {
+  config: AlgomdConfig
+  /** Share cache with consuming app's react-query. If omitted, creates an internal one. */
+  queryClient?: QueryClient
+  children: React.ReactNode
+}
+
+const defaultQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 60_000,
+      retry: 2,
+    },
+  },
+})
+
+export function AlgomdProvider({ config, queryClient, children }: AlgomdProviderProps) {
+  const contextValue = useMemo<AlgomdContextValue>(() => ({
+    config,
+    resolveImageUrl: config.resolveImageUrl ?? defaultResolveImageUrl,
+  }), [config])
+
+  const content = (
+    <AlgomdContext.Provider value={contextValue}>
+      {children}
+    </AlgomdContext.Provider>
+  )
+
+  // If a queryClient is provided (shared), don't wrap with another QueryClientProvider
+  if (queryClient) {
+    return content
+  }
+
+  return (
+    <QueryClientProvider client={defaultQueryClient}>
+      {content}
+    </QueryClientProvider>
+  )
+}

package/src/provider/context.ts

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react'
+import type { AlgomdConfig } from './types'
+import { defaultResolveImageUrl } from './imageResolver'
+
+export interface AlgomdContextValue {
+  config: AlgomdConfig
+  resolveImageUrl: (src: string, width: number, quality?: number) => string
+}
+
+export const AlgomdContext = createContext<AlgomdContextValue | null>(null)
+
+export function useAlgomd(): AlgomdContextValue {
+  const ctx = useContext(AlgomdContext)
+  if (!ctx) {
+    throw new Error('useAlgomd must be used within an <AlgomdProvider>')
+  }
+  return ctx
+}

package/src/provider/imageResolver.ts

@@ -0,0 +1,12 @@
+/**
+ * Default image URL resolver using Akita CDN proxy.
+ * Transforms IPFS and HTTP(S) URLs into optimized CDN URLs.
+ */
+export function defaultResolveImageUrl(src: string, width: number, quality = 75): string {
+  if (!src.startsWith('ipfs://') && !src.startsWith('https://') && !src.startsWith('http://'))
+    return src
+  const format = src.includes('.gif') ? 'gif' : 'jpeg'
+  const params = [`${width}x`, `q${quality}`, format]
+  const resolved = src.replace('ipfs://', 'https://ipfs.akita.community/ipfs/')
+  return `https://imageproxy.akita.community/${params.join(',')}/${resolved}`
+}

package/src/provider/index.ts

@@ -0,0 +1,5 @@
+export { AlgomdProvider } from './AlgomdProvider'
+export { useAlgomd } from './context'
+export { defaultResolveImageUrl } from './imageResolver'
+export { NETWORK_DEFAULTS } from './networks'
+export type { AlgomdConfig, AlgomdNetwork } from './types'

package/src/provider/networks.ts

@@ -0,0 +1,23 @@
+import type { AlgomdNetwork } from './types'
+
+export const NETWORK_DEFAULTS: Record<AlgomdNetwork, {
+  algodServer: string
+  algodPort?: number
+  algodToken?: string
+  indexerServer: string
+  indexerToken?: string
+}> = {
+  mainnet: {
+    algodServer: 'https://mainnet-api.4160.nodely.dev',
+    indexerServer: 'https://mainnet-idx.4160.nodely.dev',
+  },
+  testnet: {
+    algodServer: 'https://testnet-api.4160.nodely.dev',
+    indexerServer: 'https://testnet-idx.4160.nodely.dev',
+  },
+  localnet: {
+    algodServer: 'http://localhost:4001',
+    algodToken: 'a'.repeat(64),
+    indexerServer: 'http://localhost:8980',
+  },
+}

package/src/provider/types.ts

@@ -0,0 +1,17 @@
+export type AlgomdNetwork = 'mainnet' | 'testnet' | 'localnet'
+
+export interface AlgomdConfig {
+  /** Network - determines default algod/indexer URLs */
+  network: AlgomdNetwork
+  /** Override algod server URL */
+  algodServer?: string
+  algodPort?: number
+  algodToken?: string
+  /** Override indexer server URL (needed for Transaction) */
+  indexerServer?: string
+  indexerToken?: string
+  /** Override NFD API URL (default: https://api.nf.domains) */
+  nfdApiUrl?: string
+  /** Override image URL resolver (default: Akita CDN proxy) */
+  resolveImageUrl?: (src: string, width: number, quality?: number) => string
+}