@dimina-kit/devtools 0.4.0-dev.20260702175315 → 0.4.0-dev.20260703051110

package/dist/preload/instrumentation/wxml-extract.js

@@ -130,25 +130,39 @@ function resolveTagName(instance) {
         return pascalToKebab(name);
     return name;
 }
+/** Props/attrs entries that never surface in the WXML panel (internal Vue plumbing, falsy booleans). */
+function isSkippedProp(key, value) {
+    if (typeof value === 'function' || value === undefined)
+        return true;
+    if (key === 'data' || key.startsWith('__'))
+        return true;
+    return typeof value === 'boolean' && !value;
+}
+/** Drop the `dd-` internal-marker classes so the panel shows only user-authored classes. */
+function cleanClassAttr(value) {
+    return value.split(/\s+/).filter((c) => !c.startsWith('dd-')).join(' ');
+}
+function stringifyPropValue(value) {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+}
+function assignProp(out, key, value) {
+    if (isSkippedProp(key, value))
+        return;
+    if (key === 'class' && typeof value === 'string') {
+        const cleaned = cleanClassAttr(value);
+        if (cleaned)
+            out[key] = cleaned;
+        return;
+    }
+    out[key] = stringifyPropValue(value);
+}
 function extractProps(instance) {
     const out = {};
     for (const raw of [instance.props, instance.attrs]) {
         if (!raw)
             continue;
         for (const [k, v] of Object.entries(raw)) {
-            if (typeof v === 'function' || v === undefined)
-                continue;
-            if (k === 'data' || k.startsWith('__'))
-                continue;
-            if (typeof v === 'boolean' && !v)
-                continue;
-            if (k === 'class' && typeof v === 'string') {
-                const cleaned = v.split(/\s+/).filter((c) => !c.startsWith('dd-')).join(' ');
-                if (cleaned)
-                    out[k] = cleaned;
-                continue;
-            }
-            out[k] = typeof v === 'object' ? JSON.stringify(v) : String(v);
+            assignProp(out, k, v);
         }
     }
     return out;
@@ -209,65 +223,83 @@ function isCommentVNode(vnode) {
     const children = typeof vnode.children === 'string' ? vnode.children : '';
     return /^v-(if|else|else-if|for)$/.test(children);
 }
+function textNode(text) {
+    return { tagName: '#text', attrs: {}, children: [], text };
+}
+/** A component vnode's children come from walking its mounted instance, not `vnode.children`. */
+function childrenFromComponentVNode(component, depth) {
+    const result = walkInstance(component, depth + 1);
+    if (!result)
+        return [];
+    return Array.isArray(result) ? result : [result];
+}
+/** A `<Suspense>` vnode's visible content is whichever branch is currently active. */
+function childrenFromSuspenseVNode(suspense, depth) {
+    const activeBranch = suspense.activeBranch;
+    return activeBranch ? extractChildrenFromVNode(activeBranch, depth + 1) : [];
+}
+/**
+ * A vnode whose OWN `children` is a plain string only counts as a text node when
+ * its `type` is a symbol/string (a real element or fragment) — a component vnode
+ * with string `children` is slot content, not text, and is handled elsewhere.
+ * Returns null when this vnode is not (top-level) text, so the caller falls
+ * through to the array-children path.
+ */
+function directTextChild(vnode) {
+    if (typeof vnode.children !== 'string' || !vnode.children.trim())
+        return null;
+    const vnodeType = vnode.type;
+    if (typeof vnodeType !== 'symbol' && typeof vnodeType !== 'string')
+        return null;
+    return [textNode(vnode.children.trim())];
+}
+function textChildEntry(child) {
+    const trimmed = child.trim();
+    return trimmed ? [textNode(trimmed)] : [];
+}
+/** A DOM-typed child (`type` is its tag name string): text leaf, internal wrapper, or a normal subtree. */
+function domTypedChildEntries(c, depth) {
+    if (isInternalElement(c))
+        return extractChildrenFromVNode(c, depth + 1);
+    if (typeof c.children === 'string' && c.children.trim())
+        return [textNode(c.children.trim())];
+    return extractChildrenFromVNode(c, depth + 1);
+}
+/** One entry from a vnode's `children` array, normalized to zero or more WXML nodes. */
+function extractChildEntry(child, depth) {
+    if (!child)
+        return [];
+    if (typeof child === 'string')
+        return textChildEntry(child);
+    if (typeof child !== 'object')
+        return [];
+    const c = child;
+    if (c.component)
+        return childrenFromComponentVNode(c.component, depth);
+    if (typeof c.type === 'symbol')
+        return extractChildrenFromVNode(c, depth + 1);
+    if (typeof c.type === 'string')
+        return domTypedChildEntries(c, depth);
+    return extractChildrenFromVNode(c, depth + 1);
+}
 function extractChildrenFromVNode(vnode, depth) {
     if (!vnode || depth > 50)
         return [];
     if (isCommentVNode(vnode))
         return [];
-    if (vnode.component) {
-        const result = walkInstance(vnode.component, depth + 1);
-        return result ? (Array.isArray(result) ? result : [result]) : [];
-    }
-    if (vnode.suspense) {
-        const suspense = vnode.suspense;
-        const activeBranch = suspense.activeBranch;
-        return activeBranch ? extractChildrenFromVNode(activeBranch, depth + 1) : [];
-    }
-    if (typeof vnode.children === 'string' && vnode.children.trim()) {
-        const vnodeType = vnode.type;
-        if (typeof vnodeType === 'symbol' || typeof vnodeType === 'string') {
-            return [{ tagName: '#text', attrs: {}, children: [], text: vnode.children.trim() }];
-        }
-    }
+    if (vnode.component)
+        return childrenFromComponentVNode(vnode.component, depth);
+    if (vnode.suspense)
+        return childrenFromSuspenseVNode(vnode.suspense, depth);
+    const directText = directTextChild(vnode);
+    if (directText)
+        return directText;
     const kids = vnode.children;
     if (!Array.isArray(kids))
         return [];
     const result = [];
     for (const child of kids) {
-        if (!child)
-            continue;
-        if (typeof child === 'string') {
-            const trimmed = child.trim();
-            if (trimmed)
-                result.push({ tagName: '#text', attrs: {}, children: [], text: trimmed });
-            continue;
-        }
-        if (typeof child !== 'object')
-            continue;
-        const c = child;
-        if (c.component) {
-            const walked = walkInstance(c.component, depth + 1);
-            if (walked)
-                result.push(...(Array.isArray(walked) ? walked : [walked]));
-            continue;
-        }
-        if (typeof c.type === 'symbol') {
-            result.push(...extractChildrenFromVNode(c, depth + 1));
-            continue;
-        }
-        if (typeof c.type === 'string') {
-            if (isInternalElement(c)) {
-                result.push(...extractChildrenFromVNode(c, depth + 1));
-            }
-            else if (typeof c.children === 'string' && c.children.trim()) {
-                result.push({ tagName: '#text', attrs: {}, children: [], text: c.children.trim() });
-            }
-            else {
-                result.push(...extractChildrenFromVNode(c, depth + 1));
-            }
-            continue;
-        }
-        result.push(...extractChildrenFromVNode(c, depth + 1));
+        result.push(...extractChildEntry(child, depth));
     }
     return result;
 }

package/dist/preload/runtime/main-api-runner.d.ts

@@ -1,4 +1,4 @@
-type LooseApiHandler = (this: any, params?: unknown) => unknown | Promise<unknown>;
+type LooseApiHandler = (params?: unknown) => unknown | Promise<unknown>;
 export interface ApiRunVerdict {
     ok: boolean;
     result?: unknown;