@xenide-io/suite-client 0.5.0 → 0.6.0

package/dist/index.mjs

@@ -9417,8 +9417,12 @@ function createAnalyticsClient(config) {
       defaults,
       person_profiles: "identified_only",
       autocapture: true,
-      capture_pageview: true,
-      capture_pageleave: true,
+      // Pageviews are captured explicitly via `pageview()` (mount + route
+      // change) so every `$pageview` carries the app/super-properties and the
+      // behaviour is identical across all apps. The SDK's own pageview capture
+      // is disabled to avoid double-counting and `defaults`-dependent behaviour.
+      capture_pageview: false,
+      capture_pageleave: false,
       persistence: "localStorage+cookie",
       cross_subdomain_cookie: true
     });
@@ -9476,6 +9480,7 @@ function createAnalyticsClient(config) {
     if (sessionId) headers["X-POSTHOG-SESSION-ID"] = sessionId;
     return headers;
   }
+  if (isBrowser()) init();
   return {
     init,
     identify,
@@ -9502,6 +9507,7 @@ function createApiClient(config) {
   let accessToken = null;
   let refreshToken = null;
   let activeWorkspaceId = null;
+  const etagBodies = /* @__PURE__ */ new Map();
   let authFailureHandler = null;
   let authFailureFired = false;
   let refreshPromise = null;
@@ -9593,6 +9599,7 @@ function createApiClient(config) {
         window.localStorage.removeItem(WORKSPACE_KEY);
       }
       if (changed) {
+        etagBodies.clear();
         config.onWorkspaceChange?.(id2);
         if (id2 && previousWorkspaceId) {
           track("Workspace Switched", {
@@ -9626,6 +9633,7 @@ function createApiClient(config) {
     accessToken = null;
     refreshToken = null;
     activeWorkspaceId = null;
+    etagBodies.clear();
     if (typeof window !== "undefined") {
       window.localStorage.removeItem(ACCESS_KEY);
       window.localStorage.removeItem(REFRESH_KEY);
@@ -9713,6 +9721,12 @@ function createApiClient(config) {
       headers["X-Active-Workspace-Id"] = wsId;
     }
     applyContextHeaders(headers);
+    const method = (requestInit.method ?? "GET").toUpperCase();
+    const etagKey = `${method}:${wsId ?? ""}:${path}`;
+    if (method === "GET") {
+      const hit = etagBodies.get(etagKey);
+      if (hit) headers["If-None-Match"] = hit.etag;
+    }
     const url = path.startsWith("http") ? path : `${API_URL}${path}`;
     if (config.enforceSameOrigin && !skipAuth && path.startsWith("http") && !url.startsWith(API_URL)) {
       throw new Error("Refusing to send the session to an unexpected origin.");
@@ -9744,6 +9758,26 @@ function createApiClient(config) {
         triggerAuthFailure();
       }
     }
+    if (method === "GET" && res.status === 304) {
+      const hit = etagBodies.get(etagKey);
+      if (hit) {
+        return new Response(hit.body, {
+          status: 200,
+          headers: { "Content-Type": "application/json", ETag: hit.etag }
+        });
+      }
+    }
+    if (method === "GET" && res.ok) {
+      const etag = res.headers.get("ETag");
+      if (etag) {
+        const cachedBody = await res.clone().text();
+        if (etagBodies.size >= 40) {
+          const oldest = etagBodies.keys().next().value;
+          if (oldest) etagBodies.delete(oldest);
+        }
+        etagBodies.set(etagKey, { etag, body: cachedBody });
+      }
+    }
     return res;
   }
   async function parseApiError(res) {
@@ -9838,8 +9872,6 @@ function createAuthReturnPath(config) {
     }
   }
   function readPortalHandoff(fallbackNext = DEFAULT_NEXT) {
-    const cached = cachedHandoff(fallbackNext);
-    if (cached) return cached;
     const hash = new URLSearchParams(window.location.hash.replace(/^#/, ""));
     const query = new URLSearchParams(window.location.search);
     const nextRaw = hash.get("next") || query.get("next");
@@ -9852,19 +9884,18 @@ function createAuthReturnPath(config) {
     if (result.code || result.token) {
       sessionStorage.setItem(HANDOFF_KEY, JSON.stringify(result));
     }
-    return result;
+    return result.code || result.token ? result : cachedHandoff(fallbackNext) ?? result;
   }
   let redeemInflight = null;
+  let redeemKey = "";
   function track(event, properties) {
     try {
       config.onAnalyticsEvent?.(event, properties);
     } catch {
     }
   }
-  async function redeemPortalHandoff(apiUrl, fallbackNext = DEFAULT_NEXT) {
-    redeemInflight ?? (redeemInflight = (async () => {
-      const { code, token, refresh, next } = readPortalHandoff(fallbackNext);
-      if (!code) return { code: null, token, refresh, next };
+  async function requestSwitchCode(apiUrl, code) {
+    try {
       const response = await fetch(`${apiUrl.replace(/\/$/, "")}${REDEEM_PATH}`, {
         method: "POST",
         headers: {
@@ -9873,21 +9904,57 @@ function createAuthReturnPath(config) {
         },
         body: JSON.stringify({ code })
       });
-      if (!response.ok) {
+      if (!response.ok) return "dead";
+      return await response.json();
+    } catch {
+      return "retry";
+    }
+  }
+  async function redeemPortalHandoff(apiUrl, fallbackNext = DEFAULT_NEXT) {
+    const handoff = readPortalHandoff(fallbackNext);
+    const key = JSON.stringify([apiUrl, handoff]);
+    if (redeemInflight && redeemKey === key) {
+      return redeemInflight.then((result) => {
+        if (result.token) sessionStorage.removeItem(HANDOFF_KEY);
+        return result;
+      });
+    }
+    redeemKey = key;
+    const { code, token, refresh, next } = handoff;
+    redeemInflight = (async () => {
+      if (!code) {
+        sessionStorage.removeItem(HANDOFF_KEY);
+        return { code: null, token, refresh, next };
+      }
+      let outcome = await requestSwitchCode(apiUrl, code);
+      if (outcome === "retry") outcome = await requestSwitchCode(apiUrl, code);
+      if (outcome === "retry") {
+        track("Cross-App Switch", { success: false });
+        return { code: null, token: null, refresh: null, next };
+      }
+      if (outcome === "dead") {
+        sessionStorage.removeItem(HANDOFF_KEY);
+        track("Cross-App Switch", { success: false });
+        return { code: null, token: null, refresh: null, next };
+      }
+      const redeemedToken = outcome.token || outcome.access || null;
+      if (!redeemedToken) {
+        sessionStorage.removeItem(HANDOFF_KEY);
         track("Cross-App Switch", { success: false });
         return { code: null, token: null, refresh: null, next };
       }
-      const data = await response.json();
       sessionStorage.removeItem(HANDOFF_KEY);
-      const redeemedToken = data.token || data.access || null;
-      track("Cross-App Switch", { success: Boolean(redeemedToken) });
+      track("Cross-App Switch", { success: true });
       return {
         code: null,
         token: redeemedToken,
-        refresh: data.refresh || null,
+        refresh: outcome.refresh || null,
         next
       };
-    })());
+    })().then((result) => {
+      if (!result.token && redeemKey === key) redeemInflight = null;
+      return result;
+    });
     return redeemInflight;
   }
   function readAuthReturnPath() {
@@ -10199,6 +10266,165 @@ function createWorkspaceAppearanceApi(config) {
   };
 }
 
+// src/cache/persist-query-cache.ts
+var SUITE_QUERY_CACHE_MAX_AGE_MS = 30 * 60 * 1e3;
+var MAX_SNAPSHOT_CHARS = 15e5;
+function suiteCacheBuster(tokenKey, workspaceKey) {
+  if (typeof window === "undefined") return "";
+  let token = null;
+  let workspace = null;
+  try {
+    token = window.localStorage.getItem(tokenKey);
+    workspace = window.localStorage.getItem(workspaceKey) || readCookie("xenide_active_workspace_id");
+  } catch {
+    return "";
+  }
+  const subject = subjectFromAccessToken(token);
+  if (!subject || !workspace) return "";
+  return `${subject}:${workspace}`;
+}
+function readJsonSnapshot(key, buster, maxAgeMs) {
+  if (typeof window === "undefined" || !buster) return null;
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed.buster !== buster || typeof parsed.savedAt !== "number") return null;
+    if (Date.now() - parsed.savedAt > maxAgeMs) return null;
+    return parsed.value ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeJsonSnapshot(key, buster, value) {
+  if (typeof window === "undefined" || !buster) return;
+  try {
+    const raw = JSON.stringify({ buster, savedAt: Date.now(), value });
+    if (raw.length > MAX_SNAPSHOT_CHARS) return;
+    window.localStorage.setItem(key, raw);
+  } catch {
+  }
+}
+function persistSuiteQueries(queryClient, options) {
+  const maxAgeMs = options.maxAgeMs ?? SUITE_QUERY_CACHE_MAX_AGE_MS;
+  restore(queryClient, options, maxAgeMs);
+  let timer = 0;
+  const unsubscribe = queryClient.getQueryCache().subscribe(() => {
+    if (typeof window === "undefined") return;
+    window.clearTimeout(timer);
+    timer = window.setTimeout(() => save(queryClient, options), 400);
+  });
+  return () => {
+    if (typeof window !== "undefined") window.clearTimeout(timer);
+    unsubscribe();
+  };
+}
+function restore(queryClient, options, maxAgeMs) {
+  const buster = suiteCacheBuster(options.tokenKey, options.workspaceKey);
+  const stored = readJsonSnapshot(
+    options.storageKey,
+    buster,
+    maxAgeMs
+  );
+  if (!Array.isArray(stored)) return;
+  for (const entry of stored) {
+    if (!entry || !Array.isArray(entry.queryKey) || !allowed(entry.queryKey, options.allow)) {
+      continue;
+    }
+    queryClient.setQueryData(entry.queryKey, entry.data);
+    void queryClient.invalidateQueries({
+      queryKey: entry.queryKey,
+      refetchType: "none"
+    });
+  }
+}
+function save(queryClient, options) {
+  const buster = suiteCacheBuster(options.tokenKey, options.workspaceKey);
+  if (!buster) return;
+  const queries = queryClient.getQueryCache().getAll().filter(
+    (query) => query.state.status === "success" && query.state.data !== void 0 && allowed(query.queryKey, options.allow)
+  ).map((query) => ({ queryKey: query.queryKey, data: query.state.data }));
+  writeJsonSnapshot(options.storageKey, buster, queries);
+}
+function allowed(queryKey, allow) {
+  return allow.some((rule) => {
+    if (typeof rule === "string") return queryKey[0] === rule;
+    return rule.every((part, index) => queryKey[index] === part);
+  });
+}
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  const prefix = `${name}=`;
+  const entry = document.cookie.split("; ").find((item) => item.startsWith(prefix));
+  if (!entry) return null;
+  try {
+    return decodeURIComponent(entry.slice(prefix.length)) || null;
+  } catch {
+    return entry.slice(prefix.length) || null;
+  }
+}
+function subjectFromAccessToken(token) {
+  if (!token) return "";
+  const segment = token.split(".")[1];
+  if (!segment) return "";
+  try {
+    const base64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const json = JSON.parse(atob(padded));
+    return typeof json.sub === "string" ? json.sub : "";
+  } catch {
+    return "";
+  }
+}
+var SUITE_APP_QUERY_CACHES = {
+  kraken: {
+    storageKey: "kraken-query-cache:v1",
+    tokenKey: "kraken_access_token",
+    workspaceKey: "kraken_active_workspace_id",
+    allow: ["kraken-sidebar"]
+  },
+  shellstack: {
+    storageKey: "shellstack-query-cache:v1",
+    tokenKey: "portal_access_token",
+    workspaceKey: "portal_active_workspace_id",
+    allow: ["calendar-events", "org-workspaces", "organisation", "org-team", "directory"]
+  },
+  tides: {
+    storageKey: "tides-query-cache:v1",
+    tokenKey: "tides_access_token",
+    workspaceKey: "tides_active_workspace_id",
+    allow: [
+      ["tides", "projects"],
+      ["tides", "clients"],
+      ["tides", "workspace-members"],
+      ["tides", "workspace-tags"],
+      ["tides", "project-statuses"]
+    ]
+  },
+  turtletime: {
+    storageKey: "tt-query-cache:v1",
+    tokenKey: "tt_access_token",
+    workspaceKey: "tt_active_workspace_id",
+    allow: [
+      ["tt", "tracker-catalog"],
+      ["tt", "projects"],
+      ["tt", "clients"],
+      ["tt", "categories"]
+    ]
+  },
+  shelly: {
+    storageKey: "shelly-query-cache:v1",
+    tokenKey: "shelly_access_token",
+    workspaceKey: "shelly_active_workspace_id",
+    allow: [
+      ["shelly", "skills"],
+      ["shelly", "crews"],
+      ["shelly", "mcp-servers"],
+      ["shelly", "models"]
+    ]
+  }
+};
+
 // src/sync/create-cross-app-sync.ts
 function createCrossAppSync(config) {
   const pollMs = config.pollMs ?? 5e3;
@@ -10342,6 +10568,74 @@ function createLiveRefresh(sync) {
   return { subscribeLiveRefresh, hasPendingCrossAppSync };
 }
 
+// src/sync/use-suite-revisions.ts
+import { useEffect, useRef } from "react";
+function nextRevisionTick(seen, ready, data) {
+  if (!data) return { seen, ready, changed: [] };
+  const next = { ...seen };
+  if (!ready) {
+    for (const [topic, value] of Object.entries(data)) {
+      if (typeof value === "number") next[topic] = value;
+    }
+    return { seen: next, ready: true, changed: [] };
+  }
+  const changed = [];
+  for (const [topic, value] of Object.entries(data)) {
+    if (typeof value !== "number" || next[topic] === value) continue;
+    next[topic] = value;
+    changed.push(topic);
+  }
+  return { seen: next, ready: true, changed };
+}
+function useSuiteRevisions(options) {
+  const loadRef = useRef(options.load);
+  const onTopicRef = useRef(options.onTopic);
+  loadRef.current = options.load;
+  onTopicRef.current = options.onTopic;
+  const pollMs = options.pollMs ?? 15e3;
+  const scope = options.scope ?? "";
+  const seenScope = useRef(null);
+  useEffect(() => {
+    if (!options.enabled || typeof window === "undefined") return;
+    const switching = seenScope.current !== null && seenScope.current !== scope;
+    seenScope.current = scope;
+    let seen = {};
+    let ready = switching;
+    let timer;
+    const tick = async () => {
+      let data = null;
+      try {
+        data = await loadRef.current();
+      } catch {
+        return;
+      }
+      const step = nextRevisionTick(seen, ready, data);
+      seen = step.seen;
+      ready = step.ready;
+      for (const topic of step.changed) onTopicRef.current(topic);
+    };
+    const stop = () => {
+      if (timer !== void 0) window.clearInterval(timer);
+      timer = void 0;
+    };
+    const start = () => {
+      if (timer !== void 0) return;
+      void tick();
+      timer = window.setInterval(() => void tick(), pollMs);
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === "visible") start();
+      else stop();
+    };
+    if (document.visibilityState === "visible") start();
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      stop();
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [options.enabled, pollMs, scope]);
+}
+
 // src/notifications/create-notifications-client.ts
 function createNotificationsClient(config) {
   const { api, parseApiError } = config;
@@ -10487,6 +10781,47 @@ function createWebPushClient(config) {
   return { supported, getState, enable, disable };
 }
 
+// src/notifications/use-email-notification-preference.ts
+import { useCallback, useEffect as useEffect2, useState } from "react";
+var EMAIL_PREFERENCE_PATH = "/api/notifications/email/";
+function useEmailNotificationPreference(api, parseApiError) {
+  const [enabled, setEnabled] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  useEffect2(() => {
+    let cancelled = false;
+    api.get(EMAIL_PREFERENCE_PATH).then(async (res) => {
+      if (!res.ok || cancelled) return;
+      const data = await res.json();
+      if (!cancelled) setEnabled(Boolean(data.enabled));
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [api]);
+  const onChange = useCallback(
+    (next) => {
+      setBusy(true);
+      setError("");
+      setEnabled(next);
+      api.patch(EMAIL_PREFERENCE_PATH, { enabled: next }).then(async (res) => {
+        if (!res.ok) {
+          setEnabled(!next);
+          setError(await parseApiError(res));
+        }
+      }).catch((err) => {
+        setEnabled(!next);
+        setError(
+          err instanceof Error ? err.message : "Could not save email notifications."
+        );
+      }).finally(() => setBusy(false));
+    },
+    [api, parseApiError]
+  );
+  return { enabled, busy, error, onChange };
+}
+
 // src/ai/suite-ai-job.ts
 function activeSuiteAiJobs(jobs) {
   return jobs.filter(
@@ -10568,12 +10903,12 @@ function createJsonLd(config) {
 }
 
 // src/hooks/use-is-night.ts
-import { useEffect, useState } from "react";
+import { useEffect as useEffect3, useState as useState2 } from "react";
 var NIGHT_START_HOUR = 18;
 var NIGHT_END_HOUR = 6;
 function useIsNight() {
-  const [isNight, setIsNight] = useState(false);
-  useEffect(() => {
+  const [isNight, setIsNight] = useState2(false);
+  useEffect3(() => {
     const check = () => {
       const hour = (/* @__PURE__ */ new Date()).getHours();
       return hour >= NIGHT_START_HOUR || hour < NIGHT_END_HOUR;
@@ -10597,6 +10932,8 @@ export {
   ERROR_RETRYABLE,
   FREE_PLAN_SEAT_HELP,
   ORGANISATION_SEAT_HELP,
+  SUITE_APP_QUERY_CACHES,
+  SUITE_QUERY_CACHE_MAX_AGE_MS,
   TIDES_ACCESS_HELP,
   TURTLETIME_ACCESS_HELP,
   WEBHOOK_ACTIVITY_ACTIONS,
@@ -10624,9 +10961,12 @@ export {
   formatAppError,
   hasAppAccess,
   isErrorCode,
+  nextRevisionTick,
   normalizeError,
   normalizeThrown,
+  persistSuiteQueries,
   planSeatSummary,
+  readJsonSnapshot,
   resolveSubscriptionTier,
   seatTypeDescription,
   seatTypeFromFlags,
@@ -10634,10 +10974,14 @@ export {
   selectedToWebhookActions,
   sortedSuiteAiEvents,
   suiteAiEventSummary,
+  suiteCacheBuster,
   tierAllowsTidesOnlySeats,
   tierAllowsTurtletime,
   tierLabel,
+  useEmailNotificationPreference,
   useIsNight,
-  webhookActionsToSelected
+  useSuiteRevisions,
+  webhookActionsToSelected,
+  writeJsonSnapshot
 };
 //# sourceMappingURL=index.mjs.map