@symbo.ls/sdk 3.1.1 → 3.2.3

package/dist/node/state/RootStateManager.js

@@ -0,0 +1,57 @@
+import * as utils from "@domql/utils";
+import { rootBus } from "./rootEventBus.js";
+const { isFunction } = utils.default || utils;
+class RootStateManager {
+  constructor(rootState) {
+    this._rootState = rootState;
+  }
+  /**
+   * Apply change tuples to the root state using the built-in setPathCollection
+   * of Symbo.ls APP state tree.
+   *
+   * @param {Array} changes – eg. ['update', ['foo'], 'bar']
+   * @param {Object} opts   – forwarded to setPathCollection
+   */
+  applyChanges(changes = [], opts = {}) {
+    if (!this._rootState || !isFunction(this._rootState.setPathCollection)) {
+      return;
+    }
+    const result = this._rootState.setPathCollection(changes, {
+      preventUpdate: true,
+      ...opts
+    });
+    try {
+      const changedKeys = /* @__PURE__ */ new Set();
+      changes.forEach((tuple) => {
+        const [, path = []] = tuple;
+        if (!Array.isArray(path) || !path.length) {
+          return;
+        }
+        if (path[0] === "components" && typeof path[1] === "string") {
+          changedKeys.add(path[1]);
+        }
+        if (path[0] === "schema" && path[1] === "components" && typeof path[2] === "string") {
+          changedKeys.add(path[2]);
+        }
+      });
+      if (changedKeys.size) {
+        console.log("emit components:changed", [...changedKeys]);
+        rootBus.emit("components:changed", [...changedKeys]);
+      }
+    } catch (err) {
+      console.error("[RootStateManager] emit components:changed failed", err);
+    }
+    return result;
+  }
+  setVersion(v) {
+    if (this._rootState) {
+      this._rootState.version = v;
+    }
+  }
+  get root() {
+    return this._rootState;
+  }
+}
+export {
+  RootStateManager
+};

package/dist/node/state/rootEventBus.js

@@ -0,0 +1,46 @@
+const getGlobalBus = () => {
+  if (globalThis.__SMBLS_ROOT_BUS__) {
+    return globalThis.__SMBLS_ROOT_BUS__;
+  }
+  const events = {};
+  const bus = {
+    on(event, handler) {
+      (events[event] ||= []).push(handler);
+    },
+    off(event, handler) {
+      const list = events[event];
+      if (!list) {
+        return;
+      }
+      const idx = list.indexOf(handler);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+      }
+    },
+    emit(event, payload) {
+      const list = events[event];
+      if (!list || !list.length) {
+        return;
+      }
+      list.slice().forEach((fn) => {
+        try {
+          fn(payload);
+        } catch (err) {
+          console.error("[rootBus] handler error for", event, err);
+        }
+      });
+    }
+  };
+  Object.defineProperty(bus, "_listeners", {
+    value: events,
+    enumerable: false
+  });
+  globalThis.__SMBLS_ROOT_BUS__ = bus;
+  return bus;
+};
+const rootBus = getGlobalBus();
+var rootEventBus_default = rootBus;
+export {
+  rootEventBus_default as default,
+  rootBus
+};

package/dist/node/utils/CollabClient.js

@@ -0,0 +1,128 @@
+import { io } from "socket.io-client";
+import * as Y from "yjs";
+import { IndexeddbPersistence } from "y-indexeddb";
+import Dexie from "dexie";
+import { nanoid } from "nanoid";
+import environment from "../config/environment.js";
+import { diffJson, applyOpsToJson } from "./jsonDiff.js";
+class CollabClient {
+  /* public fields */
+  socket = null;
+  ydoc = null;
+  branch = "main";
+  live = false;
+  projectId = null;
+  jwt = null;
+  /* private state */
+  _buffer = [];
+  _flushTimer = null;
+  _clientId = nanoid();
+  _outboxStore = null;
+  // Dexie table
+  _readyResolve;
+  ready = new Promise((res) => this._readyResolve = res);
+  constructor({ jwt, projectId, branch = "main", live = false }) {
+    Object.assign(this, { jwt, projectId, branch, live });
+    this.ydoc = new Y.Doc();
+    new IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
+    this._outboxStore = createDexieOutbox(`${projectId}:${branch}`);
+    this.socket = io(environment.socketUrl, {
+      path: "/collab-socket",
+      transports: ["websocket"],
+      auth: { token: jwt, projectId, branch, live },
+      reconnectionAttempts: Infinity,
+      reconnectionDelayMax: 4e3
+    });
+    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", (flag) => {
+      this.live = flag;
+    }).on("connect", this._onConnect).on("error", (e) => console.warn("[collab] socket error", e));
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    this.ydoc.on("afterTransaction", (tr) => {
+      if (tr.origin === "remote") {
+        return;
+      }
+      const currentJson = this.ydoc.getMap("root").toJSON();
+      const ops = diffJson(this._prevJson, currentJson);
+      this._prevJson = currentJson;
+      if (!ops.length) {
+        return;
+      }
+      this._queueOps(ops);
+    });
+  }
+  /* ---------- public helpers ---------- */
+  toggleLive(flag) {
+    this.socket.emit("toggleLive", Boolean(flag));
+  }
+  sendCursor(data) {
+    this.socket.emit("cursor", data);
+  }
+  sendPresence(d) {
+    this.socket.emit("presence", d);
+  }
+  /* ---------- private handlers ---------- */
+  _onSnapshot = ({
+    data
+    /* Uint8Array */
+  }) => {
+    Y.applyUpdate(this.ydoc, Uint8Array.from(data));
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  };
+  _onOps = ({ changes }) => {
+    applyOpsToJson(changes, this.ydoc);
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+  };
+  _onCommit = async ({ version }) => {
+    await this._outboxStore.clear();
+    console.info("[collab] committed", version);
+  };
+  _onConnect = async () => {
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+    const queued = await this._outboxStore.toArray();
+    if (queued.length) {
+      this.socket.emit("ops", {
+        changes: queued.flatMap((e) => e.ops),
+        ts: Date.now(),
+        clientId: this._clientId
+      });
+      await this._outboxStore.clear();
+    }
+  };
+  /* ---------- buffering & debounce ---------- */
+  _queueOps(ops) {
+    this._buffer.push(...ops);
+    this._outboxStore.put({ id: nanoid(), ops });
+    if (this.live && this.socket.connected) {
+      this._flushNow();
+    } else {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = setTimeout(() => this._flushNow(), 40);
+    }
+  }
+  _flushNow() {
+    if (!this._buffer.length || !this.socket.connected) {
+      return;
+    }
+    this.socket.emit("ops", {
+      changes: this._buffer,
+      ts: Date.now(),
+      clientId: this._clientId
+    });
+    this._buffer.length = 0;
+  }
+}
+function createDexieOutbox(name) {
+  const db = new Dexie(`collab-${name}`);
+  db.version(1).stores({ outbox: "id, ops" });
+  return db.table("outbox");
+}
+export {
+  CollabClient
+};

package/dist/node/utils/TokenManager.js

@@ -0,0 +1,390 @@
+class TokenManager {
+  constructor(options = {}) {
+    this.config = {
+      storagePrefix: "symbols_",
+      storageType: "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;
+    }
+    switch (this.config.storageType) {
+      case "sessionStorage":
+        return window.sessionStorage;
+      case "memory":
+        return this._memoryStorage;
+      default:
+        return window.localStorage;
+    }
+  }
+  /**
+   * 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
+};