@xenide-io/suite-client 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1111 @@
+// src/errors/codes.ts
+var ERROR_CODES = {
+  AUTH_001: "E-AUTH-001",
+  AUTH_002: "E-AUTH-002",
+  AUTH_003: "E-AUTH-003",
+  VALID_001: "E-VALID-001",
+  DATA_001: "E-DATA-001",
+  DATA_002: "E-DATA-002",
+  LIMIT_001: "E-LIMIT-001",
+  NET_001: "E-NET-001",
+  EXT_001: "E-EXT-001",
+  EXT_002: "E-EXT-002",
+  SYS_001: "E-SYS-001",
+  SYS_002: "E-SYS-002",
+  CLIENT_001: "E-CLIENT-001",
+  CLIENT_002: "E-CLIENT-002"
+};
+var DEFAULT_ERROR_CODE = "E-SYS-001";
+var ERROR_COPY = {
+  "E-AUTH-001": "Sign-in was not accepted. Check your details and try again.",
+  "E-AUTH-002": "Your session has ended. Sign in again to continue.",
+  "E-AUTH-003": "You do not have access to this. Ask an administrator for access.",
+  "E-VALID-001": "Some details need correcting before this can be saved.",
+  "E-DATA-001": "We could not find what you asked for. It may have been removed.",
+  "E-DATA-002": "This conflicts with existing information. Review it and try again.",
+  "E-LIMIT-001": "Too many requests right now. Wait a moment and try again.",
+  "E-NET-001": "We could not reach the service. Try again in a moment.",
+  "E-EXT-001": "The <capability> is unavailable right now. Try again shortly.",
+  "E-EXT-002": "The <capability> could not complete that request. Try again, or adjust the input.",
+  "E-SYS-001": "Something went wrong on our side. We have recorded it. Try again.",
+  "E-SYS-002": "This feature is temporarily unavailable while we carry out maintenance.",
+  "E-CLIENT-001": "You appear to be offline. Check your connection and try again.",
+  "E-CLIENT-002": "We could not read the response. Reload the page and try again."
+};
+var ERROR_RETRYABLE = {
+  "E-AUTH-001": false,
+  "E-AUTH-002": true,
+  "E-AUTH-003": false,
+  "E-VALID-001": false,
+  "E-DATA-001": false,
+  "E-DATA-002": false,
+  "E-LIMIT-001": true,
+  "E-NET-001": true,
+  "E-EXT-001": true,
+  "E-EXT-002": true,
+  "E-SYS-001": true,
+  "E-SYS-002": false,
+  "E-CLIENT-001": true,
+  "E-CLIENT-002": true
+};
+var ERROR_CODE_SET = new Set(Object.values(ERROR_CODES));
+function isErrorCode(value) {
+  return typeof value === "string" && ERROR_CODE_SET.has(value);
+}
+function copyFor(code, capability) {
+  const copy = ERROR_COPY[code] ?? ERROR_COPY[DEFAULT_ERROR_CODE];
+  if (copy.includes("<capability>")) {
+    return copy.replace("<capability>", capability ?? "service");
+  }
+  return copy;
+}
+
+// src/errors/normalize.ts
+var STATUS_TO_CODE = {
+  400: ERROR_CODES.VALID_001,
+  401: ERROR_CODES.AUTH_001,
+  403: ERROR_CODES.AUTH_003,
+  404: ERROR_CODES.DATA_001,
+  405: ERROR_CODES.SYS_001,
+  409: ERROR_CODES.DATA_002,
+  422: ERROR_CODES.VALID_001,
+  429: ERROR_CODES.LIMIT_001,
+  500: ERROR_CODES.SYS_001,
+  502: ERROR_CODES.EXT_002,
+  503: ERROR_CODES.NET_001
+};
+function codeForStatus(status) {
+  if (STATUS_TO_CODE[status]) return STATUS_TO_CODE[status];
+  if (status >= 500) return ERROR_CODES.SYS_001;
+  if (status >= 400) return ERROR_CODES.VALID_001;
+  return ERROR_CODES.SYS_001;
+}
+function build(code, correlationId, retryable, capability) {
+  return {
+    code,
+    message: copyFor(code, capability),
+    ...correlationId ? { correlationId } : {},
+    retryable: retryable ?? ERROR_RETRYABLE[code]
+  };
+}
+function extractEnvelope(input) {
+  if (typeof input !== "object" || input === null) return null;
+  const error = input.error;
+  if (typeof error !== "object" || error === null) return null;
+  const record = error;
+  return {
+    code: typeof record.code === "string" ? record.code : "",
+    correlationId: typeof record.correlation_id === "string" ? record.correlation_id : void 0,
+    retryable: typeof record.retryable === "boolean" ? record.retryable : void 0
+  };
+}
+function normalizeError(input, fallback = DEFAULT_ERROR_CODE, capability) {
+  const envelope = extractEnvelope(input);
+  if (!envelope) return build(fallback, void 0, void 0, capability);
+  const resolved = isErrorCode(envelope.code) ? envelope.code : fallback;
+  return build(
+    resolved,
+    envelope.correlationId,
+    envelope.retryable,
+    capability
+  );
+}
+async function appErrorFromResponse(response, capability) {
+  const fallback = codeForStatus(response.status);
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  return normalizeError(body, fallback, capability);
+}
+function normalizeThrown(input, capability) {
+  if (typeof navigator !== "undefined" && navigator.onLine === false) {
+    return build(ERROR_CODES.CLIENT_001, void 0, void 0, capability);
+  }
+  if (input instanceof DOMException && input.name === "AbortError") {
+    return build(ERROR_CODES.NET_001, void 0, void 0, capability);
+  }
+  return build(ERROR_CODES.NET_001, void 0, void 0, capability);
+}
+function formatAppError(error) {
+  return `${error.message} (Reference: ${error.code})`;
+}
+
+// src/api/create-api-client.ts
+function createApiClient(config) {
+  const API_URL = config.baseUrl ?? process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:8000";
+  const SHARED_WORKSPACE_COOKIE = config.workspaceCookieName ?? "xenide_active_workspace_id";
+  const SHARED_WORKSPACE_COOKIE_DOMAIN = config.workspaceCookieDomain ?? process.env.NEXT_PUBLIC_WORKSPACE_COOKIE_DOMAIN;
+  const ACCESS_KEY = config.accessTokenKey ?? `${config.storagePrefix}_access_token`;
+  const REFRESH_KEY = config.refreshTokenKey ?? `${config.storagePrefix}_refresh_token`;
+  const WORKSPACE_KEY = config.workspaceKey ?? `${config.storagePrefix}_active_workspace_id`;
+  let accessToken = null;
+  let refreshToken = null;
+  let activeWorkspaceId = null;
+  let authFailureHandler = null;
+  let authFailureFired = false;
+  let refreshPromise = null;
+  function readSharedWorkspaceId() {
+    if (typeof document === "undefined") return null;
+    const prefix = `${SHARED_WORKSPACE_COOKIE}=`;
+    const entry = document.cookie.split("; ").find((item) => item.startsWith(prefix));
+    if (!entry) return null;
+    const raw = entry.slice(prefix.length);
+    if (!raw) return null;
+    try {
+      return decodeURIComponent(raw) || null;
+    } catch {
+      return raw;
+    }
+  }
+  function writeSharedWorkspaceId(id) {
+    if (typeof document === "undefined") return;
+    const value = id ? encodeURIComponent(id) : "";
+    const maxAge = id ? 60 * 60 * 24 * 365 : 0;
+    const domain = SHARED_WORKSPACE_COOKIE_DOMAIN ? `; domain=${SHARED_WORKSPACE_COOKIE_DOMAIN}` : "";
+    document.cookie = `${SHARED_WORKSPACE_COOKIE}=${value}; path=/; max-age=${maxAge}; SameSite=Lax${domain}`;
+  }
+  function onAuthFailure(handler) {
+    authFailureHandler = handler;
+    authFailureFired = false;
+  }
+  function triggerAuthFailure() {
+    if (authFailureFired) return;
+    authFailureFired = true;
+    authFailureHandler?.();
+  }
+  function setTokens(access, refresh) {
+    accessToken = access;
+    refreshToken = refresh;
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem(ACCESS_KEY, access);
+      window.localStorage.setItem(REFRESH_KEY, refresh);
+    }
+  }
+  function getAccessToken() {
+    if (accessToken) return accessToken;
+    if (typeof window !== "undefined") {
+      accessToken = window.localStorage.getItem(ACCESS_KEY);
+    }
+    return accessToken;
+  }
+  function getRefreshToken() {
+    if (refreshToken) return refreshToken;
+    if (typeof window !== "undefined") {
+      refreshToken = window.localStorage.getItem(REFRESH_KEY);
+    }
+    return refreshToken;
+  }
+  function setActiveWorkspaceId(id, options) {
+    const changed = activeWorkspaceId !== id;
+    activeWorkspaceId = id;
+    if (typeof window !== "undefined") {
+      if (id) {
+        window.localStorage.setItem(WORKSPACE_KEY, id);
+      } else {
+        window.localStorage.removeItem(WORKSPACE_KEY);
+      }
+      if (changed) config.onWorkspaceChange?.(id);
+    }
+    if (options?.share) writeSharedWorkspaceId(id);
+  }
+  function getActiveWorkspaceId() {
+    if (activeWorkspaceId) return activeWorkspaceId;
+    if (typeof window !== "undefined") {
+      activeWorkspaceId = readSharedWorkspaceId() ?? window.localStorage.getItem(WORKSPACE_KEY);
+    }
+    return activeWorkspaceId;
+  }
+  function restoreWorkspace() {
+    if (typeof window !== "undefined") {
+      activeWorkspaceId = readSharedWorkspaceId() ?? window.localStorage.getItem(WORKSPACE_KEY);
+    }
+  }
+  function clearAuth() {
+    accessToken = null;
+    refreshToken = null;
+    activeWorkspaceId = null;
+    if (typeof window !== "undefined") {
+      window.localStorage.removeItem(ACCESS_KEY);
+      window.localStorage.removeItem(REFRESH_KEY);
+      window.localStorage.removeItem(WORKSPACE_KEY);
+      const prefixes = config.sessionStorageClearPrefixes ?? [];
+      if (prefixes.length > 0) {
+        try {
+          for (let i = window.sessionStorage.length - 1; i >= 0; i -= 1) {
+            const key = window.sessionStorage.key(i);
+            if (key && prefixes.some((prefix) => key.startsWith(prefix))) {
+              window.sessionStorage.removeItem(key);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  function restoreTokens() {
+    if (typeof window !== "undefined") {
+      accessToken = window.localStorage.getItem(ACCESS_KEY);
+      refreshToken = window.localStorage.getItem(REFRESH_KEY);
+      activeWorkspaceId = readSharedWorkspaceId() ?? window.localStorage.getItem(WORKSPACE_KEY);
+    }
+  }
+  async function refreshAccessToken() {
+    if (refreshPromise) return refreshPromise;
+    refreshPromise = refreshAccessTokenInternal().finally(() => {
+      refreshPromise = null;
+    });
+    return refreshPromise;
+  }
+  async function refreshAccessTokenInternal() {
+    const refresh = getRefreshToken();
+    if (!refresh) {
+      triggerAuthFailure();
+      return false;
+    }
+    try {
+      const res = await fetch(`${API_URL}${config.refreshPath}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({ refresh })
+      });
+      if (!res.ok) {
+        clearAuth();
+        triggerAuthFailure();
+        return false;
+      }
+      const data = await res.json();
+      setTokens(data.access, data.refresh);
+      authFailureFired = false;
+      return true;
+    } catch {
+      clearAuth();
+      triggerAuthFailure();
+      return false;
+    }
+  }
+  async function apiFetch(path, options = {}) {
+    const token = getAccessToken();
+    const headers = {
+      Accept: "application/json",
+      ...options.headers
+    };
+    const body = options.body;
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    if (!isFormData) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const wsId = getActiveWorkspaceId();
+    if (wsId) {
+      headers["X-Active-Workspace-Id"] = wsId;
+    }
+    const url = path.startsWith("http") ? path : `${API_URL}${path}`;
+    async function doFetch() {
+      try {
+        return await fetch(url, { ...options, headers });
+      } catch {
+        throw new Error(
+          `Could not reach the API at ${API_URL}. Is the Django backend running?`
+        );
+      }
+    }
+    let res = await doFetch();
+    if (res.status === 401 && token) {
+      const refreshed = await refreshAccessToken();
+      if (refreshed) {
+        const newToken = getAccessToken();
+        if (newToken) {
+          headers["Authorization"] = `Bearer ${newToken}`;
+        }
+        res = await doFetch();
+        if (res.status === 401) {
+          triggerAuthFailure();
+        }
+      }
+    }
+    return res;
+  }
+  async function parseApiError(res) {
+    return formatAppError(await appErrorFromResponse(res));
+  }
+  const api = {
+    get: (path) => apiFetch(path),
+    post: (path, body, options = {}) => apiFetch(path, {
+      ...options,
+      method: "POST",
+      body: body instanceof FormData ? body : body ? JSON.stringify(body) : void 0
+    }),
+    put: (path, body) => apiFetch(path, {
+      method: "PUT",
+      body: body instanceof FormData ? body : body ? JSON.stringify(body) : void 0
+    }),
+    patch: (path, body) => apiFetch(path, {
+      method: "PATCH",
+      body: body instanceof FormData ? body : body ? JSON.stringify(body) : void 0
+    }),
+    delete: (path) => apiFetch(path, { method: "DELETE" })
+  };
+  return {
+    API_URL,
+    onAuthFailure,
+    setTokens,
+    getAccessToken,
+    getRefreshToken,
+    setActiveWorkspaceId,
+    getActiveWorkspaceId,
+    restoreWorkspace,
+    clearAuth,
+    restoreTokens,
+    refreshAccessToken,
+    parseApiError,
+    api
+  };
+}
+
+// src/auth/create-auth-return-path.ts
+function createAuthReturnPath(config) {
+  const RETURN_KEY = config.returnKey;
+  const HANDOFF_KEY = config.handoffKey ?? "ss_portal_handoff";
+  const DEFAULT_NEXT = config.defaultNext ?? "/today";
+  const PORTAL_CALLBACK_PATH = config.portalCallbackPath ?? "/auth/portal/callback";
+  const REDEEM_PATH = config.redeemPath ?? "/api/portal/auth/switch/redeem";
+  function isSafeAuthReturnPath(path) {
+    if (!path || path[0] !== "/" || path.startsWith("//") || path.startsWith("/\\")) {
+      return false;
+    }
+    if (path.includes("\\") || path.includes("://")) return false;
+    return true;
+  }
+  function stashAuthReturnPath(path) {
+    if (typeof window === "undefined" || !isSafeAuthReturnPath(path)) return;
+    sessionStorage.setItem(RETURN_KEY, path);
+  }
+  function portalHandoffUrl(base, data, next, fallbackNext = DEFAULT_NEXT) {
+    const dest = isSafeAuthReturnPath(next) ? next : fallbackNext;
+    const hash = new URLSearchParams();
+    if (data.code) {
+      hash.set("code", data.code);
+    } else {
+      const token = data.token || data.access || "";
+      if (token) hash.set("token", token);
+      if (data.refresh) hash.set("refresh", data.refresh);
+    }
+    hash.set("next", dest);
+    return `${base.replace(/\/$/, "")}${PORTAL_CALLBACK_PATH}#${hash.toString()}`;
+  }
+  function cachedHandoff(fallbackNext) {
+    try {
+      const raw = sessionStorage.getItem(HANDOFF_KEY);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (!parsed.code && !parsed.token) return null;
+      return {
+        code: parsed.code || null,
+        token: parsed.token || null,
+        refresh: parsed.refresh || null,
+        next: isSafeAuthReturnPath(parsed.next) ? parsed.next : fallbackNext
+      };
+    } catch {
+      sessionStorage.removeItem(HANDOFF_KEY);
+      return null;
+    }
+  }
+  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");
+    const result = {
+      code: hash.get("code") || query.get("code"),
+      token: hash.get("token") || query.get("token"),
+      refresh: hash.get("refresh") || query.get("refresh"),
+      next: isSafeAuthReturnPath(nextRaw) ? nextRaw : fallbackNext
+    };
+    if (result.code || result.token) {
+      sessionStorage.setItem(HANDOFF_KEY, JSON.stringify(result));
+    }
+    return result;
+  }
+  let redeemInflight = null;
+  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 };
+      const response = await fetch(`${apiUrl.replace(/\/$/, "")}${REDEEM_PATH}`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code })
+      });
+      if (!response.ok) return { code: null, token: null, refresh: null, next };
+      const data = await response.json();
+      sessionStorage.removeItem(HANDOFF_KEY);
+      return {
+        code: null,
+        token: data.token || data.access || null,
+        refresh: data.refresh || null,
+        next
+      };
+    })());
+    return redeemInflight;
+  }
+  function readAuthReturnPath() {
+    if (typeof window === "undefined") return null;
+    const path = sessionStorage.getItem(RETURN_KEY);
+    return isSafeAuthReturnPath(path) ? path : null;
+  }
+  function signInHrefWithReturn(fallbackRedirect) {
+    const path = isSafeAuthReturnPath(fallbackRedirect) ? fallbackRedirect : readAuthReturnPath();
+    if (!path) return "/login";
+    return `/login?redirect=${encodeURIComponent(path)}`;
+  }
+  function registerHrefWithReturn(returnPath) {
+    return `/register?redirect=${encodeURIComponent(returnPath)}`;
+  }
+  return {
+    isSafeAuthReturnPath,
+    stashAuthReturnPath,
+    portalHandoffUrl,
+    readPortalHandoff,
+    redeemPortalHandoff,
+    readAuthReturnPath,
+    signInHrefWithReturn,
+    registerHrefWithReturn
+  };
+}
+
+// src/workspace/access.ts
+var WORKSPACE_SEAT_HELP = "Each member uses one workspace seat. Inviting someone reserves a seat until the invite is revoked or accepted.";
+var ORGANISATION_SEAT_HELP = "Each organisation member uses one seat across all your workspaces. One invite gives them access to every workspace in your organisation.";
+var TIDES_ACCESS_HELP = "Tides \u2014 project management.";
+var TURTLETIME_ACCESS_HELP = "TurtleTime \u2014 time tracking add-on (Basic plan and above).";
+var FREE_PLAN_SEAT_HELP = "Free personal workspaces include one product app only. Create an organisation on ShellStack for both apps and integration.";
+function hasAppAccess(canAccessTurtletime, canAccessTides) {
+  return canAccessTurtletime || canAccessTides;
+}
+function canDisableAppAccess(app, canAccessTurtletime, canAccessTides) {
+  if (app === "turtletime") return canAccessTides;
+  return canAccessTurtletime;
+}
+
+// src/workspace/subscription.ts
+var TIER_LABELS = {
+  free: "Free",
+  plus: "Plus",
+  ai_plus: "AI Plus",
+  basic: "Basic",
+  pro: "Pro",
+  enterprise: "Enterprise"
+};
+function tierLabel(tier) {
+  if (tier === "basic" || tier === "pro") return "Plus";
+  return TIER_LABELS[tier] ?? "Free";
+}
+function resolveSubscriptionTier(workspace) {
+  const tier = workspace?.subscription?.tier ?? workspace?.subscription_tier;
+  if (tier === "plus" || tier === "ai_plus" || tier === "basic" || tier === "pro" || tier === "enterprise" || tier === "free") {
+    return tier === "basic" || tier === "pro" ? "plus" : tier;
+  }
+  return "free";
+}
+function tierAllowsTurtletime(tier) {
+  return tier !== "free";
+}
+function defaultInviteSeatType(tier) {
+  return tierAllowsTurtletime(tier) ? "integrated" : "tides";
+}
+function tierAllowsTidesOnlySeats() {
+  return false;
+}
+function seatTypeFromFlags(canAccessTurtletime, canAccessTides) {
+  if (canAccessTurtletime && canAccessTides) return "integrated";
+  return "tides";
+}
+function flagsFromSeatType(seatType) {
+  if (seatType === "integrated") {
+    return { can_access_turtletime: true, can_access_tides: true };
+  }
+  return { can_access_turtletime: false, can_access_tides: true };
+}
+function seatTypeLabel(seatType) {
+  return seatType === "integrated" ? "Tides + TurtleTime" : "Tides";
+}
+function seatTypeDescription(tier, seatType) {
+  if (seatType === "integrated") {
+    return "Project management and time tracking with TT\u2194Tides integration.";
+  }
+  if (!tierAllowsTidesOnlySeats()) {
+    return "Project management included on the Free plan.";
+  }
+  return "Project management only \u2014 no TurtleTime time tracking.";
+}
+function planSeatSummary(subscription) {
+  if (!subscription) return "";
+  const { tier, limits, usage } = subscription;
+  const seatCap = limits.seats ?? limits.integrated_seats;
+  const seatCount = usage.seats ?? usage.integrated_seats;
+  if (tier === "enterprise") {
+    return "Unlimited seats";
+  }
+  if (seatCap != null) {
+    return `${seatCount}/${seatCap} seats`;
+  }
+  return "";
+}
+
+// src/workspace/create-brand-settings.ts
+function createBrandSettings(config) {
+  const DEFAULT_BRAND_TITLE = config.defaultTitle;
+  const BRAND_SETTINGS_CHANGED = config.changedEvent;
+  const brandState = {
+    logo: null,
+    title: null,
+    showTitle: true
+  };
+  function notifyBrandChange() {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event(BRAND_SETTINGS_CHANGED));
+    }
+  }
+  function applyWorkspaceBrand(payload) {
+    if ("brand_logo" in payload) {
+      brandState.logo = payload.brand_logo ?? null;
+    }
+    if ("brand_title" in payload) {
+      const title = payload.brand_title;
+      brandState.title = title?.trim() ? title.trim() : null;
+    }
+    if ("brand_show_title" in payload && payload.brand_show_title !== void 0) {
+      brandState.showTitle = payload.brand_show_title;
+    }
+    notifyBrandChange();
+  }
+  function getBrandLogo() {
+    return brandState.logo;
+  }
+  function getCustomBrandTitle() {
+    return brandState.title;
+  }
+  function getBrandShowTitle() {
+    return brandState.showTitle;
+  }
+  function getDisplayBrandTitle() {
+    if (!getBrandShowTitle()) return null;
+    const custom = getCustomBrandTitle();
+    if (custom === null) return DEFAULT_BRAND_TITLE;
+    return custom || DEFAULT_BRAND_TITLE;
+  }
+  function setBrandLogo(dataUrl) {
+    brandState.logo = dataUrl;
+    notifyBrandChange();
+  }
+  function setCustomBrandTitle(title) {
+    brandState.title = title?.trim() ? title.trim() : null;
+    notifyBrandChange();
+  }
+  function setBrandShowTitle(show) {
+    brandState.showTitle = show;
+    notifyBrandChange();
+  }
+  function resetBrandTitle() {
+    brandState.title = null;
+    brandState.showTitle = true;
+    notifyBrandChange();
+  }
+  return {
+    DEFAULT_BRAND_TITLE,
+    BRAND_SETTINGS_CHANGED,
+    /** @deprecated Use BRAND_SETTINGS_CHANGED */
+    BRAND_LOGO_CHANGED: BRAND_SETTINGS_CHANGED,
+    applyWorkspaceBrand,
+    getBrandLogo,
+    getCustomBrandTitle,
+    getBrandShowTitle,
+    getDisplayBrandTitle,
+    setBrandLogo,
+    setCustomBrandTitle,
+    setBrandShowTitle,
+    resetBrandTitle
+  };
+}
+
+// src/workspace/create-workspace-appearance.ts
+function createWorkspaceAppearance(config) {
+  const WORKSPACE_CHANGED = config.changedEvent;
+  const THEME_STORAGE_BASE = config.themeStorageBase;
+  function notifyWorkspaceChanged() {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new Event(WORKSPACE_CHANGED));
+    }
+  }
+  function scopedStorageKey(base, workspaceId) {
+    const wsId = workspaceId ?? config.getActiveWorkspaceId();
+    return wsId ? `${base}:${wsId}` : base;
+  }
+  function getScopedStorageItem(base, workspaceId) {
+    if (typeof window === "undefined") return null;
+    try {
+      const scoped = localStorage.getItem(scopedStorageKey(base, workspaceId));
+      if (scoped !== null) return scoped;
+      const wsId = workspaceId ?? config.getActiveWorkspaceId();
+      if (wsId) {
+        return localStorage.getItem(base);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  function setScopedStorageItem(base, value, workspaceId) {
+    if (typeof window === "undefined") return;
+    const key = scopedStorageKey(base, workspaceId);
+    if (value === null) {
+      localStorage.removeItem(key);
+    } else {
+      localStorage.setItem(key, value);
+    }
+  }
+  return {
+    WORKSPACE_CHANGED,
+    THEME_STORAGE_BASE,
+    notifyWorkspaceChanged,
+    scopedStorageKey,
+    getScopedStorageItem,
+    setScopedStorageItem
+  };
+}
+
+// src/workspace/create-workspace-appearance-api.ts
+var WorkspaceAppearanceError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+};
+function normalizeTheme(value) {
+  return value === "light" ? "light" : "dark";
+}
+function parseAppearancePayload(data) {
+  const raw = data.appearance ?? data;
+  return {
+    theme: normalizeTheme(raw.theme),
+    brand_logo: raw.brand_logo ?? null,
+    brand_title: raw.brand_title ?? null,
+    brand_show_title: Boolean(raw.brand_show_title)
+  };
+}
+function createWorkspaceAppearanceApi(config) {
+  const { api, parseApiError, basePath, applyWorkspaceBrand } = config;
+  async function fetchWorkspaceAppearance() {
+    const res = await api.get(basePath);
+    if (!res.ok) {
+      throw new WorkspaceAppearanceError(await parseApiError(res), res.status);
+    }
+    const data = await res.json();
+    return parseAppearancePayload(data);
+  }
+  async function updateWorkspaceAppearance(patch) {
+    const hasFileUpload = patch.brand_logo_file instanceof File;
+    const shouldClearLogo = patch.clear_brand_logo === true;
+    if (hasFileUpload || shouldClearLogo) {
+      const formData = new FormData();
+      if (patch.theme) formData.append("theme", patch.theme);
+      if (patch.brand_title !== void 0) {
+        formData.append("brand_title", patch.brand_title ?? "");
+      }
+      if (patch.brand_show_title !== void 0) {
+        formData.append(
+          "brand_show_title",
+          patch.brand_show_title ? "true" : "false"
+        );
+      }
+      if (hasFileUpload && patch.brand_logo_file) {
+        formData.append("brand_logo", patch.brand_logo_file);
+      }
+      if (shouldClearLogo) {
+        formData.append("clear_brand_logo", "true");
+      }
+      const res2 = await api.patch(basePath, formData);
+      if (!res2.ok) {
+        throw new Error(await parseApiError(res2));
+      }
+      const data2 = await res2.json();
+      return parseAppearancePayload(data2);
+    }
+    const res = await api.patch(basePath, {
+      theme: patch.theme,
+      brand_title: patch.brand_title,
+      brand_show_title: patch.brand_show_title
+    });
+    if (!res.ok) {
+      throw new Error(await parseApiError(res));
+    }
+    const data = await res.json();
+    return parseAppearancePayload(data);
+  }
+  function cacheWorkspaceAppearanceLocally(appearance) {
+    applyWorkspaceBrand({
+      brand_logo: appearance.brand_logo,
+      brand_title: appearance.brand_title,
+      brand_show_title: appearance.brand_show_title
+    });
+  }
+  return {
+    WorkspaceAppearanceError,
+    fetchWorkspaceAppearance,
+    updateWorkspaceAppearance,
+    cacheWorkspaceAppearanceLocally
+  };
+}
+
+// src/sync/create-cross-app-sync.ts
+function createCrossAppSync(config) {
+  const pollMs = config.pollMs ?? 5e3;
+  const lastKnown = {
+    time: 0,
+    integration: 0,
+    tasks: 0
+  };
+  const subscribers = [];
+  let pollInterval = null;
+  let pollListeners = 0;
+  async function fetchCheckpoint() {
+    try {
+      const res = await config.api.get(config.checkpointPath);
+      if (!res.ok) return null;
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }
+  function notify(topic) {
+    for (const sub of subscribers) {
+      if (!sub.topic || sub.topic === topic) {
+        if (lastKnown[topic] > sub.lastSync) {
+          sub.lastSync = lastKnown[topic];
+          sub.callback();
+        }
+      }
+    }
+  }
+  function checkAndNotify(data) {
+    const tasks = data.tasks_synced_at || 0;
+    const time = data.time_synced_at || 0;
+    const integration = data.integration_synced_at || 0;
+    if (tasks > lastKnown.tasks) {
+      lastKnown.tasks = tasks;
+      notify("tasks");
+    }
+    if (time > lastKnown.time) {
+      lastKnown.time = time;
+      notify("time");
+    }
+    if (integration > lastKnown.integration) {
+      lastKnown.integration = integration;
+      notify("integration");
+    }
+  }
+  function startPolling() {
+    if (pollInterval !== null || typeof window === "undefined") return;
+    void fetchCheckpoint().then((data) => data && checkAndNotify(data));
+    pollInterval = window.setInterval(() => {
+      if (document.visibilityState === "visible") {
+        void fetchCheckpoint().then((data) => data && checkAndNotify(data));
+      }
+    }, pollMs);
+  }
+  function stopPolling() {
+    if (pollListeners > 0) return;
+    if (pollInterval !== null) {
+      window.clearInterval(pollInterval);
+      pollInterval = null;
+    }
+  }
+  function broadcastCrossAppSync(_topic) {
+    void _topic;
+  }
+  function subscribeCrossAppSync(onSync, topic) {
+    if (typeof window === "undefined") return () => {
+    };
+    const sub = {
+      topic,
+      callback: onSync,
+      lastSync: lastKnown[topic || "tasks"]
+    };
+    subscribers.push(sub);
+    pollListeners += 1;
+    startPolling();
+    return () => {
+      const index = subscribers.indexOf(sub);
+      if (index >= 0) subscribers.splice(index, 1);
+      pollListeners -= 1;
+      if (pollListeners <= 0) stopPolling();
+    };
+  }
+  function lastCrossAppSyncTime(topic) {
+    return topic ? lastKnown[topic] : Math.max(...Object.values(lastKnown));
+  }
+  return {
+    broadcastCrossAppSync,
+    subscribeCrossAppSync,
+    lastCrossAppSyncTime
+  };
+}
+
+// src/sync/create-live-refresh.ts
+function createLiveRefresh(sync) {
+  function hasPendingCrossAppSync(topic, since) {
+    return sync.lastCrossAppSyncTime(topic) > since;
+  }
+  function subscribeLiveRefresh(refresh, options = {}) {
+    if (typeof window === "undefined") return () => {
+    };
+    const cleanups = [];
+    let lastRefreshAt = Date.now();
+    const trigger = () => {
+      lastRefreshAt = Date.now();
+      refresh();
+    };
+    for (const eventName of options.localEvents ?? []) {
+      window.addEventListener(eventName, trigger);
+      cleanups.push(() => window.removeEventListener(eventName, trigger));
+    }
+    cleanups.push(sync.subscribeCrossAppSync(trigger, options.crossAppTopic));
+    const shouldRefreshOnFocus = () => hasPendingCrossAppSync(options.crossAppTopic, lastRefreshAt);
+    const onVisibility = () => {
+      if (document.visibilityState === "visible" && shouldRefreshOnFocus()) {
+        trigger();
+      }
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    cleanups.push(
+      () => document.removeEventListener("visibilitychange", onVisibility)
+    );
+    const onFocus = () => {
+      if (shouldRefreshOnFocus()) {
+        trigger();
+      }
+    };
+    window.addEventListener("focus", onFocus);
+    cleanups.push(() => window.removeEventListener("focus", onFocus));
+    if (options.pollMs && options.pollMs > 0) {
+      const interval = window.setInterval(() => {
+        if (document.visibilityState === "visible") trigger();
+      }, options.pollMs);
+      cleanups.push(() => window.clearInterval(interval));
+    }
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  }
+  return { subscribeLiveRefresh, hasPendingCrossAppSync };
+}
+
+// src/notifications/create-notifications-client.ts
+function createNotificationsClient(config) {
+  const { api, parseApiError } = config;
+  const CACHE_MS = config.cacheMs ?? 15e3;
+  const LIST_PATH = config.listPath ?? "/api/notifications/";
+  let notificationsCache = null;
+  let notificationsInflight = null;
+  async function fetchSuiteNotifications() {
+    if (notificationsCache && Date.now() - notificationsCache.at < CACHE_MS) {
+      return notificationsCache.data;
+    }
+    if (notificationsInflight) return notificationsInflight;
+    notificationsInflight = (async () => {
+      try {
+        const res = await api.get(LIST_PATH);
+        if (!res.ok) throw new Error(await parseApiError(res));
+        const data = await res.json();
+        const result = {
+          notifications: data.notifications ?? [],
+          unread_count: data.unread_count ?? 0
+        };
+        notificationsCache = { data: result, at: Date.now() };
+        return result;
+      } finally {
+        notificationsInflight = null;
+      }
+    })();
+    return notificationsInflight;
+  }
+  async function markSuiteNotificationRead(id) {
+    const res = await api.post(`${LIST_PATH}${id}/read/`);
+    if (!res.ok) throw new Error(await parseApiError(res));
+    notificationsCache = null;
+  }
+  async function markAllSuiteNotificationsRead() {
+    const res = await api.post(`${LIST_PATH}read-all/`);
+    if (!res.ok) throw new Error(await parseApiError(res));
+    notificationsCache = null;
+  }
+  return {
+    fetchSuiteNotifications,
+    markSuiteNotificationRead,
+    markAllSuiteNotificationsRead
+  };
+}
+
+// src/ai/suite-ai-job.ts
+function activeSuiteAiJobs(jobs) {
+  return jobs.filter(
+    (job) => job.status === "pending" || job.status === "running"
+  );
+}
+function sortedSuiteAiEvents(events) {
+  return [...events].sort((a, b) => a.sequence - b.sequence);
+}
+function suiteAiEventSummary(event) {
+  const summary = event?.summary.replace(/[\u0000-\u001f]/g, " ").replace(/\s+/g, " ").trim();
+  if (summary) return summary;
+  if (event?.event_type === "queued") return "Shelly request queued";
+  if (event?.event_type === "started")
+    return "Shelly started preparing a reply";
+  if (event?.event_type === "completed") return "Shelly reply ready";
+  if (event?.event_type === "failed") return "AI request failed";
+  return "Shelly is working";
+}
+
+// src/webhooks/webhook-activity-actions.ts
+var WEBHOOK_ACTIVITY_ACTIONS = [
+  { id: "created", label: "Task created" },
+  { id: "updated", label: "Task updated" },
+  { id: "status_changed", label: "Task status changed" },
+  { id: "assigned", label: "Task assigned" },
+  { id: "commented", label: "Comment posted" },
+  { id: "project_renamed", label: "Project renamed" },
+  { id: "project_status_changed", label: "Project archived or restored" }
+];
+var ALL_WEBHOOK_ACTION_IDS = WEBHOOK_ACTIVITY_ACTIONS.map(
+  (action) => action.id
+);
+function webhookActionsToSelected(stored) {
+  if (!stored || stored.length === 0) {
+    return new Set(ALL_WEBHOOK_ACTION_IDS);
+  }
+  return new Set(stored);
+}
+function selectedToWebhookActions(selected) {
+  if (selected.size >= ALL_WEBHOOK_ACTION_IDS.length) {
+    return [];
+  }
+  return ALL_WEBHOOK_ACTION_IDS.filter((id) => selected.has(id));
+}
+
+// src/seo/create-json-ld.ts
+function createJsonLd(config) {
+  const publisherName = config.publisherName ?? "Xenide";
+  const publisherUrl = config.publisherUrl ?? "https://xenide.io";
+  return JSON.stringify({
+    "@context": "https://schema.org",
+    "@type": "SoftwareApplication",
+    name: config.name,
+    url: config.url,
+    description: config.description,
+    applicationCategory: config.applicationCategory ?? "BusinessApplication",
+    ...config.applicationSubCategory ? { applicationSubCategory: config.applicationSubCategory } : {},
+    operatingSystem: config.operatingSystem ?? "Web",
+    browserRequirements: "Requires JavaScript. Requires HTML5.",
+    softwareVersion: config.softwareVersion ?? "1.0",
+    offers: {
+      "@type": "Offer",
+      price: config.price ?? "0",
+      priceCurrency: config.priceCurrency ?? "AUD"
+    },
+    publisher: {
+      "@type": "Organization",
+      name: publisherName,
+      url: publisherUrl
+    },
+    author: {
+      "@type": "Organization",
+      name: publisherName,
+      url: publisherUrl
+    },
+    inLanguage: config.inLanguage ?? "en-AU"
+  });
+}
+
+// src/hooks/use-is-night.ts
+import { useEffect, useState } from "react";
+var NIGHT_START_HOUR = 18;
+var NIGHT_END_HOUR = 6;
+function useIsNight() {
+  const [isNight, setIsNight] = useState(false);
+  useEffect(() => {
+    const check = () => {
+      const hour = (/* @__PURE__ */ new Date()).getHours();
+      return hour >= NIGHT_START_HOUR || hour < NIGHT_END_HOUR;
+    };
+    setIsNight(check());
+    let timeout;
+    const update = () => {
+      const next = check();
+      setIsNight((current) => current !== next ? next : current);
+      timeout = setTimeout(update, 6e4);
+    };
+    timeout = setTimeout(update, 6e4);
+    return () => clearTimeout(timeout);
+  }, []);
+  return isNight;
+}
+export {
+  DEFAULT_ERROR_CODE,
+  ERROR_CODES,
+  ERROR_COPY,
+  ERROR_RETRYABLE,
+  FREE_PLAN_SEAT_HELP,
+  ORGANISATION_SEAT_HELP,
+  TIDES_ACCESS_HELP,
+  TURTLETIME_ACCESS_HELP,
+  WEBHOOK_ACTIVITY_ACTIONS,
+  WORKSPACE_SEAT_HELP,
+  WorkspaceAppearanceError,
+  activeSuiteAiJobs,
+  appErrorFromResponse,
+  canDisableAppAccess,
+  codeForStatus,
+  copyFor,
+  createApiClient,
+  createAuthReturnPath,
+  createBrandSettings,
+  createCrossAppSync,
+  createJsonLd,
+  createLiveRefresh,
+  createNotificationsClient,
+  createWorkspaceAppearance,
+  createWorkspaceAppearanceApi,
+  defaultInviteSeatType,
+  flagsFromSeatType,
+  formatAppError,
+  hasAppAccess,
+  isErrorCode,
+  normalizeError,
+  normalizeThrown,
+  planSeatSummary,
+  resolveSubscriptionTier,
+  seatTypeDescription,
+  seatTypeFromFlags,
+  seatTypeLabel,
+  selectedToWebhookActions,
+  sortedSuiteAiEvents,
+  suiteAiEventSummary,
+  tierAllowsTidesOnlySeats,
+  tierAllowsTurtletime,
+  tierLabel,
+  useIsNight,
+  webhookActionsToSelected
+};
+//# sourceMappingURL=index.mjs.map