@starci/eslint-grammar-core 0.13.0 → 0.14.0

package/dist/lib/app-shell-owner-source.js

@@ -0,0 +1,159 @@
+/** Resolve only an imported header's owned source and selected public export. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+import parser from "@typescript-eslint/parser";
+import { SourceCode } from "eslint";
+import { importOf, variableOf } from "@starci/eslint-canon-fe/lib/bindings.mjs";
+import { resolveImport } from "@starci/eslint-canon-fe/lib/scope.mjs";
+import { hfsOf } from "@starci/eslint-canon-fe/lib/hfs.mjs";
+import { walk } from "@starci/eslint-canon-fe/lib/ast.mjs";
+import { loadArchitectureConfig } from "../../runtime/scripts/hfs/architecture/config.mjs";
+import { workspaceSourceEntry } from "../../runtime/scripts/hfs/architecture/typescript.mjs";
+import { openHfs } from "../../runtime/scripts/hfs/slots.mjs";
+const RUNTIME = fileURLToPath(new URL("../../runtime/", import.meta.url));
+const roots = new WeakMap();
+const origins = new WeakMap();
+const stateOf = (context) => {
+    const root = hfsOf(context).repoRoot;
+    const snapshot = origins.get(context.sourceCode) ?? context.sourceCode;
+    let state = roots.get(snapshot);
+    if (state === undefined) {
+        state = { root, files: new Map(), proofs: new Map(), workspaces: null };
+        roots.set(snapshot, state);
+    }
+    return state;
+};
+/** A workspace package from the text of its `package.json`. */
+const workspaceOf = (root, text) => {
+    const manifest = JSON.parse(text);
+    const record = typeof manifest === "object" && manifest !== null ? manifest : {};
+    return {
+        root,
+        workspace: true,
+        name: "name" in record && typeof record.name === "string" ? record.name : null,
+        manifest,
+        exports: "exports" in record ? record.exports : undefined,
+    };
+};
+const workspaceFile = (context, source) => {
+    const state = stateOf(context);
+    if (!state.workspaces) {
+        const hfs = openHfs({ root: RUNTIME, repoRoot: state.root });
+        const config = loadArchitectureConfig(state.root, { hfs });
+        state.workspaces = config.workspaces.map((relative) => {
+            const root = path.join(state.root, relative);
+            return workspaceOf(root, fs.readFileSync(path.join(root, "package.json"), "utf8"));
+        });
+    }
+    const workspace = state.workspaces.find((entry) => entry.name && (source === entry.name || source.startsWith(`${entry.name}/`)));
+    return workspace ? workspaceSourceEntry(ts, workspace, source) : null;
+};
+const sourceFile = (context, source) => {
+    const target = resolveImport(context, source) ?? workspaceFile(context, source);
+    if (!target)
+        return null;
+    const hfs = hfsOf(context);
+    return [target, `${target}.tsx`, `${target}.ts`, `${target}/index.tsx`, `${target}/index.ts`]
+        .find((file) => /\.[cm]?[jt]sx?$/i.test(file) && !/\.d\.[cm]?ts$/i.test(file) && ts.sys.fileExists(file) && hfs.classify(file).status === "owned") ?? null;
+};
+/** Record the parent of a child node: the parser leaves it to ESLint's traversal, which this independent parse bypasses. */
+const adopt = (child, parent) => {
+    if (typeof child === "object" && child !== null && "type" in child && child.type)
+        Reflect.set(child, "parent", parent);
+};
+const sourceContext = (context, filename) => {
+    const state = stateOf(context);
+    const known = state.files.get(filename);
+    if (known)
+        return known;
+    const text = fs.readFileSync(filename, "utf8");
+    const parsed = parser.parseForESLint(text, { filePath: filename, sourceType: "module", ecmaFeatures: { jsx: true }, range: true, loc: true, tokens: true, comment: true });
+    const sourceCode = new SourceCode({
+        text,
+        ast: parsed.ast,
+        scopeManager: parsed.scopeManager,
+        visitorKeys: parsed.visitorKeys,
+        parserServices: parsed.services,
+    });
+    const view = sourceCode;
+    walk(view, parsed.ast, (node) => {
+        for (const key of view.visitorKeys[node.type] ?? []) {
+            const value = Reflect.get(node, key);
+            const values = Array.isArray(value) ? value : [value];
+            for (const child of values)
+                adopt(child, node);
+        }
+    });
+    const owned = { filename, sourceCode: view, settings: context.settings, program: parsed.ast };
+    origins.set(view, origins.get(context.sourceCode) ?? context.sourceCode);
+    state.files.set(filename, owned);
+    return owned;
+};
+const moduleContext = (context, source) => {
+    const filename = sourceFile(context, source);
+    return filename ? sourceContext(context, filename) : null;
+};
+const namedDeclaration = (declaration, name) => {
+    if (declaration?.type === "FunctionDeclaration")
+        return declaration.id?.name === name ? declaration : null;
+    if (declaration?.type !== "VariableDeclaration")
+        return null;
+    return declaration.declarations.find((entry) => entry.id.type === "Identifier" && entry.id.name === name)?.init ?? null;
+};
+/** The name an export specifier spells: an identifier's name or a string literal's value. */
+const specifierName = (name) => (name.type === "Identifier" ? name.name : name.value);
+const namedExport = (context, statement, name, visited) => {
+    const value = namedDeclaration(statement.declaration, name);
+    if (value)
+        return { matched: true, owner: { context, value } };
+    const specifier = statement.specifiers.find((entry) => specifierName(entry.exported) === name);
+    if (!specifier)
+        return { matched: false };
+    if (!statement.source)
+        return { matched: true, owner: { context, value: specifier.local } };
+    const target = moduleContext(context, String(statement.source.value));
+    return { matched: true, owner: target ? headerExport(target, specifierName(specifier.local), visited) : null };
+};
+/** The selected exported value, following public barrels without scanning unrelated imported implementations. */
+const headerExport = (context, name, seen = new Set()) => {
+    const key = `${context.filename}:${name}`;
+    if (seen.has(key))
+        return null;
+    const visited = new Set(seen).add(key);
+    for (const statement of context.program.body) {
+        if (statement.type === "ExportDefaultDeclaration" && name === "default")
+            return { context, value: statement.declaration };
+        if (statement.type === "ExportNamedDeclaration") {
+            const found = namedExport(context, statement, name, visited);
+            if (found.matched)
+                return found.owner;
+        }
+        if (statement.type === "ExportAllDeclaration") {
+            const target = moduleContext(context, String(statement.source.value));
+            const found = target && headerExport(target, name, visited);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+};
+/** An imported JSX owner, or null when its implementation cannot be proved from owned source. */
+export const importedHeader = (context, opening) => {
+    const name = opening.name;
+    const identifier = name.type === "JSXIdentifier" ? name : name.type === "JSXMemberExpression" ? name.object : null;
+    if (identifier?.type !== "JSXIdentifier")
+        return null;
+    const imported = importOf(context, identifier);
+    if (!imported)
+        return null;
+    const definition = variableOf(context, identifier)?.defs.find((entry) => entry.type === "ImportBinding");
+    if (name.type === "JSXMemberExpression" && definition?.node.type !== "ImportNamespaceSpecifier")
+        return null;
+    const target = moduleContext(context, imported.source);
+    const exported = name.type === "JSXMemberExpression" ? name.property.name : imported.imported ?? "default";
+    return target ? headerExport(target, exported) : null;
+};
+/** The per-repository proof cache shares the same lifetime as parsed header source. */
+export const headerProofs = (context) => stateOf(context).proofs;

package/dist/lib/app-shell-owner.d.ts

@@ -0,0 +1,7 @@
+/** Imported shell-band delegation requires its canonical composition in every visible source alternative. */
+import type { TSESTree } from "@typescript-eslint/types";
+import type { ReaderContext, Resolved } from "./types.ts";
+/** True only for an imported JSX header whose owned implementation reaches a canonical Grammar bar. */
+export declare const provesImportedBar: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => boolean | null;
+/** True only when every visible compact-header alternative reaches a left Drawer with a drawer Sidebar. */
+export declare const provesNavigationOpener: (context: ReaderContext, expression: Resolved | null | undefined) => boolean;

package/dist/lib/app-shell-owner.js

@@ -0,0 +1,97 @@
+import { functionOf, importOf } from "@starci/eslint-canon-fe/lib/bindings.mjs";
+import { isBarControl, propOf, realNode, resolveLocal, textProp } from "./app-shell.js";
+import { isNavigationDrawer } from "./app-shell-scope.js";
+import { visitFunction, visitVisible } from "./app-shell-visible.js";
+import { headerProofs, importedHeader } from "./app-shell-owner-source.js";
+const OVERLAYS = new Set(["Dialog", "AlertDialog", "Drawer", "Popover", "DropdownMenu", "Tooltip"]);
+const importBinding = (context, opening) => {
+    const name = opening.name.type === "JSXMemberExpression" ? opening.name.object : opening.name;
+    return name.type === "JSXIdentifier" ? importOf(context, name) : null;
+};
+const reactFragment = (context, opening) => {
+    const imported = importBinding(context, opening);
+    return imported?.source === "react" && (imported.imported === "Fragment" || opening.name.type === "JSXMemberExpression" && opening.name.property.name === "Fragment");
+};
+const proveOwner = (owner, seen, kind) => {
+    if (!owner)
+        return false;
+    const { context, value } = owner;
+    const key = `${kind}:${context.filename}:${value.range.join(":")}`;
+    const proofs = headerProofs(context);
+    const known = proofs.get(key);
+    if (known !== undefined)
+        return known;
+    if (seen.has(key))
+        return false;
+    const fn = functionOf(context, realNode(resolveLocal(context, value)));
+    const valid = fn !== null && proveComposition(context, (visit, branch) => visitFunction(context, fn, visit, new Set(), branch, []), new Set(seen).add(key), kind);
+    proofs.set(key, valid);
+    return valid;
+};
+/** Drawer bodies must expose navigation on every branch, outside nested overlay content. */
+const proveDrawerBody = (context, opening, seen) => proveComposition(context, (visit, branch) => {
+    const children = opening.parent.children.filter((child) => child.type !== "JSXText" || child.value.trim());
+    if (children.length)
+        for (const child of children)
+            visitVisible(context, child, visit, new Set(), branch);
+    else
+        visitVisible(context, propOf(context, opening, "children").value, visit, new Set(), branch);
+}, seen, "sidebar");
+const matchesComposition = (context, opening, name, seen, kind) => {
+    if (kind === "drawer")
+        return isNavigationDrawer(context, opening) && proveDrawerBody(context, opening, seen);
+    if (kind === "sidebar")
+        return name === "Sidebar" && textProp(context, opening, "presentation") === "drawer";
+    return name !== null && ["TopBar", "NavigationFeatureNav"].includes(name);
+};
+const proveComposition = (context, render, seen, kind) => {
+    const pending = [new Map()];
+    for (let choices = pending.pop(); choices; choices = pending.pop()) {
+        const current = choices;
+        const branch = [];
+        let found = false;
+        let unknown = false;
+        render((opening, name) => {
+            if (reactFragment(context, opening))
+                return;
+            if (matchesComposition(context, opening, name, seen, kind)) {
+                found = true;
+                return false;
+            }
+            if (name !== null && OVERLAYS.has(name))
+                return false;
+            if (kind === "bar" && (name !== null && ["header", "nav", "main"].includes(name) || isBarControl(context, opening, name))) {
+                unknown = true;
+                return false;
+            }
+            if (name === null && importBinding(context, opening)) {
+                if (proveOwner(importedHeader(context, opening), seen, kind))
+                    found = true;
+                else
+                    unknown = true;
+                return false;
+            }
+            return undefined;
+        }, (node) => {
+            if (!current.has(node))
+                branch.push(node);
+            return current.get(node) ?? "consequent";
+        });
+        const missing = branch.find((node) => !current.has(node));
+        if (missing)
+            pending.push(new Map([...choices, [missing, "alternate"]]), new Map([...choices, [missing, "consequent"]]));
+        else if (!found || unknown)
+            return false;
+    }
+    return true;
+};
+/** True only for an imported JSX header whose owned implementation reaches a canonical Grammar bar. */
+export const provesImportedBar = (context, opening) => {
+    if (reactFragment(context, opening))
+        return null;
+    if (!importBinding(context, opening))
+        return null;
+    return proveOwner(importedHeader(context, opening), new Set(), "bar");
+};
+/** True only when every visible compact-header alternative reaches a left Drawer with a drawer Sidebar. */
+export const provesNavigationOpener = (context, expression) => proveComposition(context, (visit, branch) => visitVisible(context, expression, visit, new Set(), branch), new Set(), "drawer");

package/dist/lib/app-shell-scope.d.ts

@@ -0,0 +1,13 @@
+/** Structural app-shell ownership, distinct from generic flow-based site chrome. */
+import type { TSESTree } from "@typescript-eslint/types";
+import type { ReaderContext } from "./types.ts";
+/** A workspace identity or a sidebar/navigation slot identifies an application shell structurally. */
+export declare const isAppShell: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => boolean;
+/** A left Drawer containing a drawer Sidebar is the mobile navigation opener, including an extracted client owner. */
+export declare const isNavigationDrawer: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => boolean;
+/** Shell-named React owners and the HFS layout kind compose an app frame, rather than page-local navigation. */
+export declare const ownsAppFrame: (context: ReaderContext, node: TSESTree.JSXOpeningElement) => boolean;
+/** Every visible opening hosted by a structurally identified app shell in this source file. */
+export declare const appBarOpenings: (context: ReaderContext) => Set<TSESTree.JSXOpeningElement>;
+/** Grammar bars are app bars unless an explicit generic flow shell establishes site-chrome ownership. */
+export declare const isAppBar: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => boolean;

package/dist/lib/app-shell-scope.js

@@ -0,0 +1,93 @@
+import { walk } from "@starci/eslint-canon-fe/lib/ast.mjs";
+import { kindOfFile, roleOfFile } from "@starci/eslint-canon-fe/lib/scope.mjs";
+import { grammarName, propOf, textProp } from "./app-shell.js";
+import { visitVisible } from "./app-shell-visible.js";
+/** A workspace identity or a sidebar/navigation slot identifies an application shell structurally. */
+export const isAppShell = (context, opening) => {
+    if (grammarName(context, opening) !== "WorkspaceShell")
+        return false;
+    const viewport = textProp(context, opening, "viewport");
+    if (viewport === "fixed" || viewport !== "flow" && ownsAppFrame(context, opening))
+        return true;
+    const navigation = propOf(context, opening, "navigation");
+    if (navigation.value !== null || !navigation.known)
+        return true;
+    let identity = false;
+    visitVisible(context, propOf(context, opening, "header").value, (_node, name) => {
+        if (name === "IdentityLockup")
+            identity = true;
+    });
+    return identity;
+};
+/** A left Drawer containing a drawer Sidebar is the mobile navigation opener, including an extracted client owner. */
+export const isNavigationDrawer = (context, opening) => {
+    if (grammarName(context, opening) !== "Drawer" || textProp(context, opening, "placement") !== "left")
+        return false;
+    let sidebar = false;
+    const inspect = (node, name) => {
+        if (name === "Sidebar" && textProp(context, node, "presentation") === "drawer")
+            sidebar = true;
+    };
+    for (const child of opening.parent.children)
+        visitVisible(context, child, inspect);
+    visitVisible(context, propOf(context, opening, "children").value, inspect);
+    return sidebar;
+};
+/** Shell-named React owners and the HFS layout kind compose an app frame, rather than page-local navigation. */
+export const ownsAppFrame = (context, node) => {
+    if (kindOfFile(context) === "layouts" || roleOfFile(context) === "layout")
+        return true;
+    let rendered = null;
+    let shellName = false;
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === "ReturnStatement")
+            rendered = current.argument;
+        if (current.type === "FunctionDeclaration") {
+            shellName = /Shell(?:Base)?$/.test(current.id?.name ?? "");
+            break;
+        }
+        if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+            rendered ??= current.body;
+            shellName = current.parent?.type === "VariableDeclarator" && /Shell(?:Base)?$/.test(current.parent.id.type === "Identifier" ? current.parent.id.name : "");
+            break;
+        }
+    }
+    if (shellName)
+        return true;
+    let sidebar = false;
+    visitVisible(context, rendered, (_opening, name) => { if (name === "Sidebar")
+        sidebar = true; });
+    return sidebar;
+};
+const APP_BAR_CACHE = new WeakMap();
+/** Every visible opening hosted by a structurally identified app shell in this source file. */
+export const appBarOpenings = (context) => {
+    const source = context.sourceCode;
+    const cached = APP_BAR_CACHE.get(source);
+    if (cached)
+        return cached;
+    const openings = new Set();
+    walk(source, source.ast, (node) => {
+        if (node.type !== "JSXOpeningElement" || !isAppShell(context, node))
+            return;
+        for (const slot of ["header", "compactHeader"]) {
+            visitVisible(context, propOf(context, node, slot).value, (opening) => { openings.add(opening); });
+        }
+    });
+    APP_BAR_CACHE.set(source, openings);
+    return openings;
+};
+/** Grammar bars are app bars unless an explicit generic flow shell establishes site-chrome ownership. */
+export const isAppBar = (context, opening) => {
+    const barName = grammarName(context, opening);
+    if (barName !== "TopBar" && barName !== "NavigationFeatureNav")
+        return false;
+    for (let current = opening.parent; current; current = current.parent) {
+        if (current.type !== "JSXElement")
+            continue;
+        const shell = current.openingElement;
+        if (grammarName(context, shell) === "WorkspaceShell" && textProp(context, shell, "viewport") === "flow" && !isAppShell(context, shell))
+            return false;
+    }
+    return true;
+};

package/dist/lib/app-shell-visible.d.ts

@@ -0,0 +1,13 @@
+/** Traverse only the visible bar composition and its local React owners. */
+import type { TSESTree } from "@typescript-eslint/types";
+import type { FunctionNode, Node, ReaderContext, Resolved } from "./types.ts";
+/** Which side of a conditional the traversal follows: one branch, or `both`. */
+export type Choice = "consequent" | "alternate" | "both";
+/** Called for every visible opening element; returning `false` skips its slots and children. */
+export type Visit = (opening: TSESTree.JSXOpeningElement, name: string | null, ancestors: readonly TSESTree.JSXOpeningElement[]) => boolean | void;
+/** Decides, per conditional node, which branch to follow. */
+export type Branch = (node: Node) => Choice;
+/** Visible JSX composition only: menu, popover and drawer bodies are outside the navbar band. */
+export declare const visitVisible: (context: ReaderContext, expression: Resolved | null | undefined, visit: Visit, seen?: Set<Resolved>, branch?: Branch, ancestors?: readonly TSESTree.JSXOpeningElement[]) => void;
+/** Visit a rendered owner's returns with the same branch, overlay and local-binding semantics as inline JSX. */
+export declare const visitFunction: (context: ReaderContext, fn: FunctionNode, visit: Visit, seen: Set<Resolved>, branch: Branch, ancestors: readonly TSESTree.JSXOpeningElement[]) => void;

package/dist/lib/app-shell-visible.js

@@ -0,0 +1,117 @@
+import { functionOf, variableOf } from "@starci/eslint-canon-fe/lib/bindings.mjs";
+import { grammarName, propOf, realNode, resolveLocal } from "./app-shell.js";
+const BAR_SLOTS = {
+    WorkspaceShell: ["header", "compactHeader"],
+    TopBar: ["brand", "navigation", "actions"],
+    NavigationFeatureNav: ["identity", "navigation", "actions", "compactNavigationTrigger"],
+    DropdownMenu: ["trigger"],
+    Popover: ["trigger"],
+    Drawer: ["trigger"],
+};
+/** Visible JSX composition only: menu, popover and drawer bodies are outside the navbar band. */
+export const visitVisible = (context, expression, visit, seen = new Set(), branch = () => "both", ancestors = []) => {
+    const node = resolveLocal(context, expression);
+    if (!node || seen.has(node))
+        return;
+    const visited = new Set(seen).add(node);
+    const next = (child) => visitVisible(context, child, visit, visited, branch, ancestors);
+    switch (node.type) {
+        case "JSXExpressionContainer":
+            next(node.expression);
+            break;
+        case "JSXFragment":
+            for (const child of node.children)
+                next(child);
+            break;
+        case "ConditionalExpression":
+            visitConditional(node, next, branch);
+            break;
+        case "LogicalExpression":
+            visitLogical(context, node, next, branch);
+            break;
+        case "ArrayExpression":
+            for (const item of node.elements)
+                next(item);
+            break;
+        case "JSXElement":
+            visitElement(context, node, visit, visited, branch, ancestors);
+            break;
+        default:
+    }
+};
+const visitConditional = (node, next, branch) => {
+    const choice = branch(node);
+    if (choice !== "alternate")
+        next(node.consequent);
+    if (choice !== "consequent")
+        next(node.alternate);
+};
+const visitLogical = (context, node, next, branch) => {
+    const left = resolveLocal(context, node.left);
+    const known = left?.type === "Literal";
+    const leftValue = left?.type === "Literal" ? left.value : undefined;
+    let right = node.operator === "&&" ? Boolean(leftValue) : !leftValue;
+    if (node.operator === "??")
+        right = leftValue === null;
+    if (!known) {
+        const choice = branch(node);
+        if (choice === "both") {
+            next(node.left);
+            next(node.right);
+            return;
+        }
+        right = choice === "consequent";
+    }
+    next(right ? node.right : node.left);
+};
+const visitElement = (context, node, visit, seen, branch, ancestors) => {
+    const opening = node.openingElement;
+    const name = grammarName(context, opening);
+    if (visit(opening, name, ancestors) === false)
+        return;
+    const inside = [...ancestors, opening];
+    const next = (child) => visitVisible(context, child, visit, seen, branch, inside);
+    if (name === null && opening.name.type === "JSXIdentifier") {
+        const fn = functionOf(context, realNode(resolveLocal(context, opening.name))) ?? variableOf(context, opening.name)?.defs.find((definition) => definition.type === "FunctionName")?.node;
+        if (fn)
+            visitFunction(context, fn, visit, seen, branch, inside);
+    }
+    const slots = name === null ? undefined : BAR_SLOTS[name];
+    if (slots)
+        for (const slot of slots)
+            next(propOf(context, opening, slot).value);
+    if (name !== null && ["DropdownMenu", "Popover", "Drawer"].includes(name))
+        return;
+    for (const child of node.children)
+        next(child);
+};
+/** Visit a rendered owner's returns with the same branch, overlay and local-binding semantics as inline JSX. */
+export const visitFunction = (context, fn, visit, seen, branch, ancestors) => {
+    if (fn.body.type !== "BlockStatement")
+        return visitVisible(context, fn.body, visit, seen, branch, ancestors);
+    visitStatements(context, fn.body.body, visit, seen, branch, ancestors);
+};
+const visitStatements = (context, statements, visit, seen, branch, ancestors) => {
+    for (const statement of statements) {
+        if (statement.type === "ReturnStatement") {
+            visitVisible(context, statement.argument, visit, seen, branch, ancestors);
+            return true;
+        }
+        if (statement.type === "BlockStatement" && visitStatements(context, statement.body, visit, seen, branch, ancestors))
+            return true;
+        if (statement.type === "IfStatement") {
+            if (visitIf(context, statement, visit, seen, branch, ancestors))
+                return true;
+        }
+    }
+    return false;
+};
+const visitIf = (context, statement, visit, seen, branch, ancestors) => {
+    const condition = resolveLocal(context, statement.test);
+    let choice = branch(statement);
+    if (condition?.type === "Literal")
+        choice = condition.value ? "consequent" : "alternate";
+    const consequent = choice !== "alternate" && visitStatements(context, [statement.consequent], visit, seen, branch, ancestors);
+    const alternate = choice !== "consequent" && statement.alternate && visitStatements(context, [statement.alternate], visit, seen, branch, ancestors);
+    return choice === "consequent" && consequent || choice === "alternate" && alternate || consequent && alternate;
+};

package/dist/lib/app-shell.d.ts

@@ -0,0 +1,27 @@
+/** Static readers for the visible Grammar app-bar composition, including local JSX owners. */
+import type { TSESTree } from "@typescript-eslint/types";
+import type { Node, ReaderContext, Resolved } from "./types.ts";
+/** The effective value of a prop: `known` is false when an unresolvable spread could still supply it. */
+export interface PropValue {
+    readonly known: boolean;
+    readonly value: Node | null;
+    readonly present?: true;
+}
+/** Bar policy also counts labelled/value/selection/action field owners, so an extra control cannot vanish from the cluster. */
+export declare const isBarControl: (context: ReaderContext, opening: TSESTree.JSXOpeningElement, name: string | null) => boolean;
+/** A literal or constant's initializer, without type-only wrappers. */
+export declare const resolveLocal: (context: ReaderContext, expression: Resolved | null | undefined, seen?: Set<Resolved>) => Resolved | null | undefined;
+/** A resolved value as a parsed node; a synthesized member stands for no function or value of the tree. */
+export declare const realNode: (value: Resolved | null | undefined) => Node | null | undefined;
+/** The imported Grammar component's name; aliases and namespace imports keep their identity. */
+export declare const grammarName: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => string | null;
+/** The text a property key spells: an identifier's name or a string literal's value; null for any other key. */
+export declare const propertyKeyText: (key: Node) => string | null;
+/** The effective prop, respecting JSX spread order; unknown later spreads cannot prove a value. */
+export declare const propOf: (context: ReaderContext, opening: TSESTree.JSXOpeningElement, name: string) => PropValue;
+/** A statically proven string prop, or null for missing/unknown values. */
+export declare const textProp: (context: ReaderContext, opening: TSESTree.JSXOpeningElement, name: string) => string | null;
+/** The source spelling is semantic evidence for an icon or action whose translated label is dynamic. */
+export declare const semanticText: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => string;
+/** The right-cluster role and the Grammar kind that must draw it. */
+export declare const clusterRole: (context: ReaderContext, opening: TSESTree.JSXOpeningElement, name: string | null) => string | null;