@shuffleio/shuffle-mcps 0.0.59 → 0.0.63

package/dist/analytics-JGBV375U.mjs

@@ -0,0 +1,20 @@
+import {
+  GA_EVENTS,
+  initAnalytics,
+  trackCTA,
+  trackEvent,
+  trackOnboardingStep,
+  trackPageView,
+  trackPredefinedEvent,
+  trackReferralParams
+} from "./chunk-TUSSDUVQ.mjs";
+export {
+  GA_EVENTS,
+  initAnalytics,
+  trackCTA,
+  trackEvent,
+  trackOnboardingStep,
+  trackPageView,
+  trackPredefinedEvent,
+  trackReferralParams
+};

package/dist/{appsCache-VD3DQH53.mjs → appsCache-2UYFFT3V.mjs}

@@ -2,7 +2,8 @@ import {
   fetchApps,
   fetchAppsViaApiConfig,
   invalidateAppsCache
-} from "./chunk-7HRNENGV.mjs";
+} from "./chunk-DSJHIKBO.mjs";
+import "./chunk-XNE7PKME.mjs";
 export {
   fetchApps,
   fetchAppsViaApiConfig,

package/dist/auth-utils-HYVXQKTL.mjs

@@ -0,0 +1,12 @@
+import {
+  backfillAppImages,
+  deduplicateAuthApps,
+  isValidationFresh,
+  seedImageCache
+} from "./chunk-2NCPSII6.mjs";
+export {
+  backfillAppImages,
+  deduplicateAuthApps,
+  isValidationFresh,
+  seedImageCache
+};

package/dist/chunk-2NCPSII6.mjs

@@ -0,0 +1,105 @@
+// ../Shuffle-Core/auth-utils.ts
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+function isValidationFresh(validation) {
+  if (validation?.valid !== true) return false;
+  if (!validation.last_valid) return true;
+  const cutoff = Date.now() - THIRTY_DAYS_MS;
+  const lastValidMs = validation.last_valid > 1e12 ? validation.last_valid : validation.last_valid * 1e3;
+  return lastValidMs >= cutoff;
+}
+function deduplicateAuthApps(apps) {
+  const appMap = /* @__PURE__ */ new Map();
+  apps.forEach((auth) => {
+    if (!auth.app?.name) return;
+    if (!auth.active && !isValidationFresh(auth.validation)) return;
+    const normalizedName = auth.app.name.toLowerCase().trim().replace(/[\s_\-]+/g, "_");
+    const existing = appMap.get(normalizedName);
+    const isValidated = isValidationFresh(auth.validation);
+    const entryImage = auth.app.large_image || "";
+    const instance = {
+      label: auth.label || auth.id || "Default",
+      isValidated
+    };
+    if (!existing) {
+      appMap.set(normalizedName, {
+        app: auth.app,
+        hasValidAuth: isValidated,
+        bestImage: entryImage,
+        instances: [instance]
+      });
+    } else {
+      existing.instances.push(instance);
+      if (isValidated) existing.hasValidAuth = true;
+      if (!existing.bestImage && entryImage) existing.bestImage = entryImage;
+      if (isValidated && !existing.app.large_image && entryImage) {
+        existing.app = { ...existing.app, large_image: entryImage };
+      }
+    }
+  });
+  return Array.from(appMap.values());
+}
+var _imageCache = /* @__PURE__ */ new Map();
+var _pendingLookups = /* @__PURE__ */ new Map();
+var _normalize = (n) => n.toLowerCase().replace(/[\s_\-]+/g, "_");
+function seedImageCache(appName, imageUrl) {
+  if (appName && imageUrl) _imageCache.set(_normalize(appName), imageUrl);
+}
+async function backfillAppImages(dedupedApps) {
+  for (const d of dedupedApps) {
+    const norm = _normalize(d.app.name);
+    const existingImg = d.bestImage || d.app.large_image;
+    if (existingImg) {
+      _imageCache.set(norm, existingImg);
+    } else if (_imageCache.has(norm)) {
+      const cached = _imageCache.get(norm);
+      if (cached) {
+        d.bestImage = cached;
+        d.app = { ...d.app, large_image: cached };
+      }
+    }
+  }
+  const missing = dedupedApps.filter((d) => !d.bestImage && !d.app.large_image && !_imageCache.has(_normalize(d.app.name)));
+  if (missing.length === 0) return dedupedApps;
+  try {
+    const { algoliasearch } = await import("algoliasearch");
+    const client = algoliasearch("JNSS5CFDZZ", "33e4e3564f4f060e96e0531957bed552");
+    await Promise.all(missing.map(async (entry) => {
+      const norm = _normalize(entry.app.name);
+      if (!_pendingLookups.has(norm)) {
+        _pendingLookups.set(norm, (async () => {
+          try {
+            const result = await client.searchSingleIndex({
+              indexName: "appsearch",
+              searchParams: { query: entry.app.name, hitsPerPage: 3 }
+            });
+            const match = result.hits.find(
+              (h) => _normalize(h.name || "") === norm
+            );
+            const url2 = match?.image_url || "";
+            _imageCache.set(norm, url2);
+            return url2;
+          } catch {
+            _imageCache.set(norm, "");
+            return null;
+          } finally {
+            _pendingLookups.delete(norm);
+          }
+        })());
+      }
+      const url = await _pendingLookups.get(norm);
+      if (url) {
+        entry.bestImage = url;
+        entry.app = { ...entry.app, large_image: url };
+      }
+    }));
+  } catch {
+  }
+  return dedupedApps;
+}
+
+export {
+  isValidationFresh,
+  deduplicateAuthApps,
+  seedImageCache,
+  backfillAppImages
+};

package/dist/chunk-DSJHIKBO.mjs

@@ -0,0 +1,64 @@
+import {
+  API_CONFIG,
+  getAuthHeader
+} from "./chunk-XNE7PKME.mjs";
+
+// appsCache.ts
+var TTL_MS = 3e4;
+var ERROR_TTL_MS = 3e4;
+var cache = /* @__PURE__ */ new Map();
+var cacheKey = (o) => `${o.baseUrl}|${o.path || "/api/v1/apps"}|${o.apiKey || ""}|${o.orgId || ""}`;
+var doFetch = async (o) => {
+  const headers = {
+    ...getAuthHeader(o.orgId || void 0)
+  };
+  if (o.apiKey) headers["Authorization"] = `Bearer ${o.apiKey}`;
+  if (o.orgId) headers["Org-Id"] = o.orgId;
+  const response = await fetch(`${o.baseUrl}${o.path || "/api/v1/apps"}`, {
+    credentials: "include",
+    headers
+  });
+  if (!response.ok) return [];
+  const data = await response.json();
+  if (Array.isArray(data)) return data;
+  return Array.isArray(data?.data) ? data.data : [];
+};
+var fetchApps = (opts) => {
+  const key = cacheKey(opts);
+  const entry = cache.get(key) || {};
+  if (entry.data && entry.fetchedAt && Date.now() - entry.fetchedAt < TTL_MS) {
+    return Promise.resolve(entry.data);
+  }
+  if (entry.promise) return entry.promise;
+  const promise = doFetch(opts).then((data) => {
+    cache.set(key, { data, fetchedAt: Date.now() });
+    return data;
+  }).catch(() => {
+    cache.set(key, { data: [], fetchedAt: Date.now() - (TTL_MS - ERROR_TTL_MS) });
+    return [];
+  });
+  cache.set(key, { ...entry, promise });
+  return promise;
+};
+var invalidateAppsCache = (opts) => {
+  if (!opts) {
+    cache.clear();
+    return;
+  }
+  cache.delete(cacheKey(opts));
+};
+var fetchAppsViaApiConfig = () => {
+  const headers = getAuthHeader();
+  const orgId = headers["Org-Id"] || null;
+  return fetchApps({
+    baseUrl: API_CONFIG.baseUrl,
+    apiKey: API_CONFIG.apiKey,
+    orgId
+  });
+};
+
+export {
+  fetchApps,
+  invalidateAppsCache,
+  fetchAppsViaApiConfig
+};