@symbo.ls/sdk 3.1.1 → 3.1.2

package/dist/cjs/services/SocketIOService.js

@@ -66,7 +66,7 @@ class SocketService extends import_BaseService.BaseService {
   init() {
     try {
       const { _context, _options } = this;
-      const socketUrl = import_environment.default.socketUrl || _options.socketUrl || "https://socket.symbols.app/";
+      const socketUrl = import_environment.default.socketUrl || _options.socketUrl;
       if (!socketUrl) {
         throw new Error("Socket URL is required");
       }
@@ -103,6 +103,9 @@ class SocketService extends import_BaseService.BaseService {
         userId: (_e = _context.user) == null ? void 0 : _e.id,
         socketUrl: this._info.config.url,
         location: window.location.host,
+        // onConnect: () => {
+        //   console.log('waz')
+        // },
         onChange: this._handleMessage.bind(this),
         sessionId: this._sessionId,
         usersName: (_f = _context.user) == null ? void 0 : _f.name,
@@ -144,7 +147,7 @@ class SocketService extends import_BaseService.BaseService {
     import_client.send.call(
       this._socket,
       type,
-      opts.preventDeepStringify ? payload : deepStringify(payload)
+      opts.useDeepStringify ? deepStringify(payload) : payload
     );
   }
   _handleMessage(event, data) {
@@ -175,38 +178,27 @@ class SocketService extends import_BaseService.BaseService {
     }
   }
   _handleChangeEvent(data) {
-    var _a, _b, _c;
-    if (data.canvas) {
-      const { clients } = data.canvas;
-      const [firstClientKey] = Object.keys(clients);
-      const monaco = clients && clients[firstClientKey] && clients[firstClientKey].monaco;
-      if (monaco) {
-        const Canvas = this._context.element && this._context.element.getCanvas();
-        if (Canvas) {
-          Canvas.Chosen.EditorPanels.update({}, { forceMonacoUpdate: true });
-        }
-      }
-      return;
-    }
-    const componentUpdates = ((_a = data.schema) == null ? void 0 : _a.components) || ((_b = data.schema) == null ? void 0 : _b.pages);
-    if (window.location.pathname.includes("/canvas") && componentUpdates) {
-      for (const updatedComponent in componentUpdates) {
-        if (Object.hasOwn(componentUpdates, updatedComponent)) {
-          (_c = this._context.element) == null ? void 0 : _c.updateComponentOnCanvas(updatedComponent);
-        }
-      }
+    const { type, changes, version } = data;
+    if (version) this._context.state.version = version;
+    if (changes) {
+      window.requestAnimationFrame(async () => {
+        await this._context.state.setPathCollection(changes, {
+          preventReplace: type === "canvas",
+          preventUpdate: true,
+          fromSocket: true,
+          userId: data.userId,
+          changes
+        });
+      });
     }
   }
   _handleClientsEvent(data) {
-    const { root } = Object.getPrototypeOf(this._context.state);
+    const { root } = this._context.state;
     root.replace(
       { clients: data },
       {
-        fromSync: true,
-        preventUpdate: ["Iframe"],
-        preventModalUpdate: true,
-        preventStateUpdateListener: true,
-        execStateFunction: true
+        fromSocket: true,
+        preventUpdate: true
       }
     );
   }
@@ -223,9 +215,9 @@ class SocketService extends import_BaseService.BaseService {
           element.__ref.root,
           {},
           {
-            fromSync: true,
+            fromSocket: true,
             updateStateOptions: {
-              fromSync: true,
+              fromSocket: true,
               preventStateUpdateListener: 1
               // !isModalRoute(data.route, element)
             }
@@ -240,9 +232,9 @@ class SocketService extends import_BaseService.BaseService {
         element.__ref.root,
         {},
         {
-          fromSync: true,
+          fromSocket: true,
           updateStateOptions: {
-            fromSync: true
+            fromSocket: true
           }
         }
       );
@@ -262,11 +254,17 @@ class SocketService extends import_BaseService.BaseService {
       this._reconnectAttempts++;
       this._updateStatus("reconnecting");
       setTimeout(() => {
-        this.connect().then(() => {
-          this._reconnectAttempts = 0;
-        }).catch(() => {
+        try {
+          const connected = this.connect();
+          if (connected) {
+            this._reconnectAttempts = 0;
+          } else {
+            this._handleReconnect();
+          }
+        } catch (error) {
+          console.error("Reconnection failed:", error);
           this._handleReconnect();
-        });
+        }
       }, this._reconnectDelay * this._reconnectAttempts);
     } else {
       this._updateStatus("failed");

package/dist/cjs/services/SymstoryService.js

@@ -40,7 +40,7 @@ class SymstoryService extends import_BaseService.BaseService {
     super(config);
     this._client = null;
     this._cache = /* @__PURE__ */ new Map();
-    this._state = null;
+    this._state = {};
     this._socketService = this._context.services.socket;
     this._undoStack = [];
     this._redoStack = [];
@@ -59,7 +59,7 @@ class SymstoryService extends import_BaseService.BaseService {
         }
       });
       this._client = import_symstoryClient.default.client;
-      this._state = state;
+      this._state = this._isObject(state) ? state : {};
       if (socketUrl) {
         await this._socketService.init();
       }
@@ -79,6 +79,30 @@ class SymstoryService extends import_BaseService.BaseService {
       throw error;
     }
   }
+  // publish a new version
+  async publish({ version, type = "minor" } = {}) {
+    if (version) {
+      await this._client.publishVersion(version, { type });
+    } else {
+      await this.updateData([], { type });
+    }
+  }
+  // get changes between versions
+  async getChanges({ versionId, versionValue, branch } = {}) {
+    return this._client.getChanges({ versionId, versionValue, branch });
+  }
+  safeStringify(obj) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(obj, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return;
+        }
+        seen.add(value);
+      }
+      return value;
+    });
+  }
   // Update project data
   async updateData(changes, options = {}, callback) {
     var _a;
@@ -93,35 +117,33 @@ class SymstoryService extends import_BaseService.BaseService {
       isRedo
     } = options;
     try {
-      if ("isOld" in this._context.state && this._context.state.isOld) {
+      const { state } = this._context;
+      if ("isOld" in state && state.isOld) {
         return;
       }
-      const updates = changes.map((change) => {
-        var _a2;
-        return {
-          change,
-          prev: (_a2 = this._context.state) == null ? void 0 : _a2.getByPath(change[1])
-        };
-      });
-      if (this._context.state && "setPathCollection" in this._context.state && !quietUpdate) {
-        this._context.state.setPathCollection(changes, {
+      const updates = changes.map((change) => ({
+        change,
+        prev: state == null ? void 0 : state.getByPath(change[1])
+      }));
+      if (state && "setPathCollection" in state && !quietUpdate) {
+        await state.setPathCollection(changes, {
           preventUpdate: true,
           ...options
         });
-        if ("__element" in this._state && isFunction(callback)) {
-          callback.call(this._state.__element);
-        }
-      }
-      const filteredUpdates = updates.filter(
-        ({ change, prev }) => change[3] !== void 0 || JSON.stringify(change[2]) !== JSON.stringify(prev)
-      );
-      if (!filteredUpdates.length) {
-        return;
       }
-      if (!fromSocket && !isUndo) {
-        if (!updates.length) {
-          return;
+      const filteredUpdates = updates.filter(({ change, prev }) => {
+        if (change && change.err) {
+          delete change.err;
+        }
+        if (prev && prev.err) {
+          delete prev.err;
         }
+        return (
+          // eslint-disable-next-line no-undefined
+          change[3] !== void 0 || this.safeStringify(change[2]) !== this.safeStringify(prev)
+        );
+      });
+      if (!fromSocket && !isUndo) {
         if (!isRedo) {
           this._redoStack.length = 0;
         }
@@ -138,27 +160,49 @@ class SymstoryService extends import_BaseService.BaseService {
         if (isFunction(change)) {
           return [action, path, (change == null ? void 0 : change.toString()) ?? change];
         }
+        if (change && change.err) {
+          delete change.err;
+        }
         return [
           action,
           path,
           isObjectLike(change) ? deepStringify(change, Array.isArray(change) ? [] : {}) : change
         ];
       });
-      const res = await this._client.update(stringifiedData, {
-        type,
-        message,
-        branch
-      });
+      const res = await this._context.services.core.applyProjectChanges(
+        state.projectId,
+        stringifiedData,
+        {
+          type,
+          message,
+          branch
+        }
+      );
+      if (this._socketService._socket) {
+        this._socketService.send("change", {
+          type: "update",
+          changes: stringifiedData,
+          version: res == null ? void 0 : res.value
+        });
+      }
       if (res == null ? void 0 : res.value) {
         this._context.symstory = {
           ...this._context.symstory,
           version: res.value
         };
-        if (this._context.state && "quietUpdate" in this._context.state) {
-          this._context.state.quietUpdate({ version: res.value });
+        if (state && "quietUpdate" in state) {
+          const { isVersionsOpen } = state;
+          if (isVersionsOpen) {
+            state.quietUpdate({ version: res.value });
+          } else {
+            state.version = res.value;
+          }
         }
         this._cache.clear();
       }
+      if ("__element" in this._state && isFunction(callback)) {
+        await callback.call(this._state.__element, changes, res);
+      }
       return res;
     } catch (error) {
       if (isFunction(callback)) {
@@ -184,13 +228,12 @@ class SymstoryService extends import_BaseService.BaseService {
       })),
       options
     });
-    return new Promise(
-      (resolve) => this.updateData(
-        changes,
-        { ...options, isUndo: true, message: `Undo: ${options.message || ""}` },
-        () => resolve(changes)
-      )
+    await this.updateData(
+      changes,
+      { ...options, isUndo: true, message: `Undo: ${options.message || ""}` },
+      () => changes
     );
+    return changes;
   }
   async redo() {
     if (!this._redoStack.length) {
@@ -202,27 +245,26 @@ class SymstoryService extends import_BaseService.BaseService {
       change[1],
       prev
     ]);
-    return new Promise(
-      (resolve) => this.updateData(
-        changes,
-        { ...options, isRedo: true, message: `Redo: ${options.message || ""}` },
-        () => resolve(changes)
-      )
+    await this.updateData(
+      changes,
+      { ...options, isRedo: true, message: `Redo: ${options.message || ""}` },
+      () => changes
     );
+    return changes;
   }
   // Delete project data
-  async deleteData(path, options = {}) {
+  async deleteData(path, options = {}, callback) {
     this._requireReady();
     try {
       const changes = [["delete", path]];
-      return await this._client.update(changes, options);
+      return await this.updateData(changes, options, callback);
     } catch (error) {
       throw new Error(`Failed to delete data: ${error.message}`);
     }
   }
   // Get project data
   async getData(query, options = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     this._requireReady();
     try {
       const {
@@ -247,7 +289,7 @@ class SymstoryService extends import_BaseService.BaseService {
       try {
         const result = await this._client.get(query, branch, version);
         if (!bypassCache && cacheKey) {
-          this._cache.set(cacheKey, result);
+          (_c = this._cache) == null ? void 0 : _c.set(cacheKey, result);
         }
         return result;
       } finally {
@@ -260,6 +302,10 @@ class SymstoryService extends import_BaseService.BaseService {
       throw new Error(`Failed to get data: ${error.message}`);
     }
   }
+  // Helper method to check if a variable is a valid object
+  _isObject(variable) {
+    return variable !== null && typeof variable === "object" && !Array.isArray(variable);
+  }
   // Helper method to generate cache key
   _generateCacheKey(query, branch, version) {
     if (!query) {
@@ -293,6 +339,9 @@ class SymstoryService extends import_BaseService.BaseService {
   }
   async createBranch(branch, options = {}) {
     this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
     try {
       return await this._client.createBranch(branch, options);
     } catch (error) {
@@ -301,6 +350,9 @@ class SymstoryService extends import_BaseService.BaseService {
   }
   async editBranch(branch, options = {}) {
     this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
     try {
       return await this._client.editBranch(branch, options);
     } catch (error) {
@@ -309,6 +361,9 @@ class SymstoryService extends import_BaseService.BaseService {
   }
   async deleteBranch(branch) {
     this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
     try {
       return await this._client.deleteBranch(branch);
     } catch (error) {
@@ -317,6 +372,9 @@ class SymstoryService extends import_BaseService.BaseService {
   }
   async mergeBranch(branch, options = {}) {
     this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
     try {
       return await this._client.mergeBranch(branch, options);
     } catch (error) {
@@ -357,7 +415,8 @@ class SymstoryService extends import_BaseService.BaseService {
       return await this.updateData(
         [
           ["update", [type, data.key], value],
-          ["update", ["schema", type, data.key], schema]
+          ["update", ["schema", type, data.key], schema],
+          ...options.additionalChanges || []
         ],
         {
           message: `Created ${data.key} in ${type}`,
@@ -369,6 +428,32 @@ class SymstoryService extends import_BaseService.BaseService {
       throw new Error(`Failed to add item: ${error.message}`);
     }
   }
+  async addMultipleItems(items, options = {}, callback) {
+    this._requireReady();
+    const updateData = [];
+    items.forEach((item) => {
+      const [type, data] = item;
+      const { value, ...schema } = data;
+      import_validation.validateParams.type(type);
+      import_validation.validateParams.data(data, type);
+      updateData.push(
+        ["update", [type, data.key], value],
+        ["update", ["schema", type, data.key], schema]
+      );
+    });
+    try {
+      return await this.updateData(
+        [...updateData, ...options.additionalChanges || []],
+        {
+          message: `Created ${updateData.length} items`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to add item: ${error.message}`);
+    }
+  }
   async updateItem(type, data, options = {}, callback) {
     this._requireReady();
     try {
@@ -416,7 +501,8 @@ class SymstoryService extends import_BaseService.BaseService {
       return await this.updateData(
         [
           ["delete", [type, key]],
-          ["delete", ["schema", type, key]]
+          ["delete", ["schema", type, key]],
+          ...options.additionalChanges || []
         ],
         {
           message: `Deleted ${key} from ${type}`,

package/dist/cjs/services/index.js

@@ -19,24 +19,24 @@ var services_exports = {};
 __export(services_exports, {
   AIService: () => import_AIService.AIService,
   AuthService: () => import_AuthService.AuthService,
-  BasedService: () => import_BasedService.BasedService,
+  CoreService: () => import_CoreService.CoreService,
   SocketService: () => import_SocketIOService.SocketService,
   SymstoryService: () => import_SymstoryService.SymstoryService,
   createAIService: () => createAIService,
   createAuthService: () => createAuthService,
-  createBasedService: () => createBasedService,
+  createCoreService: () => createCoreService,
   createSocketService: () => createSocketService,
   createSymstoryService: () => createSymstoryService
 });
 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");
 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);