woodsportal-client-sdk 4.0.4-dev.9 → 4.0.7-dev.1

package/dist/chunk-B2OVKOJU.js

@@ -0,0 +1,633 @@
+import { getStorageKeys, isCookieExpired, getCookie, isCorruptCookieRawValue, stringifyCookieValue, setCookie, parseCookieJson } from './chunk-YNOZWRK3.js';
+import { WP_STORAGE_KEYS, wpClientIframeRefreshKey, wpClientIframeRefreshExpKey } from './chunk-BKT4MFQM.js';
+import axios from 'axios';
+
+// src/main/core/utils/constants.ts
+WP_STORAGE_KEYS.c.auth.login;
+WP_STORAGE_KEYS.c.auth.refresh;
+WP_STORAGE_KEYS.c.auth.portal;
+WP_STORAGE_KEYS.c.auth.sub;
+var HUBSPOT_DATA = WP_STORAGE_KEYS.c.hub;
+var HUB_ID = "hubId";
+var DEV_PORTAL_ID = "devPortalId";
+var PORTAL_ID = "portalId";
+var DEV_API_URL = "devApiUrl";
+
+// src/main/core/utils/localStorage.ts
+var memory = /* @__PURE__ */ new Map();
+var memoryStore = {
+  getItem(key) {
+    return memory.has(key) ? memory.get(key) : null;
+  },
+  setItem(key, value) {
+    memory.set(key, value);
+  },
+  removeItem(key) {
+    memory.delete(key);
+  }
+};
+function resolveStore() {
+  if (typeof globalThis === "undefined") {
+    return memoryStore;
+  }
+  const ls = globalThis.localStorage;
+  if (!ls || typeof ls.getItem !== "function") {
+    return memoryStore;
+  }
+  try {
+    const probeKey = "__woodsportal_client_sdk_ls_probe__";
+    ls.setItem(probeKey, "1");
+    ls.removeItem(probeKey);
+    return ls;
+  } catch {
+    return memoryStore;
+  }
+}
+var storage = {
+  set: (key, value) => {
+    resolveStore().setItem(key, JSON.stringify(value));
+  },
+  get: (key) => {
+    const item = resolveStore().getItem(key);
+    return item ? JSON.parse(item) : null;
+  },
+  remove: (key) => {
+    resolveStore().removeItem(key);
+  }
+};
+
+// src/main/core/utils/runtime-hub-context.ts
+var initializedHubId = "";
+var initializedDevPortalId = "";
+var initializedDevApiUrl = "";
+function setRuntimeHttpClientHubContext(partial) {
+  if (partial.hubId != null) {
+    initializedHubId = partial.hubId;
+  }
+  if (partial.devPortalId != null) {
+    initializedDevPortalId = partial.devPortalId;
+  }
+  if (partial.devApiUrl != null) {
+    initializedDevApiUrl = partial.devApiUrl;
+  }
+}
+function getRuntimeHttpClientHubId() {
+  return initializedHubId;
+}
+function getRuntimeHttpClientDevPortalId() {
+  return initializedDevPortalId;
+}
+function getRuntimeHttpClientDevApiUrl() {
+  return initializedDevApiUrl;
+}
+
+// src/main/core/utils/hub-context.ts
+function readStorageField(key) {
+  const hubSpotData = storage.get(HUBSPOT_DATA);
+  const value = hubSpotData?.[key];
+  return value != null && String(value).trim() !== "" ? String(value) : "";
+}
+var config = {
+  get hubId() {
+    return readStorageField(HUB_ID) || getRuntimeHttpClientHubId();
+  },
+  get devPortalId() {
+    return readStorageField(DEV_PORTAL_ID) || getRuntimeHttpClientDevPortalId();
+  },
+  get portalId() {
+    return readStorageField(PORTAL_ID);
+  },
+  get devApiUrl() {
+    return readStorageField(DEV_API_URL) || getRuntimeHttpClientDevApiUrl();
+  }
+};
+var setConfig = {
+  setDevPortalId(portalId) {
+    const existing = storage.get(HUBSPOT_DATA) || {};
+    storage.set(HUBSPOT_DATA, {
+      ...existing,
+      [PORTAL_ID]: portalId
+    });
+  }
+};
+
+// src/main/core/http/iframe-session-storage.ts
+var iframeStorageMode = false;
+function setIframeStorageMode(enabled) {
+  iframeStorageMode = enabled;
+}
+function isIframeStorageMode() {
+  return iframeStorageMode;
+}
+function resolveHubId() {
+  const fromWindow = typeof window !== "undefined" ? window.hubSpotData?.hubId : void 0;
+  const fromConfig = config.hubId;
+  return fromWindow ?? fromConfig ?? "default";
+}
+function iframeKey() {
+  return wpClientIframeRefreshKey(resolveHubId());
+}
+function iframeExpKey() {
+  return wpClientIframeRefreshExpKey(resolveHubId());
+}
+function readIframeRefreshToken() {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return null;
+  }
+  try {
+    const raw = window.localStorage.getItem(iframeKey());
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function writeIframeRefreshToken(token, expiresAtMs) {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return;
+  }
+  try {
+    window.localStorage.setItem(iframeKey(), JSON.stringify(token));
+    if (expiresAtMs != null) {
+      window.localStorage.setItem(iframeExpKey(), String(expiresAtMs));
+    }
+  } catch {
+  }
+}
+
+// src/main/core/utils/error-log-sanitize.ts
+var SENSITIVE_FIELD_NAMES = /* @__PURE__ */ new Set(["token", "refreshtoken", "accesstoken", "password", "secret", "authorization", "otp", "code"]);
+function isSensitiveField(name) {
+  const normalized = name.toLowerCase();
+  return SENSITIVE_FIELD_NAMES.has(normalized) || normalized.includes("password");
+}
+function redactValue(value) {
+  if (value == null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(redactValue);
+  }
+  const input = value;
+  const output = {};
+  for (const [key, nested] of Object.entries(input)) {
+    output[key] = isSensitiveField(key) ? "[redacted]" : redactValue(nested);
+  }
+  return output;
+}
+function sanitizeAxiosErrorData(data) {
+  if (data == null || typeof data !== "object") {
+    return data;
+  }
+  const payload = data;
+  const safeFields = ["errorCode", "message", "errorMessage", "detailedMessage", "correlationId", "category", "statusCode"];
+  const summary = {};
+  for (const field of safeFields) {
+    if (field in payload) {
+      summary[field] = payload[field];
+    }
+  }
+  if (Object.keys(summary).length > 0) {
+    return summary;
+  }
+  return redactValue(payload);
+}
+function redactLogMeta(meta) {
+  if (meta == null) {
+    return meta;
+  }
+  return redactValue(meta);
+}
+
+// src/main/core/logging/logger.ts
+var LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var DEFAULT_CONFIG = {
+  level: "info",
+  namespace: "woodsportal-sdk",
+  enabled: true,
+  httpTracing: true
+};
+var runtimeConfig = { ...DEFAULT_CONFIG };
+var customSinks;
+function shouldEmit(level) {
+  if (!runtimeConfig.enabled || runtimeConfig.level === "silent") {
+    return false;
+  }
+  return LEVEL_RANK[level] >= LEVEL_RANK[runtimeConfig.level];
+}
+function formatPrefix(context) {
+  return `[${runtimeConfig.namespace}] ${context}`;
+}
+function defaultDebug(context, message, meta) {
+  if (meta != null) {
+    console.debug(formatPrefix(context), message, meta);
+    return;
+  }
+  console.debug(formatPrefix(context), message);
+}
+function defaultInfo(context, message, meta) {
+  if (meta != null) {
+    console.info(formatPrefix(context), message, meta);
+    return;
+  }
+  console.info(formatPrefix(context), message);
+}
+function defaultWarn(context, message, meta) {
+  if (meta != null) {
+    console.warn(formatPrefix(context), message, meta);
+    return;
+  }
+  console.warn(formatPrefix(context), message);
+}
+function defaultError(context, error, meta) {
+  if (axios.isAxiosError(error)) {
+    const payload = {
+      message: error.message,
+      status: error.response?.status,
+      statusText: error.response?.statusText,
+      data: sanitizeAxiosErrorData(error.response?.data),
+      url: error.config?.url,
+      method: error.config?.method,
+      ...redactLogMeta(meta)
+    };
+    console.error(formatPrefix(context), payload);
+    return;
+  }
+  if (error instanceof Error) {
+    if (meta != null) {
+      console.error(formatPrefix(context), error.message, error, redactLogMeta(meta));
+      return;
+    }
+    console.error(formatPrefix(context), error.message, error);
+    return;
+  }
+  if (meta != null) {
+    console.error(formatPrefix(context), error, redactLogMeta(meta));
+    return;
+  }
+  console.error(formatPrefix(context), error);
+}
+function configureLogger(config2 = {}) {
+  runtimeConfig = {
+    level: config2.level ?? DEFAULT_CONFIG.level,
+    namespace: config2.namespace ?? DEFAULT_CONFIG.namespace,
+    enabled: config2.enabled ?? DEFAULT_CONFIG.enabled,
+    httpTracing: config2.httpTracing ?? DEFAULT_CONFIG.httpTracing
+  };
+  customSinks = config2.sinks;
+}
+function isHttpTracingEnabled() {
+  return runtimeConfig.enabled && runtimeConfig.httpTracing && shouldEmit("debug");
+}
+var logger = {
+  debug(context, message, meta) {
+    if (!shouldEmit("debug")) return;
+    const sink = customSinks?.debug ?? defaultDebug;
+    sink(context, message, redactLogMeta(meta));
+  },
+  info(context, message, meta) {
+    if (!shouldEmit("info")) return;
+    const sink = customSinks?.info ?? defaultInfo;
+    sink(context, message, redactLogMeta(meta));
+  },
+  warn(context, message, meta) {
+    if (!shouldEmit("warn")) return;
+    const sink = customSinks?.warn ?? defaultWarn;
+    sink(context, message, redactLogMeta(meta));
+  },
+  error(context, error, meta) {
+    if (!shouldEmit("error")) return;
+    const sink = customSinks?.error ?? defaultError;
+    sink(context, error, redactLogMeta(meta));
+  }
+};
+
+// src/main/core/http/token-store.ts
+var accessToken = null;
+var tokenExpiresAt = null;
+var accessTtlMs = null;
+var refreshCallback = null;
+var refreshBufferSeconds = 60;
+var refreshPromise = null;
+var lastRefreshFailed = false;
+var lastSuccessfulRefreshAt = null;
+var sessionLifecycleListener = null;
+var MIN_SHORT_TTL_BUFFER_MS = 5e3;
+var MIN_PROACTIVE_REFRESH_INTERVAL_MS = 3e4;
+function getEffectiveBufferMs(ttlMs) {
+  const capMs = refreshBufferSeconds * 1e3;
+  let buffer;
+  if (ttlMs <= capMs) {
+    buffer = Math.max(MIN_SHORT_TTL_BUFFER_MS, Math.floor(ttlMs * 0.2));
+  } else {
+    buffer = capMs;
+  }
+  const maxBuffer = Math.max(0, ttlMs - 1e3);
+  return Math.min(buffer, maxBuffer);
+}
+function getCurrentBufferMs() {
+  if (accessTtlMs != null && accessTtlMs > 0) {
+    return getEffectiveBufferMs(accessTtlMs);
+  }
+  return refreshBufferSeconds * 1e3;
+}
+function getAccessToken() {
+  return accessToken;
+}
+function setSessionLifecycleListener(listener) {
+  sessionLifecycleListener = listener;
+}
+function notifySessionLifecycleChange() {
+  try {
+    sessionLifecycleListener?.();
+  } catch {
+  }
+}
+function persistRefreshExhausted() {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return;
+  }
+  try {
+    window.sessionStorage.setItem(WP_STORAGE_KEYS.c.auth.refreshExhausted, JSON.stringify({ ts: Date.now() }));
+  } catch {
+  }
+}
+function clearPersistedRefreshExhausted() {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return;
+  }
+  try {
+    window.sessionStorage.removeItem(WP_STORAGE_KEYS.c.auth.refreshExhausted);
+  } catch {
+  }
+}
+function readPersistedRefreshExhausted() {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return false;
+  }
+  try {
+    return Boolean(window.sessionStorage.getItem(WP_STORAGE_KEYS.c.auth.refreshExhausted));
+  } catch {
+    return false;
+  }
+}
+function hydrateSessionRefreshState() {
+  if (readPersistedRefreshExhausted()) {
+    lastRefreshFailed = true;
+  }
+}
+function clearSessionRefreshExhaustedState() {
+  lastRefreshFailed = false;
+  clearPersistedRefreshExhausted();
+}
+function markRefreshFailed() {
+  lastRefreshFailed = true;
+  persistRefreshExhausted();
+  clearAccessToken();
+  notifySessionLifecycleChange();
+}
+function storAccessToken(token, expiresIn) {
+  accessToken = token;
+  clearSessionRefreshExhaustedState();
+  if (expiresIn != null && expiresIn > 0) {
+    accessTtlMs = expiresIn * 1e3;
+    tokenExpiresAt = Date.now() + accessTtlMs;
+  } else {
+    accessTtlMs = null;
+    tokenExpiresAt = null;
+  }
+  notifySessionLifecycleChange();
+}
+function clearAccessToken() {
+  accessToken = null;
+  tokenExpiresAt = null;
+  accessTtlMs = null;
+  lastSuccessfulRefreshAt = null;
+}
+function resetSessionAuthState() {
+  lastSuccessfulRefreshAt = null;
+}
+function setRefreshBufferSeconds(seconds) {
+  refreshBufferSeconds = Math.max(0, seconds);
+}
+function didLastRefreshFail() {
+  return lastRefreshFailed;
+}
+function isSessionRefreshExhausted() {
+  if (lastRefreshFailed) {
+    return true;
+  }
+  if (readPersistedRefreshExhausted()) {
+    lastRefreshFailed = true;
+    return true;
+  }
+  return false;
+}
+function isExpiresAccessToken() {
+  if (!accessToken) return true;
+  if (tokenExpiresAt === null) return false;
+  const bufferMs = getCurrentBufferMs();
+  return Date.now() >= tokenExpiresAt - bufferMs;
+}
+function setRefreshCallback(callback) {
+  refreshCallback = callback;
+}
+function isRefreshInFlight() {
+  return refreshPromise != null;
+}
+async function refreshSession(options = {}) {
+  const { force = false } = options;
+  if (!force && lastSuccessfulRefreshAt != null && Date.now() - lastSuccessfulRefreshAt < MIN_PROACTIVE_REFRESH_INTERVAL_MS) {
+    return;
+  }
+  if (!refreshCallback) {
+    return;
+  }
+  if (!refreshPromise) {
+    refreshPromise = (async () => {
+      const { withRefreshLock } = await import('./refresh-lock-JQVP4YOS.js');
+      await withRefreshLock(async () => {
+        const { getRefreshToken: getRefreshToken2 } = await import('./auth-utils-Z5P6SMLJ.js');
+        const refreshToken = getRefreshToken2();
+        if (!refreshToken) {
+          markRefreshFailed();
+          const storageKey = getStorageKeys().refreshToken;
+          const hasCookieKey = typeof document !== "undefined" && typeof storageKey === "string" && storageKey.length > 0 && document.cookie.includes(`${storageKey}=`);
+          logger.warn("auth", "refresh session aborted: missing refresh token", {
+            operation: "refreshSession",
+            storageKey,
+            hasCookieKey,
+            iframeStorageMode: isIframeStorageMode()
+          });
+          throw new Error("Session expired: missing refresh token");
+        }
+        const result = await refreshCallback(refreshToken);
+        if (!result.success || !result.token) {
+          markRefreshFailed();
+          throw new Error("Session refresh failed");
+        }
+        lastRefreshFailed = false;
+        lastSuccessfulRefreshAt = Date.now();
+      });
+    })().finally(() => {
+      refreshPromise = null;
+    });
+  }
+  await refreshPromise;
+}
+async function ensureValidRefresh() {
+  if (!isExpiresAccessToken()) {
+    return;
+  }
+  await refreshSession({ force: true });
+}
+function isAuthenticateApp() {
+  const token = getAccessToken();
+  if (token) {
+    const bufferMs = getCurrentBufferMs();
+    if (tokenExpiresAt === null || Date.now() < tokenExpiresAt - bufferMs) {
+      return true;
+    }
+  }
+  if (!isCookieExpired(getStorageKeys().refreshToken)) {
+    if (lastRefreshFailed && !token) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isAuthenticated() {
+  return isAuthenticateApp();
+}
+function isAccessTokenExpired() {
+  return isExpiresAccessToken();
+}
+function hasRefreshSession() {
+  if (isSessionRefreshExhausted() && !accessToken) {
+    return false;
+  }
+  const refreshKey = getStorageKeys().refreshToken;
+  if (!refreshKey || isCookieExpired(refreshKey)) {
+    return false;
+  }
+  if (!readRefreshTokenValue()) {
+    return false;
+  }
+  if (lastRefreshFailed && !accessToken) {
+    return false;
+  }
+  return true;
+}
+function readRefreshTokenValue() {
+  const key = getStorageKeys().refreshToken;
+  const raw = getCookie(key);
+  if (!isCorruptCookieRawValue(raw)) {
+    return raw;
+  }
+  if (isIframeStorageMode()) {
+    return readIframeRefreshToken();
+  }
+  return null;
+}
+function hasValidAccessToken() {
+  return Boolean(getAccessToken()) && !isExpiresAccessToken();
+}
+
+// src/main/core/http/auth-utils.ts
+function writeJsonCookie(key, data, expire) {
+  if (!key) {
+    return;
+  }
+  const serialized = stringifyCookieValue(data);
+  if (serialized == null) {
+    return;
+  }
+  setCookie(key, serialized, expire);
+}
+var setLoggedInDetails = async (data) => {
+  return new Promise((resolve) => {
+    const keys = getStorageKeys();
+    writeJsonCookie(keys.loginDetails, data);
+    if (keys.authUser !== keys.loginDetails) {
+      writeJsonCookie(keys.authUser, data);
+    }
+    resolve();
+  });
+};
+var setProfileDetails = async (data) => {
+  return new Promise((resolve) => {
+    writeJsonCookie(getStorageKeys().loginDetails, data);
+    resolve();
+  });
+};
+function setRefreshToken(token, expiresAt) {
+  return new Promise((resolve) => {
+    if (!token || typeof token !== "string") {
+      resolve();
+      return;
+    }
+    let expiresMs;
+    if (typeof expiresAt === "number" && expiresAt > 1e12) {
+      expiresMs = expiresAt;
+    } else if (typeof expiresAt === "number" && expiresAt > 1e9) {
+      expiresMs = expiresAt * 1e3;
+    } else {
+      expiresMs = Date.now() + (expiresAt || 0) * 1e3;
+    }
+    const serialized = stringifyCookieValue(token);
+    if (serialized != null) {
+      setCookie(getStorageKeys().refreshToken, serialized, new Date(expiresMs));
+    }
+    if (isIframeStorageMode()) {
+      writeIframeRefreshToken(token, expiresMs);
+    }
+    resolve();
+  });
+}
+function setAccessToken(token, expiresIn) {
+  return new Promise((resolve) => {
+    storAccessToken(token, expiresIn);
+    resolve();
+  });
+}
+var setPortal = async (data) => {
+  return new Promise((resolve) => {
+    writeJsonCookie(getStorageKeys().portal, data ?? {});
+    resolve();
+  });
+};
+var setSubscriptionType = async (data) => {
+  return new Promise((resolve) => {
+    writeJsonCookie(getStorageKeys().subscriptionType, data ?? "BASIC");
+    resolve();
+  });
+};
+function getProfile() {
+  return parseCookieJson(getStorageKeys().loginDetails);
+}
+function getRefreshToken() {
+  const raw = getCookie(getStorageKeys().refreshToken);
+  if (!isCorruptCookieRawValue(raw)) {
+    return raw;
+  }
+  if (isIframeStorageMode()) {
+    return readIframeRefreshToken();
+  }
+  return null;
+}
+function getPortal() {
+  return parseCookieJson(getStorageKeys().portal);
+}
+function getSubscriptionType() {
+  return parseCookieJson(getStorageKeys().subscriptionType);
+}
+
+export { DEV_API_URL, DEV_PORTAL_ID, HUBSPOT_DATA, HUB_ID, clearAccessToken, clearSessionRefreshExhaustedState, config, configureLogger, didLastRefreshFail, ensureValidRefresh, getAccessToken, getPortal, getProfile, getRefreshToken, getSubscriptionType, hasRefreshSession, hasValidAccessToken, hydrateSessionRefreshState, isAccessTokenExpired, isAuthenticateApp, isAuthenticated, isExpiresAccessToken, isHttpTracingEnabled, isRefreshInFlight, isSessionRefreshExhausted, logger, refreshSession, resetSessionAuthState, sanitizeAxiosErrorData, setAccessToken, setConfig, setIframeStorageMode, setLoggedInDetails, setPortal, setProfileDetails, setRefreshBufferSeconds, setRefreshCallback, setRefreshToken, setRuntimeHttpClientHubContext, setSessionLifecycleListener, setSubscriptionType, storAccessToken, storage };
+//# sourceMappingURL=chunk-B2OVKOJU.js.map
+//# sourceMappingURL=chunk-B2OVKOJU.js.map