@archie/devtools 0.0.29 → 0.0.30

package/dist/inspector.standalone.js

@@ -615,6 +615,122 @@
         }
       }
 
+      // ARCH-1065 M3 (v2.3.0) — the nearest data-agent-row-bearing element
+      // SELF-outward. This is `nearestRowId` above but returning the ELEMENT
+      // (not just its id), because QUERY_COLLECTION_ORDER needs the row
+      // root's sibling `data-agent-entity`/`data-agent-collection-order`
+      // frame too, not only the row id. Nested collections resolve correctly
+      // "for free": walking self-outward finds the INNERMOST row root first,
+      // i.e. the nearest enclosing collection of the target node.
+      function nearestRowRootElement(el) {
+        var node = el
+        for (var depth = 0; node && depth < MAX_ANCHOR_CHAIN; depth++) {
+          if (node.nodeType === 1 && typeof node.getAttribute === "function") {
+            var rowId = node.getAttribute("data-agent-row")
+            if (typeof rowId === "string" && rowId !== "") return node
+          }
+          node = node.parentElement
+        }
+        return null
+      }
+
+      // The first row-root element stamped with the given entity name,
+      // anywhere in the document. Used when QUERY_COLLECTION_ORDER is
+      // addressed by `entity` alone (no `selector`) — the entity-name
+      // targeting mode.
+      function findFirstRowRootForEntity(entity) {
+        if (typeof entity !== "string" || entity === "") return null
+        try {
+          return safeQuerySelector(
+            '[data-agent-entity="' +
+              escapeAttributeSelectorValue(entity) +
+              '"][data-agent-row]'
+          )
+        } catch (e) {
+          return null
+        }
+      }
+
+      // Every row root that belongs to the SAME collection instantiation as
+      // `rowRootEl`: the babel codemod (M2) stamps each `.map()` row's root
+      // element as a DIRECT child of whatever wraps the `.map()` call, so
+      // siblings sharing `data-agent-entity` under `rowRootEl`'s parent ARE
+      // the collection, in DOM order. Falls back to `[rowRootEl]` alone when
+      // no parent is reachable (defensive — should not happen for an
+      // attached element).
+      function collectionRowElements(rowRootEl, entity) {
+        var parent = rowRootEl.parentElement
+        if (!parent) return [rowRootEl]
+        var siblings = []
+        var kids = parent.children
+        for (var i = 0; i < kids.length; i++) {
+          var kid = kids[i]
+          if (
+            kid.nodeType === 1 &&
+            typeof kid.getAttribute === "function" &&
+            kid.getAttribute("data-agent-entity") === entity &&
+            kid.hasAttribute("data-agent-row")
+          ) {
+            siblings.push(kid)
+          }
+        }
+        return siblings.length > 0 ? siblings : [rowRootEl]
+      }
+
+      // ARCH-1065 M3 (v2.3.0) — {entity, order, rowIds, rowCount} for the
+      // collection enclosing a target node, read live off the DOM
+      // (data-agent-entity/-row/-collection-order, D18) and cross-checked
+      // against window.__slice[entity].length when the slice is available.
+      //
+      // `order` fails CLOSED ("derived") on anything but an explicit
+      // "stable" attribute value. babel-plugin-collection-binding stamps
+      // entity/row/collection-order ATOMICALLY — three addAttr calls back to
+      // back with no branch between them — and no other emitter of
+      // data-agent-row exists. So data-agent-row present WITHOUT
+      // data-agent-collection-order can only mean the stamping contract
+      // never ran for this element: the order is UNKNOWN, not "stable".
+      // Defaulting unknown to "stable" would let the FE permit a drag whose
+      // Save can't be honored (silent, user-visible corruption); defaulting
+      // to "derived" only disables reorder on markup we can't vouch for.
+      function queryCollectionOrder(rowRootEl) {
+        if (!rowRootEl) return null
+        var entity = rowRootEl.getAttribute("data-agent-entity")
+        if (typeof entity !== "string" || entity === "") return null
+
+        var orderAttr = rowRootEl.getAttribute("data-agent-collection-order")
+        var order = orderAttr === "stable" ? "stable" : "derived"
+
+        var rowElements = collectionRowElements(rowRootEl, entity)
+        var rowIds = []
+        for (var i = 0; i < rowElements.length; i++) {
+          var rowId = rowElements[i].getAttribute("data-agent-row")
+          if (typeof rowId === "string" && rowId !== "") rowIds.push(rowId)
+        }
+        var domRowCount = rowIds.length
+
+        var sliceRows = resolveSliceEntityRows(entity)
+        var sliceRowCount = sliceRows ? sliceRows.length : null
+
+        // `rowCount` is the A17 primary field — DOM population, the same
+        // rows the FE samples values from. `domRowCount`/`sliceRowCount` are
+        // the divergence-diagnostic pair (identical to rowCount when the
+        // slice agrees, or absent from parity entirely when the slice is
+        // unavailable). Known limit: two same-entity `.map()`s that happen
+        // to share one DOM parent merge into a single reported collection —
+        // rare by construction (siblings of a `.map()` output share a
+        // parent by definition), and there is no collection-INSTANCE stamp
+        // (only per-row entity/row/order) to disambiguate two side-by-side
+        // instantiations of the same entity.
+        return {
+          entity: entity,
+          order: order,
+          rowIds: rowIds,
+          rowCount: domRowCount,
+          domRowCount: domRowCount,
+          sliceRowCount: sliceRowCount,
+        }
+      }
+
       if (window._inspectorSharedTargetObserver) {
         try {
           window._inspectorSharedTargetObserver.disconnect()
@@ -1231,7 +1347,10 @@
         // `QUERY_SLICE_FIELD` in the message protocol, and
         // `capabilities.bindingContract` below. No existing field changed
         // shape, so `protocolVersion` stays 1.
-        version: "2.2.0",
+        // 2.3.0 (ARCH-1065 A17-support): additive only — `QUERY_COLLECTION_ORDER`
+        // in the message protocol and `capabilities.collectionOrderQuery`
+        // below. No existing field changed shape, so `protocolVersion` stays 1.
+        version: "2.3.0",
         protocolVersion: 1,
         capabilities: {
           // 2.1.1: function-valued __editorMeta props are invoked before any
@@ -1257,6 +1376,12 @@
           // before relying on either — a frozen pre-1065 inspector has
           // neither.
           collectionBinding: true,
+          // ARCH-1065 A17-support (v2.3.0): `QUERY_COLLECTION_ORDER` resolves
+          // the enclosing collection's order ("stable"/"derived") and row
+          // ids/count for a target node, off the same data-agent-* grammar
+          // as `collectionBinding`. Hosts MUST feature-detect on this flag —
+          // a frozen pre-2.3.0 inspector has no handler for the message.
+          collectionOrderQuery: true,
           // The BUILD-TIME contract version this specific page was stamped
           // with, forwarded verbatim from `<meta name="archie-binding-contract">`
           // when the kit build emitted one — null on any page built before
@@ -3881,6 +4006,58 @@
             field: queryField,
             result: queryResult,
           })
+        } else if (event.data && event.data.type === "QUERY_COLLECTION_ORDER") {
+          // ARCH-1065 M3 (v2.3.0) — {order, rowIds, rowCount} for the
+          // collection enclosing a target node, so the FE can refuse
+          // reorder-at-drag on "derived" collections and drive the
+          // repetition-aware enum threshold off rowCount. Mirrors
+          // QUERY_SLICE_FIELD's request/response envelope and graceful
+          // (result: null) failure shape.
+          //
+          // Targeting, in priority order:
+          //   1. `selector` — a CSS selector for ANY element inside the
+          //      collection (a row, or a leaf nested inside one); resolved
+          //      the same way other selector-addressed messages resolve one
+          //      (`findElementBySelector`), then walked up to the nearest
+          //      enclosing row root.
+          //   2. `entity` alone (no selector) — the first row root in the
+          //      document stamped with that entity name.
+          //   3. neither — mirrors QUERY_SLICE_FIELD's no-rowId fallback:
+          //      the currently selected (else hovered) element.
+          var collectionQuerySelector =
+            typeof event.data.selector === "string" && event.data.selector !== ""
+              ? event.data.selector
+              : null
+          var collectionQueryEntity =
+            typeof event.data.entity === "string" && event.data.entity !== ""
+              ? event.data.entity
+              : null
+
+          var collectionRowRoot = null
+          if (collectionQuerySelector) {
+            var collectionTargetEl = findElementBySelector(collectionQuerySelector)
+            collectionRowRoot = collectionTargetEl
+              ? nearestRowRootElement(collectionTargetEl)
+              : null
+          } else if (collectionQueryEntity) {
+            collectionRowRoot = findFirstRowRootForEntity(collectionQueryEntity)
+          } else {
+            var collectionContextEl = getSelectedElement() || highlightedElement
+            collectionRowRoot = collectionContextEl
+              ? nearestRowRootElement(collectionContextEl)
+              : null
+          }
+
+          var collectionQueryResult = queryCollectionOrder(collectionRowRoot)
+
+          postMessageToParent({
+            type: "COLLECTION_ORDER_RESULT",
+            requestId: event.data.requestId,
+            entity: collectionQueryResult
+              ? collectionQueryResult.entity
+              : collectionQueryEntity,
+            result: collectionQueryResult,
+          })
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archie/devtools",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "DevTools for Archie generated applications - Route synchronization and editor communication",
   "repository": {
     "type": "git",