@archie/devtools 0.0.26 → 0.0.27

package/dist/collection-binding.mjs

@@ -0,0 +1,521 @@
+import {
+  meaningfulChildren
+} from "./chunk-4VGQJ3PW.mjs";
+
+// src/babel-plugin-collection-binding.ts
+import { VISITOR_KEYS } from "@babel/types";
+var ATTR_ENTITY = "data-agent-entity";
+var ATTR_ROW = "data-agent-row";
+var ATTR_FIELD = "data-agent-field";
+var ATTR_FIELD_STATE = "data-agent-field-state";
+var ATTR_FIELD_PARTS = "data-agent-field-parts";
+var ATTR_FIELD_SLOT = "data-agent-field-slot";
+var ATTR_COLLECTION_ORDER = "data-agent-collection-order";
+var SLICE_ROOT_NAME = "slice";
+var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
+var MAX_SOURCE_CHAIN_HOPS = 4;
+var MAX_PROJECTION_DEPTH = 3;
+function babelPluginCollectionBinding({ types: t }, opts = {}) {
+  const { fileExclude = /node_modules/ } = opts;
+  function hasOwnAttr(elementPath, name) {
+    return elementPath.node.openingElement.attributes.some(
+      (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name })
+    );
+  }
+  function addAttr(elementPath, name, value) {
+    if (hasOwnAttr(elementPath, name)) return;
+    elementPath.node.openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier(name), value));
+  }
+  function getTagName(opening) {
+    const { name } = opening;
+    if (t.isJSXIdentifier(name)) return name.name;
+    if (t.isJSXMemberExpression(name)) {
+      const parts = [];
+      let current = name;
+      while (t.isJSXMemberExpression(current)) {
+        parts.unshift(current.property.name);
+        current = current.object;
+      }
+      if (t.isJSXIdentifier(current)) parts.unshift(current.name);
+      return parts.join(".");
+    }
+    return "";
+  }
+  function isLowercaseTag(tag) {
+    return tag.length > 0 && tag[0] === tag[0].toLowerCase();
+  }
+  function getAttrName(attr) {
+    return t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+  }
+  function isPageSliceBinding(scope) {
+    const binding = scope.getBinding(SLICE_ROOT_NAME);
+    if (!binding) return true;
+    return binding.scope === binding.scope.getProgramParent();
+  }
+  function isUseMemoCallee(callee) {
+    if (t.isIdentifier(callee, { name: "useMemo" })) return true;
+    return t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property, { name: "useMemo" });
+  }
+  function resolveSliceSource(expr, scope, hops, hasSort) {
+    if (t.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (!t.isExpression(callee)) return null;
+      if (isUseMemoCallee(callee)) {
+        const [factory] = expr.arguments;
+        if (!factory || !t.isArrowFunctionExpression(factory)) return null;
+        if (!t.isExpression(factory.body)) return null;
+        return resolveSliceSource(factory.body, scope, hops, hasSort);
+      }
+      if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property)) {
+        const method = callee.property.name;
+        if (!CHAIN_METHODS.has(method)) return null;
+        if (!t.isExpression(callee.object)) return null;
+        return resolveSliceSource(callee.object, scope, hops, hasSort || method === "sort");
+      }
+      return null;
+    }
+    if (t.isMemberExpression(expr)) {
+      if (!t.isIdentifier(expr.object, { name: SLICE_ROOT_NAME })) return null;
+      if (!isPageSliceBinding(scope)) return null;
+      if (!expr.computed && t.isIdentifier(expr.property)) {
+        return { entity: expr.property.name, hasSort };
+      }
+      if (expr.computed && t.isStringLiteral(expr.property)) {
+        return { entity: expr.property.value, hasSort };
+      }
+      return null;
+    }
+    if (t.isIdentifier(expr)) {
+      if (hops >= MAX_SOURCE_CHAIN_HOPS) return null;
+      const binding = scope.getBinding(expr.name);
+      if (!binding || !binding.constant) return null;
+      const declarator = binding.path;
+      if (!declarator.isVariableDeclarator()) return null;
+      const init = declarator.node.init;
+      if (!init || !t.isExpression(init)) return null;
+      return resolveSliceSource(init, declarator.scope, hops + 1, hasSort);
+    }
+    return null;
+  }
+  function buildScopeFromParam(param) {
+    if (t.isIdentifier(param)) {
+      return { identifiers: /* @__PURE__ */ new Map([[param.name, { kind: "self" }]]) };
+    }
+    if (t.isObjectPattern(param)) {
+      const identifiers = /* @__PURE__ */ new Map();
+      for (const prop of param.properties) {
+        if (!t.isObjectProperty(prop) || prop.computed) continue;
+        const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+        if (!key || key.includes(",")) continue;
+        const value = prop.value;
+        let localName = null;
+        if (t.isIdentifier(value)) localName = value.name;
+        else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) localName = value.left.name;
+        if (!localName) continue;
+        identifiers.set(localName, { kind: "field", field: key });
+      }
+      if (identifiers.size === 0) return null;
+      return { identifiers };
+    }
+    return null;
+  }
+  function buildOptionalRowIdExpression(idValueExpr) {
+    return t.conditionalExpression(
+      t.binaryExpression("==", t.cloneNode(idValueExpr), t.nullLiteral()),
+      t.identifier("undefined"),
+      t.callExpression(t.identifier("String"), [idValueExpr])
+    );
+  }
+  function computeRowIdExpression(scope) {
+    for (const [localName, binding] of scope.identifiers) {
+      if (binding.kind === "self") {
+        return buildOptionalRowIdExpression(
+          t.optionalMemberExpression(t.identifier(localName), t.identifier("id"), false, true)
+        );
+      }
+    }
+    for (const [localName, binding] of scope.identifiers) {
+      if (binding.kind === "field" && binding.field === "id") {
+        return buildOptionalRowIdExpression(t.identifier(localName));
+      }
+    }
+    return null;
+  }
+  function isStaticLiteralExpr(node) {
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node)) {
+      return true;
+    }
+    return t.isTemplateLiteral(node) && node.expressions.length === 0;
+  }
+  function containsEvaluation(node) {
+    if (!node) return false;
+    if (t.isCallExpression(node) || t.isOptionalCallExpression(node) || t.isNewExpression(node) || t.isTaggedTemplateExpression(node)) {
+      return true;
+    }
+    const keys = VISITOR_KEYS[node.type] ?? [];
+    for (const key of keys) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (child && typeof child === "object" && "type" in child) {
+            if (containsEvaluation(child)) return true;
+          }
+        }
+      } else if (value && typeof value === "object" && "type" in value) {
+        if (containsEvaluation(value)) return true;
+      }
+    }
+    return false;
+  }
+  function classifyMemberField(expr, scope) {
+    if (!t.isIdentifier(expr.object)) return null;
+    const binding = scope.identifiers.get(expr.object.name);
+    if (!binding || binding.kind !== "self") return null;
+    if (!expr.computed) {
+      if (!t.isIdentifier(expr.property)) return null;
+      if (expr.property.name === "id") return null;
+      return { kind: "static", field: expr.property.name };
+    }
+    if (t.isStringLiteral(expr.property)) {
+      if (expr.property.value === "id") return null;
+      if (expr.property.value.includes(",")) return null;
+      return { kind: "static", field: expr.property.value };
+    }
+    return { kind: "unresolved-computed" };
+  }
+  function fieldNameForBranch(expr, scope) {
+    if (t.isIdentifier(expr)) {
+      const binding = scope.identifiers.get(expr.name);
+      return binding?.kind === "field" ? binding.field : null;
+    }
+    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
+      const verdict = classifyMemberField(expr, scope);
+      return verdict?.kind === "static" ? verdict.field : null;
+    }
+    return null;
+  }
+  function flattenNullish(expr) {
+    const parts = [];
+    let current = expr;
+    while (t.isLogicalExpression(current) && current.operator === "??") {
+      parts.unshift(current.right);
+      current = current.left;
+    }
+    parts.unshift(current);
+    return parts;
+  }
+  function classifyNullishChain(expr, scope) {
+    const parts = flattenNullish(expr);
+    if (parts.length < 2) return null;
+    const last = parts[parts.length - 1];
+    if (parts.length === 2 && isStaticLiteralExpr(last)) {
+      const field = fieldNameForBranch(parts[0], scope);
+      return field ? { kind: "static", field } : null;
+    }
+    const fields = parts.map((p) => fieldNameForBranch(p, scope));
+    if (fields.some((f) => f === null)) return null;
+    const distinct = new Set(fields);
+    if (distinct.size === 1) return { kind: "static", field: fields[0] };
+    let acc = t.stringLiteral(fields[fields.length - 1]);
+    for (let i = parts.length - 2; i >= 0; i -= 1) {
+      acc = t.conditionalExpression(
+        t.binaryExpression("!=", t.cloneNode(parts[i]), t.nullLiteral()),
+        t.stringLiteral(fields[i]),
+        acc
+      );
+    }
+    return { kind: "runtime", expr: acc };
+  }
+  function classifySimpleLogicalOr(expr, scope) {
+    if (!isStaticLiteralExpr(expr.right)) return null;
+    const field = fieldNameForBranch(expr.left, scope);
+    return field ? { kind: "static", field } : null;
+  }
+  function classifyConditional(expr, scope) {
+    const { test, consequent, alternate } = expr;
+    if (!t.isExpression(test) || !t.isExpression(consequent) || !t.isExpression(alternate)) return null;
+    if (isStaticLiteralExpr(consequent) && isStaticLiteralExpr(alternate)) {
+      const testField = fieldNameForBranch(test, scope);
+      return testField ? { kind: "static", field: testField } : null;
+    }
+    const consField = fieldNameForBranch(consequent, scope);
+    const altField = fieldNameForBranch(alternate, scope);
+    if (!consField || !altField) return null;
+    if (consField === altField) return { kind: "static", field: consField };
+    if (containsEvaluation(test)) return null;
+    return {
+      kind: "runtime",
+      expr: t.conditionalExpression(t.cloneNode(test), t.stringLiteral(consField), t.stringLiteral(altField))
+    };
+  }
+  function classifyFieldExpr(expr, scope) {
+    if (t.isIdentifier(expr)) {
+      const binding = scope.identifiers.get(expr.name);
+      return binding?.kind === "field" ? { kind: "static", field: binding.field } : null;
+    }
+    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
+      return classifyMemberField(expr, scope);
+    }
+    if (t.isLogicalExpression(expr) && expr.operator === "??") return classifyNullishChain(expr, scope);
+    if (t.isLogicalExpression(expr) && expr.operator === "||") return classifySimpleLogicalOr(expr, scope);
+    if (t.isConditionalExpression(expr)) return classifyConditional(expr, scope);
+    return null;
+  }
+  function applyFieldVerdict(elementPath, verdict) {
+    if (!verdict) return;
+    if (verdict.kind === "unresolved-computed") {
+      addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("unresolved"));
+      return;
+    }
+    if (verdict.kind === "static") {
+      addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
+      return;
+    }
+    addAttr(elementPath, ATTR_FIELD, t.jsxExpressionContainer(verdict.expr));
+  }
+  function meaningfulChildPaths(elementPath) {
+    const meaningfulSet = new Set(meaningfulChildren(t, elementPath.node.children));
+    const childPaths = elementPath.get("children");
+    return childPaths.filter((p) => meaningfulSet.has(p.node));
+  }
+  function isStaticExpressionContainer(container) {
+    if (t.isJSXEmptyExpression(container.expression)) return true;
+    return isStaticLiteralExpr(container.expression);
+  }
+  function isInvisibleRenderExpr(expr) {
+    if (t.isNullLiteral(expr)) return true;
+    if (t.isBooleanLiteral(expr)) return true;
+    if (t.isStringLiteral(expr) && expr.value === "") return true;
+    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0 && expr.quasis.length === 1 && expr.quasis[0].value.cooked === "") {
+      return true;
+    }
+    return false;
+  }
+  function stampPureLeaf(elementPath, expr, scope) {
+    if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) return;
+    applyFieldVerdict(elementPath, classifyFieldExpr(expr, scope));
+  }
+  function stampLabelValueOrMixed(elementPath, childPaths, scope) {
+    if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    const hasInvisibleSibling = childPaths.some(
+      (p) => p.isJSXExpressionContainer() && t.isExpression(p.node.expression) && isInvisibleRenderExpr(p.node.expression)
+    );
+    if (hasInvisibleSibling) return;
+    const dynamicEntries = [];
+    childPaths.forEach((p, index) => {
+      if (!p.isJSXExpressionContainer()) return;
+      const container = p.node;
+      if (isStaticExpressionContainer(container)) return;
+      if (!t.isExpression(container.expression)) return;
+      dynamicEntries.push({ index, expr: container.expression });
+    });
+    if (dynamicEntries.length === 0) return;
+    if (dynamicEntries.length === 1) {
+      const { index, expr } = dynamicEntries[0];
+      const verdict = classifyFieldExpr(expr, scope);
+      if (!verdict) return;
+      applyFieldVerdict(elementPath, verdict);
+      if (verdict.kind !== "unresolved-computed") {
+        addAttr(elementPath, ATTR_FIELD_SLOT, t.stringLiteral(String(index)));
+      }
+      return;
+    }
+    const fields = [];
+    for (const { expr } of dynamicEntries) {
+      const verdict = classifyFieldExpr(expr, scope);
+      if (!verdict || verdict.kind !== "static") return;
+      fields.push(verdict.field);
+    }
+    if (new Set(fields).size <= 1) return;
+    addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("mixed"));
+    addAttr(elementPath, ATTR_FIELD_PARTS, t.stringLiteral(fields.join(",")));
+  }
+  function resolveComponentDefinition(tagName, fromPath) {
+    if (tagName.includes(".")) return null;
+    const binding = fromPath.scope.getBinding(tagName);
+    if (!binding) return null;
+    if (binding.scope !== binding.scope.getProgramParent()) return null;
+    const bp = binding.path;
+    if (bp.isFunctionDeclaration()) return bp;
+    if (bp.isVariableDeclarator()) {
+      const init = bp.get("init");
+      if (!Array.isArray(init) && (init.isArrowFunctionExpression() || init.isFunctionExpression())) {
+        return init;
+      }
+    }
+    return null;
+  }
+  function buildCalleePropContext(fnPath) {
+    const [first] = fnPath.node.params;
+    if (!first || !t.isObjectPattern(first)) return null;
+    const propMap = /* @__PURE__ */ new Map();
+    for (const prop of first.properties) {
+      if (!t.isObjectProperty(prop) || prop.computed) continue;
+      const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      const value = prop.value;
+      let localName = null;
+      if (t.isIdentifier(value)) localName = value.name;
+      else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) localName = value.left.name;
+      if (!localName) continue;
+      propMap.set(key, localName);
+    }
+    if (propMap.size === 0) return null;
+    return { propMap };
+  }
+  function findReturnedJsxPath(fnPath) {
+    const body = fnPath.get("body");
+    if (Array.isArray(body)) return null;
+    if (body.isBlockStatement()) {
+      const returnPaths = [];
+      body.traverse({
+        Function(inner) {
+          inner.skip();
+        },
+        ReturnStatement(rp) {
+          returnPaths.push(rp);
+        }
+      });
+      if (returnPaths.length !== 1) return null;
+      const arg = returnPaths[0].get("argument");
+      if (Array.isArray(arg) || !arg.node) return null;
+      return arg.isJSXElement() ? arg : null;
+    }
+    return body.isJSXElement() ? body : null;
+  }
+  function findSelfForwardingLocalName(usagePath, scope, propCtx) {
+    for (const attr of usagePath.node.openingElement.attributes) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const localName = propCtx.propMap.get(getAttrName(attr));
+      if (!localName) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expr = value.expression;
+      if (!t.isIdentifier(expr)) continue;
+      const binding = scope.identifiers.get(expr.name);
+      if (binding?.kind === "self") return localName;
+    }
+    return null;
+  }
+  function resolveRowRoot(jsxPath, scope, depth) {
+    const tag = getTagName(jsxPath.node.openingElement);
+    if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (depth >= MAX_PROJECTION_DEPTH) return null;
+    const fnPath = resolveComponentDefinition(tag, jsxPath);
+    if (!fnPath) return null;
+    const propCtx = buildCalleePropContext(fnPath);
+    if (!propCtx) return null;
+    const localName = findSelfForwardingLocalName(jsxPath, scope, propCtx);
+    if (!localName) return null;
+    const innerReturn = findReturnedJsxPath(fnPath);
+    if (!innerReturn) return null;
+    return resolveRowRoot(innerReturn, { identifiers: /* @__PURE__ */ new Map([[localName, { kind: "self" }]]) }, depth + 1);
+  }
+  function resolveFieldProjection(jsxPath, scope, depth) {
+    const tag = getTagName(jsxPath.node.openingElement);
+    if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (depth >= MAX_PROJECTION_DEPTH) return null;
+    const fnPath = resolveComponentDefinition(tag, jsxPath);
+    if (!fnPath) return null;
+    const propCtx = buildCalleePropContext(fnPath);
+    if (!propCtx) return null;
+    const identifiers = /* @__PURE__ */ new Map();
+    for (const attr of jsxPath.node.openingElement.attributes) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const localName = propCtx.propMap.get(getAttrName(attr));
+      if (!localName) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expr = value.expression;
+      if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) continue;
+      if (t.isIdentifier(expr)) {
+        const binding = scope.identifiers.get(expr.name);
+        if (binding?.kind === "self") {
+          identifiers.set(localName, { kind: "self" });
+          continue;
+        }
+      }
+      const verdict = classifyFieldExpr(expr, scope);
+      if (verdict?.kind === "static") {
+        identifiers.set(localName, { kind: "field", field: verdict.field });
+      }
+    }
+    if (identifiers.size === 0) return null;
+    const innerReturn = findReturnedJsxPath(fnPath);
+    if (!innerReturn) return null;
+    return resolveFieldProjection(innerReturn, { identifiers }, depth + 1);
+  }
+  function walkFieldsWithinRow(elementPath, scope) {
+    const childPaths = meaningfulChildPaths(elementPath);
+    const hasElementChild = childPaths.some((p) => p.isJSXElement());
+    if (hasElementChild) {
+      for (const childPath of childPaths) {
+        if (!childPath.isJSXElement()) continue;
+        handleStructuralChild(childPath, scope);
+      }
+      return;
+    }
+    if (childPaths.length === 0) return;
+    const exprChildren = childPaths.filter((p) => p.isJSXExpressionContainer());
+    if (childPaths.length === 1 && exprChildren.length === 1) {
+      stampPureLeaf(elementPath, exprChildren[0].node.expression, scope);
+      return;
+    }
+    if (childPaths.length > 1) {
+      stampLabelValueOrMixed(elementPath, childPaths, scope);
+    }
+  }
+  function handleStructuralChild(childPath, scope) {
+    const tag = getTagName(childPath.node.openingElement);
+    if (isLowercaseTag(tag)) {
+      walkFieldsWithinRow(childPath, scope);
+      return;
+    }
+    const projected = resolveFieldProjection(childPath, scope, 0);
+    if (!projected) return;
+    walkFieldsWithinRow(projected.hostPath, projected.scope);
+  }
+  function processSliceMap(callPath) {
+    const node = callPath.node;
+    const callee = node.callee;
+    if (!t.isMemberExpression(callee) || callee.computed) return;
+    if (!t.isIdentifier(callee.property, { name: "map" })) return;
+    if (!t.isExpression(callee.object)) return;
+    const source = resolveSliceSource(callee.object, callPath.scope, 0, false);
+    if (!source) return;
+    const [callback] = node.arguments;
+    if (!callback || !t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) return;
+    if (callback.params.length === 0) return;
+    const callbackPath = callPath.get("arguments.0");
+    if (Array.isArray(callbackPath)) return;
+    if (!callbackPath.isArrowFunctionExpression() && !callbackPath.isFunctionExpression()) return;
+    const initialScope = buildScopeFromParam(callback.params[0]);
+    if (!initialScope) return;
+    const returnedJsx = findReturnedJsxPath(callbackPath);
+    if (!returnedJsx) return;
+    const resolvedRoot = resolveRowRoot(returnedJsx, initialScope, 0);
+    if (!resolvedRoot) return;
+    const rowIdExpr = computeRowIdExpression(resolvedRoot.scope);
+    if (!rowIdExpr) return;
+    const { hostPath, scope } = resolvedRoot;
+    if (hasOwnAttr(hostPath, ATTR_ENTITY)) return;
+    addAttr(hostPath, ATTR_ENTITY, t.stringLiteral(source.entity));
+    addAttr(hostPath, ATTR_ROW, t.jsxExpressionContainer(rowIdExpr));
+    addAttr(hostPath, ATTR_COLLECTION_ORDER, t.stringLiteral(source.hasSort ? "derived" : "stable"));
+    walkFieldsWithinRow(hostPath, scope);
+  }
+  return {
+    name: "babel-plugin-collection-binding",
+    visitor: {
+      CallExpression(path, state) {
+        const filename = state.filename ?? "";
+        if (fileExclude.test(filename)) return;
+        processSliceMap(path);
+      }
+    }
+  };
+}
+export {
+  babelPluginCollectionBinding
+};

package/dist/index.js

@@ -206,6 +206,13 @@ function babelPluginDndAuto({ types: t }, opts = {}) {
 
 // src/babel-plugin-editor-meta.ts
 var nodePath = __toESM(require("path"));
+function meaningfulChildren(t, children) {
+  return children.filter((child) => {
+    if (t.isJSXText(child)) return child.value.trim() !== "";
+    if (t.isJSXExpressionContainer(child)) return !t.isJSXEmptyExpression(child.expression);
+    return true;
+  });
+}
 var KIT_SLOT_ATTR = "data-kit-slot";
 var MAX_SLOT_SEGMENTS = 4;
 var NON_BINDING_ATTRS = /* @__PURE__ */ new Set(["__editorMeta", "key", "ref", KIT_SLOT_ATTR]);
@@ -450,8 +457,7 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     let fn = path.getFunctionParent();
     while (fn) {
       const [first] = fn.node.params;
-      if (first && t.isObjectPattern(first)) {
-        if (fn.scope.parent !== fn.scope.getProgramParent()) return null;
+      if (first && t.isObjectPattern(first) && fn.scope.parent === fn.scope.getProgramParent()) {
         return {
           componentScope: fn.scope,
           propMap: buildPropMap(first),
@@ -575,13 +581,6 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const props = collectPropIdentifiers(expr, scope, ctx);
     return props.length > 0 ? { kind: "formatted", prop: props[0] } : null;
   }
-  function meaningfulChildren(children) {
-    return children.filter((child) => {
-      if (t.isJSXText(child)) return child.value.trim() !== "";
-      if (t.isJSXExpressionContainer(child)) return !t.isJSXEmptyExpression(child.expression);
-      return true;
-    });
-  }
   function collectPropBindings(path, attrs) {
     const ctx = resolvePropContext(path);
     if (!ctx || ctx.propMap.size === 0) return { bindings: [], owner: null };
@@ -590,7 +589,7 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const bindings = [];
     const elementPath = path.parentPath;
     if (elementPath && elementPath.isJSXElement()) {
-      const children = meaningfulChildren(elementPath.node.children);
+      const children = meaningfulChildren(t, elementPath.node.children);
       const isSoleChild = children.length === 1;
       for (const child of children) {
         if (!t.isJSXExpressionContainer(child)) continue;