@trojanbox-vcp-test/site-edit-engine 0.1.0 → 0.2.0

package/dist/internal/ast/locators/resolve-locator.js

@@ -1,920 +0,0 @@
-import _traverse from "@babel/traverse";
-import { createDiagnostic, locatorFailure } from "../diagnostics/index.js";
-import { parseForLocator } from "../parser/index.js";
-/* node:coverage ignore next */
-const traverse = (typeof _traverse === "function" ? _traverse : _traverse.default);
-const siblingOrdinalCache = new WeakMap();
-const structuralChildrenCache = new WeakMap();
-export function resolveLocator(source, locator) {
-    const parsed = parseForLocator(source, locator);
-    if (!parsed.ok) {
-        return locatorFailure(source, parsed.diagnostic.code, parsed.diagnostic.message, locator.kind);
-    }
-    const result = resolveLocatorPath(parsed.ast, locator);
-    if (!result.ok) {
-        return locatorFailure(source, result.diagnostic.code, result.diagnostic.message, locator.kind, result.diagnostic.details);
-    }
-    return {
-        ok: true,
-        match: {
-            locatorKind: result.match.locatorKind,
-            node: result.match.node,
-            start: result.match.start,
-            end: result.match.end,
-        },
-    };
-}
-export function resolveLocatorPath(ast, locator) {
-    if (locator.kind === "jsx-node") {
-        return resolveJsxNodeLocator(ast, locator);
-    }
-    if (locator.kind === "jsx-attribute") {
-        return resolveJsxAttributeLocator(ast, locator);
-    }
-    if (locator.kind === "value") {
-        return resolveValueLocator(ast, locator);
-    }
-    if (locator.kind === "expression") {
-        return resolveExpressionLocator(ast, locator);
-    }
-    if (locator.kind === "directive") {
-        return resolveDirectiveLocator(ast, locator);
-    }
-    if (locator.kind === "export") {
-        return resolveExportLocator(ast, locator);
-    }
-    return {
-        ok: false,
-        diagnostic: createDiagnostic("unsupported-syntax", `Unsupported locator kind: ${locator.kind}`),
-    };
-}
-function resolveJsxNodeLocator(ast, locator) {
-    return locator.strategy === "source-range"
-        ? resolveJsxNodeBySourceRange(ast, locator)
-        : resolveJsxNodeByStructuralPath(ast, locator);
-}
-function resolveJsxNodeBySourceRange(ast, locator) {
-    let best = null;
-    traverse(ast, {
-        JSXElement(path) {
-            if (!hasExactRange(path.node, locator.sourceRange)) {
-                return;
-            }
-            const candidate = toInternalMatch("jsx-node", path);
-            if (!candidate) {
-                return;
-            }
-            if (!best) {
-                best = candidate;
-                return;
-            }
-            if (candidate.end - candidate.start < best.end - best.start) {
-                best = candidate;
-            }
-        },
-    });
-    if (!best)
-        return failLocator("jsx-node", "locator-miss", "JSX node not found for source-range locator");
-    const bestMatch = best;
-    if (locator.expectedIdentity &&
-        !matchesExpectedJsxIdentity(bestMatch.path, locator.expectedIdentity)) {
-        return failLocator("jsx-node", "locator-miss", "JSX node failed expected identity validation");
-    }
-    return { ok: true, match: bestMatch };
-}
-function resolveJsxNodeByStructuralPath(ast, locator) {
-    // 检测 fragment root 作为编辑目标 — 返回明确 unsupported-syntax
-    if (locator.structuralPath === "") {
-        const componentFuncPath = findComponentFunctionPath(ast, locator.component);
-        if (componentFuncPath) {
-            const fragmentResult = checkComponentFragmentRoot(componentFuncPath);
-            if (fragmentResult) {
-                return fragmentResult;
-            }
-        }
-    }
-    let match = null;
-    traverse(ast, {
-        JSXElement(path) {
-            const candidateComponent = getEnclosingComponentName(path);
-            if (candidateComponent !== locator.component) {
-                return;
-            }
-            if (computeJsxStructuralPath(path) !== locator.structuralPath) {
-                return;
-            }
-            const candidate = toInternalMatch("jsx-node", path);
-            if (!candidate) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(path.node.loc, locator.expectedRange)) {
-                return;
-            }
-            /* node:coverage ignore start */
-            match = candidate;
-            path.stop();
-            /* node:coverage ignore stop */
-        },
-        JSXFragment(path) {
-            const candidateComponent = getEnclosingComponentName(path);
-            if (candidateComponent !== locator.component) {
-                return;
-            }
-            if (computeJsxStructuralPath(path) !==
-                locator.structuralPath) {
-                return;
-            }
-            const candidate = toInternalMatch("jsx-node", path);
-            if (!candidate) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(path.node.loc, locator.expectedRange)) {
-                return;
-            }
-            /* node:coverage ignore start */
-            match = candidate;
-            path.stop();
-            /* node:coverage ignore stop */
-        },
-    });
-    if (!match) {
-        return failLocator("jsx-node", "locator-miss", "JSX node not found for structural-path locator");
-    }
-    return { ok: true, match };
-}
-/**
- * 查找组件对应的函数节点路径
- * 支持 FunctionDeclaration、ArrowFunctionExpression、FunctionExpression
- */
-function findComponentFunctionPath(ast, componentName) {
-    let result = null;
-    traverse(ast, {
-        FunctionDeclaration(path) {
-            if (path.node.id?.name === componentName) {
-                result = path;
-                path.stop();
-            }
-        },
-        VariableDeclarator(path) {
-            if (path.node.id.type === "Identifier" &&
-                path.node.id.name === componentName) {
-                const init = path.get("init");
-                if (init.isArrowFunctionExpression() || init.isFunctionExpression()) {
-                    result = init;
-                }
-                path.stop();
-            }
-        },
-    });
-    return result;
-}
-/**
- * 检查组件函数是否返回 JSXFragment 作为根节点
- * 返回 unsupported-syntax diagnostic 或 null
- */
-function checkComponentFragmentRoot(funcPath) {
-    if (funcPath.isArrowFunctionExpression()) {
-        const body = funcPath.get("body");
-        // 块体箭头函数：检查 return 语句
-        if (body.isBlockStatement()) {
-            const returnStmt = body
-                .get("body")
-                .find((stmt) => stmt.isReturnStatement());
-            if (returnStmt) {
-                const argument = returnStmt.get("argument");
-                const target = argument.isParenthesizedExpression()
-                    ? argument.get("expression")
-                    : argument;
-                if (target.isJSXFragment()) {
-                    return failLocator("jsx-node", "unsupported-syntax", "JSXFragment is not a supported edit target");
-                }
-            }
-            return null;
-        }
-        // 简洁体箭头函数：直接检查 body
-        const target = body.isParenthesizedExpression()
-            ? body.get("expression")
-            : body;
-        if (target.isJSXFragment()) {
-            return failLocator("jsx-node", "unsupported-syntax", "JSXFragment is not a supported edit target");
-        }
-        return null;
-    }
-    if (funcPath.isFunctionDeclaration() || funcPath.isFunctionExpression()) {
-        const body = funcPath.get("body");
-        if (body.isBlockStatement()) {
-            const returnStmt = body
-                .get("body")
-                .find((stmt) => stmt.isReturnStatement());
-            if (returnStmt) {
-                const argument = returnStmt.get("argument");
-                // 处理 return ( <></> ) 的 ParenthesizedExpression 包裹
-                const target = argument.isParenthesizedExpression()
-                    ? argument.get("expression")
-                    : argument;
-                if (target.isJSXFragment()) {
-                    return failLocator("jsx-node", "unsupported-syntax", "JSXFragment is not a supported edit target");
-                }
-            }
-        }
-    }
-    return null;
-}
-function resolveJsxAttributeLocator(ast, locator) {
-    const elementMatch = resolveJsxNodeLocator(ast, locator.element);
-    if (!elementMatch.ok) {
-        return elementMatch;
-    }
-    const elementPath = elementMatch.match.path;
-    const openingElement = elementPath.get("openingElement");
-    const attributes = openingElement.get("attributes");
-    const attributePath = attributes.find((attribute) => isNamedJsxAttributePath(attribute, locator.name));
-    if (!attributePath || !attributePath.isJSXAttribute()) {
-        return failLocator("jsx-attribute", "locator-miss", `JSX attribute '${locator.name}' not found`);
-    }
-    const match = toInternalMatch("jsx-attribute", attributePath);
-    if (!match) {
-        return failLocator("jsx-attribute", "locator-miss", `JSX attribute '${locator.name}' has no source range`);
-    }
-    return { ok: true, match };
-}
-function resolveValueLocator(ast, locator) {
-    const rootPath = resolveValueRootPath(ast, locator);
-    if (!rootPath.ok) {
-        return rootPath;
-    }
-    const resolvedPath = followValuePath(rootPath.match.path, locator.path ?? []);
-    if (!resolvedPath.ok) {
-        return resolvedPath;
-    }
-    if (locator.expectedRange &&
-        !matchesRange(resolvedPath.match.path.node.loc, locator.expectedRange)) {
-        return failLocator("value", "locator-miss", "Resolved value does not match expected range");
-    }
-    return { ok: true, match: resolvedPath.match };
-}
-function resolveExpressionLocator(ast, locator) {
-    let match = null;
-    traverse(ast, {
-        Identifier(path) {
-            if (!isExpressionPath(path)) {
-                return;
-            }
-            const normalized = normalizeExpressionPath(path);
-            if (!normalized) {
-                return;
-            }
-            if (!matchesExpressionLocator(normalized, locator)) {
-                return;
-            }
-            const candidate = toInternalMatch("expression", path);
-            if (!candidate) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(path.node.loc, locator.expectedRange)) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-        MemberExpression(path) {
-            const normalized = normalizeExpressionPath(path);
-            if (!normalized) {
-                return;
-            }
-            if (!matchesExpressionLocator(normalized, locator)) {
-                return;
-            }
-            const candidate = toInternalMatch("expression", path);
-            if (!candidate) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(path.node.loc, locator.expectedRange)) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-    });
-    if (!match) {
-        return failLocator("expression", "locator-miss", "Expression not found");
-    }
-    return { ok: true, match };
-}
-function resolveDirectiveLocator(ast, locator) {
-    let match = null;
-    traverse(ast, {
-        Program(path) {
-            const directives = path.get("directives");
-            const directivePath = directives.find((directive) => directive.node.value.value === locator.value);
-            if (!directivePath) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(directivePath.node.loc, locator.expectedRange)) {
-                return;
-            }
-            const candidate = toInternalMatch("directive", directivePath);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-    });
-    if (!match) {
-        return failLocator("directive", "locator-miss", `Directive '${locator.value}' not found`);
-    }
-    return { ok: true, match };
-}
-function resolveExportLocator(ast, locator) {
-    let match = null;
-    traverse(ast, {
-        ExportNamedDeclaration(path) {
-            if (locator.exportKind === "generate-metadata") {
-                const declaration = path.get("declaration");
-                if (declaration.isFunctionDeclaration() &&
-                    declaration.node.id?.name === "generateMetadata") {
-                    const candidate = toInternalMatch("export", declaration);
-                    if (!candidate) {
-                        return;
-                    }
-                    if (locator.expectedRange &&
-                        !matchesRange(declaration.node.loc, locator.expectedRange)) {
-                        return;
-                    }
-                    match = candidate;
-                    path.stop();
-                    return;
-                }
-                if (!declaration.isVariableDeclaration()) {
-                    return;
-                }
-                const declarator = findNamedVariableDeclarator(declaration, "generateMetadata");
-                if (!declarator || !declarator.isVariableDeclarator()) {
-                    return;
-                }
-                const initPath = declarator.get("init");
-                if (!initPath.node) {
-                    return;
-                }
-                const candidate = toInternalMatch("export", initPath);
-                if (!candidate) {
-                    return;
-                }
-                if (locator.expectedRange &&
-                    !matchesRange(initPath.node.loc, locator.expectedRange)) {
-                    return;
-                }
-                match = candidate;
-                path.stop();
-                return;
-            }
-            const declaration = path.get("declaration");
-            if (!declaration.isVariableDeclaration()) {
-                return;
-            }
-            const declarator = findNamedVariableDeclarator(declaration, locator.exportKind === "named" ? locator.name : "metadata");
-            if (!declarator || !declarator.isVariableDeclarator()) {
-                return;
-            }
-            const initPath = declarator.get("init");
-            if (!initPath.node) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(initPath.node.loc, locator.expectedRange)) {
-                return;
-            }
-            const candidate = toInternalMatch("export", initPath);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-        ExportDefaultDeclaration(path) {
-            if (locator.exportKind !== "default") {
-                return;
-            }
-            const declaration = path.get("declaration");
-            const candidate = toInternalMatch("export", declaration);
-            if (!candidate) {
-                return;
-            }
-            if (locator.expectedRange &&
-                !matchesRange(declaration.node.loc, locator.expectedRange)) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-    });
-    if (!match) {
-        return failLocator("export", "export-not-found", `Export '${describeExport(locator)}' not found`);
-    }
-    return { ok: true, match };
-}
-function resolveValueRootPath(ast, locator) {
-    let match = null;
-    traverse(ast, {
-        Expression(path) {
-            if (match || locator.root.kind !== "expression") {
-                return;
-            }
-            if (!hasExactRange(path.node, locator.root.sourceRange)) {
-                return;
-            }
-            const candidate = toInternalMatch("value", path);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-        VariableDeclarator(path) {
-            if (match) {
-                return;
-            }
-            if (locator.root.kind === "binding") {
-                if (path.node.id.type !== "Identifier" ||
-                    path.node.id.name !== locator.root.name) {
-                    return;
-                }
-                const initPath = path.get("init");
-                if (!initPath.node) {
-                    return;
-                }
-                const candidate = toInternalMatch("value", initPath);
-                if (!candidate) {
-                    return;
-                }
-                match = candidate;
-                path.stop();
-                return;
-            }
-            if (locator.root.kind !== "hook-state") {
-                return;
-            }
-            const hookStateRoot = locator.root;
-            const idPath = path.get("id");
-            const initPath = path.get("init");
-            if (!idPath.isArrayPattern() || !initPath.isCallExpression()) {
-                return;
-            }
-            const stateIndex = idPath.node.elements.findIndex((element) => element?.type === "Identifier" && element.name === hookStateRoot.name);
-            if (stateIndex !== 0) {
-                return;
-            }
-            const callee = initPath.node.callee;
-            const hookName = callee.type === "Identifier"
-                ? callee.name
-                : callee.type === "MemberExpression" &&
-                    callee.property.type === "Identifier"
-                    ? callee.property.name
-                    : null;
-            if (hookName !== hookStateRoot.hook) {
-                return;
-            }
-            const argIndex = hookStateRoot.hook === "useReducer" ? 1 : 0;
-            const argPath = path.get(`init.arguments.${argIndex}`);
-            if (!argPath || Array.isArray(argPath) || !argPath.node) {
-                return;
-            }
-            const candidate = toInternalMatch("value", argPath);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-        ExportNamedDeclaration(path) {
-            if (match || locator.root.kind !== "named-export") {
-                return;
-            }
-            const declaration = path.get("declaration");
-            if (!declaration.isVariableDeclaration()) {
-                return;
-            }
-            const declarator = findNamedVariableDeclarator(declaration, locator.root.name);
-            if (!declarator || !declarator.isVariableDeclarator()) {
-                return;
-            }
-            const initPath = declarator.get("init");
-            if (!initPath.node) {
-                return;
-            }
-            const candidate = toInternalMatch("value", initPath);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-        ExportDefaultDeclaration(path) {
-            if (match || locator.root.kind !== "default-export") {
-                return;
-            }
-            const declaration = path.get("declaration");
-            const candidate = toInternalMatch("value", declaration);
-            if (!candidate) {
-                return;
-            }
-            match = candidate;
-            path.stop();
-        },
-    });
-    if (!match)
-        return failLocator("value", locator.root.kind === "named-export" ||
-            locator.root.kind === "default-export"
-            ? "export-not-found"
-            : locator.root.kind === "expression"
-                ? "locator-miss"
-                : "binding-not-found", "Value root was not found");
-    return { ok: true, match };
-}
-function followValuePath(path, segments) {
-    let current = unwrapValueAssertion(path);
-    for (const segment of segments) {
-        current = unwrapValueAssertion(current);
-        if (segment.kind === "property") {
-            if (!current.isObjectExpression()) {
-                return failLocator("value", "unsupported-syntax", "Property path requires object expression");
-            }
-            const properties = current.get("properties");
-            if (properties.some((property) => !property.isObjectProperty())) {
-                return failLocator("value", "unsupported-syntax", "Spread properties are not supported");
-            }
-            const propertyPath = properties.find((property) => matchesObjectPropertyName(property, segment.name));
-            if (!propertyPath || !propertyPath.isObjectProperty()) {
-                return failLocator("value", "property-not-found", `Property '${segment.name}' not found`);
-            }
-            current = propertyPath.get("value");
-            continue;
-        }
-        if (!current.isArrayExpression()) {
-            return failLocator("value", "unsupported-syntax", "Array index path requires array expression");
-        }
-        const elements = current.get("elements");
-        if (elements.some((element) => element.node?.type === "SpreadElement")) {
-            return failLocator("value", "unsupported-syntax", "Spread array elements are not supported");
-        }
-        const elementPath = elements[segment.index];
-        if (!elementPath?.node) {
-            return failLocator("value", "array-index-out-of-range", `Array index ${segment.index} is out of range`);
-        }
-        current = elementPath;
-    }
-    current = unwrapValueAssertion(current);
-    /* node:coverage ignore start */
-    const match = toInternalMatch("value", current);
-    if (!match) {
-        return failLocator("value", "locator-miss", "Resolved value has no source range");
-    }
-    return { ok: true, match };
-    /* node:coverage ignore stop */
-}
-function unwrapValueAssertion(path) {
-    let current = path;
-    while (current.isTSAsExpression() ||
-        current.isTSSatisfiesExpression() ||
-        current.isTSNonNullExpression()) {
-        current = current.get("expression");
-    }
-    return current;
-}
-function toInternalMatch(locatorKind, path) {
-    const node = path.node;
-    if (node.start == null || node.end == null) {
-        return null;
-    }
-    return {
-        locatorKind,
-        node,
-        start: node.start,
-        end: node.end,
-        path,
-    };
-}
-function hasExactRange(node, sourceRange) {
-    return matchesRange(node.loc, sourceRange);
-}
-function matchesRange(loc, range) {
-    if (!loc) {
-        return false;
-    }
-    return (loc.start.line === range.startLine &&
-        loc.start.column === range.startColumn &&
-        loc.end.line === range.endLine &&
-        loc.end.column === range.endColumn);
-}
-function computeJsxStructuralPath(path) {
-    const segments = [];
-    let current = path;
-    const targetNode = path.node;
-    while (current) {
-        if (current.isJSXElement()) {
-            const tagName = getJsxTagName(current.node.openingElement);
-            if (tagName) {
-                if (/^[A-Z]/.test(tagName)) {
-                    segments.unshift(`component:${tagName}#${computeSiblingOrdinal(current, tagName)}`);
-                }
-                else {
-                    segments.unshift(`${tagName}#${computeSiblingOrdinal(current, tagName)}`);
-                }
-            }
-        }
-        else if (current.isJSXFragment() && current.node === targetNode) {
-            segments.unshift("fragment");
-        }
-        if (!current.parentPath || isComponentBoundary(current.parentPath))
-            break;
-        current = current.parentPath;
-    }
-    return segments.join("/");
-}
-function computeSiblingOrdinal(path, tagName) {
-    const owner = findStructuralParent(path);
-    if (!owner) {
-        return 0;
-    }
-    const cached = siblingOrdinalCache
-        .get(owner.node)
-        ?.get(tagName)
-        ?.get(path.node);
-    if (cached !== undefined) {
-        return cached;
-    }
-    let ordinal = 0;
-    let tagOrdinals = siblingOrdinalCache.get(owner.node)?.get(tagName);
-    if (!tagOrdinals) {
-        let containerCache = siblingOrdinalCache.get(owner.node);
-        if (!containerCache) {
-            containerCache = new Map();
-            siblingOrdinalCache.set(owner.node, containerCache);
-        }
-        tagOrdinals = new WeakMap();
-        containerCache.set(tagName, tagOrdinals);
-    }
-    for (const sibling of collectStructuralChildren(owner)) {
-        if (getJsxTagName(sibling.node.openingElement) === tagName) {
-            tagOrdinals.set(sibling.node, ordinal);
-            if (sibling.node === path.node) {
-                return ordinal;
-            }
-            ordinal++;
-        }
-    }
-    return tagOrdinals.get(path.node) ?? 0;
-}
-function findStructuralParent(path) {
-    let current = path.parentPath;
-    let fragmentOwner = null;
-    while (current) {
-        if (current.isJSXFragment()) {
-            fragmentOwner = current;
-            current = current.parentPath;
-            continue;
-        }
-        if (current.isJSXElement()) {
-            return current;
-        }
-        current = current.parentPath;
-    }
-    return fragmentOwner;
-}
-function collectStructuralChildren(owner) {
-    const cached = structuralChildrenCache.get(owner.node);
-    if (cached) {
-        return cached;
-    }
-    const structuralChildren = [];
-    const children = owner.get("children");
-    for (const child of children) {
-        if (Array.isArray(child)) {
-            continue;
-        }
-        if (child.isJSXElement()) {
-            structuralChildren.push(child);
-            continue;
-        }
-        if (child.isJSXFragment()) {
-            structuralChildren.push(...collectStructuralChildren(child));
-            continue;
-        }
-        if (child.isJSXExpressionContainer()) {
-            structuralChildren.push(...collectExpressionStructuralChildren(child.get("expression")));
-        }
-    }
-    structuralChildrenCache.set(owner.node, structuralChildren);
-    return structuralChildren;
-}
-function collectExpressionStructuralChildren(expression) {
-    if (expression.isJSXElement()) {
-        return [expression];
-    }
-    if (expression.isJSXFragment()) {
-        return collectStructuralChildren(expression);
-    }
-    if (expression.isParenthesizedExpression()) {
-        return collectExpressionStructuralChildren(expression.get("expression"));
-    }
-    if (expression.isLogicalExpression() && expression.node.operator === "&&") {
-        return collectExpressionStructuralChildren(expression.get("right"));
-    }
-    if (expression.isConditionalExpression()) {
-        return [
-            ...collectExpressionStructuralChildren(expression.get("consequent")),
-            ...collectExpressionStructuralChildren(expression.get("alternate")),
-        ];
-    }
-    if (expression.isArrayExpression()) {
-        return expression.get("elements").flatMap((element) => {
-            if (Array.isArray(element) || !element.node || !element.isExpression()) {
-                return [];
-            }
-            return collectExpressionStructuralChildren(element);
-        });
-    }
-    return [];
-}
-function getJsxTagName(openingElement) {
-    if (openingElement.name.type === "JSXIdentifier") {
-        return openingElement.name.name;
-    }
-    if (openingElement.name.type === "JSXMemberExpression") {
-        return flattenJsxMemberExpression(openingElement.name);
-    }
-    return null;
-}
-function flattenJsxMemberExpression(expression) {
-    const parts = [];
-    let current = expression;
-    while (current.type === "JSXMemberExpression") {
-        parts.unshift(current.property.name);
-        current = current.object;
-    }
-    parts.unshift(current.name);
-    return parts.join(".");
-}
-function getEnclosingComponentName(path) {
-    let current = path;
-    while (current) {
-        if (current.isFunctionDeclaration()) {
-            return current.node.id?.name ?? null;
-        }
-        if ((current.isArrowFunctionExpression() || current.isFunctionExpression()) &&
-            current.parentPath?.isVariableDeclarator()) {
-            const id = current.parentPath.node.id;
-            return id.type === "Identifier" ? id.name : null;
-        }
-        current = current.parentPath;
-    }
-    return null;
-}
-function isComponentBoundary(path) {
-    if (path.isFunctionDeclaration() ||
-        path.isFunctionExpression() ||
-        path.isArrowFunctionExpression()) {
-        return true;
-    }
-    return false;
-}
-function isExpressionPath(path) {
-    if (!path.isExpression()) {
-        return false;
-    }
-    if (path.parentPath?.isMemberExpression({ property: path.node })) {
-        return false;
-    }
-    return true;
-}
-function normalizeExpressionPath(path) {
-    if (path.isIdentifier()) {
-        return {
-            base: path.node.name,
-            path: [],
-        };
-    }
-    if (!path.isMemberExpression()) {
-        return null;
-    }
-    const segments = [];
-    let current = path.node;
-    while (current.type === "MemberExpression") {
-        if (current.computed) {
-            if (current.property.type === "NumericLiteral") {
-                segments.unshift({ kind: "index", index: current.property.value });
-            }
-            else if (current.property.type === "StringLiteral") {
-                segments.unshift({ kind: "property", name: current.property.value });
-            }
-            else {
-                return null;
-            }
-        }
-        else if (current.property.type === "Identifier") {
-            segments.unshift({ kind: "property", name: current.property.name });
-        }
-        else {
-            return null;
-        }
-        if (current.object.type === "Identifier") {
-            return {
-                base: current.object.name,
-                path: segments,
-            };
-        }
-        if (current.object.type !== "MemberExpression") {
-            return null;
-        }
-        current = current.object;
-    }
-    return null;
-}
-function matchesExpressionLocator(expression, locator) {
-    return (expression.base === locator.base &&
-        sameValuePath(expression.path, locator.path ?? []));
-}
-function sameValuePath(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    for (let index = 0; index < left.length; index += 1) {
-        const leftSegment = left[index];
-        const rightSegment = right[index];
-        if (leftSegment.kind !== rightSegment.kind) {
-            return false;
-        }
-        if (leftSegment.kind === "property") {
-            if (rightSegment.kind !== "property" ||
-                leftSegment.name !== rightSegment.name) {
-                return false;
-            }
-            continue;
-        }
-        if (rightSegment.kind !== "index" ||
-            leftSegment.index !== rightSegment.index) {
-            return false;
-        }
-    }
-    return true;
-}
-function getObjectPropertyKey(node) {
-    if (node.key.type === "Identifier") {
-        return node.key.name;
-    }
-    if (node.key.type === "StringLiteral") {
-        return node.key.value;
-    }
-    return null;
-}
-function describeExport(locator) {
-    if (locator.exportKind === "named") {
-        return locator.name;
-    }
-    return locator.exportKind;
-}
-function failLocator(locatorKind, code, message, details) {
-    return {
-        ok: false,
-        diagnostic: createDiagnostic(code, message, locatorKind, details),
-    };
-}
-function matchesExpectedJsxIdentity(path, expectedIdentity) {
-    const component = getEnclosingComponentName(path);
-    if (component !== expectedIdentity.component) {
-        return false;
-    }
-    return computeJsxStructuralPath(path) === expectedIdentity.structuralPath;
-}
-function isNamedJsxAttributePath(attribute, name) {
-    if (!attribute.isJSXAttribute()) {
-        return false;
-    }
-    if (attribute.node.name.type !== "JSXIdentifier") {
-        return false;
-    }
-    return attribute.node.name.name === name;
-}
-function findNamedVariableDeclarator(declaration, name) {
-    return declaration.get("declarations").find((item) => {
-        if (!item.isVariableDeclarator()) {
-            return false;
-        }
-        if (item.node.id.type !== "Identifier") {
-            return false;
-        }
-        return item.node.id.name === name;
-    });
-}
-function matchesObjectPropertyName(property, name) {
-    if (!property.isObjectProperty()) {
-        return false;
-    }
-    return getObjectPropertyKey(property.node) === name;
-}