@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-GYBMMWGF.js

@@ -0,0 +1,163 @@
+'use client';
+import { useSyncExternalStore, useState, useRef, useCallback, useMemo, useEffect } from 'react';
+import dynamic from 'next/dynamic';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+
+// src/signal/store.ts
+var pendingEvents = [];
+var pendingOutcomes = [];
+var MAX_PENDING = 100;
+var warnedNoBridge = false;
+var STUB = Object.freeze({
+  config: null,
+  loading: true,
+  error: null,
+  trackEvent: (event) => {
+    if (pendingEvents.length < MAX_PENDING) pendingEvents.push(event);
+    else if (!warnedNoBridge) {
+      warnedNoBridge = true;
+      console.warn("[site-kit] Signal events are queuing but no SignalBridge has mounted \u2014 is signal enabled on SiteKitLayout?");
+    }
+  },
+  trackOutcome: (outcome) => {
+    if (pendingOutcomes.length < MAX_PENDING) pendingOutcomes.push(outcome);
+  },
+  getExperiment: () => null,
+  refreshConfig: async () => {
+  }
+});
+var current = STUB;
+var listeners = /* @__PURE__ */ new Set();
+function emit() {
+  for (const l of listeners) l();
+}
+function publishSignal(value) {
+  const firstPublish = current === STUB;
+  current = value;
+  if (firstPublish) {
+    pendingEvents.splice(0).forEach((e) => value.trackEvent(e));
+    pendingOutcomes.splice(0).forEach((o) => value.trackOutcome(o));
+  }
+  emit();
+}
+function resetSignal() {
+  current = STUB;
+  emit();
+}
+function subscribe(onChange) {
+  listeners.add(onChange);
+  return () => listeners.delete(onChange);
+}
+var getSnapshot = () => current;
+var getServerSnapshot = () => STUB;
+function useSignal() {
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+var LazySignalCore = dynamic(
+  () => import('./SignalCore-S6DO3VQV.js').then((m) => ({ default: m.SignalCore })),
+  { ssr: false }
+);
+function SignalBridge({
+  enabled = true,
+  realtime = true,
+  experiments = true,
+  behaviorTracking = true,
+  visitorId: externalVisitorId,
+  sessionId: externalSessionId,
+  pageMetadataRef,
+  children
+}) {
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const coreRef = useRef(null);
+  const pendingEventsRef = useRef([]);
+  const pendingOutcomesRef = useRef([]);
+  const handleState = useCallback((state) => {
+    setConfig(state.config);
+    setLoading(state.loading);
+    setError(state.error);
+  }, []);
+  const handleRegister = useCallback((api) => {
+    coreRef.current = api;
+    if (api) {
+      pendingEventsRef.current.splice(0).forEach((event) => api.trackEvent(event));
+      pendingOutcomesRef.current.splice(0).forEach((outcome) => api.trackOutcome(outcome));
+    }
+  }, []);
+  const trackEvent = useCallback((event) => {
+    if (coreRef.current) {
+      coreRef.current.trackEvent(event);
+    } else {
+      pendingEventsRef.current.push(event);
+    }
+  }, []);
+  const trackOutcome = useCallback((outcome) => {
+    if (coreRef.current) {
+      coreRef.current.trackOutcome(outcome);
+    } else {
+      pendingOutcomesRef.current.push(outcome);
+    }
+  }, []);
+  const getExperiment = useCallback((experimentId) => {
+    return coreRef.current?.getExperiment(experimentId) ?? null;
+  }, []);
+  const refreshConfig = useCallback(async () => {
+    await coreRef.current?.refreshConfig();
+  }, []);
+  const contextValue = useMemo(() => ({
+    config,
+    loading,
+    error,
+    trackEvent,
+    trackOutcome,
+    getExperiment,
+    refreshConfig
+  }), [config, loading, error, trackEvent, trackOutcome, getExperiment, refreshConfig]);
+  useEffect(() => {
+    publishSignal(contextValue);
+  }, [contextValue]);
+  useEffect(() => () => resetSignal(), []);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    children,
+    enabled && /* @__PURE__ */ jsx(
+      LazySignalCore,
+      {
+        enabled,
+        realtime,
+        experiments,
+        behaviorTracking,
+        externalVisitorId,
+        externalSessionId,
+        pageMetadataRef,
+        onRegister: handleRegister,
+        onState: handleState
+      }
+    )
+  ] });
+}
+function useSignalConfig() {
+  const { config } = useSignal();
+  return config;
+}
+function useSignalEvent() {
+  const { trackEvent } = useSignal();
+  return trackEvent;
+}
+function useSignalOutcome() {
+  const { trackOutcome } = useSignal();
+  return { trackOutcome };
+}
+function useSignalExperiment(experimentId) {
+  const { getExperiment, config } = useSignal();
+  const assignment = getExperiment(experimentId);
+  const experiment = config?.experiments?.find((e) => e.id === experimentId);
+  const isRunning = experiment?.status === "running";
+  return {
+    assignment: isRunning ? assignment : null,
+    variant: isRunning && assignment ? assignment.variant_key : null,
+    isControl: !assignment || assignment.variant_key === "control"
+  };
+}
+
+export { SignalBridge, useSignal, useSignalConfig, useSignalEvent, useSignalExperiment, useSignalOutcome };

package/dist/chunk-GYF2ULVO.js

@@ -0,0 +1,14 @@
+// src/articles/widget-styles.ts
+var widgetStyle = {
+  padding: 20,
+  backgroundColor: "var(--sk-bg-elevated)",
+  borderRadius: 12
+};
+var widgetTitleStyle = {
+  margin: "0 0 16px",
+  fontSize: 16,
+  fontWeight: 600,
+  color: "var(--sk-text-primary)"
+};
+
+export { widgetStyle, widgetTitleStyle };

package/dist/chunk-HPUXKMNR.js

@@ -0,0 +1,148 @@
+import { SITE_KIT_VERSION } from './chunk-7ZHJIRM3.js';
+
+// src/shared/siteToken.ts
+var SITE_TOKEN_PREFIX = "st1.";
+var REFRESH_SKEW_MS = 5 * 6e4;
+var REFRESH_TIMEOUT_MS = 6e3;
+var STORAGE_KEY = "__sonor_site_token__";
+function isSiteToken(credential) {
+  return typeof credential === "string" && credential.startsWith(SITE_TOKEN_PREFIX);
+}
+function decodeSiteTokenClaims(token) {
+  if (!isSiteToken(token)) return null;
+  const seg = token.split(".")[1];
+  if (!seg) return null;
+  try {
+    const b64 = seg.replace(/-/g, "+").replace(/_/g, "/");
+    const json = typeof atob === "function" ? atob(b64) : Buffer.from(seg, "base64url").toString("utf8");
+    const claims = JSON.parse(json);
+    return typeof claims === "object" && claims ? claims : null;
+  } catch {
+    return null;
+  }
+}
+function credentialBreakerId(credential) {
+  if (!credential) return "(anonymous)";
+  const claims = decodeSiteTokenClaims(credential);
+  if (claims?.pid) return `pid:${claims.pid}`;
+  return credential.slice(0, 16);
+}
+function initialTokenState() {
+  return {
+    seed: void 0,
+    isToken: false,
+    apiUrl: "https://api.sonor.io",
+    token: null,
+    refreshing: null
+  };
+}
+var TOKEN_STATE_KEY = "__SONOR_SITE_TOKEN_STATE__";
+var state = (() => {
+  if (typeof window === "undefined") return initialTokenState();
+  const w = window;
+  return w[TOKEN_STATE_KEY] ?? (w[TOKEN_STATE_KEY] = initialTokenState());
+})();
+function readStoredToken() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return typeof parsed?.token === "string" ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+function storeToken(token) {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify({ token }));
+  } catch {
+  }
+  try {
+    ;
+    window.__SITE_KIT_API_KEY__ = token;
+  } catch {
+  }
+}
+function tokenExp(token) {
+  const claims = decodeSiteTokenClaims(token);
+  return typeof claims?.exp === "number" ? claims.exp * 1e3 : 0;
+}
+function configureSiteCredential(opts) {
+  state.seed = opts.credential;
+  state.isToken = isSiteToken(opts.credential);
+  if (opts.apiUrl) state.apiUrl = opts.apiUrl.replace(/\/+$/, "");
+  if (!state.isToken) {
+    state.token = null;
+    return;
+  }
+  const prior = state.token;
+  let best = opts.credential ?? null;
+  const stored = readStoredToken();
+  if (stored && tokenExp(stored) > tokenExp(best)) best = stored;
+  if (prior && tokenExp(prior) > tokenExp(best)) best = prior;
+  state.token = best;
+}
+function needsRefresh() {
+  if (!state.isToken) return false;
+  if (!state.token) return true;
+  return Date.now() >= tokenExp(state.token) - REFRESH_SKEW_MS;
+}
+async function doRefresh() {
+  const current = state.token;
+  if (!current) return null;
+  try {
+    const res = await fetch(`${state.apiUrl}/api/public/site-token/refresh`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-sitekit-version": SITE_KIT_VERSION,
+        // Send the current token as x-api-key too, so the server's key-scoped
+        // throttler buckets refreshes by token rather than by shared CDN IP.
+        "x-api-key": current
+      },
+      body: JSON.stringify({ token: current }),
+      signal: typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(REFRESH_TIMEOUT_MS) : void 0
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => null);
+    const next = data?.token;
+    if (typeof next === "string" && isSiteToken(next)) {
+      state.token = next;
+      storeToken(next);
+      return next;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function refreshSiteToken() {
+  if (!state.isToken) return Promise.resolve(null);
+  if (state.refreshing) return state.refreshing;
+  state.refreshing = doRefresh().finally(() => {
+    state.refreshing = null;
+  });
+  return state.refreshing;
+}
+async function getFreshCredential(seed) {
+  if (!state.isToken && isSiteToken(seed)) {
+    configureSiteCredential({ credential: seed });
+  }
+  if (!state.isToken) return seed ?? state.seed;
+  if (needsRefresh()) {
+    const refreshed = await refreshSiteToken();
+    if (refreshed) return refreshed;
+  }
+  return state.token ?? seed ?? state.seed;
+}
+function isTokenMode() {
+  return state.isToken;
+}
+function currentCredential(seed) {
+  if (!state.isToken) return seed ?? state.seed;
+  return state.token ?? seed ?? state.seed;
+}
+
+export { configureSiteCredential, credentialBreakerId, currentCredential, getFreshCredential, isSiteToken, isTokenMode, refreshSiteToken };

package/dist/chunk-HXJ54KAM.js

@@ -0,0 +1,122 @@
+import { getSiteConfig } from './chunk-Z22QVHT4.js';
+import { withSiteParam, withSiteBody } from './chunk-MJP63SSS.js';
+import { resolveSiteHost } from './chunk-FESKKJAS.js';
+import { NextResponse } from 'next/server.js';
+
+var DEFAULT_PORTAL_URL = "https://api.sonor.io";
+function envApiUrl() {
+  const raw = typeof process !== "undefined" && process.env ? process.env.SONOR_API_URL : void 0;
+  return typeof raw === "string" && raw ? raw : void 0;
+}
+var DEFAULT_FETCH_TIMEOUT_MS = 300;
+var FAILURE_COOLDOWN_MS = 3e4;
+var rulesCache = /* @__PURE__ */ new Map();
+function getRedirectCacheKey(apiKey, domain, site) {
+  const scope = apiKey ? `key:${apiKey}` : `domain:${domain || ""}`;
+  return `${scope}|site:${site}`;
+}
+async function fetchRedirectRules(config) {
+  const now = Date.now();
+  const cacheSeconds = config.cacheSeconds ?? 300;
+  const baseUrl = config.portalApiUrl || envApiUrl() || DEFAULT_PORTAL_URL;
+  const rawKey = config.apiKey ?? (typeof process !== "undefined" && process.env ? process.env.SONOR_API_KEY : void 0);
+  const apiKey = typeof rawKey === "string" ? rawKey : void 0;
+  let domain = config.domain;
+  if (!apiKey && !domain) {
+    const siteConfig = await getSiteConfig({ apiUrl: baseUrl });
+    domain = siteConfig?.domain;
+  }
+  const site = resolveSiteHost(config.site);
+  const cacheKey = getRedirectCacheKey(apiKey, domain, site);
+  const cached = rulesCache.get(cacheKey);
+  if (cached && now < cached.expiry) {
+    return cached.rules;
+  }
+  try {
+    let url;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) {
+      url = withSiteParam(`${baseUrl}/api/public/seo/redirects`, site);
+      headers["x-api-key"] = apiKey;
+    } else if (domain) {
+      url = withSiteParam(`${baseUrl}/api/public/seo/redirects?domain=${encodeURIComponent(domain)}`, site);
+    } else {
+      return [];
+    }
+    const timeoutMs = config.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    const signal = typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(timeoutMs) : void 0;
+    const res = await fetch(url, {
+      headers,
+      signal,
+      // No-op in proxy (outside the data cache) but real in RSC renders,
+      // where the not-found resolver runs.
+      next: { revalidate: cacheSeconds }
+    });
+    if (!res.ok) {
+      console.error(`[site-kit] Failed to fetch redirects: ${res.status}`);
+      rulesCache.set(cacheKey, { rules: cached?.rules ?? [], expiry: now + FAILURE_COOLDOWN_MS });
+      return cached?.rules ?? [];
+    }
+    const data = await res.json();
+    const rules = (data.redirects || []).filter((r) => r.is_enabled);
+    rulesCache.set(cacheKey, { rules, expiry: now + cacheSeconds * 1e3 });
+    return rules;
+  } catch (error) {
+    console.error("[site-kit] Error fetching redirects:", error);
+    rulesCache.set(cacheKey, { rules: cached?.rules ?? [], expiry: now + FAILURE_COOLDOWN_MS });
+    return cached?.rules ?? [];
+  }
+}
+function findRedirectMatch(pathname, rules) {
+  return rules.find((r) => {
+    if (r.from_path === pathname) return true;
+    const normalizedFrom = r.from_path.endsWith("/") ? r.from_path.slice(0, -1) : r.from_path;
+    const normalizedPath = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+    return normalizedFrom === normalizedPath;
+  });
+}
+async function handleManagedRedirects(request, config) {
+  const pathname = request.nextUrl.pathname;
+  if (pathname.startsWith("/_next") || pathname.startsWith("/api") || pathname.includes(".")) {
+    return void 0;
+  }
+  const rules = await fetchRedirectRules(config);
+  const match = findRedirectMatch(pathname, rules);
+  if (!match) {
+    return void 0;
+  }
+  const redirectUrl = new URL(match.to_path, request.url);
+  request.nextUrl.searchParams.forEach((value, key) => {
+    redirectUrl.searchParams.set(key, value);
+  });
+  trackRedirectHit(config, match.from_path, config.domain).catch(() => {
+  });
+  const statusCode = parseInt(match.redirect_type);
+  return NextResponse.redirect(redirectUrl, statusCode);
+}
+async function trackRedirectHit(config, fromPath, domainForHit) {
+  try {
+    const baseUrl = config.portalApiUrl || envApiUrl() || DEFAULT_PORTAL_URL;
+    const domain = domainForHit ?? config.domain ?? (await getSiteConfig({ apiKey: config.apiKey, apiUrl: baseUrl }))?.domain;
+    if (!domain) return;
+    await fetch(`${baseUrl}/api/public/seo/redirects/hit`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(withSiteBody({ domain, from_path: fromPath }, config.site))
+    });
+  } catch {
+  }
+}
+async function generateNextRedirects(config) {
+  const rules = await fetchRedirectRules({ fetchTimeoutMs: 1e4, ...config, cacheSeconds: 0 });
+  return rules.map((r) => ({
+    source: r.from_path,
+    destination: r.to_path,
+    permanent: r.redirect_type === "301" || r.redirect_type === "308"
+  }));
+}
+function clearRedirectCache() {
+  rulesCache.clear();
+}
+
+export { clearRedirectCache, fetchRedirectRules, findRedirectMatch, generateNextRedirects, handleManagedRedirects, trackRedirectHit };

package/dist/chunk-I6WUCBKI.js

@@ -0,0 +1,99 @@
+'use client';
+import { sanitizeFleetVersion, buildFleetHeartbeatPayload } from './chunk-ZTZQPYP6.js';
+import { useDeferredActivation } from './chunk-YC7ELZS3.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { sonorFetch } from './chunk-4WI3FU5L.js';
+import { SITE_KIT_VERSION } from './chunk-7ZHJIRM3.js';
+import { useRef, useEffect } from 'react';
+
+// src/fleet/heartbeat.ts
+var FLEET_HEARTBEAT_PATH = "/api/public/fleet/heartbeat";
+function detectNextVersion() {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  return sanitizeFleetVersion(w.__SITE_KIT_NEXT_VERSION__ ?? w.next?.version ?? null);
+}
+async function sendFleetHeartbeat(opts) {
+  const { apiUrl, apiKey } = opts;
+  if (!apiUrl || !apiKey) return false;
+  const target = resolveAnalyticsTarget(opts);
+  if (!target) return false;
+  const payload = buildFleetHeartbeatPayload({
+    kitVersion: opts.kitVersion || SITE_KIT_VERSION,
+    nextVersion: opts.nextVersion,
+    modules: opts.modules,
+    site: opts.site,
+    source: opts.source
+  });
+  try {
+    const res = await sonorFetch(
+      `${target.apiUrl.replace(/\/$/, "")}${FLEET_HEARTBEAT_PATH}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      },
+      { apiKey: target.apiKey, retries: 0 }
+    );
+    if (opts.debug) {
+      console.info(
+        `[Sonor fleet] heartbeat ${res.status} v${payload.kit_version} [${payload.modules.join(",") || "none"}]`
+      );
+    }
+    return res.ok;
+  } catch (err) {
+    if (opts.debug) console.info("[Sonor fleet] heartbeat skipped (network)", err);
+    return false;
+  }
+}
+var SESSION_GUARD_KEY = "_sk_fleet_hb";
+function FleetHeartbeat({
+  apiUrl,
+  apiKey,
+  site,
+  modules,
+  nextVersion,
+  defer = true,
+  oncePerSession = true,
+  debug = false,
+  allowInFrame = false,
+  allowLocalhost = false
+}) {
+  const ready = useDeferredActivation(defer);
+  const sentRef = useRef(false);
+  useEffect(() => {
+    if (!ready || sentRef.current) return;
+    if (typeof window === "undefined") return;
+    const w = window;
+    const target = resolveAnalyticsTarget({ apiUrl, apiKey, allowInFrame, allowLocalhost, debug });
+    if (!target) return;
+    const { apiUrl: url, apiKey: key } = target;
+    const resolvedSite = site ?? w.__SITE_KIT_SITE__ ?? window.location.host ?? "";
+    if (oncePerSession) {
+      const stamp = `${SITE_KIT_VERSION}:${resolvedSite}`;
+      try {
+        if (sessionStorage.getItem(SESSION_GUARD_KEY) === stamp) {
+          sentRef.current = true;
+          return;
+        }
+        sessionStorage.setItem(SESSION_GUARD_KEY, stamp);
+      } catch {
+      }
+    }
+    sentRef.current = true;
+    void sendFleetHeartbeat({
+      apiUrl: url,
+      apiKey: key,
+      site: resolvedSite,
+      modules,
+      nextVersion: nextVersion ?? detectNextVersion(),
+      source: "client",
+      allowInFrame,
+      allowLocalhost,
+      debug
+    });
+  }, [ready, apiUrl, apiKey, site, modules, nextVersion, oncePerSession, debug, allowInFrame, allowLocalhost]);
+  return null;
+}
+
+export { FLEET_HEARTBEAT_PATH, FleetHeartbeat, detectNextVersion, sendFleetHeartbeat };