@symbo.ls/sdk 2.33.1 → 2.33.2

package/dist/cjs/utils/ordering.js

@@ -167,14 +167,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -259,12 +259,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/dist/esm/index.js

@@ -42782,14 +42782,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t4;
     const p3 = normalizePath(path);
-    if (!Array.isArray(p3) || p3.length < 3) {
+    if (!Array.isArray(p3) || p3.length < 2) {
       continue;
     }
     if (p3[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p3;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p3.slice(0, -1);
+    const childKey = p3[p3.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -42874,12 +42874,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k3);
     if (pending && pending.size) {
-      const existing = new Set(v3.keys);
+      const existingKeys = v3.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j3 = 0; j3 < existingKeys.length; j3++) {
+        if (META_KEYS.has(existingKeys[j3])) {
+          firstMetaIndex = j3;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v3.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k3);

package/dist/esm/services/CollabService.js

@@ -24857,14 +24857,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -24949,12 +24949,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/dist/esm/services/ProjectService.js

@@ -926,14 +926,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -1018,12 +1018,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/dist/esm/services/index.js

@@ -42782,14 +42782,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t4;
     const p3 = normalizePath(path);
-    if (!Array.isArray(p3) || p3.length < 3) {
+    if (!Array.isArray(p3) || p3.length < 2) {
       continue;
     }
     if (p3[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p3;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p3.slice(0, -1);
+    const childKey = p3[p3.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -42874,12 +42874,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k3);
     if (pending && pending.size) {
-      const existing = new Set(v3.keys);
+      const existingKeys = v3.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j3 = 0; j3 < existingKeys.length; j3++) {
+        if (META_KEYS.has(existingKeys[j3])) {
+          firstMetaIndex = j3;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v3.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k3);

package/dist/esm/utils/changePreprocessor.js

@@ -220,14 +220,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -312,12 +312,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/dist/esm/utils/ordering.js

@@ -144,14 +144,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -236,12 +236,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/dist/node/utils/ordering.js

@@ -143,14 +143,14 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const [action, path] = t;
     const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 3) {
+    if (!Array.isArray(p) || p.length < 2) {
       continue;
     }
     if (p[0] === "schema") {
       continue;
     }
-    const [typeName, containerKey, childKey] = p;
-    const containerPath = [typeName, containerKey];
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
     const key = JSON.stringify(containerPath);
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
@@ -235,12 +235,47 @@ function computeOrdersForTuples(root, tuples = []) {
     }
     const pending = pendingChildrenByContainer.get(k);
     if (pending && pending.size) {
-      const existing = new Set(v.keys);
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
       for (const child of pending) {
-        if (existing.has(child)) {
+        if (existingSet.has(child)) {
           continue;
         }
-        v.keys.push(child);
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
       }
     }
     seen.add(k);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.33.1",
+  "version": "2.33.2",
   "type": "module",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",
@@ -46,12 +46,12 @@
     "test:user": "cross-env NODE_ENV=$NODE_ENV npx tape integration-tests/index.js integration-tests/user/*.test.js | tap-spec"
   },
   "dependencies": {
-    "@domql/element": "^2.33.1",
-    "@domql/utils": "^2.33.1",
+    "@domql/element": "^2.33.2",
+    "@domql/utils": "^2.33.2",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.33.1",
-    "@symbo.ls/socket": "^2.33.1",
+    "@symbo.ls/router": "^2.33.2",
+    "@symbo.ls/socket": "^2.33.2",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -73,5 +73,5 @@
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "29bf734428f60467fe608adeb00c3caad30398fa"
+  "gitHead": "57240a2eaa9945f0e889bd40005e331b602c467b"
 }

package/src/utils/ordering.js

@@ -125,20 +125,24 @@ function extractTopLevelKeysFromCode (code) {
 
 export function computeOrdersForTuples (root, tuples = []) {
   // Pre-scan tuples to collect child keys that will be added/updated for each
-  // data container (e.g. ['pages', '/']). This lets us include keys created in
-  // the same batch even if they are not yet present in the state object when
-  // we compute orders.
+  // container object. This lets us include keys created in the same batch even
+  // if they are not yet present in the state object when we compute orders.
   const pendingChildrenByContainer = new Map()
   for (let i = 0; i < tuples.length; i++) {
     const t = tuples[i]
     if (!Array.isArray(t)) { continue }
     const [action, path] = t
     const p = normalizePath(path)
-    if (!Array.isArray(p) || p.length < 3) { continue }
+    if (!Array.isArray(p) || p.length < 2) { continue }
     // Ignore schema edits here – we want actual data container child keys
     if (p[0] === 'schema') { continue }
-    const [typeName, containerKey, childKey] = p
-    const containerPath = [typeName, containerKey]
+
+    // Treat the immediate parent as the container and the final segment as the
+    // child key, regardless of depth. This ensures nested containers such as
+    // ['components', 'Comp1', 'MainContent', 'TXButton'] correctly record
+    // 'TXButton' as a child of ['components', 'Comp1', 'MainContent'].
+    const containerPath = p.slice(0, -1)
+    const childKey = p[p.length - 1]
     const key = JSON.stringify(containerPath)
     if (!pendingChildrenByContainer.has(key)) {
       pendingChildrenByContainer.set(key, new Set())
@@ -228,10 +232,33 @@ export function computeOrdersForTuples (root, tuples = []) {
     // Merge in any pending children (for containers without schema edits)
     const pending = pendingChildrenByContainer.get(k)
     if (pending && pending.size) {
-      const existing = new Set(v.keys)
+      const existingKeys = v.keys
+      const existingSet = new Set(existingKeys)
+
+      // Meta keys such as 'props' and 'text' should typically stay at the end
+      // of the order. When inserting brand-new children we try to place them
+      // before the first meta key so that structural children appear first.
+      const META_KEYS = new Set([
+        'style', 'class', 'text', 'html', 'content', 'data', 'attr', 'state', 'scope',
+        'define', 'on', 'extend', 'extends', 'childExtend', 'childExtends',
+        'children', 'component', 'context', 'tag', 'key', '__order', 'if'
+      ])
+
+      let firstMetaIndex = existingKeys.length
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j
+          break
+        }
+      }
+
       for (const child of pending) {
-        if (existing.has(child)) { continue }
-        v.keys.push(child)
+        if (existingSet.has(child)) { continue }
+        const insertIndex = firstMetaIndex
+        existingKeys.splice(insertIndex, 0, child)
+        existingSet.add(child)
+        // Keep subsequent new children grouped together in front of meta keys
+        firstMetaIndex++
       }
     }
     seen.add(k)