@symbo.ls/sdk 3.1.1 → 3.2.3

package/dist/cjs/services/index.js

@@ -17,26 +17,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var services_exports = {};
 __export(services_exports, {
-  AIService: () => import_AIService.AIService,
   AuthService: () => import_AuthService.AuthService,
-  BasedService: () => import_BasedService.BasedService,
-  SocketService: () => import_SocketIOService.SocketService,
-  SymstoryService: () => import_SymstoryService.SymstoryService,
-  createAIService: () => createAIService,
+  CollabService: () => import_CollabService.CollabService,
+  CoreService: () => import_CoreService.CoreService,
   createAuthService: () => createAuthService,
-  createBasedService: () => createBasedService,
-  createSocketService: () => createSocketService,
-  createSymstoryService: () => createSymstoryService
+  createCollabService: () => createCollabService,
+  createCoreService: () => createCoreService
 });
 module.exports = __toCommonJS(services_exports);
-var import_BasedService = require("./BasedService.js");
-var import_SymstoryService = require("./SymstoryService.js");
 var import_AuthService = require("./AuthService.js");
-var import_AIService = require("./AIService.js");
-var import_SocketIOService = require("./SocketIOService.js");
+var import_CoreService = require("./CoreService.js");
+var import_CollabService = require("./CollabService.js");
 const createService = (ServiceClass, config) => new ServiceClass(config);
-const createBasedService = (config) => createService(import_BasedService.BasedService, config);
-const createSymstoryService = (config) => createService(import_SymstoryService.SymstoryService, config);
 const createAuthService = (config) => createService(import_AuthService.AuthService, config);
-const createAIService = (config) => createService(import_AIService.AIService, config);
-const createSocketService = (config) => createService(import_SocketIOService.SocketService, config);
+const createCoreService = (config) => createService(import_CoreService.CoreService, config);
+const createCollabService = (config) => createService(import_CollabService.CollabService, config);

package/dist/cjs/state/RootStateManager.js

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RootStateManager_exports = {};
+__export(RootStateManager_exports, {
+  RootStateManager: () => RootStateManager
+});
+module.exports = __toCommonJS(RootStateManager_exports);
+var utils = __toESM(require("@domql/utils"), 1);
+var import_rootEventBus = require("./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]);
+        import_rootEventBus.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;
+  }
+}

package/dist/cjs/state/rootEventBus.js

@@ -0,0 +1,65 @@
+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 rootEventBus_exports = {};
+__export(rootEventBus_exports, {
+  default: () => rootEventBus_default,
+  rootBus: () => rootBus
+});
+module.exports = __toCommonJS(rootEventBus_exports);
+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;

package/dist/cjs/utils/CollabClient.js

@@ -0,0 +1,157 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CollabClient_exports = {};
+__export(CollabClient_exports, {
+  CollabClient: () => CollabClient
+});
+module.exports = __toCommonJS(CollabClient_exports);
+var import_socket = require("socket.io-client");
+var Y = __toESM(require("yjs"), 1);
+var import_y_indexeddb = require("y-indexeddb");
+var import_dexie = __toESM(require("dexie"), 1);
+var import_nanoid = require("nanoid");
+var import_environment = __toESM(require("../config/environment.js"), 1);
+var import_jsonDiff = require("./jsonDiff.js");
+class CollabClient {
+  /* public fields */
+  socket = null;
+  ydoc = null;
+  branch = "main";
+  live = false;
+  projectId = null;
+  jwt = null;
+  /* private state */
+  _buffer = [];
+  _flushTimer = null;
+  _clientId = (0, import_nanoid.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 import_y_indexeddb.IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
+    this._outboxStore = createDexieOutbox(`${projectId}:${branch}`);
+    this.socket = (0, import_socket.io)(import_environment.default.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 = (0, import_jsonDiff.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 }) => {
+    (0, import_jsonDiff.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: (0, import_nanoid.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 import_dexie.default(`collab-${name}`);
+  db.version(1).stores({ outbox: "id, ops" });
+  return db.table("outbox");
+}