@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/node/utils/TokenManager.js

@@ -1,403 +0,0 @@
-class TokenManager {
-  constructor(options = {}) {
-    this.config = {
-      storagePrefix: "symbols_",
-      storageType: typeof window === "undefined" || process.env.NODE_ENV === "test" || process.env.NODE_ENV === "testing" ? "memory" : "localStorage",
-      // 'localStorage' | 'sessionStorage' | 'memory'
-      refreshBuffer: 60 * 1e3,
-      // Refresh 1 minute before expiry
-      maxRetries: 3,
-      apiUrl: options.apiUrl || "/api",
-      onTokenRefresh: options.onTokenRefresh || null,
-      onTokenExpired: options.onTokenExpired || null,
-      onTokenError: options.onTokenError || null,
-      ...options
-    };
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    this.refreshPromise = null;
-    this.refreshTimeout = null;
-    this.retryCount = 0;
-    this.loadTokens();
-  }
-  /**
-   * Storage keys
-   */
-  get storageKeys() {
-    return {
-      accessToken: `${this.config.storagePrefix}access_token`,
-      refreshToken: `${this.config.storagePrefix}refresh_token`,
-      expiresAt: `${this.config.storagePrefix}expires_at`,
-      expiresIn: `${this.config.storagePrefix}expires_in`
-    };
-  }
-  /**
-   * Get storage instance based on configuration
-   */
-  get storage() {
-    if (typeof window === "undefined") {
-      return this._memoryStorage;
-    }
-    const safeGetStorage = (provider) => {
-      try {
-        const storage = provider();
-        const testKey = `${this.config.storagePrefix}__tm_test__`;
-        storage.setItem(testKey, "1");
-        storage.removeItem(testKey);
-        return storage;
-      } catch {
-        return null;
-      }
-    };
-    const localStorageInstance = safeGetStorage(() => window.localStorage);
-    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage);
-    switch (this.config.storageType) {
-      case "sessionStorage":
-        return sessionStorageInstance || this._memoryStorage;
-      case "memory":
-        return this._memoryStorage;
-      default:
-        return localStorageInstance || this._memoryStorage;
-    }
-  }
-  /**
-   * Memory storage fallback for server-side rendering
-   */
-  _memoryStorage = {
-    _data: {},
-    getItem: (key) => this._memoryStorage._data[key] || null,
-    setItem: (key, value) => {
-      this._memoryStorage._data[key] = value;
-    },
-    removeItem: (key) => {
-      delete this._memoryStorage._data[key];
-    },
-    clear: () => {
-      this._memoryStorage._data = {};
-    }
-  };
-  /**
-   * Set tokens and persist to storage
-   */
-  setTokens(tokenData) {
-    const {
-      access_token: accessToken,
-      refresh_token: refreshToken,
-      expires_in: expiresIn,
-      token_type: tokenType = "Bearer"
-    } = tokenData;
-    if (!accessToken) {
-      throw new Error("Access token is required");
-    }
-    const now = Date.now();
-    const expiresAt = expiresIn ? now + expiresIn * 1e3 : null;
-    this.tokens = {
-      accessToken,
-      refreshToken: refreshToken || this.tokens.refreshToken,
-      expiresAt,
-      expiresIn,
-      tokenType
-    };
-    this.saveTokens();
-    this.scheduleRefresh();
-    if (this.config.onTokenRefresh) {
-      this.config.onTokenRefresh(this.tokens);
-    }
-    return this.tokens;
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.tokens.accessToken;
-  }
-  /**
-   * Get current refresh token
-   */
-  getRefreshToken() {
-    return this.tokens.refreshToken;
-  }
-  /**
-   * Get authorization header value
-   */
-  getAuthHeader() {
-    const token = this.getAccessToken();
-    if (!token) {
-      return null;
-    }
-    return `${this.tokens.tokenType || "Bearer"} ${token}`;
-  }
-  /**
-   * Check if access token is valid and not expired
-   */
-  isAccessTokenValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    const isValid = now < this.tokens.expiresAt - this.config.refreshBuffer;
-    if (!isValid) {
-      console.log("[TokenManager] Access token is expired or near expiry:", {
-        now: new Date(now).toISOString(),
-        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
-        refreshBuffer: this.config.refreshBuffer
-      });
-    }
-    return isValid;
-  }
-  /**
-   * Check if access token exists and is not expired (without refresh buffer)
-   */
-  isAccessTokenActuallyValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    return now < this.tokens.expiresAt;
-  }
-  /**
-   * Check if tokens exist (regardless of expiry)
-   */
-  hasTokens() {
-    return Boolean(this.tokens.accessToken);
-  }
-  /**
-   * Check if refresh token exists
-   */
-  hasRefreshToken() {
-    return Boolean(this.tokens.refreshToken);
-  }
-  /**
-   * Automatically refresh tokens if needed
-   */
-  async ensureValidToken() {
-    if (!this.hasTokens()) {
-      return null;
-    }
-    if (this.isAccessTokenValid()) {
-      return this.getAccessToken();
-    }
-    if (!this.hasRefreshToken()) {
-      this.clearTokens();
-      if (this.config.onTokenExpired) {
-        this.config.onTokenExpired();
-      }
-      return null;
-    }
-    try {
-      await this.refreshTokens();
-      return this.getAccessToken();
-    } catch (error) {
-      this.clearTokens();
-      if (this.config.onTokenError) {
-        this.config.onTokenError(error);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Refresh access token using refresh token
-   */
-  async refreshTokens() {
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    if (!this.hasRefreshToken()) {
-      throw new Error("No refresh token available");
-    }
-    if (this.retryCount >= this.config.maxRetries) {
-      throw new Error("Max refresh retries exceeded");
-    }
-    this.refreshPromise = this._performRefresh();
-    try {
-      const result = await this.refreshPromise;
-      this.retryCount = 0;
-      return result;
-    } catch (error) {
-      this.retryCount++;
-      throw error;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  /**
-   * Perform the actual token refresh request
-   */
-  async _performRefresh() {
-    var _a;
-    const refreshToken = this.getRefreshToken();
-    const response = await fetch(`${this.config.apiUrl}/core/auth/refresh`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ refreshToken })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.message || `Token refresh failed: ${response.status}`);
-    }
-    const responseData = await response.json();
-    if (responseData.success && responseData.data && responseData.data.tokens) {
-      const { tokens } = responseData.data;
-      const tokenData = {
-        access_token: tokens.accessToken,
-        refresh_token: tokens.refreshToken,
-        expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-        token_type: "Bearer"
-      };
-      return this.setTokens(tokenData);
-    }
-    return this.setTokens(responseData);
-  }
-  /**
-   * Schedule automatic token refresh
-   */
-  scheduleRefresh() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    if (!this.tokens.expiresAt || !this.hasRefreshToken()) {
-      return;
-    }
-    const now = Date.now();
-    const refreshTime = this.tokens.expiresAt - this.config.refreshBuffer;
-    const delay = Math.max(0, refreshTime - now);
-    this.refreshTimeout = setTimeout(async () => {
-      try {
-        await this.refreshTokens();
-      } catch (error) {
-        console.error("Automatic token refresh failed:", error);
-        if (this.config.onTokenError) {
-          this.config.onTokenError(error);
-        }
-      }
-    }, delay);
-  }
-  /**
-   * Save tokens to storage
-   */
-  saveTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      if (this.tokens.accessToken) {
-        storage.setItem(keys.accessToken, this.tokens.accessToken);
-      }
-      if (this.tokens.refreshToken) {
-        storage.setItem(keys.refreshToken, this.tokens.refreshToken);
-      }
-      if (this.tokens.expiresAt) {
-        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
-      }
-      if (this.tokens.expiresIn) {
-        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error saving tokens to storage:", error);
-    }
-  }
-  /**
-   * Load tokens from storage
-   */
-  loadTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      const accessToken = storage.getItem(keys.accessToken);
-      const refreshToken = storage.getItem(keys.refreshToken);
-      const expiresAt = storage.getItem(keys.expiresAt);
-      const expiresIn = storage.getItem(keys.expiresIn);
-      if (accessToken) {
-        this.tokens = {
-          accessToken,
-          refreshToken,
-          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-          tokenType: "Bearer"
-        };
-        this.scheduleRefresh();
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error loading tokens from storage:", error);
-      this.tokens = {
-        accessToken: null,
-        refreshToken: null,
-        expiresAt: null,
-        expiresIn: null
-      };
-    }
-  }
-  /**
-   * Clear all tokens
-   */
-  clearTokens() {
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    const { storage } = this;
-    const keys = this.storageKeys;
-    Object.values(keys).forEach((key) => {
-      storage.removeItem(key);
-    });
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.retryCount = 0;
-  }
-  /**
-   * Get token status information
-   */
-  getTokenStatus() {
-    const hasTokens = this.hasTokens();
-    const isValid = this.isAccessTokenValid();
-    const { expiresAt } = this.tokens;
-    const timeToExpiry = expiresAt ? expiresAt - Date.now() : null;
-    return {
-      hasTokens,
-      isValid,
-      hasRefreshToken: this.hasRefreshToken(),
-      expiresAt,
-      timeToExpiry,
-      willExpireSoon: timeToExpiry ? timeToExpiry < this.config.refreshBuffer : false
-    };
-  }
-  /**
-   * Cleanup resources
-   */
-  destroy() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.refreshPromise = null;
-  }
-}
-let defaultTokenManager = null;
-const getTokenManager = (options) => {
-  if (!defaultTokenManager) {
-    defaultTokenManager = new TokenManager(options);
-  }
-  return defaultTokenManager;
-};
-const createTokenManager = (options) => new TokenManager(options);
-export {
-  TokenManager,
-  createTokenManager,
-  getTokenManager
-};

package/dist/node/utils/changePreprocessor.js

@@ -1,180 +0,0 @@
-import { diffJson } from "./jsonDiff.js";
-import { computeOrdersForTuples } from "./ordering.js";
-function isPlainObject(val) {
-  return val && typeof val === "object" && !Array.isArray(val);
-}
-function getByPathSafe(root, path) {
-  if (!root || typeof root.getByPath !== "function") {
-    return null;
-  }
-  try {
-    return root.getByPath(path);
-  } catch {
-    return null;
-  }
-}
-function resolveNextValueFromTuples(tuples, path) {
-  if (!Array.isArray(tuples) || !Array.isArray(path)) {
-    return null;
-  }
-  for (let i = tuples.length - 1; i >= 0; i--) {
-    const t = tuples[i];
-    if (!Array.isArray(t) || t.length < 3) {
-      continue;
-    }
-    const [action, tuplePath, tupleValue] = t;
-    if (action !== "update" && action !== "set" || !Array.isArray(tuplePath)) {
-      continue;
-    }
-    if (tuplePath.length > path.length) {
-      continue;
-    }
-    let isPrefix = true;
-    for (let j = 0; j < tuplePath.length; j++) {
-      if (tuplePath[j] !== path[j]) {
-        isPrefix = false;
-        break;
-      }
-    }
-    if (!isPrefix) {
-      continue;
-    }
-    if (tuplePath.length === path.length) {
-      return tupleValue;
-    }
-    let current = tupleValue;
-    for (let j = tuplePath.length; j < path.length; j++) {
-      if (current == null) {
-        return null;
-      }
-      current = current[path[j]];
-    }
-    if (current !== null) {
-      return current;
-    }
-  }
-  return null;
-}
-function preprocessChanges(root, tuples = [], options = {}) {
-  const expandTuple = (t) => {
-    const [action, path, value] = t || [];
-    const isSchemaPath = Array.isArray(path) && path[0] === "schema";
-    const isFilesPath = Array.isArray(path) && path[0] === "files";
-    if (action === "delete") {
-      return [t];
-    }
-    const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2 || isSchemaPath && path.length === 3) && isPlainObject(value);
-    if (!canConsiderExpansion || isFilesPath || value && value.type === "files") {
-      return [t];
-    }
-    const prevRaw = getByPathSafe(root, path);
-    const isCreatePath = Array.isArray(path) && action === "update" && // e.g. ['update', ['components', 'NewKey'], {...}]
-    (!isSchemaPath && path.length === 2 || // e.g. ['update', ['schema', 'components', 'NewKey'], {...}]
-    isSchemaPath && path.length === 3) && (prevRaw === null || typeof prevRaw === "undefined");
-    if (isCreatePath) {
-      return [t];
-    }
-    const prev = prevRaw || {};
-    const next = value || {};
-    if (!isPlainObject(prev) || !isPlainObject(next)) {
-      return [t];
-    }
-    const ops = diffJson(prev, next, []);
-    if (!ops.length) {
-      return [t];
-    }
-    const out = [];
-    for (let i = 0; i < ops.length; i++) {
-      const op = ops[i];
-      const fullPath = [...path, ...op.path];
-      const last = fullPath[fullPath.length - 1];
-      if (op.action === "set") {
-        out.push(["update", fullPath, op.value]);
-      } else if (op.action === "del") {
-        if (last !== "__order") {
-          out.push(["delete", fullPath]);
-        }
-      }
-    }
-    return out;
-  };
-  const minimizeTuples = (input) => {
-    const out = [];
-    const seen2 = /* @__PURE__ */ new Set();
-    for (let i = 0; i < input.length; i++) {
-      const expanded = expandTuple(input[i]);
-      for (let k = 0; k < expanded.length; k++) {
-        const tuple = expanded[k];
-        const isDelete = Array.isArray(tuple) && tuple[0] === "delete";
-        const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === "__order";
-        if (!isOrderKey) {
-          const key = JSON.stringify(tuple);
-          if (!seen2.has(key)) {
-            seen2.add(key);
-            out.push(tuple);
-          }
-        }
-      }
-    }
-    return out;
-  };
-  const granularChanges = (() => {
-    try {
-      const res = minimizeTuples(tuples);
-      if (options.append && options.append.length) {
-        res.push(...options.append);
-      }
-      return res;
-    } catch {
-      return Array.isArray(tuples) ? tuples.slice() : [];
-    }
-  })();
-  const hydratedGranularChanges = granularChanges.map((t) => {
-    if (!Array.isArray(t) || t.length < 3) {
-      return t;
-    }
-    const [action, path] = t;
-    if (action !== "update" && action !== "set" || !Array.isArray(path)) {
-      return t;
-    }
-    const nextValue = resolveNextValueFromTuples(tuples, path);
-    if (nextValue === null) {
-      return t;
-    }
-    return [action, path, nextValue];
-  });
-  const baseOrders = computeOrdersForTuples(root, hydratedGranularChanges);
-  const preferOrdersMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tuples.length; i++) {
-    const t = tuples[i];
-    if (!Array.isArray(t) || t.length < 3) {
-      continue;
-    }
-    const [action, path, value] = t;
-    const isFilesPath = Array.isArray(path) && path[0] === "files";
-    if (action !== "update" || !Array.isArray(path) || path.length !== 1 && path.length !== 2 || !isPlainObject(value) || isFilesPath || value && value.type === "files") {
-      continue;
-    }
-    const keys = Object.keys(value).filter((k) => k !== "__order");
-    const key = JSON.stringify(path);
-    preferOrdersMap.set(key, { path, keys });
-  }
-  const mergedOrders = [];
-  const seen = /* @__PURE__ */ new Set();
-  preferOrdersMap.forEach((v, k) => {
-    seen.add(k);
-    mergedOrders.push(v);
-  });
-  for (let i = 0; i < baseOrders.length; i++) {
-    const v = baseOrders[i];
-    const k = JSON.stringify(v.path);
-    if (!seen.has(k)) {
-      seen.add(k);
-      mergedOrders.push(v);
-    }
-  }
-  return { granularChanges: hydratedGranularChanges, orders: mergedOrders };
-}
-export {
-  preprocessChanges
-};

package/dist/node/utils/jsonDiff.js

@@ -1,116 +0,0 @@
-function isPlainObject(o) {
-  return o && typeof o === "object" && !Array.isArray(o);
-}
-function deepEqual(a, b) {
-  if (Object.is(a, b)) {
-    return true;
-  }
-  if (typeof a === "function" && typeof b === "function") {
-    try {
-      return a.toString() === b.toString();
-    } catch {
-      return false;
-    }
-  }
-  if (typeof a === "function" || typeof b === "function") {
-    return false;
-  }
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return String(a) === String(b);
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (a && b && typeof a === "object" && typeof b === "object") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    for (let i = 0; i < aKeys.length; i++) {
-      const key = aKeys[i];
-      if (!Object.hasOwn(b, key)) {
-        return false;
-      }
-      if (!deepEqual(a[key], b[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-import * as Y from "yjs";
-function getRootMap(ydoc) {
-  return ydoc.getMap("root");
-}
-function diffJson(prev, next, prefix = []) {
-  const ops = [];
-  const _prefix = Array.isArray(prefix) ? prefix : [];
-  for (const key in prev) {
-    if (Object.hasOwn(prev, key) && !(key in next)) {
-      ops.push({ action: "del", path: [..._prefix, key] });
-    }
-  }
-  for (const key in next) {
-    if (Object.hasOwn(next, key)) {
-      const pVal = prev == null ? void 0 : prev[key];
-      const nVal = next[key];
-      if (isPlainObject(pVal) && isPlainObject(nVal)) {
-        ops.push(...diffJson(pVal, nVal, [..._prefix, key]));
-      } else if (!deepEqual(pVal, nVal)) {
-        ops.push({ action: "set", path: [..._prefix, key], value: nVal });
-      }
-    }
-  }
-  return ops;
-}
-function applyOpsToJson(ops, ydoc) {
-  if (!ydoc || !Array.isArray(ops) || !ops.length) {
-    return;
-  }
-  ydoc.transact(() => {
-    const root = getRootMap(ydoc);
-    ops.forEach((op) => {
-      const { action, path = [], value } = op || {};
-      if (!path.length) {
-        return;
-      }
-      let target = root;
-      for (let i = 0; i < path.length - 1; i++) {
-        const key = path[i];
-        let next = target.get(key);
-        if (!(next instanceof Y.Map)) {
-          const fresh = new Y.Map();
-          if (isPlainObject(next)) {
-            Object.entries(next).forEach(([k, v]) => fresh.set(k, v));
-          }
-          target.set(key, fresh);
-          next = fresh;
-        }
-        target = next;
-      }
-      const last = path[path.length - 1];
-      if (action === "set") {
-        target.set(last, value);
-      } else if (action === "del") {
-        target.delete(last);
-      }
-    });
-  }, "remote");
-}
-export {
-  applyOpsToJson,
-  diffJson
-};