@symbo.ls/sdk 2.34.35 → 3.1.1

package/dist/cjs/services/CollabService.js

@@ -1,743 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var CollabService_exports = {};
-__export(CollabService_exports, {
-  CollabService: () => CollabService
-});
-module.exports = __toCommonJS(CollabService_exports);
-var import_BaseService = require("./BaseService.js");
-var import_CollabClient = require("../utils/CollabClient.js");
-var import_RootStateManager = require("../state/RootStateManager.js");
-var import_rootEventBus = require("../state/rootEventBus.js");
-var import_validation = require("../utils/validation.js");
-var import_utils = require("@domql/utils");
-var import_changePreprocessor = require("../utils/changePreprocessor.js");
-const FUNCTION_META_KEYS = ["node", "__ref", "__element", "parent", "parse"];
-function stringifyFunctionsForTransport(value, seen = /* @__PURE__ */ new WeakMap()) {
-  if (value === null || typeof value !== "object") {
-    return typeof value === "function" ? value.toString() : value;
-  }
-  if (seen.has(value)) {
-    return seen.get(value);
-  }
-  const clone = Array.isArray(value) ? [] : {};
-  seen.set(value, clone);
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      clone[i] = stringifyFunctionsForTransport(value[i], seen);
-    }
-    return clone;
-  }
-  const keys = Object.keys(value);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (!FUNCTION_META_KEYS.includes(key)) {
-      clone[key] = stringifyFunctionsForTransport(value[key], seen);
-    }
-  }
-  return clone;
-}
-class CollabService extends import_BaseService.BaseService {
-  constructor(config) {
-    super(config);
-    this._client = null;
-    this._stateManager = null;
-    this._connected = false;
-    this._connecting = false;
-    this._connectPromise = null;
-    this._connectionMeta = null;
-    this._pendingConnectReject = null;
-    this._undoStack = [];
-    this._redoStack = [];
-    this._isUndoRedo = false;
-    this._pendingOps = [];
-    this._onSocketConnect = this._onSocketConnect.bind(this);
-    this._onSocketDisconnect = this._onSocketDisconnect.bind(this);
-    this._onSocketError = this._onSocketError.bind(this);
-  }
-  init({ context }) {
-    super.init({ context });
-    if (context == null ? void 0 : context.state) {
-      try {
-        this._stateManager = new import_RootStateManager.RootStateManager(context.state);
-      } catch (err) {
-        this._setError(err);
-        throw err;
-      }
-    }
-    this._setReady();
-  }
-  /**
-   * Overridden to re-initialise the state manager once the root state becomes
-   * available via a subsequent SDK `updateContext()` call.
-   */
-  updateContext(context = {}) {
-    super.updateContext(context);
-    if (context.state) {
-      this._stateManager = new import_RootStateManager.RootStateManager(context.state);
-    }
-  }
-  /**
-   * Ensure that the state manager exists. This is called right before any
-   * operation that requires access to the root state (e.g. `connect()`).
-   * Throws an explicit error if the root state is still missing so that the
-   * caller can react accordingly.
-   */
-  _ensureStateManager() {
-    var _a, _b;
-    if (!this._stateManager) {
-      if (!((_a = this._context) == null ? void 0 : _a.state)) {
-        throw new Error("[CollabService] Cannot operate without root state");
-      }
-      this._stateManager = new import_RootStateManager.RootStateManager(this._context.state);
-    }
-    const root = (_b = this._stateManager) == null ? void 0 : _b.root;
-    if (root && !root.__element) {
-      root.__element = {
-        /**
-         * Very small subset of the DOMQL `call` API that we rely on inside the
-         * CollabService for browser notifications and data helpers.
-         * In a Node.js test context we simply log or return fallbacks.
-         */
-        call: (method, ...args) => {
-          switch (method) {
-            case "openNotification": {
-              const [payload = {}] = args;
-              const { type = "info", title = "", message = "" } = payload;
-              const logger = type === "error" ? console.error : console.log;
-              logger(`[Notification] ${title}${message ? ` \u2013 ${message}` : ""}`);
-              return;
-            }
-            case "deepStringifyFunctions": {
-              return (0, import_utils.deepStringifyFunctions)(...args);
-            }
-            default:
-              return {};
-          }
-        }
-      };
-    }
-  }
-  /* ---------- Connection Management ---------- */
-  async connect(options = {}) {
-    if (this._connectPromise) {
-      return this._connectPromise;
-    }
-    this._connectPromise = (async () => {
-      var _a;
-      this._connecting = true;
-      this._connected = false;
-      this._ensureStateManager();
-      const mergedOptions = {
-        ...this._context,
-        ...options
-      };
-      let { authToken: jwt } = mergedOptions;
-      const { projectId, branch = "main", pro } = mergedOptions;
-      if (!jwt && this._tokenManager) {
-        try {
-          jwt = await this._tokenManager.ensureValidToken();
-        } catch (error) {
-          console.warn(
-            "[CollabService] Failed to obtain auth token from token manager",
-            error
-          );
-        }
-        if (!jwt && typeof this._tokenManager.getAccessToken === "function") {
-          jwt = this._tokenManager.getAccessToken();
-        }
-      }
-      if (!jwt) {
-        throw new Error("[CollabService] Cannot connect without auth token");
-      }
-      this._context = {
-        ...this._context,
-        authToken: jwt,
-        projectId,
-        branch,
-        pro
-      };
-      if (!projectId) {
-        const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-        const el = state.__element;
-        el.call("openNotification", {
-          type: "error",
-          title: "projectId is required",
-          message: "projectId is required for CollabService connection"
-        });
-        throw new Error("projectId is required for CollabService connection");
-      }
-      if (this._client) {
-        await this.disconnect();
-      }
-      this._client = new import_CollabClient.CollabClient({
-        jwt,
-        projectId,
-        branch,
-        live: Boolean(pro)
-      });
-      const { socket } = this._client;
-      try {
-        await new Promise((resolve, reject) => {
-          if (!socket) {
-            reject(new Error("[CollabService] Socket instance missing"));
-            return;
-          }
-          if (socket.connected) {
-            resolve();
-            return;
-          }
-          const cleanup = () => {
-            socket.off("connect", handleConnect);
-            socket.off("connect_error", handleError);
-            socket.off("error", handleError);
-            socket.off("disconnect", handleDisconnect);
-            if (this._pendingConnectReject === handleError) {
-              this._pendingConnectReject = null;
-            }
-          };
-          const handleConnect = () => {
-            cleanup();
-            resolve();
-          };
-          const handleError = (error) => {
-            cleanup();
-            reject(
-              error instanceof Error ? error : new Error(String(error || "Unknown connection error"))
-            );
-          };
-          const handleDisconnect = (reason) => {
-            handleError(
-              reason instanceof Error ? reason : new Error(
-                `[CollabService] Socket disconnected before connect: ${reason || "unknown"}`
-              )
-            );
-          };
-          this._pendingConnectReject = handleError;
-          socket.once("connect", handleConnect);
-          socket.once("connect_error", handleError);
-          socket.once("error", handleError);
-          socket.once("disconnect", handleDisconnect);
-        });
-      } catch (error) {
-        socket == null ? void 0 : socket.disconnect();
-        this._client = null;
-        this._connectionMeta = null;
-        throw error;
-      }
-      this._attachSocketLifecycleListeners();
-      if (socket == null ? void 0 : socket.connected) {
-        this._onSocketConnect();
-      }
-      socket == null ? void 0 : socket.on("ops", ({ changes }) => {
-        console.log(`ops event`);
-        this._stateManager.applyChanges(changes, { fromSocket: true });
-      });
-      socket == null ? void 0 : socket.on("commit", ({ version }) => {
-        if (version) {
-          this._stateManager.setVersion(version);
-        }
-        import_rootEventBus.rootBus.emit("checkpoint:done", { version, origin: "auto" });
-      });
-      socket == null ? void 0 : socket.on("clients", this._handleClientsEvent.bind(this));
-      socket == null ? void 0 : socket.on("bundle:done", this._handleBundleDoneEvent.bind(this));
-      socket == null ? void 0 : socket.on("bundle:error", this._handleBundleErrorEvent.bind(this));
-      if (this._pendingOps.length) {
-        console.log(
-          `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
-        );
-        this._pendingOps.forEach(
-          ({ changes, granularChanges, orders, options: opOptions }) => {
-            const { message } = opOptions || {};
-            const ts = Date.now();
-            const payload = {
-              changes,
-              granularChanges,
-              orders,
-              ts
-            };
-            if (message) {
-              payload.message = message;
-            }
-            this.socket.emit("ops", payload);
-          }
-        );
-        this._pendingOps.length = 0;
-      }
-      await this._client.ready;
-      this._connectionMeta = {
-        projectId,
-        branch,
-        live: Boolean(pro)
-      };
-      return this.getConnectionInfo();
-    })();
-    try {
-      return await this._connectPromise;
-    } finally {
-      this._connecting = false;
-      this._connectPromise = null;
-    }
-  }
-  disconnect() {
-    var _a;
-    if ((_a = this._client) == null ? void 0 : _a.socket) {
-      if (this._pendingConnectReject) {
-        this._pendingConnectReject(
-          new Error("[CollabService] Connection attempt aborted")
-        );
-        this._pendingConnectReject = null;
-      }
-      this._detachSocketLifecycleListeners();
-      if (typeof this._client.dispose === "function") {
-        this._client.dispose();
-      } else {
-        this._client.socket.disconnect();
-      }
-    }
-    this._client = null;
-    this._connected = false;
-    this._connecting = false;
-    this._connectionMeta = null;
-    this._pendingConnectReject = null;
-    console.log("[CollabService] Disconnected");
-  }
-  isConnected() {
-    var _a, _b;
-    return Boolean(this._connected && ((_b = (_a = this._client) == null ? void 0 : _a.socket) == null ? void 0 : _b.connected));
-  }
-  getConnectionInfo() {
-    var _a, _b, _c;
-    return {
-      connected: this.isConnected(),
-      connecting: this._connecting,
-      projectId: ((_a = this._connectionMeta) == null ? void 0 : _a.projectId) ?? null,
-      branch: ((_b = this._connectionMeta) == null ? void 0 : _b.branch) ?? null,
-      live: ((_c = this._connectionMeta) == null ? void 0 : _c.live) ?? null,
-      pendingOps: this._pendingOps.length,
-      undoStackSize: this.getUndoStackSize(),
-      redoStackSize: this.getRedoStackSize()
-    };
-  }
-  /* convenient shortcuts */
-  get ydoc() {
-    var _a;
-    return (_a = this._client) == null ? void 0 : _a.ydoc;
-  }
-  get socket() {
-    var _a;
-    return (_a = this._client) == null ? void 0 : _a.socket;
-  }
-  toggleLive(f) {
-    var _a;
-    (_a = this._client) == null ? void 0 : _a.toggleLive(f);
-  }
-  sendCursor(d) {
-    var _a;
-    (_a = this._client) == null ? void 0 : _a.sendCursor(d);
-  }
-  sendPresence(d) {
-    var _a;
-    (_a = this._client) == null ? void 0 : _a.sendPresence(d);
-  }
-  /* ---------- data helpers ---------- */
-  updateData(tuples, options = {}) {
-    var _a, _b;
-    this._ensureStateManager();
-    const { isUndo = false, isRedo = false } = options;
-    if (!isUndo && !isRedo && !this._isUndoRedo) {
-      this._trackForUndo(tuples, options);
-    }
-    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
-    const { granularChanges: processedTuples, orders } = (0, import_changePreprocessor.preprocessChanges)(
-      root,
-      tuples,
-      options
-    );
-    if (options.append && options.append.length) {
-      processedTuples.push(...options.append);
-    }
-    this._stateManager.applyChanges(tuples, { ...options });
-    const stringifiedGranularTuples = stringifyFunctionsForTransport(processedTuples);
-    const stringifiedTuples = stringifyFunctionsForTransport(tuples);
-    const { message } = options;
-    if (!this.isConnected()) {
-      console.warn("[CollabService] Not connected, queuing real-time update");
-      this._pendingOps.push({
-        changes: stringifiedTuples,
-        granularChanges: stringifiedGranularTuples,
-        orders,
-        options
-      });
-      return;
-    }
-    if ((_b = this.socket) == null ? void 0 : _b.connected) {
-      const ts = Date.now();
-      const payload = {
-        changes: stringifiedTuples,
-        granularChanges: stringifiedGranularTuples,
-        orders,
-        ts
-      };
-      if (message) {
-        payload.message = message;
-      }
-      this.socket.emit("ops", payload);
-    }
-    return { success: true };
-  }
-  _trackForUndo(tuples, options) {
-    var _a;
-    const undoOperations = tuples.map((tuple) => {
-      const [action, path] = tuple;
-      const currentValue = this._getValueAtPath(path);
-      if (action === "delete") {
-        return ["update", path, currentValue];
-      }
-      if (typeof currentValue !== "undefined") {
-        return ["update", path, currentValue];
-      }
-      return ["delete", path];
-    });
-    this._undoStack.push({
-      operations: undoOperations,
-      originalOperations: tuples,
-      options,
-      timestamp: Date.now()
-    });
-    this._redoStack.length = 0;
-    const maxUndoSteps = ((_a = this._options) == null ? void 0 : _a.maxUndoSteps) || 50;
-    if (this._undoStack.length > maxUndoSteps) {
-      this._undoStack.shift();
-    }
-  }
-  _getValueAtPath(path) {
-    var _a;
-    const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-    if (!state || !state.getByPath) {
-      return null;
-    }
-    try {
-      return state.getByPath(path);
-    } catch (error) {
-      console.warn("[CollabService] Could not get value at path:", path, error);
-      return null;
-    }
-  }
-  undo() {
-    var _a;
-    if (!this._undoStack.length) {
-      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-      const el = state.__element;
-      el.call("openNotification", {
-        type: "error",
-        title: "Nothing to undo"
-      });
-      throw new Error("Nothing to undo");
-    }
-    if (!this.isConnected()) {
-      console.warn("[CollabService] Not connected, cannot undo");
-      return;
-    }
-    const undoItem = this._undoStack.pop();
-    const { operations, originalOperations, options } = undoItem;
-    this._redoStack.push({
-      operations: originalOperations,
-      originalOperations: operations,
-      options,
-      timestamp: Date.now()
-    });
-    this._isUndoRedo = true;
-    try {
-      this.updateData(operations, {
-        ...options,
-        isUndo: true,
-        message: `Undo: ${options.message || "operation"}`
-      });
-    } finally {
-      this._isUndoRedo = false;
-    }
-    return operations;
-  }
-  redo() {
-    var _a;
-    if (!this._redoStack.length) {
-      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-      const el = state.__element;
-      el.call("openNotification", {
-        type: "error",
-        title: "Nothing to redo"
-      });
-      throw new Error("Nothing to redo");
-    }
-    if (!this.isConnected()) {
-      console.warn("[CollabService] Not connected, cannot redo");
-      return;
-    }
-    const redoItem = this._redoStack.pop();
-    const { operations, originalOperations, options } = redoItem;
-    this._undoStack.push({
-      operations: originalOperations,
-      originalOperations: operations,
-      options,
-      timestamp: Date.now()
-    });
-    this._isUndoRedo = true;
-    try {
-      this.updateData(operations, {
-        ...options,
-        isRedo: true,
-        message: `Redo: ${options.message || "operation"}`
-      });
-    } finally {
-      this._isUndoRedo = false;
-    }
-    return operations;
-  }
-  /* ---------- Undo/Redo State ---------- */
-  canUndo() {
-    return this._undoStack.length > 0;
-  }
-  canRedo() {
-    return this._redoStack.length > 0;
-  }
-  getUndoStackSize() {
-    return this._undoStack.length;
-  }
-  getRedoStackSize() {
-    return this._redoStack.length;
-  }
-  clearUndoHistory() {
-    this._undoStack.length = 0;
-    this._redoStack.length = 0;
-  }
-  addItem(type, data, opts = {}) {
-    try {
-      import_validation.validateParams.type(type);
-      import_validation.validateParams.data(data, type);
-      const { value, ...schema } = data;
-      const tuples = [
-        ["update", [type, data.key], value],
-        ["update", ["schema", type, data.key], schema || {}]
-      ];
-      const updatedOpts = { ...opts, skipComponentsChangedEvent: true };
-      return this.updateData(tuples, updatedOpts);
-    } catch (error) {
-      throw new Error(`Failed to add item: ${error.message}`, { cause: error });
-    }
-  }
-  addMultipleItems(items, opts = {}) {
-    var _a;
-    const tuples = [];
-    try {
-      items.forEach(([type, data]) => {
-        import_validation.validateParams.type(type);
-        import_validation.validateParams.data(data, type);
-        const { value, ...schema } = data;
-        tuples.push(
-          ["update", [type, data.key], value],
-          ["update", ["schema", type, data.key], schema]
-        );
-      });
-      this.updateData([...tuples, ...opts.append || []], {
-        message: `Created ${tuples.length} items`,
-        ...opts
-      });
-      return tuples;
-    } catch (error) {
-      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-      const el = state.__element;
-      el.call("openNotification", {
-        type: "error",
-        title: "Failed to add item",
-        message: error.message
-      });
-      throw new Error(`Failed to add item: ${error.message}`, { cause: error });
-    }
-  }
-  updateItem(type, data, opts = {}) {
-    var _a;
-    try {
-      import_validation.validateParams.type(type);
-      import_validation.validateParams.data(data, type);
-      const { value, ...schema } = data;
-      const tuples = [
-        ["update", [type, data.key], value],
-        ["update", ["schema", type, data.key], schema]
-      ];
-      return this.updateData(tuples, opts);
-    } catch (error) {
-      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-      const el = state.__element;
-      el.call("openNotification", {
-        type: "error",
-        title: "Failed to update item",
-        message: error.message
-      });
-      throw new Error(`Failed to update item: ${error.message}`, {
-        cause: error
-      });
-    }
-  }
-  deleteItem(type, key, opts = {}) {
-    var _a;
-    try {
-      import_validation.validateParams.type(type);
-      import_validation.validateParams.key(key, type);
-      const tuples = [
-        ["delete", [type, key]],
-        ["delete", ["schema", type, key]],
-        ...opts.append || []
-      ];
-      return this.updateData(tuples, {
-        message: `Deleted ${key} from ${type}`,
-        ...opts
-      });
-    } catch (error) {
-      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
-      const el = state.__element;
-      el.call("openNotification", {
-        type: "error",
-        title: "Failed to delete item",
-        message: error.message
-      });
-      throw new Error(`Failed to delete item: ${error.message}`, {
-        cause: error
-      });
-    }
-  }
-  /* ---------- socket event helpers ---------- */
-  /**
-   * Handle "clients" or "presence" events coming from the collab socket.
-   * The backend sends the full `clients` object which we directly patch to
-   * the root state, mimicking the legacy SocketService behaviour so that
-   * existing UI components keep working unmodified.
-   */
-  _handleClientsEvent(data = {}) {
-    var _a;
-    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
-    if (root && typeof root.replace === "function") {
-      root.clients = data;
-    }
-    import_rootEventBus.rootBus.emit("clients:updated", data);
-  }
-  /* ---------- Dependency bundling events ---------- */
-  _handleBundleDoneEvent({
-    project,
-    ticket,
-    dependencies = {},
-    schema = {}
-  } = {}) {
-    var _a;
-    console.info("[CollabService] Bundle done", { project, ticket });
-    try {
-      this._ensureStateManager();
-      const { dependencies: schemaDependencies = {} } = schema || {};
-      const tuples = [
-        ["update", ["dependencies"], dependencies],
-        ["update", ["schema", "dependencies"], schemaDependencies]
-      ];
-      this._stateManager.applyChanges(tuples, {
-        fromSocket: true,
-        preventFetchDeps: true,
-        preventUpdate: ["Iframe"]
-      });
-    } catch (err) {
-      console.error("[CollabService] Failed to update deps after bundle", err);
-    }
-    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
-    const el = root == null ? void 0 : root.__element;
-    if (el == null ? void 0 : el.call) {
-      el.call("openNotification", {
-        type: "success",
-        title: "Dependencies ready",
-        message: `Project ${project} dependencies have been bundled successfully.`
-      });
-    }
-    import_rootEventBus.rootBus.emit("bundle:done", { project, ticket });
-  }
-  _handleBundleErrorEvent({ project, ticket, error } = {}) {
-    var _a;
-    console.error("[CollabService] Bundle error", { project, ticket, error });
-    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
-    const el = root == null ? void 0 : root.__element;
-    if (el == null ? void 0 : el.call) {
-      el.call("openNotification", {
-        type: "error",
-        title: "Dependency bundle failed",
-        message: error || `An error occurred while bundling dependencies for project ${project}.`
-      });
-    }
-    import_rootEventBus.rootBus.emit("bundle:error", { project, ticket, error });
-  }
-  /* ---------- Manual checkpoint ---------- */
-  _attachSocketLifecycleListeners() {
-    var _a;
-    const socket = (_a = this._client) == null ? void 0 : _a.socket;
-    if (!socket) {
-      return;
-    }
-    socket.on("connect", this._onSocketConnect);
-    socket.on("disconnect", this._onSocketDisconnect);
-    socket.on("connect_error", this._onSocketError);
-  }
-  _detachSocketLifecycleListeners() {
-    var _a;
-    const socket = (_a = this._client) == null ? void 0 : _a.socket;
-    if (!socket) {
-      return;
-    }
-    socket.off("connect", this._onSocketConnect);
-    socket.off("disconnect", this._onSocketDisconnect);
-    socket.off("connect_error", this._onSocketError);
-  }
-  _onSocketConnect() {
-    this._connected = true;
-  }
-  _onSocketDisconnect(reason) {
-    this._connected = false;
-    if (reason && reason !== "io client disconnect") {
-      console.warn("[CollabService] Socket disconnected", reason);
-    }
-  }
-  _onSocketError(error) {
-    console.warn("[CollabService] Socket connection error", error);
-  }
-  /**
-   * Manually request a checkpoint / commit of buffered operations on the server.
-   * Resolves with the new version number once the backend confirms via the
-   * regular "commit" event.
-   */
-  checkpoint() {
-    if (!this.isConnected()) {
-      console.warn("[CollabService] Not connected, cannot request checkpoint");
-      return Promise.reject(new Error("Not connected"));
-    }
-    return new Promise((resolve) => {
-      var _a, _b;
-      const handler = ({ version }) => {
-        var _a2;
-        (_a2 = this.socket) == null ? void 0 : _a2.off("commit", handler);
-        import_rootEventBus.rootBus.emit("checkpoint:done", { version, origin: "manual" });
-        resolve(version);
-      };
-      (_a = this.socket) == null ? void 0 : _a.once("commit", handler);
-      (_b = this.socket) == null ? void 0 : _b.emit("checkpoint");
-    });
-  }
-}