@dcoder-x/plugin-shared 0.1.3 → 0.1.5

package/dist/extractors/InteractionGraphExtractor.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionGraphExtractor = void 0;
+const ComponentContextResolver_1 = require("./ComponentContextResolver");
+const MODAL_STATE_PATTERN = /^(is|show|open|visible)/i;
+/**
+ * Extracts interaction graphs from React component ASTs.
+ * Maps event handlers -> state mutations -> conditional renders, navigation, and async effects.
+ */
+class InteractionGraphExtractor {
+    constructor() {
+        this.contextResolver = new ComponentContextResolver_1.ComponentContextResolver();
+    }
+    /**
+     * Extract all interactions (trigger -> effect mappings) from a component.
+     */
+    extractInteractions(componentPath, componentName) {
+        const context = this.contextResolver.extractContext(componentPath, componentName);
+        const interactions = [];
+        componentPath.traverse({
+            JSXOpeningElement: (jsxPath) => {
+                const attributes = jsxPath.node.attributes || [];
+                for (const attr of attributes) {
+                    if (attr.type !== 'JSXAttribute' ||
+                        !attr.name?.name?.startsWith('on'))
+                        continue;
+                    const eventName = attr.name.name;
+                    // Path A: handler calls a known state setter → find conditional effect
+                    const settersCalledByEvent = this.resolveStateSettersForAttribute(attr, context);
+                    if (settersCalledByEvent.length > 0) {
+                        const interaction = this.buildInteractionFromSetters(jsxPath, componentPath, eventName, context, settersCalledByEvent);
+                        if (interaction) {
+                            interactions.push(interaction);
+                            continue;
+                        }
+                    }
+                    // Path B: handler contains router.push / router.replace → navigation effect
+                    const navTarget = this.resolveRouterNavigation(attr, context);
+                    if (navTarget) {
+                        const tagName = jsxPath.node.name?.name || 'unknown';
+                        interactions.push({
+                            trigger: { event: eventName, element: tagName },
+                            effect: {
+                                type: 'asyncEffect',
+                                waitStrategy: 'domSettle',
+                                settleMs: 0,
+                            },
+                        });
+                        continue;
+                    }
+                    // Path C: handler calls a setter with a modal/open-like name → domSettle fallback
+                    if (settersCalledByEvent.length > 0) {
+                        const hasModalSetter = settersCalledByEvent.some((s) => MODAL_STATE_PATTERN.test(s));
+                        if (hasModalSetter) {
+                            const tagName = jsxPath.node.name?.name || 'unknown';
+                            interactions.push({
+                                trigger: {
+                                    event: eventName,
+                                    element: tagName,
+                                    setsState: settersCalledByEvent[0],
+                                },
+                                effect: {
+                                    type: 'conditionalRender',
+                                    waitStrategy: 'domSettle',
+                                    settleMs: 150,
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+        });
+        return interactions;
+    }
+    buildInteractionFromSetters(jsxPath, componentPath, eventName, context, settersCalledByEvent) {
+        const tagName = jsxPath.node.name?.name || 'unknown';
+        const stateVar = settersCalledByEvent[0];
+        const trigger = {
+            event: eventName,
+            element: tagName,
+            setsState: stateVar,
+        };
+        // Try to find a conditional render driven by this state variable
+        const effect = this.findConditionalEffect(jsxPath, componentPath, stateVar);
+        if (effect) {
+            return { trigger, effect };
+        }
+        // Fallback: if setter name looks modal-like, emit a domSettle effect
+        if (MODAL_STATE_PATTERN.test(stateVar)) {
+            return {
+                trigger,
+                effect: {
+                    type: 'conditionalRender',
+                    waitStrategy: 'domSettle',
+                    settleMs: 150,
+                },
+            };
+        }
+        // Generic async/loading pattern: setter name contains loading, pending, fetching
+        if (/loading|pending|fetching|submitting/i.test(stateVar)) {
+            return {
+                trigger,
+                effect: {
+                    type: 'asyncEffect',
+                    waitStrategy: 'domSettle',
+                    settleMs: 300,
+                },
+            };
+        }
+        return null;
+    }
+    /**
+     * Detect router.push() / router.replace() / navigate() calls inside a handler.
+     * Returns the destination route string if found, otherwise null.
+     */
+    resolveRouterNavigation(attr, context) {
+        if (attr.type !== 'JSXAttribute' || !attr.value || attr.value.type !== 'JSXExpressionContainer') {
+            return null;
+        }
+        const expression = attr.value.expression;
+        if (!expression)
+            return null;
+        const body = expression.type === 'ArrowFunctionExpression' || expression.type === 'FunctionExpression'
+            ? expression.body
+            : expression.type === 'Identifier'
+                ? this.findHandlerBody(expression.name, context)
+                : null;
+        if (!body)
+            return null;
+        return this.extractRouterCallFromNode(body);
+    }
+    findHandlerBody(handlerName, context) {
+        const handler = context.eventHandlers.find((h) => h.name === handlerName);
+        return handler?._body ?? null;
+    }
+    extractRouterCallFromNode(node) {
+        if (!node || typeof node !== 'object')
+            return null;
+        if (node.type === 'CallExpression') {
+            const callee = node.callee;
+            const isRouterCall = (callee?.type === 'MemberExpression' &&
+                (callee.object?.name === 'router' || callee.object?.name === 'navigate') &&
+                (callee.property?.name === 'push' || callee.property?.name === 'replace')) ||
+                (callee?.type === 'Identifier' && callee.name === 'navigate');
+            if (isRouterCall && node.arguments?.[0]?.type === 'StringLiteral') {
+                return node.arguments[0].value;
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    const found = this.extractRouterCallFromNode(child);
+                    if (found)
+                        return found;
+                }
+            }
+            else if (value && typeof value === 'object') {
+                const found = this.extractRouterCallFromNode(value);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    resolveStateSettersForAttribute(attr, context) {
+        if (attr.type !== 'JSXAttribute' || !attr.value || attr.value.type !== 'JSXExpressionContainer') {
+            return [];
+        }
+        const expression = attr.value.expression;
+        if (!expression)
+            return [];
+        const setterMap = new Map();
+        for (const stateVar of context.stateVariables) {
+            if (stateVar.setter) {
+                setterMap.set(stateVar.setter, stateVar.name);
+            }
+        }
+        if (expression.type === 'Identifier') {
+            const handler = context.eventHandlers.find((h) => h.name === expression.name);
+            return handler?.callsStateSetters ?? [];
+        }
+        if (expression.type === 'ArrowFunctionExpression' || expression.type === 'FunctionExpression') {
+            const result = new Set();
+            this.collectSettersFromNode(expression.body, setterMap, result);
+            return Array.from(result);
+        }
+        return [];
+    }
+    collectSettersFromNode(node, setterMap, result) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'CallExpression') {
+            const callee = node.callee;
+            if (callee?.type === 'Identifier') {
+                const stateName = setterMap.get(callee.name);
+                if (stateName)
+                    result.add(stateName);
+            }
+            else if (callee?.type === 'MemberExpression' && callee.property?.type === 'Identifier') {
+                const stateName = setterMap.get(callee.property.name);
+                if (stateName)
+                    result.add(stateName);
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value)
+                    this.collectSettersFromNode(child, setterMap, result);
+            }
+            else if (value && typeof value === 'object') {
+                this.collectSettersFromNode(value, setterMap, result);
+            }
+        }
+    }
+    findConditionalEffect(jsxPath, componentPath, stateVar) {
+        return (this.findConditionalEffectInAncestors(jsxPath, stateVar) ||
+            this.findConditionalEffectInComponent(componentPath, stateVar));
+    }
+    findConditionalEffectInAncestors(jsxPath, stateVar) {
+        let effectFound = null;
+        let current = jsxPath.parentPath;
+        while (current && !effectFound) {
+            const node = current.node;
+            if (node.type === 'LogicalExpression') {
+                if (this.nodeReferencesState(node.left, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.right);
+                    if (rendersWhenTrue) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue,
+                            waitStrategy: 'elementAppears',
+                            selector: `[data-clippy-component='${rendersWhenTrue}']`,
+                        };
+                    }
+                }
+            }
+            if (node.type === 'ConditionalExpression') {
+                if (this.nodeReferencesState(node.test, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.consequent);
+                    const rendersWhenFalse = this.extractComponentNameFromNode(node.alternate);
+                    if (rendersWhenTrue || rendersWhenFalse) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue: rendersWhenTrue ?? undefined,
+                            rendersWhenFalse: rendersWhenFalse ?? undefined,
+                            waitStrategy: 'elementAppears',
+                            selector: rendersWhenTrue
+                                ? `[data-clippy-component='${rendersWhenTrue}']`
+                                : undefined,
+                        };
+                    }
+                }
+            }
+            current = current.parentPath;
+        }
+        return effectFound;
+    }
+    findConditionalEffectInComponent(componentPath, stateVar) {
+        let effectFound = null;
+        componentPath.traverse({
+            LogicalExpression: (path) => {
+                if (effectFound)
+                    return;
+                const node = path.node;
+                if (this.nodeReferencesState(node.left, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.right);
+                    if (rendersWhenTrue) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue,
+                            waitStrategy: 'elementAppears',
+                            selector: `[data-clippy-component='${rendersWhenTrue}']`,
+                        };
+                    }
+                }
+            },
+            ConditionalExpression: (path) => {
+                if (effectFound)
+                    return;
+                const node = path.node;
+                if (this.nodeReferencesState(node.test, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.consequent);
+                    const rendersWhenFalse = this.extractComponentNameFromNode(node.alternate);
+                    if (rendersWhenTrue || rendersWhenFalse) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue: rendersWhenTrue ?? undefined,
+                            rendersWhenFalse: rendersWhenFalse ?? undefined,
+                            waitStrategy: 'elementAppears',
+                            selector: rendersWhenTrue
+                                ? `[data-clippy-component='${rendersWhenTrue}']`
+                                : undefined,
+                        };
+                    }
+                }
+            },
+        });
+        return effectFound;
+    }
+    nodeReferencesState(node, stateVar) {
+        if (node.type === 'Identifier' && node.name === stateVar)
+            return true;
+        if (node.type === 'MemberExpression')
+            return this.nodeReferencesState(node.object, stateVar);
+        if (node.type === 'CallExpression')
+            return this.nodeReferencesState(node.callee, stateVar);
+        if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
+            return (this.nodeReferencesState(node.left, stateVar) ||
+                this.nodeReferencesState(node.right, stateVar));
+        }
+        if (node.type === 'UnaryExpression')
+            return this.nodeReferencesState(node.argument, stateVar);
+        return false;
+    }
+    extractComponentNameFromNode(node) {
+        if (!node)
+            return null;
+        if (node.type === 'JSXElement' && node.openingElement?.name?.name) {
+            const name = node.openingElement.name.name;
+            return /^[A-Z]/.test(name) ? name : null;
+        }
+        if (node.type === 'JSXFragment')
+            return null;
+        if (node.type === 'Identifier' && /^[A-Z]/.test(node.name))
+            return node.name;
+        if (node.type === 'MemberExpression' && node.property?.name)
+            return node.property.name;
+        return null;
+    }
+}
+exports.InteractionGraphExtractor = InteractionGraphExtractor;

package/dist/extractors/SelectorGenerator.d.ts

@@ -1,5 +1,10 @@
 import type { DiscoveredElement, ElementWithSelectors } from '../types';
 export declare class SelectorGenerator {
-    generate(elements: DiscoveredElement[]): ElementWithSelectors[];
+    generate(elements: DiscoveredElement[], injectedMap?: Record<string, Array<{
+        clippyId: string;
+        component: string;
+        tag: string;
+        line: number;
+    }>>): ElementWithSelectors[];
     private generateForElement;
 }

package/dist/extractors/SelectorGenerator.js

@@ -2,15 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectorGenerator = void 0;
 class SelectorGenerator {
-    generate(elements) {
+    generate(elements, injectedMap) {
         return elements.map((el) => ({
             ...el,
-            selectors: this.generateForElement(el),
+            selectors: this.generateForElement(el, injectedMap),
         }));
     }
-    generateForElement(el) {
+    generateForElement(el, injectedMap) {
         const candidates = [];
         const p = el.staticProps;
+        // Prefer injected clippy ids when available for the element's file
+        try {
+            if (injectedMap && el.filePath) {
+                const entries = injectedMap[el.filePath];
+                if (entries && entries.length) {
+                    // Prefer exact line match when available
+                    let match = null;
+                    if (el.loc && el.loc.line) {
+                        match = entries.find((e) => e.line === el.loc.line);
+                    }
+                    // Fallback to tag/component match
+                    if (!match) {
+                        match = entries.find((e) => e.tag === el.tag);
+                    }
+                    if (match) {
+                        candidates.push({
+                            type: 'clippy_id',
+                            value: `[data-clippy-id="${match.clippyId}"]`,
+                            confidence: 0.999,
+                        });
+                    }
+                }
+            }
+        }
+        catch { }
         if (p['data-testid']) {
             candidates.push({
                 type: 'testid',

package/dist/index.d.ts

@@ -1 +1,7 @@
-export type { ClippyPluginOptions, ModuleGraphSource, RollupModuleInfo, DiscoveredRoute, DiscoveredElement, SelectorCandidate, ElementWithSelectors, FlowEdge, InferredFlow, KnowledgePackage, } from './types';
+export * from './types';
+export * from './injection/ClippyIdInjector';
+export * from './injection/IdStrategy';
+export * from './buildId';
+export * from './upload/Adapter';
+export * from './upload/BackendAdapter';
+export * from './upload/BackendUploadAdapter';

package/dist/index.js

@@ -1,2 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./injection/ClippyIdInjector"), exports);
+__exportStar(require("./injection/IdStrategy"), exports);
+__exportStar(require("./buildId"), exports);
+__exportStar(require("./upload/Adapter"), exports);
+__exportStar(require("./upload/BackendAdapter"), exports);
+__exportStar(require("./upload/BackendUploadAdapter"), exports);

package/dist/injection/ClippyIdInjector.d.ts

@@ -0,0 +1,17 @@
+export interface InjectedEntry {
+    clippyId: string;
+    component: string;
+    tag: string;
+    line: number;
+    label?: string;
+}
+export interface InjectResult {
+    source: string;
+    injectedCount: number;
+    injected: InjectedEntry[];
+}
+/**
+ * Inject data-clippy-id and data-clippy-component attributes into intrinsic HTML elements.
+ * IDs incorporate the route-derived component name and visible label text for readability.
+ */
+export declare function injectClippyIds(source: string, filePath: string, routePath?: string): InjectResult;

package/dist/injection/ClippyIdInjector.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectClippyIds = injectClippyIds;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const HtmlTagGuards_1 = require("./HtmlTagGuards");
+const IdStrategy_1 = require("./IdStrategy");
+/**
+ * Inject data-clippy-id and data-clippy-component attributes into intrinsic HTML elements.
+ * IDs incorporate the route-derived component name and visible label text for readability.
+ */
+function injectClippyIds(source, filePath, routePath) {
+    let ast;
+    try {
+        ast = (0, parser_1.parse)(source, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+            ranges: true,
+        });
+    }
+    catch {
+        return { source, injectedCount: 0, injected: [] };
+    }
+    const edits = [];
+    const injected = [];
+    (0, traverse_1.default)(ast, {
+        JSXOpeningElement(path) {
+            const opening = path.node;
+            const tagName = (0, HtmlTagGuards_1.getJSXTagName)(opening.name);
+            if (!tagName || !(0, HtmlTagGuards_1.isIntrinsicTag)(tagName))
+                return;
+            const attrs = opening.attributes;
+            if ((0, HtmlTagGuards_1.hasAttribute)(attrs, 'data-clippy-id'))
+                return;
+            // Resolve component name: prefer enclosing name, fall back to route-derived or filename
+            const enclosing = (0, IdStrategy_1.findEnclosingComponentName)(path);
+            let componentName;
+            if (enclosing && !IdStrategy_1.GENERIC_COMPONENT_NAMES.has(enclosing)) {
+                componentName = enclosing;
+            }
+            else if (routePath) {
+                componentName = (0, IdStrategy_1.deriveRouteComponentName)(routePath);
+            }
+            else {
+                componentName = (0, IdStrategy_1.deriveComponentName)(filePath);
+            }
+            const line = opening.loc?.start.line ?? 0;
+            // Extract visible label text from element children for ID enrichment
+            const labelText = extractLabelFromOpeningElement(path, attrs);
+            const clippyId = (0, IdStrategy_1.deriveClippyId)(componentName, tagName, line, routePath, labelText ?? undefined);
+            const componentAttr = (0, HtmlTagGuards_1.hasAttribute)(attrs, 'data-clippy-component')
+                ? ''
+                : ` data-clippy-component="${componentName}"`;
+            const insertText = ` data-clippy-id="${clippyId}"${componentAttr}`;
+            const insertIndex = findAttributeInsertIndex(source, opening.range);
+            if (insertIndex === null)
+                return;
+            edits.push({ index: insertIndex, text: insertText });
+            injected.push({
+                clippyId,
+                component: componentName,
+                tag: tagName,
+                line,
+                label: labelText ?? undefined,
+            });
+        },
+    });
+    if (edits.length === 0) {
+        return { source, injectedCount: 0, injected: [] };
+    }
+    const transformed = applyEdits(source, edits);
+    return { source: transformed, injectedCount: edits.length, injected };
+}
+/**
+ * Extract a usable label from the element's attributes and children.
+ * Priority: aria-label > title > visible text content > placeholder > name.
+ */
+function extractLabelFromOpeningElement(path, attrs) {
+    // Check attributes first — fastest path
+    for (const attr of attrs) {
+        if (attr.type !== 'JSXAttribute')
+            continue;
+        const name = attr.name?.name;
+        if (name !== 'aria-label' && name !== 'title')
+            continue;
+        if (attr.value?.type === 'StringLiteral')
+            return attr.value.value;
+        if (attr.value?.type === 'JSXExpressionContainer' &&
+            attr.value.expression?.type === 'StringLiteral')
+            return attr.value.expression.value;
+    }
+    // Extract visible text from children
+    const parent = path.parentPath?.node;
+    if (parent?.children) {
+        const text = extractTextFromChildren(parent.children, 0);
+        const joined = text.join(' ').trim();
+        if (joined && joined.length <= 60) {
+            const sanitized = (0, IdStrategy_1.sanitizeLabelForId)(joined);
+            if (sanitized)
+                return joined; // return raw joined text; sanitization happens in deriveClippyId
+        }
+    }
+    // Fallback to placeholder / name for inputs
+    for (const attr of attrs) {
+        if (attr.type !== 'JSXAttribute')
+            continue;
+        const name = attr.name?.name;
+        if (name !== 'placeholder' && name !== 'name')
+            continue;
+        if (attr.value?.type === 'StringLiteral')
+            return attr.value.value;
+    }
+    return null;
+}
+function extractTextFromChildren(children, depth) {
+    if (depth > 3)
+        return [];
+    const texts = [];
+    for (const child of children) {
+        if (child.type === 'JSXText') {
+            const t = child.value.trim();
+            if (t)
+                texts.push(t);
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            if (child.expression?.type === 'StringLiteral') {
+                texts.push(child.expression.value);
+            }
+            else if (child.expression?.type === 'TemplateLiteral' &&
+                child.expression.quasis?.length === 1) {
+                const raw = child.expression.quasis[0].value.raw.trim();
+                if (raw)
+                    texts.push(raw);
+            }
+        }
+        else if (child.type === 'JSXElement') {
+            const childTag = child.openingElement?.name?.name || '';
+            if (!/^(Icon|Svg|Loader|Spinner|Arrow|Check|Plus|Minus|Close|X)[A-Z]?/i.test(childTag)) {
+                texts.push(...extractTextFromChildren(child.children || [], depth + 1));
+            }
+        }
+    }
+    return texts.filter(Boolean);
+}
+function findAttributeInsertIndex(source, range) {
+    if (!range)
+        return null;
+    const end = range[1];
+    const closeCharIndex = source.lastIndexOf('>', end - 1);
+    if (closeCharIndex === -1)
+        return null;
+    return closeCharIndex;
+}
+function applyEdits(source, edits) {
+    const sorted = edits.slice().sort((a, b) => b.index - a.index);
+    let result = source;
+    for (const edit of sorted) {
+        result = result.slice(0, edit.index) + edit.text + result.slice(edit.index);
+    }
+    return result;
+}

package/dist/injection/HtmlTagGuards.d.ts

@@ -0,0 +1,3 @@
+export declare function isIntrinsicTag(tagName: string): boolean;
+export declare function getJSXTagName(name: any): string | null;
+export declare function hasAttribute(attributes: any[], name: string): boolean;

package/dist/injection/HtmlTagGuards.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIntrinsicTag = isIntrinsicTag;
+exports.getJSXTagName = getJSXTagName;
+exports.hasAttribute = hasAttribute;
+const HTML_TAGS = new Set([
+    'a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo',
+    'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup',
+    'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed',
+    'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'head', 'header', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen',
+    'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter',
+    'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture',
+    'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select',
+    'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody',
+    'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track',
+    'u', 'ul', 'var', 'video', 'wbr',
+]);
+function isIntrinsicTag(tagName) {
+    return HTML_TAGS.has(tagName);
+}
+function getJSXTagName(name) {
+    if (!name)
+        return null;
+    if (name.type === 'JSXIdentifier') {
+        return name.name;
+    }
+    if (name.type === 'JSXMemberExpression') {
+        return null;
+    }
+    if (name.type === 'JSXNamespacedName') {
+        return null;
+    }
+    return null;
+}
+function hasAttribute(attributes, name) {
+    return attributes.some((attr) => attr.type === 'JSXAttribute' &&
+        attr.name &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === name);
+}