@symbo.ls/sdk 2.32.1 → 2.32.4

package/dist/cjs/services/CollabService.js

@@ -26,8 +26,7 @@ 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_jsonDiff = require("../utils/jsonDiff.js");
-var import_ordering = require("../utils/ordering.js");
+var import_changePreprocessor = require("../utils/changePreprocessor.js");
 class CollabService extends import_BaseService.BaseService {
   constructor(config) {
     super(config);
@@ -164,8 +163,8 @@ class CollabService extends import_BaseService.BaseService {
       console.log(
         `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
       );
-      this._pendingOps.forEach(({ changes, orders }) => {
-        this.socket.emit("ops", { changes, orders, ts: Date.now() });
+      this._pendingOps.forEach(({ changes, granularChanges, orders }) => {
+        this.socket.emit("ops", { changes, granularChanges, orders, ts: Date.now() });
       });
       this._pendingOps.length = 0;
     }
@@ -207,94 +206,24 @@ class CollabService extends import_BaseService.BaseService {
   }
   /* ---------- data helpers ---------- */
   updateData(tuples, options = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     this._ensureStateManager();
     const { isUndo = false, isRedo = false } = options;
     if (!isUndo && !isRedo && !this._isUndoRedo) {
       this._trackForUndo(tuples, options);
     }
-    const processedTuples = (() => {
-      var _a2;
-      try {
-        const root = (_a2 = this._stateManager) == null ? void 0 : _a2.root;
-        const isPlainObject = (o) => o && typeof o === "object" && !Array.isArray(o);
-        const getByPath = (state2, path) => {
-          if (!state2 || typeof state2.getByPath !== "function") {
-            return null;
-          }
-          try {
-            return state2.getByPath(path);
-          } catch {
-            return null;
-          }
-        };
-        const expandTuple = (t) => {
-          const [action, path, value] = t || [];
-          const isSchemaPath = Array.isArray(path) && path[0] === "schema";
-          if (action === "delete" || isSchemaPath) {
-            return [t];
-          }
-          const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2) && isPlainObject(value);
-          if (!canConsiderExpansion) {
-            return [t];
-          }
-          const prev = getByPath(root, path) || {};
-          const next = value || {};
-          if (!isPlainObject(prev) || !isPlainObject(next)) {
-            return [t];
-          }
-          const ops = (0, import_jsonDiff.diffJson)(prev, next, []);
-          if (!ops.length) {
-            return [];
-          }
-          const arr = [];
-          for (let j = 0; j < ops.length; j++) {
-            const op = ops[j];
-            const fullPath = [...path, ...op.path];
-            const last = fullPath[fullPath.length - 1];
-            if (op.action === "set") {
-              arr.push(["update", fullPath, op.value]);
-            } else if (op.action === "del") {
-              if (last !== "__order") {
-                arr.push(["delete", fullPath]);
-              }
-            }
-          }
-          return arr;
-        };
-        const minimizeTuples = (inputTuples) => {
-          const out = [];
-          for (let i = 0; i < inputTuples.length; i++) {
-            const expanded = expandTuple(inputTuples[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) {
-                out.push(tuple);
-              }
-            }
-          }
-          console.log(`Minimized tuples`, out);
-          return out;
-        };
-        console.log(`Processing tuples`, tuples);
-        return minimizeTuples(tuples);
-      } catch (err) {
-        console.warn(
-          "[CollabService] Minimal diff expansion failed \u2013 using original tuples",
-          err
-        );
-        return tuples;
-      }
-    })();
+    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 state = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const state = (_b = this._stateManager) == null ? void 0 : _b.root;
     const el = state == null ? void 0 : state.__element;
-    const orders = (0, import_ordering.computeOrdersForTuples)(state, processedTuples);
     const stringifiedGranularTuples = (el == null ? void 0 : el.call) ? el.call(
       "deepStringifyFunctions",
       processedTuples,
@@ -307,16 +236,18 @@ class CollabService extends import_BaseService.BaseService {
       "deepStringifyFunctions",
       tuples,
       Array.isArray(tuples) ? [] : {}
-    ) : (0, import_utils.deepStringifyFunctions)(
-      tuples,
-      Array.isArray(tuples) ? [] : {}
-    );
+    ) : (0, import_utils.deepStringifyFunctions)(tuples, Array.isArray(tuples) ? [] : {});
     if (!this.isConnected()) {
       console.warn("[CollabService] Not connected, queuing real-time update");
-      this._pendingOps.push({ changes: stringifiedTuples, granularChanges: stringifiedGranularTuples, orders, options });
+      this._pendingOps.push({
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        options
+      });
       return;
     }
-    if ((_b = this.socket) == null ? void 0 : _b.connected) {
+    if ((_c = this.socket) == null ? void 0 : _c.connected) {
       console.log("[CollabService] Sending operations to the backend", {
         changes: stringifiedTuples,
         granularChanges: stringifiedGranularTuples,

package/dist/cjs/services/ProjectService.js

@@ -22,6 +22,8 @@ __export(ProjectService_exports, {
 module.exports = __toCommonJS(ProjectService_exports);
 var import_BaseService = require("./BaseService.js");
 var import_ordering = require("../utils/ordering.js");
+var import_changePreprocessor = require("../utils/changePreprocessor.js");
+var import_utils = require("@domql/utils");
 class ProjectService extends import_BaseService.BaseService {
   // ==================== PROJECT METHODS ====================
   async createProject(projectData) {
@@ -554,12 +556,15 @@ class ProjectService extends import_BaseService.BaseService {
     }
     const { message, branch = "main", type = "patch" } = options;
     const state = this._context && this._context.state;
-    const derivedOrders = options.orders || (state ? (0, import_ordering.computeOrdersForTuples)(state, changes) : []);
+    const { granularChanges, orders: preprocessorOrders } = (0, import_changePreprocessor.preprocessChanges)(state, changes, options);
+    const derivedOrders = options.orders || (preprocessorOrders && preprocessorOrders.length ? preprocessorOrders : state ? (0, import_ordering.computeOrdersForTuples)(state, granularChanges) : []);
+    const stringify = (val) => (0, import_utils.deepStringifyFunctions)(val, Array.isArray(val) ? [] : {});
     try {
       const response = await this._request(`/projects/${projectId}/changes`, {
         method: "POST",
         body: JSON.stringify({
-          changes,
+          changes: stringify(changes),
+          granularChanges: stringify(granularChanges),
           message,
           branch,
           type,

package/dist/cjs/utils/changePreprocessor.js

@@ -0,0 +1,134 @@
+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 changePreprocessor_exports = {};
+__export(changePreprocessor_exports, {
+  preprocessChanges: () => preprocessChanges
+});
+module.exports = __toCommonJS(changePreprocessor_exports);
+var import_jsonDiff = require("./jsonDiff.js");
+var import_ordering = require("./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 preprocessChanges(root, tuples = [], options = {}) {
+  const expandTuple = (t) => {
+    const [action, path, value] = t || [];
+    const isSchemaPath = Array.isArray(path) && path[0] === "schema";
+    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) {
+      return [t];
+    }
+    const prev = getByPathSafe(root, path) || {};
+    const next = value || {};
+    if (!isPlainObject(prev) || !isPlainObject(next)) {
+      return [t];
+    }
+    const ops = (0, import_jsonDiff.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 baseOrders = (0, import_ordering.computeOrdersForTuples)(root, granularChanges);
+  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;
+    if (action !== "update" || !Array.isArray(path) || path.length !== 1 && path.length !== 2 || !isPlainObject(value)) {
+      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, orders: mergedOrders };
+}

package/dist/cjs/utils/jsonDiff.js

@@ -36,12 +36,54 @@ function isPlainObject(o) {
   return o && typeof o === "object" && !Array.isArray(o);
 }
 function deepEqual(a, b) {
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch (err) {
-    console.warn("deepEqual error", err);
+  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;
 }
 function getRootMap(ydoc) {
   return ydoc.getMap("root");

package/dist/cjs/utils/ordering.js

@@ -47,14 +47,12 @@ function getParentPathsFromTuples(tuples = []) {
     "attr",
     "state",
     "scope",
-    "props",
     "define",
     "on",
     "extend",
     "extends",
     "childExtend",
     "childExtends",
-    "childProps",
     "children",
     "component",
     "context",