@symbo.ls/sdk 2.31.36 → 2.32.0

package/dist/cjs/services/CollabService.js

@@ -26,6 +26,8 @@ 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");
 class CollabService extends import_BaseService.BaseService {
   constructor(config) {
     super(config);
@@ -163,8 +165,8 @@ class CollabService extends import_BaseService.BaseService {
         console.log(
           `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
         );
-        this._pendingOps.forEach(({ tuples }) => {
-          this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+        this._pendingOps.forEach(({ changes, orders }) => {
+          this.socket.emit("ops", { changes, orders, ts: Date.now() });
         });
         this._pendingOps.length = 0;
       }
@@ -209,24 +211,118 @@ class CollabService extends import_BaseService.BaseService {
   }
   /* ---------- data helpers ---------- */
   updateData(tuples, options = {}) {
-    var _a;
+    var _a, _b;
     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;
+      }
+    })();
     if (options.append && options.append.length) {
-      tuples.push(...options.append);
+      processedTuples.push(...options.append);
     }
     this._stateManager.applyChanges(tuples, { ...options });
-    tuples = (0, import_utils.deepStringifyFunctions)(tuples, []);
+    const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const el = state == null ? void 0 : state.__element;
+    const orders = (0, import_ordering.computeOrdersForTuples)(state, processedTuples);
+    const stringifiedTuples = (el == null ? void 0 : el.call) ? el.call(
+      "deepStringifyFunctions",
+      processedTuples,
+      Array.isArray(processedTuples) ? [] : {}
+    ) : (0, import_utils.deepStringifyFunctions)(
+      processedTuples,
+      Array.isArray(processedTuples) ? [] : {}
+    );
     if (!this.isConnected()) {
       console.warn("[CollabService] Not connected, queuing real-time update");
-      this._pendingOps.push({ tuples, options });
+      this._pendingOps.push({ changes: stringifiedTuples, orders, options });
       return;
     }
-    if ((_a = this.socket) == null ? void 0 : _a.connected) {
-      this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+    if ((_b = this.socket) == null ? void 0 : _b.connected) {
+      console.log("[CollabService] Sending operations to the backend", {
+        changes: stringifiedTuples,
+        orders,
+        ts: Date.now()
+      });
+      this.socket.emit("ops", {
+        changes: stringifiedTuples,
+        orders,
+        ts: Date.now()
+      });
     }
     return { success: true };
   }

package/dist/cjs/services/ProjectService.js

@@ -21,6 +21,7 @@ __export(ProjectService_exports, {
 });
 module.exports = __toCommonJS(ProjectService_exports);
 var import_BaseService = require("./BaseService.js");
+var import_ordering = require("../utils/ordering.js");
 class ProjectService extends import_BaseService.BaseService {
   // ==================== PROJECT METHODS ====================
   async createProject(projectData) {
@@ -552,6 +553,8 @@ class ProjectService extends import_BaseService.BaseService {
       throw new Error("Changes must be an array");
     }
     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) : []);
     try {
       const response = await this._request(`/projects/${projectId}/changes`, {
         method: "POST",
@@ -559,7 +562,8 @@ class ProjectService extends import_BaseService.BaseService {
           changes,
           message,
           branch,
-          type
+          type,
+          ...derivedOrders && derivedOrders.length ? { orders: derivedOrders } : {}
         }),
         methodName: "applyProjectChanges"
       });

package/dist/cjs/utils/ordering.js

@@ -0,0 +1,295 @@
+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 ordering_exports = {};
+__export(ordering_exports, {
+  computeOrdersForTuples: () => computeOrdersForTuples,
+  computeOrdersFromState: () => computeOrdersFromState,
+  getParentPathsFromTuples: () => getParentPathsFromTuples
+});
+module.exports = __toCommonJS(ordering_exports);
+function isObjectLike(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function normalizePath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (typeof path === "string") {
+    return [path];
+  }
+  return [];
+}
+function getParentPathsFromTuples(tuples = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const parents = [];
+  const META_KEYS = /* @__PURE__ */ new Set([
+    "style",
+    "class",
+    "text",
+    "html",
+    "content",
+    "data",
+    "attr",
+    "state",
+    "scope",
+    "props",
+    "define",
+    "on",
+    "extend",
+    "extends",
+    "childExtend",
+    "childExtends",
+    "childProps",
+    "children",
+    "component",
+    "context",
+    "tag",
+    "key",
+    "__order",
+    "if"
+  ]);
+  for (let i = 0; i < tuples.length; i++) {
+    const tuple = tuples[i];
+    if (!Array.isArray(tuple) || tuple.length < 2) {
+      continue;
+    }
+    const path = normalizePath(tuple[1]);
+    if (!path.length) {
+      continue;
+    }
+    if (path[0] === "schema") {
+      continue;
+    }
+    const immediateParent = path.slice(0, -1);
+    if (immediateParent.length) {
+      const key = JSON.stringify(immediateParent);
+      if (!seen.has(key)) {
+        seen.add(key);
+        parents.push(immediateParent);
+      }
+    }
+    const last = path[path.length - 1];
+    if (META_KEYS.has(last) && path.length >= 2) {
+      const containerParent = path.slice(0, -2);
+      if (containerParent.length) {
+        const key2 = JSON.stringify(containerParent);
+        if (!seen.has(key2)) {
+          seen.add(key2);
+          parents.push(containerParent);
+        }
+      }
+    }
+    for (let j = 0; j < path.length; j++) {
+      const seg = path[j];
+      if (!META_KEYS.has(seg)) {
+        continue;
+      }
+      const containerParent2 = path.slice(0, j);
+      if (!containerParent2.length) {
+        continue;
+      }
+      const key3 = JSON.stringify(containerParent2);
+      if (!seen.has(key3)) {
+        seen.add(key3);
+        parents.push(containerParent2);
+      }
+    }
+  }
+  return parents;
+}
+function computeOrdersFromState(root, parentPaths = []) {
+  if (!root || typeof root.getByPath !== "function") {
+    return [];
+  }
+  const orders = [];
+  const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+  for (let i = 0; i < parentPaths.length; i++) {
+    const parentPath = parentPaths[i];
+    const obj = (() => {
+      try {
+        return root.getByPath(parentPath);
+      } catch {
+        return null;
+      }
+    })();
+    if (!isObjectLike(obj)) {
+      continue;
+    }
+    const keys = Object.keys(obj).filter((k) => !EXCLUDE_KEYS.has(k));
+    orders.push({ path: parentPath, keys });
+  }
+  return orders;
+}
+function normaliseSchemaCode(code) {
+  if (typeof code !== "string" || !code.length) {
+    return "";
+  }
+  return code.replaceAll("/////n", "\n").replaceAll("/////tilde", "`");
+}
+function extractTopLevelKeysFromCode(code) {
+  const src = normaliseSchemaCode(code);
+  if (!src) {
+    return [];
+  }
+  const idx = src.indexOf("export default");
+  if (idx === -1) {
+    return [];
+  }
+  let i = src.indexOf("{", idx);
+  if (i === -1) {
+    return [];
+  }
+  const keys = [];
+  let depth = 0;
+  let inStr = false;
+  let strCh = "";
+  let inEsc = false;
+  for (; i < src.length; i++) {
+    const ch = src[i];
+    if (inStr) {
+      if (inEsc) {
+        inEsc = false;
+      } else if (ch === "\\") {
+        inEsc = true;
+      } else if (ch === strCh) {
+        inStr = false;
+        strCh = "";
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inStr = true;
+      strCh = ch;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        break;
+      }
+      continue;
+    }
+    if (depth !== 1) {
+      continue;
+    }
+    if (/[A-Za-z_$]/u.test(ch)) {
+      let j = i;
+      while (j < src.length && /[A-Za-z0-9_$]/u.test(src[j])) {
+        j++;
+      }
+      let k = j;
+      while (k < src.length && /\s/u.test(src[k])) {
+        k++;
+      }
+      if (src[k] === ":") {
+        const key = src.slice(i, j);
+        keys.push(key);
+      }
+      i = j;
+      continue;
+    }
+  }
+  if (!keys.length) {
+    const bodyStart = src.indexOf("{", idx);
+    const bodyEnd = src.lastIndexOf("}");
+    if (bodyStart === -1 || bodyEnd === -1 || bodyEnd <= bodyStart) {
+      return Array.from(new Set(keys));
+    }
+    const body = src.slice(bodyStart + 1, bodyEnd);
+    const re = /(?:[A-Za-z_$][A-Za-z0-9_$]*|"[^"]+"|'[^']+')\s*:/gu;
+    for (const m of body.matchAll(re)) {
+      const raw = m[0].split(":")[0].trim();
+      const key = raw[0] === '"' || raw[0] === "'" ? raw.slice(1, -1) : raw;
+      keys.push(key);
+    }
+  }
+  return Array.from(new Set(keys));
+}
+function computeOrdersForTuples(root, tuples = []) {
+  const preferredOrderMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const p = normalizePath(path);
+    if (action !== "update" || !Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] !== "schema") {
+      continue;
+    }
+    const [, type, key] = p;
+    const containerPath = [type, key];
+    const uses = value && Array.isArray(value.uses) ? value.uses : null;
+    const code = value && value.code;
+    const obj = (() => {
+      try {
+        return root && typeof root.getByPath === "function" ? root.getByPath(containerPath) : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!obj) {
+      continue;
+    }
+    const present = new Set(Object.keys(obj));
+    const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+    const codeKeys = extractTopLevelKeysFromCode(code);
+    let resolved = [];
+    if (Array.isArray(codeKeys) && codeKeys.length) {
+      resolved = codeKeys.filter((k) => present.has(k) && !EXCLUDE_KEYS.has(k));
+    }
+    if (resolved.length && Array.isArray(uses) && uses.length) {
+      for (let u = 0; u < uses.length; u++) {
+        const keyName = uses[u];
+        if (present.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
+          resolved.push(keyName);
+        }
+      }
+    }
+    if (resolved.length) {
+      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved });
+    }
+  }
+  const parents = getParentPathsFromTuples(tuples);
+  const orders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferredOrderMap.forEach((v) => {
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      orders.push(v);
+    }
+  });
+  const fallbackOrders = computeOrdersFromState(root, parents);
+  for (let i = 0; i < fallbackOrders.length; i++) {
+    const v = fallbackOrders[i];
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      orders.push(v);
+    }
+  }
+  return orders;
+}