@lukso/transaction-view-headless 0.2.2-dev.a8c9315

package/dist/composables/index.cjs

@@ -0,0 +1,1321 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/lukso-config.ts
+function setLuksoConfig(config) {
+  globalConfig = { ...globalConfig, ...config };
+  clearAddressCache();
+  if (typeof window !== "undefined" && window.console) {
+    console.log("\u{1F310} LUKSO Config Updated:", {
+      chainId: globalConfig.chainId,
+      network: globalConfig.chainId === 42 ? "mainnet" : globalConfig.chainId === 4201 ? "testnet" : "custom",
+      addressResolution: globalConfig.enableAddressResolution
+    });
+  }
+}
+function getLuksoConfig() {
+  return { ...globalConfig };
+}
+function useLuksoMainnet() {
+  setLuksoConfig({
+    chainId: 42,
+    rpcUrl: "https://rpc.lukso.network"
+  });
+}
+function useLuksoTestnet() {
+  setLuksoConfig({
+    chainId: 4201,
+    rpcUrl: "https://rpc.testnet.lukso.network"
+  });
+}
+function cacheAddress(address, data) {
+  if (!globalConfig.enableAddressResolution) return;
+  const key = address.toLowerCase();
+  addressCache.set(key, data);
+  cacheTimestamps.set(key, Date.now());
+}
+function getCachedAddress(address) {
+  if (!globalConfig.enableAddressResolution) return null;
+  const key = address.toLowerCase();
+  const data = addressCache.get(key);
+  const timestamp = cacheTimestamps.get(key);
+  if (!data || !timestamp) return null;
+  if (Date.now() - timestamp > globalConfig.cacheDuration) {
+    addressCache.delete(key);
+    cacheTimestamps.delete(key);
+    return null;
+  }
+  return data;
+}
+function clearAddressCache() {
+  addressCache.clear();
+  cacheTimestamps.clear();
+}
+function isAddressResolutionEnabled() {
+  return globalConfig.enableAddressResolution ?? true;
+}
+async function initializeChainSignal() {
+  if (currentChainSignal.value) return;
+  try {
+    const { lukso, luksoTestnet } = await import("viem/chains");
+    const config = getLuksoConfig();
+    const chain = config.chainId === 42 ? lukso : luksoTestnet;
+    currentChainSignal.value = chain;
+  } catch (error) {
+    console.warn("Failed to initialize chain signal:", error);
+  }
+}
+var import_signals_core, DEFAULT_CONFIG, globalConfig, addressCache, cacheTimestamps, currentChainSignal;
+var init_lukso_config = __esm({
+  "src/config/lukso-config.ts"() {
+    "use strict";
+    import_signals_core = require("@preact/signals-core");
+    DEFAULT_CONFIG = {
+      chainId: 42,
+      // LUKSO mainnet
+      rpcUrl: "https://rpc.lukso.network",
+      graphqlEndpoint: "/api/graphql",
+      // Use local API proxy
+      ipfsGateway: "https://api.universalprofile.cloud/ipfs",
+      enableAddressResolution: true,
+      cacheDuration: 5 * 60 * 1e3
+      // 5 minutes
+    };
+    globalConfig = { ...DEFAULT_CONFIG };
+    addressCache = /* @__PURE__ */ new Map();
+    cacheTimestamps = /* @__PURE__ */ new Map();
+    currentChainSignal = (0, import_signals_core.signal)(null);
+  }
+});
+
+// src/hooks/useAddressResolution.ts
+var useAddressResolution_exports = {};
+__export(useAddressResolution_exports, {
+  createAddressResolutionState: () => createAddressResolutionState,
+  resolveAddress: () => resolveAddress,
+  resolveAddressWithState: () => resolveAddressWithState,
+  resolveAddresses: () => resolveAddresses
+});
+function truncateAddress(address, prefixLength = 5, suffixLength = 4) {
+  if (!address || address.length <= prefixLength + suffixLength + 2) {
+    return address;
+  }
+  const prefix = address.slice(0, 2 + prefixLength);
+  const suffix = address.slice(-suffixLength);
+  return `${prefix}...${suffix}`;
+}
+function getBatchState(chainId) {
+  let state = chainBatchStates.get(chainId);
+  if (!state) {
+    state = {
+      batchTimeout: null,
+      batchQueue: /* @__PURE__ */ new Set(),
+      batchResolvers: /* @__PURE__ */ new Map(),
+      pendingResolutions: /* @__PURE__ */ new Map(),
+      isProcessing: false
+    };
+    chainBatchStates.set(chainId, state);
+  }
+  return state;
+}
+async function processBatch(chainId) {
+  const state = getBatchState(chainId);
+  if (state.batchQueue.size === 0 || state.isProcessing) return;
+  state.isProcessing = true;
+  const addresses = Array.from(state.batchQueue);
+  state.batchQueue.clear();
+  try {
+    const { fetchMultipleAddresses: fetchMultipleAddresses2, getGraphQLEndpoint: getGraphQLEndpoint2 } = await import("@lukso/transaction-decoder");
+    const { lukso, luksoTestnet } = await import("viem/chains");
+    const chain = chainId === 42 ? lukso : luksoTestnet;
+    const graphqlEndpoint = getGraphQLEndpoint2(chain);
+    const dataKeys = addresses;
+    const results = await fetchMultipleAddresses2(dataKeys, graphqlEndpoint);
+    for (const address of addresses) {
+      const normalizedAddress = address.toLowerCase();
+      const enhanced = results.get(normalizedAddress);
+      let result;
+      if (enhanced) {
+        const profileImages = enhanced.profileImages;
+        const resolvedData = {
+          ...enhanced,
+          hasProfile: !!(enhanced.name || profileImages?.length)
+        };
+        cacheAddressForChain(address, resolvedData, chainId);
+        result = {
+          ...resolvedData,
+          address,
+          truncatedAddress: truncateAddress(address)
+        };
+      } else {
+        result = {
+          address,
+          truncatedAddress: truncateAddress(address),
+          hasProfile: false
+        };
+        cacheAddressForChain(address, { hasProfile: false }, chainId);
+      }
+      const resolver = state.batchResolvers.get(normalizedAddress);
+      if (resolver) {
+        resolver(result);
+        state.batchResolvers.delete(normalizedAddress);
+      }
+    }
+  } catch (error) {
+    console.warn(
+      "Batch address resolution failed (falling back to API):",
+      error
+    );
+    try {
+      const response = await fetch("/api/resolveAddresses", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          addresses,
+          chainId
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`API fallback failed: ${response.status}`);
+      }
+      const data = await response.json();
+      for (const address of addresses) {
+        const normalizedAddress = address.toLowerCase();
+        const resolved = data.resolved?.[normalizedAddress];
+        let result;
+        if (resolved) {
+          const resolvedData = {
+            name: resolved.name,
+            profileImage: resolved.profileImage,
+            hasProfile: !!(resolved.name || resolved.profileImage)
+          };
+          cacheAddressForChain(address, resolvedData, chainId);
+          result = {
+            address,
+            truncatedAddress: truncateAddress(address),
+            ...resolvedData
+          };
+        } else {
+          result = {
+            address,
+            truncatedAddress: truncateAddress(address),
+            hasProfile: false
+          };
+          cacheAddressForChain(address, { hasProfile: false }, chainId);
+        }
+        const resolver = state.batchResolvers.get(normalizedAddress);
+        if (resolver) {
+          resolver(result);
+          state.batchResolvers.delete(normalizedAddress);
+        }
+      }
+    } catch (fallbackError) {
+      console.warn("Both GraphQL and API resolution failed:", fallbackError);
+      for (const address of addresses) {
+        const fallback = {
+          address,
+          truncatedAddress: truncateAddress(address),
+          hasProfile: false
+        };
+        cacheAddressForChain(address, { hasProfile: false }, chainId);
+        const resolver = state.batchResolvers.get(address.toLowerCase());
+        if (resolver) {
+          resolver(fallback);
+          state.batchResolvers.delete(address.toLowerCase());
+        }
+      }
+    }
+  } finally {
+    state.isProcessing = false;
+  }
+}
+function cacheAddressForChain(address, data, chainId) {
+  const key = `${address.toLowerCase()}:${chainId}`;
+  cacheAddress(key, data);
+}
+function getCachedAddressForChain(address, chainId) {
+  const key = `${address.toLowerCase()}:${chainId}`;
+  return getCachedAddress(key);
+}
+async function getEffectiveChainId(chainId) {
+  if (chainId !== void 0) return chainId;
+  await initializeChainSignal();
+  const currentChain = currentChainSignal.value;
+  if (currentChain) {
+    return currentChain.id;
+  }
+  const config = getLuksoConfig();
+  return config.chainId;
+}
+async function resolveAddress(address, chainId) {
+  const effectiveChainId = await getEffectiveChainId(chainId);
+  const normalizedAddress = address.toLowerCase();
+  const fallback = {
+    address,
+    truncatedAddress: truncateAddress(address),
+    hasProfile: false
+  };
+  if (!isAddressResolutionEnabled()) {
+    return fallback;
+  }
+  const cached = getCachedAddressForChain(address, effectiveChainId);
+  if (cached) {
+    return {
+      ...fallback,
+      ...cached,
+      hasProfile: !!(cached.name || cached.profileImage)
+    };
+  }
+  const state = getBatchState(effectiveChainId);
+  const existingPromise = state.pendingResolutions.get(normalizedAddress);
+  if (existingPromise) {
+    return existingPromise;
+  }
+  if (state.batchQueue.has(normalizedAddress)) {
+    return Promise.resolve(fallback);
+  }
+  const resolutionPromise = new Promise((resolve) => {
+    state.batchQueue.add(normalizedAddress);
+    state.batchResolvers.set(normalizedAddress, resolve);
+    if (state.batchTimeout) {
+      clearTimeout(state.batchTimeout);
+    }
+    if (!state.isProcessing) {
+      state.batchTimeout = setTimeout(() => {
+        state.batchTimeout = null;
+        processBatch(effectiveChainId);
+      }, BATCH_DELAY);
+      if (state.batchQueue.size >= BATCH_SIZE) {
+        if (state.batchTimeout) {
+          clearTimeout(state.batchTimeout);
+          state.batchTimeout = null;
+        }
+        processBatch(effectiveChainId);
+      }
+    }
+  });
+  state.pendingResolutions.set(normalizedAddress, resolutionPromise);
+  resolutionPromise.finally(() => {
+    state.pendingResolutions.delete(normalizedAddress);
+  });
+  return resolutionPromise;
+}
+async function resolveAddresses(addresses, chainId) {
+  const results = /* @__PURE__ */ new Map();
+  const resolutionPromises = addresses.map(async (address) => {
+    const resolved = await resolveAddress(address, chainId);
+    results.set(address.toLowerCase(), resolved);
+  });
+  await Promise.all(resolutionPromises);
+  return results;
+}
+function createAddressResolutionState() {
+  return {
+    resolved: null,
+    loading: false,
+    error: null
+  };
+}
+async function resolveAddressWithState(address, _state, updateCallback, chainId) {
+  updateCallback({ loading: true, error: null });
+  try {
+    const resolved = await resolveAddress(address, chainId);
+    updateCallback({
+      resolved,
+      loading: false,
+      error: null
+    });
+  } catch (error) {
+    updateCallback({
+      loading: false,
+      error: error instanceof Error ? error.message : "Resolution failed"
+    });
+  }
+}
+var chainBatchStates, BATCH_DELAY, BATCH_SIZE;
+var init_useAddressResolution = __esm({
+  "src/hooks/useAddressResolution.ts"() {
+    "use strict";
+    init_lukso_config();
+    chainBatchStates = /* @__PURE__ */ new Map();
+    BATCH_DELAY = 0;
+    BATCH_SIZE = 50;
+  }
+});
+
+// src/composables/index.ts
+var composables_exports = {};
+__export(composables_exports, {
+  cacheAddress: () => cacheAddress,
+  clearAddressCache: () => clearAddressCache,
+  createAddressResolutionState: () => createAddressResolutionState,
+  createTransactionPlayback: () => createTransactionPlayback,
+  findAllTransactionViews: () => findAllTransactionViews,
+  findBestTransactionView: () => findBestTransactionView,
+  getCachedAddress: () => getCachedAddress,
+  getLuksoConfig: () => getLuksoConfig,
+  getValidPlaybackIndices: () => getValidPlaybackIndices,
+  isAddressResolutionEnabled: () => isAddressResolutionEnabled,
+  isValidPlaybackIndex: () => isValidPlaybackIndex,
+  resolveAddress: () => resolveAddress,
+  resolveAddressWithState: () => resolveAddressWithState,
+  resolveAddresses: () => resolveAddresses,
+  setLuksoConfig: () => setLuksoConfig,
+  useAddressResolver: () => useAddressResolver,
+  useImageLoader: () => useImageLoader,
+  useLuksoMainnet: () => useLuksoMainnet,
+  useLuksoTestnet: () => useLuksoTestnet,
+  useTransactionPlayback: () => useTransactionPlayback,
+  useTransactionView: () => useTransactionView
+});
+module.exports = __toCommonJS(composables_exports);
+init_lukso_config();
+init_useAddressResolution();
+
+// src/composables/use-image-loader.ts
+console.log(
+  "\u{1F525} LOADING NEW useAddressResolver CODE - should see GraphQL integration"
+);
+var imageLoadCache = /* @__PURE__ */ new Map();
+function getImageCacheKey(imageData, options) {
+  const imageUrls = imageData.filter((img) => img?.url || img?.src).map((img) => img.url || img.src).sort().join(",");
+  const sizeKey = `${options.width || 32}x${options.height || options.width || 32}@${options.dpr || 1}`;
+  return `${imageUrls}-${sizeKey}`;
+}
+function useImageLoader() {
+  async function loadImage(imageData, options = {}) {
+    try {
+      if (!imageData || imageData.length === 0) {
+        return null;
+      }
+      const loadOptions = {
+        width: options.width || 32,
+        height: options.height || options.width || 32,
+        dpr: options.dpr || (typeof window !== "undefined" ? window.devicePixelRatio : 1),
+        ignoreHead: true
+        // Skip HEAD requests in component context
+      };
+      const cacheKey = getImageCacheKey(imageData, loadOptions);
+      const cachedPromise = imageLoadCache.get(cacheKey);
+      if (cachedPromise) {
+        console.log("\u{1F4F8} loadImage: Using cached promise for", cacheKey);
+        return cachedPromise;
+      }
+      console.log(
+        "\u{1F4F8} loadImage: Creating new request for",
+        imageData.length,
+        "options:",
+        loadOptions
+      );
+      const loadingPromise = (async () => {
+        const { getImage } = await import("@lukso/transaction-decoder");
+        const result = await getImage(imageData, loadOptions);
+        if (result?.src) {
+          console.log("\u{1F4F8} loadImage: Selected image:", result.src);
+          return {
+            src: result.src,
+            width: result.width,
+            height: result.height
+          };
+        }
+        return null;
+      })();
+      imageLoadCache.set(cacheKey, loadingPromise);
+      loadingPromise.finally(() => {
+        loadingPromise.then((result) => {
+          if (!result) {
+            imageLoadCache.delete(cacheKey);
+          }
+        }).catch(() => {
+          imageLoadCache.delete(cacheKey);
+        });
+      });
+      return loadingPromise;
+    } catch (error) {
+      console.warn("Failed to load image:", error);
+      return null;
+    }
+  }
+  async function loadProfileImage(addressData, options = {}) {
+    if (addressData.__gqltype === "Profile") {
+      if (addressData.profileImages?.length) {
+        const result = await loadImage(addressData.profileImages, options);
+        if (result) return result;
+      }
+      if (addressData.icons?.length) {
+        const result = await loadImage(addressData.icons, options);
+        if (result) return result;
+      }
+      if (addressData.images?.length) {
+        return loadImage(addressData.images, options);
+      }
+      return null;
+    }
+    if (addressData.icons?.length) {
+      const result = await loadImage(addressData.icons, options);
+      if (result) return result;
+    }
+    if (addressData.images?.length) {
+      return loadImage(addressData.images, options);
+    }
+    return null;
+  }
+  async function loadBackgroundImage(addressData, options = {}) {
+    const imageGroup = addressData.backgroundImages || [];
+    return loadImage(imageGroup, options);
+  }
+  function getFallbackImage(addressData) {
+    const isProfile = addressData.__gqltype === "Profile";
+    return {
+      src: isProfile ? "/assets/images/profile-default.svg" : "/assets/images/token-default.svg"
+    };
+  }
+  function isContractAddress(addressData) {
+    return addressData.__gqltype !== "Profile";
+  }
+  return {
+    loadImage,
+    loadProfileImage,
+    loadBackgroundImage,
+    getFallbackImage,
+    isContractAddress
+  };
+}
+function useAddressResolver() {
+  async function resolveAddress2(address) {
+    console.log("\u{1F525} useAddressResolver.resolveAddress called with:", address);
+    try {
+      const { resolveAddress: batchedResolve } = await Promise.resolve().then(() => (init_useAddressResolution(), useAddressResolution_exports));
+      console.log("\u{1F525} useAddressResolver: calling batchedResolve...");
+      const resolved = await batchedResolve(address);
+      console.log("\u{1F525} useAddressResolver: batchedResolve returned:", resolved);
+      const result = {
+        // Preserve all image arrays from GraphQL
+        ...resolved,
+        // Override with computed values only if not already set by GraphQL
+        address: resolved.address,
+        name: resolved.name || "",
+        __gqltype: resolved.__gqltype || (resolved.hasProfile ? "Profile" : "Contract")
+      };
+      console.log("\u{1F525} useAddressResolver: returning result:", result);
+      return result;
+    } catch (error) {
+      console.error("\u{1F525} useAddressResolver: Failed to resolve address:", error);
+      return {
+        address,
+        name: "",
+        __gqltype: "Contract",
+        profileImages: [],
+        avatar: [],
+        icon: []
+      };
+    }
+  }
+  function formatDisplayName(addressData) {
+    const baseName = addressData.name?.toLowerCase?.() || addressData.lsp4TokenName || addressData.baseAsset?.lsp4TokenName || "";
+    const symbol = addressData.lsp4TokenSymbol || addressData.baseAsset?.lsp4TokenSymbol || "";
+    return symbol ? `${baseName} (${symbol})` : baseName;
+  }
+  function getAddressPrefix(addressData) {
+    return addressData.__gqltype !== "Profile" ? "\u{1FA99} " : "@";
+  }
+  function shouldShowNameColor(addressData) {
+    return addressData.__gqltype === "Profile";
+  }
+  return {
+    resolveAddress: resolveAddress2,
+    formatDisplayName,
+    getAddressPrefix,
+    shouldShowNameColor
+  };
+}
+
+// src/utils/view-matcher.ts
+var CRITERIA_WEIGHTS = {
+  recordType: 0.25,
+  // Most specific to transaction type
+  functionName: 0.2,
+  // Function-level specificity
+  context: 0.2,
+  // Context specificity (when opt-in)
+  standard: 0.15,
+  // LSP standard specificity
+  contractAddress: 0.1,
+  // Contract-specific logic
+  contextRequirements: 0.05,
+  // Context requirement matching
+  chainId: 0.03,
+  // Network-specific behavior
+  customMatcher: 0.02
+  // Custom logic (lowest weight due to unpredictability)
+};
+function calculateMatchScore(transaction, view, options) {
+  const { criteria } = view;
+  const matchedCriteria = [];
+  let totalWeight = 0;
+  let matchedWeight = 0;
+  for (const [criterion, weight] of Object.entries(CRITERIA_WEIGHTS)) {
+    const criterionKey = criterion;
+    const criterionValue = criteria[criterionKey];
+    if (criterionValue === void 0) continue;
+    totalWeight += weight;
+    if (criterionKey === "customMatcher" && typeof criterionValue === "function") {
+      try {
+        const matchCount = criterionValue(transaction);
+        if (matchCount > 0) {
+          matchedCriteria.push(criterionKey);
+          const normalizedScore = Math.min(matchCount / 10, 1);
+          matchedWeight += weight * normalizedScore;
+        }
+      } catch (error) {
+        console.warn("Custom matcher threw error:", error);
+      }
+      continue;
+    }
+    if (doesCriterionMatch(transaction, criterionKey, criterionValue, options)) {
+      matchedCriteria.push(criterionKey);
+      matchedWeight += weight;
+    }
+  }
+  const viewHasContext = criteria.context !== void 0;
+  const requestHasContext = options?.context !== void 0;
+  if (viewHasContext && !requestHasContext) {
+    matchedWeight *= 0.1;
+  } else if (!viewHasContext && requestHasContext) {
+    matchedWeight *= 0.9;
+  }
+  if (totalWeight === 0) return { score: 0, matchedCriteria: [] };
+  const score = matchedWeight / totalWeight;
+  return { score, matchedCriteria };
+}
+function doesCriterionMatch(transaction, criterion, criterionValue, options) {
+  switch (criterion) {
+    case "recordType":
+      return matchesStringOrArray(
+        transaction.recordType,
+        criterionValue
+      );
+    case "functionName":
+      return matchesStringOrArray(
+        transaction.functionName,
+        criterionValue
+      );
+    case "standard":
+      return matchesStringOrArray(
+        transaction.standard,
+        criterionValue
+      );
+    case "contractAddress":
+      return matchesStringOrArray(
+        transaction.contractAddress,
+        criterionValue
+      );
+    case "chainId":
+      return matchesNumberOrArray(transaction.chainId, criterionValue);
+    case "context":
+      if (!options?.context) return false;
+      return matchesStringOrArray(options.context, criterionValue);
+    case "contextRequirements":
+      if (!options?.contextRequirements || !criterionValue) return false;
+      return areContextRequirementsCompatible(
+        options.contextRequirements,
+        criterionValue
+      );
+    case "customMatcher":
+      if (typeof criterionValue === "function") {
+        try {
+          const matchCount = criterionValue(transaction);
+          return matchCount > 0;
+        } catch (error) {
+          console.warn("Custom matcher threw error:", error);
+          return false;
+        }
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function matchesStringOrArray(value, criteria) {
+  if (!value || !criteria) return false;
+  if (Array.isArray(criteria)) {
+    return criteria.includes(value);
+  }
+  return value === criteria;
+}
+function matchesNumberOrArray(value, criteria) {
+  if (value === void 0 || criteria === void 0) return false;
+  if (Array.isArray(criteria)) {
+    return criteria.includes(value);
+  }
+  return value === criteria;
+}
+function areContextRequirementsCompatible(requested, viewRequirements) {
+  if (requested.detailLevel && viewRequirements.detailLevel) {
+    const detailOrder = ["minimal", "summary", "full", "debug"];
+    const requestedLevel = detailOrder.indexOf(requested.detailLevel);
+    const viewLevel = detailOrder.indexOf(viewRequirements.detailLevel);
+    if (viewLevel < requestedLevel) return false;
+  }
+  if (requested.maxHeight && viewRequirements.maxHeight) {
+    if (viewRequirements.maxHeight > requested.maxHeight) return false;
+  }
+  return true;
+}
+function calculateNativeFrameworkBonus(view, requestedFramework) {
+  if (requestedFramework === "lit") {
+    return 0;
+  }
+  if (requestedFramework === "vue" && view.frameworks.vue) {
+    return 0.15;
+  }
+  if (requestedFramework === "rn" && view.frameworks.rn) {
+    return 0.15;
+  }
+  return 0;
+}
+function findMatchingViews(transaction, views, options) {
+  const matches = [];
+  const minScore = options.minScore ?? 0;
+  for (const view of views) {
+    if (!view.frameworks[options.framework]) {
+      continue;
+    }
+    const { score, matchedCriteria } = calculateMatchScore(transaction, view, {
+      context: options.context,
+      contextRequirements: options.contextRequirements
+    });
+    if (score < minScore) {
+      continue;
+    }
+    const frameworkBonus = calculateNativeFrameworkBonus(
+      view,
+      options.framework
+    );
+    const finalScore = Math.min(1, score + frameworkBonus);
+    const match = {
+      view,
+      score: finalScore,
+      matchedCriteria,
+      frameworkConfig: options.includeFrameworkConfig ? view.frameworks[options.framework] : void 0
+    };
+    matches.push(match);
+  }
+  matches.sort((a, b) => {
+    if (a.score !== b.score) {
+      return b.score - a.score;
+    }
+    return b.view.priority - a.view.priority;
+  });
+  if (options.maxMatches) {
+    return matches.slice(0, options.maxMatches);
+  }
+  return matches;
+}
+
+// src/registry/view-registry.ts
+var DefaultViewRegistry = class {
+  views = /* @__PURE__ */ new Map();
+  register(view) {
+    if (this.views.has(view.id)) {
+      console.warn(
+        `View with id "${view.id}" is already registered. Overwriting.`
+      );
+    }
+    this.views.set(view.id, view);
+  }
+  unregister(viewId) {
+    this.views.delete(viewId);
+  }
+  getAllViews() {
+    return Array.from(this.views.values());
+  }
+  findMatches(transaction, options) {
+    const allViews = this.getAllViews();
+    return findMatchingViews(transaction, allViews, options);
+  }
+  getView(viewId) {
+    return this.views.get(viewId);
+  }
+  clear() {
+    this.views.clear();
+  }
+  /**
+   * Get the best matching view (highest score) for a transaction
+   */
+  getBestMatch(transaction, options) {
+    const matches = this.findMatches(transaction, { ...options, maxMatches: 1 });
+    return matches[0] || null;
+  }
+  /**
+   * Bulk register multiple views
+   */
+  registerMany(views) {
+    for (const view of views) {
+      this.register(view);
+    }
+  }
+  /**
+   * Get stats about registered views
+   */
+  getStats() {
+    const allViews = this.getAllViews();
+    const totalViews = allViews.length;
+    const viewsByFramework = {};
+    const viewsByRecordType = {};
+    for (const view of allViews) {
+      for (const framework of Object.keys(view.frameworks)) {
+        viewsByFramework[framework] = (viewsByFramework[framework] || 0) + 1;
+      }
+      const recordType = view.criteria.recordType;
+      if (recordType) {
+        const types = Array.isArray(recordType) ? recordType : [recordType];
+        for (const type of types) {
+          viewsByRecordType[type] = (viewsByRecordType[type] || 0) + 1;
+        }
+      }
+    }
+    return {
+      totalViews,
+      viewsByFramework,
+      viewsByRecordType
+    };
+  }
+};
+var globalRegistry = null;
+function getGlobalRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new DefaultViewRegistry();
+  }
+  return globalRegistry;
+}
+
+// src/composables/use-transaction-playback.ts
+function isBatchTransaction(transaction) {
+  return transaction.resultType === "executeBatch" || transaction.resultType === "setDataBatch" || !!transaction.children?.length;
+}
+function getBatchChildren(transaction) {
+  if (!isBatchTransaction(transaction)) {
+    return [];
+  }
+  return transaction.children || [];
+}
+function selectViewAtIndex(rootTransaction, index, options) {
+  const {
+    registry = getGlobalRegistry(),
+    framework = "lit",
+    fallbackViewId,
+    minScore = 0,
+    includeFrameworkConfig = true
+  } = options;
+  const isBatch = isBatchTransaction(rootTransaction);
+  const children = getBatchChildren(rootTransaction);
+  const childCount = children.length;
+  const result = {
+    match: null,
+    transaction: null,
+    indexInfo: {
+      requested: index,
+      childIndex: null,
+      isBatchSummary: false,
+      isValid: false
+    },
+    batchInfo: {
+      isBatch,
+      childCount,
+      availableIndices: []
+    }
+  };
+  if (isBatch) {
+    result.batchInfo.availableIndices = Array.from(
+      { length: childCount + 1 },
+      (_, i) => i
+    );
+  } else {
+    result.batchInfo.availableIndices = [0, 1];
+  }
+  if (index < 0) {
+    return result;
+  }
+  if (!isBatch) {
+    if (index === 0 || index === 1) {
+      result.indexInfo.isValid = true;
+      result.transaction = rootTransaction;
+      const matchOptions = {
+        framework,
+        minScore,
+        maxMatches: 1,
+        includeFrameworkConfig
+      };
+      const matches = registry.findMatches(rootTransaction, matchOptions);
+      result.match = matches[0] || null;
+      if (!result.match && fallbackViewId) {
+        const fallbackView = registry.getView(fallbackViewId);
+        if (fallbackView && fallbackView.frameworks[framework]) {
+          result.match = {
+            view: fallbackView,
+            score: 0,
+            matchedCriteria: [],
+            frameworkConfig: includeFrameworkConfig ? fallbackView.frameworks[framework] : void 0
+          };
+        }
+      }
+      return result;
+    }
+    return result;
+  }
+  if (index === 0) {
+    result.indexInfo.isValid = true;
+    result.indexInfo.isBatchSummary = true;
+    result.transaction = rootTransaction;
+    const matchOptions = {
+      framework,
+      minScore,
+      maxMatches: 1,
+      includeFrameworkConfig
+    };
+    const matches = registry.findMatches(rootTransaction, matchOptions);
+    result.match = matches[0] || null;
+    if (!result.match && fallbackViewId) {
+      const fallbackView = registry.getView(fallbackViewId);
+      if (fallbackView && fallbackView.frameworks[framework]) {
+        result.match = {
+          view: fallbackView,
+          score: 0,
+          matchedCriteria: [],
+          frameworkConfig: includeFrameworkConfig ? fallbackView.frameworks[framework] : void 0
+        };
+      }
+    }
+    return result;
+  }
+  const childIndex = index - 1;
+  if (childIndex >= 0 && childIndex < childCount) {
+    result.indexInfo.isValid = true;
+    result.indexInfo.childIndex = childIndex;
+    result.transaction = children[childIndex];
+    const matchOptions = {
+      framework,
+      minScore,
+      maxMatches: 1,
+      includeFrameworkConfig
+    };
+    const matches = registry.findMatches(result.transaction, matchOptions);
+    result.match = matches[0] || null;
+    if (!result.match && fallbackViewId) {
+      const fallbackView = registry.getView(fallbackViewId);
+      if (fallbackView && fallbackView.frameworks[framework]) {
+        result.match = {
+          view: fallbackView,
+          score: 0,
+          matchedCriteria: [],
+          frameworkConfig: includeFrameworkConfig ? fallbackView.frameworks[framework] : void 0
+        };
+      }
+    }
+    return result;
+  }
+  return result;
+}
+function createTransactionPlayback(rootTransaction, options = {}) {
+  const isBatch = isBatchTransaction(rootTransaction);
+  const children = getBatchChildren(rootTransaction);
+  const childCount = children.length;
+  const indexCount = isBatch ? childCount + 1 : 2;
+  const availableIndices = isBatch ? Array.from({ length: childCount + 1 }, (_, i) => i) : [0, 1];
+  return {
+    rootTransaction,
+    isBatch,
+    children,
+    indexCount,
+    batchInfo: {
+      isBatch,
+      childCount,
+      availableIndices
+    },
+    getViewAtIndex: (index) => selectViewAtIndex(rootTransaction, index, options),
+    getAllViews: () => {
+      const views = [];
+      for (let i = 0; i < indexCount; i++) {
+        views.push(selectViewAtIndex(rootTransaction, i, options));
+      }
+      return views;
+    }
+  };
+}
+function useTransactionPlayback(rootTransaction, index, options = {}) {
+  return selectViewAtIndex(rootTransaction, index, options);
+}
+function isValidPlaybackIndex(transaction, index) {
+  const isBatch = isBatchTransaction(transaction);
+  if (!isBatch) {
+    return index === 0 || index === 1;
+  }
+  const childCount = getBatchChildren(transaction).length;
+  return index >= 0 && index <= childCount;
+}
+function getValidPlaybackIndices(transaction) {
+  const isBatch = isBatchTransaction(transaction);
+  if (!isBatch) {
+    return [0, 1];
+  }
+  const childCount = getBatchChildren(transaction).length;
+  return Array.from({ length: childCount + 1 }, (_, i) => i);
+}
+
+// src/composables/use-transaction-view.ts
+var import_transaction_decoder = require("@lukso/transaction-decoder");
+
+// src/registry/view-loader.ts
+var ViewLoadingError = class extends Error {
+  loader;
+  config;
+  cause;
+  constructor(message, loader, config, cause) {
+    super(message);
+    this.name = "ViewLoadingError";
+    this.loader = loader;
+    this.config = config;
+    this.cause = cause;
+  }
+};
+var UniversalViewLoader = class {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Load a component based on the framework configuration
+   */
+  async loadComponent(config) {
+    const cacheKey = this.getCacheKey(config);
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    try {
+      const component = await this.loadByStrategy(config.loader);
+      this.cache.set(cacheKey, component);
+      return component;
+    } catch (error) {
+      throw new ViewLoadingError(
+        `Failed to load component "${config.component}"`,
+        config.loader,
+        config,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  /**
+   * Load a component from a view match
+   */
+  async loadFromMatch(match) {
+    if (!match.frameworkConfig) {
+      throw new ViewLoadingError(
+        `No framework config available for view "${match.view.id}"`,
+        { type: "dynamic-import", path: "" },
+        {}
+      );
+    }
+    return this.loadComponent(match.frameworkConfig);
+  }
+  /**
+   * Load component using the specific strategy
+   */
+  async loadByStrategy(loader) {
+    switch (loader.type) {
+      case "dynamic-import":
+        return this.loadDynamicImport(loader.path);
+      case "static-import":
+        return this.loadStaticImport(loader.path);
+      case "custom-element":
+        return this.loadCustomElement(loader.tagName);
+      case "registry-lookup":
+        return this.loadFromRegistry(loader.registryKey);
+      case "custom":
+        return loader.loader({});
+      // Will be passed proper config in real usage
+      default:
+        throw new Error(`Unknown loader type: ${loader.type}`);
+    }
+  }
+  /**
+   * Dynamic import strategy (most common)
+   * Supports both static strings and lazy-loaded callbacks
+   */
+  async loadDynamicImport(path) {
+    if (typeof path === "function") {
+      const module3 = await path();
+      if (module3.default) {
+        return module3.default;
+      }
+      return module3;
+    }
+    const module2 = await import(path);
+    if (module2.default) {
+      return module2.default;
+    }
+    return module2;
+  }
+  /**
+   * Static import strategy (requires bundler support)
+   * Supports both static strings and lazy-loaded callbacks
+   */
+  async loadStaticImport(path) {
+    if (typeof path === "function") {
+      const module2 = await path();
+      if (module2.default) {
+        return module2.default;
+      }
+      return module2;
+    }
+    console.warn(
+      "Static import not implemented, falling back to dynamic import"
+    );
+    return this.loadDynamicImport(path);
+  }
+  /**
+   * Custom element strategy (for Lit components)
+   */
+  async loadCustomElement(tagName) {
+    if (typeof window !== "undefined" && window.customElements) {
+      await window.customElements.whenDefined(tagName);
+      return { tagName, type: "custom-element" };
+    }
+    throw new Error("Custom elements not available in this environment");
+  }
+  /**
+   * Registry lookup strategy (for pre-registered components)
+   */
+  async loadFromRegistry(registryKey) {
+    throw new Error(`Registry lookup not implemented for key: ${registryKey}`);
+  }
+  /**
+   * Generate cache key for component config
+   */
+  getCacheKey(config) {
+    const { loader, component, package: pkg } = config;
+    return JSON.stringify({ loader, component, package: pkg });
+  }
+  /**
+   * Clear the component cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+};
+var globalLoader = null;
+function getGlobalLoader() {
+  if (!globalLoader) {
+    globalLoader = new UniversalViewLoader();
+  }
+  return globalLoader;
+}
+
+// src/composables/use-transaction-view.ts
+function useTransactionView(transaction, options) {
+  const {
+    registry = getGlobalRegistry(),
+    autoLoad = false,
+    fallbackViewId,
+    framework = "lit",
+    minScore = 0,
+    maxMatches,
+    includeFrameworkConfig = true,
+    resolve = false,
+    chain,
+    addressCache: addressCache2
+  } = options;
+  const loader = getGlobalLoader();
+  let matches = [];
+  let bestMatch = null;
+  let component = null;
+  let isLoading = false;
+  let error = null;
+  let isResolvingAddresses = false;
+  let resolvedAddresses = {};
+  const refreshMatches = () => {
+    const matchOptions = {
+      framework,
+      minScore,
+      maxMatches,
+      includeFrameworkConfig
+    };
+    matches = registry.findMatches(transaction, matchOptions);
+    bestMatch = matches[0] || null;
+    if (!bestMatch && fallbackViewId) {
+      const fallbackView = registry.getView(fallbackViewId);
+      if (fallbackView && fallbackView.frameworks[framework]) {
+        bestMatch = {
+          view: fallbackView,
+          score: 0,
+          matchedCriteria: [],
+          frameworkConfig: includeFrameworkConfig ? fallbackView.frameworks[framework] : void 0
+        };
+      }
+    }
+  };
+  const loadMatch = async (match) => {
+    if (!match.frameworkConfig) {
+      throw new ViewLoadingError(
+        `No framework config for view "${match.view.id}" and framework "${framework}"`,
+        { type: "dynamic-import", path: "" },
+        {}
+      );
+    }
+    isLoading = true;
+    error = null;
+    try {
+      const loadedComponent = await loader.loadFromMatch(match);
+      component = loadedComponent;
+      return loadedComponent;
+    } catch (err) {
+      error = err instanceof ViewLoadingError ? err : new ViewLoadingError(
+        "Unknown loading error",
+        match.frameworkConfig.loader,
+        match.frameworkConfig,
+        err instanceof Error ? err : new Error(String(err))
+      );
+      throw error;
+    } finally {
+      isLoading = false;
+    }
+  };
+  const loadBestMatch = async () => {
+    if (!bestMatch) {
+      throw new Error("No matching view found for transaction");
+    }
+    return loadMatch(bestMatch);
+  };
+  const resolveAddressesFunc = async () => {
+    if (!resolve || !transaction.addresses || transaction.addresses.length === 0) {
+      return;
+    }
+    if (!chain) {
+      console.warn(
+        "Address resolution requested but no chain provided. Pass chain option to resolve addresses."
+      );
+      return;
+    }
+    isResolvingAddresses = true;
+    try {
+      const dataKeys = transaction.addresses.filter((addr) => addr && typeof addr === "string").map((addr) => addr.toLowerCase());
+      if (dataKeys.length === 0) {
+        return;
+      }
+      const endpoint = (0, import_transaction_decoder.getGraphQLEndpoint)(chain);
+      const resolvedMap = await (0, import_transaction_decoder.fetchMultipleAddresses)(
+        dataKeys,
+        endpoint,
+        addressCache2
+      );
+      const resolved = {};
+      resolvedMap.forEach((enhancedInfo, dataKey) => {
+        resolved[dataKey] = enhancedInfo;
+      });
+      resolvedAddresses = resolved;
+    } catch (err) {
+      console.error("Address resolution failed:", err);
+    } finally {
+      isResolvingAddresses = false;
+    }
+  };
+  refreshMatches();
+  if (resolve) {
+    resolveAddressesFunc().catch((err) => {
+      console.error("Auto address resolution failed:", err);
+    });
+  }
+  if (autoLoad && bestMatch) {
+    loadBestMatch().catch((err) => {
+      console.error("Auto-load failed:", err);
+    });
+  }
+  return {
+    matches,
+    bestMatch,
+    component,
+    isLoading,
+    error,
+    isResolvingAddresses,
+    resolvedAddresses,
+    loadMatch,
+    loadBestMatch,
+    refreshMatches,
+    resolveAddresses: resolveAddressesFunc
+  };
+}
+function findBestTransactionView(transaction, framework, registry) {
+  const reg = registry || getGlobalRegistry();
+  const matches = reg.findMatches(transaction, {
+    framework,
+    includeFrameworkConfig: true
+  });
+  return matches.length > 0 ? matches[0] : null;
+}
+function findAllTransactionViews(transaction, framework, registry) {
+  const reg = registry || getGlobalRegistry();
+  return reg.findMatches(transaction, {
+    framework,
+    includeFrameworkConfig: true
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheAddress,
+  clearAddressCache,
+  createAddressResolutionState,
+  createTransactionPlayback,
+  findAllTransactionViews,
+  findBestTransactionView,
+  getCachedAddress,
+  getLuksoConfig,
+  getValidPlaybackIndices,
+  isAddressResolutionEnabled,
+  isValidPlaybackIndex,
+  resolveAddress,
+  resolveAddressWithState,
+  resolveAddresses,
+  setLuksoConfig,
+  useAddressResolver,
+  useImageLoader,
+  useLuksoMainnet,
+  useLuksoTestnet,
+  useTransactionPlayback,
+  useTransactionView
+});
+//# sourceMappingURL=index.cjs.map