zemdomu 1.3.16 → 1.3.17

package/out/linter.d.ts

@@ -32,6 +32,10 @@ export interface Rule {
     name: string;
     /** Called before traversal begins */
     init?: () => void;
+    setHtmlContext?: (ctx: {
+        content: string;
+        lineIndex: number[];
+    }) => void;
     enterHtml?: (node: Node) => LintResult[];
     exitHtml?: (node: Node) => LintResult[];
     enterJsx?: (path: NodePath<t.JSXElement>) => LintResult[];

package/out/linter.js

@@ -24,6 +24,7 @@ const requireImageInputAlt_1 = __importDefault(require("./rules/requireImageInpu
 const requireNavLinks_1 = __importDefault(require("./rules/requireNavLinks"));
 const uniqueIds_1 = __importDefault(require("./rules/uniqueIds"));
 const noTabindexGreaterThanZero_1 = __importDefault(require("./rules/noTabindexGreaterThanZero"));
+const preventZemdomuPlaceholders_1 = __importDefault(require("./rules/preventZemdomuPlaceholders"));
 const rule_codes_1 = require("./rule-codes");
 const builtInRules = {
     requireSectionHeading: requireSectionHeading_1.default,
@@ -43,6 +44,7 @@ const builtInRules = {
     requireNavLinks: requireNavLinks_1.default,
     uniqueIds: uniqueIds_1.default,
     noTabindexGreaterThanZero: noTabindexGreaterThanZero_1.default,
+    preventZemdomuPlaceholders: preventZemdomuPlaceholders_1.default,
 };
 const defaultOptions = {
     rules: {
@@ -63,9 +65,18 @@ const defaultOptions = {
         requireNavLinks: "warning",
         uniqueIds: "error",
         noTabindexGreaterThanZero: "warning",
+        preventZemdomuPlaceholders: "warning",
     },
     customRules: [],
 };
+function buildLineIndex(content) {
+    const lines = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === "\n")
+            lines.push(i + 1);
+    }
+    return lines;
+}
 /**
  * Lint HTML/JSX/TSX content.
  */
@@ -209,6 +220,18 @@ function lint(content, options = defaultOptions) {
     if (onlyComments) {
         parseErrors = [];
     }
+    const lineIndex = buildLineIndex(content);
+    activeRules.forEach(({ rule }) => {
+        var _a;
+        if (rule.setHtmlContext) {
+            try {
+                rule.setHtmlContext({ content, lineIndex });
+            }
+            catch (e) {
+                console.error(`[ZemDomu] Error in rule ${rule.name} (${(_a = opts.filePath) !== null && _a !== void 0 ? _a : "unknown"}):`, e);
+            }
+        }
+    });
     const walk = (node) => {
         var _a, _b, _c;
         for (const { rule, severity } of activeRules) {

package/out/project-linter.js

@@ -72,13 +72,14 @@ class ProjectLinter {
             filePath,
             forceHtml: isVue || this.opts.forceHtml,
         });
+        const resolvedResults = results.map((result) => result.filePath ? result : { ...result, filePath });
         const byFile = new Map();
-        byFile.set(filePath, [...results]);
+        byFile.set(filePath, [...resolvedResults]);
         const xmlMode = /\.(jsx|tsx)$/.test(filePath) || isVue;
         if (xmlMode) {
             const component = await this.analyzer.analyzeFile(filePath);
             if (component)
-                this.analyzer.registerComponent(component, results);
+                this.analyzer.registerComponent(component, resolvedResults);
             if (this.opts.crossComponentAnalysis) {
                 const cross = this.analyzer.analyzeComponentTree();
                 for (const r of cross) {

package/out/rule-codes.d.ts

@@ -16,6 +16,7 @@ declare const RULE_CODES: {
     readonly requireNavLinks: "ZMD015";
     readonly uniqueIds: "ZMD016";
     readonly noTabindexGreaterThanZero: "ZMD017";
+    readonly preventZemdomuPlaceholders: "ZMD018";
 };
 export declare function getRuleCode(rule: string): string | undefined;
 export declare function applyRuleCode<T extends {

package/out/rule-codes.js

@@ -21,6 +21,7 @@ const RULE_CODES = {
     requireNavLinks: "ZMD015",
     uniqueIds: "ZMD016",
     noTabindexGreaterThanZero: "ZMD017",
+    preventZemdomuPlaceholders: "ZMD018",
 };
 exports.RULE_CODES = RULE_CODES;
 function getRuleCode(rule) {

package/out/rules/preventZemdomuPlaceholders.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "../linter";
+export default function preventZemdomuPlaceholders(): Rule;

package/out/rules/preventZemdomuPlaceholders.js

@@ -0,0 +1,236 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = preventZemdomuPlaceholders;
+const t = __importStar(require("@babel/types"));
+const PLACEHOLDER = "TODO-ZMD";
+function buildLineIndex(content) {
+    const lines = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === "\n")
+            lines.push(i + 1);
+    }
+    return lines;
+}
+function indexToLoc(lineIndex, index) {
+    let low = 0;
+    let high = lineIndex.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        if (lineIndex[mid] <= index) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    const line = Math.max(high, 0);
+    const column = index - lineIndex[line];
+    return { line, column };
+}
+function collectOccurrences(text, startLine, startColumn) {
+    const hits = [];
+    let idx = text.indexOf(PLACEHOLDER);
+    while (idx !== -1) {
+        const before = text.slice(0, idx);
+        const parts = before.split(/\r?\n/);
+        const lineOffset = parts.length - 1;
+        const column = lineOffset === 0 ? startColumn + parts[parts.length - 1].length : parts[parts.length - 1].length;
+        hits.push({ line: startLine + lineOffset, column });
+        idx = text.indexOf(PLACEHOLDER, idx + PLACEHOLDER.length);
+    }
+    return hits;
+}
+function addHtmlResults(results, htmlContext, absoluteIndex) {
+    if (!htmlContext) {
+        results.push({
+            line: 0,
+            column: 0,
+            message: "Unresolved Zemdomu placeholder detected",
+            rule: "preventZemdomuPlaceholders",
+        });
+        return;
+    }
+    const loc = indexToLoc(htmlContext.lineIndex, absoluteIndex);
+    results.push({
+        line: loc.line,
+        column: loc.column,
+        message: "Unresolved Zemdomu placeholder detected",
+        rule: "preventZemdomuPlaceholders",
+    });
+}
+function textNodePlaceholderResults(node, htmlContext) {
+    if (node.type !== "text")
+        return [];
+    const occurrences = [];
+    let idx = node.text.indexOf(PLACEHOLDER);
+    while (idx !== -1) {
+        occurrences.push(node.startIndex + idx);
+        idx = node.text.indexOf(PLACEHOLDER, idx + PLACEHOLDER.length);
+    }
+    if (!occurrences.length)
+        return [];
+    const results = [];
+    for (const absIdx of occurrences) {
+        addHtmlResults(results, htmlContext, absIdx);
+    }
+    return results;
+}
+function tagPlaceholderResults(node, htmlContext) {
+    if (!htmlContext) {
+        for (const value of Object.values(node.attrs)) {
+            if (value && value.includes(PLACEHOLDER)) {
+                return [
+                    {
+                        line: 0,
+                        column: 0,
+                        message: "Unresolved Zemdomu placeholder detected",
+                        rule: "preventZemdomuPlaceholders",
+                    },
+                ];
+            }
+        }
+        return [];
+    }
+    const { content } = htmlContext;
+    const tagEnd = content.indexOf(">", node.startIndex);
+    if (tagEnd === -1)
+        return [];
+    const tagSource = content.slice(node.startIndex, tagEnd + 1);
+    const results = [];
+    let idx = tagSource.indexOf(PLACEHOLDER);
+    while (idx !== -1) {
+        addHtmlResults(results, htmlContext, node.startIndex + idx);
+        idx = tagSource.indexOf(PLACEHOLDER, idx + PLACEHOLDER.length);
+    }
+    return results;
+}
+function resultsFromJsxText(text, loc) {
+    if (!loc)
+        return [];
+    const startLine = loc.start.line - 1;
+    const startColumn = loc.start.column;
+    const hits = collectOccurrences(text, startLine, startColumn);
+    return hits.map((hit) => ({
+        line: hit.line,
+        column: hit.column,
+        message: "Unresolved Zemdomu placeholder detected",
+        rule: "preventZemdomuPlaceholders",
+    }));
+}
+function checkJsxExpression(expr) {
+    if (t.isStringLiteral(expr)) {
+        return { text: expr.value, loc: expr.loc };
+    }
+    if (t.isTemplateLiteral(expr)) {
+        const raw = expr.quasis.map((q) => { var _a; return (_a = q.value.cooked) !== null && _a !== void 0 ? _a : q.value.raw; }).join("");
+        return { text: raw, loc: expr.loc };
+    }
+    return null;
+}
+function jsxAttributeResults(attr) {
+    var _a, _b, _c;
+    const value = attr.value;
+    if (!value)
+        return [];
+    if (t.isStringLiteral(value)) {
+        if (!value.value.includes(PLACEHOLDER))
+            return [];
+        return resultsFromJsxText(value.value, (_a = value.loc) !== null && _a !== void 0 ? _a : attr.loc);
+    }
+    if (t.isJSXExpressionContainer(value)) {
+        const expr = checkJsxExpression(value.expression);
+        if (!expr || !expr.text.includes(PLACEHOLDER))
+            return [];
+        return resultsFromJsxText(expr.text, (_c = (_b = expr.loc) !== null && _b !== void 0 ? _b : value.loc) !== null && _c !== void 0 ? _c : attr.loc);
+    }
+    return [];
+}
+function jsxChildResults(child) {
+    var _a;
+    if (t.isJSXText(child)) {
+        if (!child.value.includes(PLACEHOLDER))
+            return [];
+        return resultsFromJsxText(child.value, child.loc);
+    }
+    if (t.isJSXExpressionContainer(child)) {
+        const expr = checkJsxExpression(child.expression);
+        if (!expr || !expr.text.includes(PLACEHOLDER))
+            return [];
+        return resultsFromJsxText(expr.text, (_a = expr.loc) !== null && _a !== void 0 ? _a : child.loc);
+    }
+    if (t.isJSXFragment(child)) {
+        const results = [];
+        for (const fragmentChild of child.children) {
+            results.push(...jsxChildResults(fragmentChild));
+        }
+        return results;
+    }
+    return [];
+}
+function preventZemdomuPlaceholders() {
+    let htmlContext = null;
+    return {
+        name: "preventZemdomuPlaceholders",
+        setHtmlContext(ctx) {
+            htmlContext = {
+                content: ctx.content,
+                lineIndex: ctx.lineIndex.length ? ctx.lineIndex : buildLineIndex(ctx.content),
+            };
+        },
+        enterHtml(node) {
+            if (node.type === "text") {
+                return textNodePlaceholderResults(node, htmlContext);
+            }
+            if (node.type === "element") {
+                return tagPlaceholderResults(node, htmlContext);
+            }
+            return [];
+        },
+        enterJsx(path) {
+            const results = [];
+            const opening = path.node.openingElement;
+            for (const attr of opening.attributes) {
+                if (t.isJSXAttribute(attr)) {
+                    results.push(...jsxAttributeResults(attr));
+                }
+            }
+            for (const child of path.node.children) {
+                results.push(...jsxChildResults(child));
+            }
+            return results;
+        },
+    };
+}

package/out/rules/requireButtonText.js

@@ -36,26 +36,245 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = requireButtonText;
 const t = __importStar(require("@babel/types"));
 const utils_1 = require("./utils");
+const HTML_ARIA_LABEL_ATTRS = ['aria-label'];
+const HTML_ARIA_LABELLEDBY_ATTRS = ['aria-labelledby'];
+const HTML_ARIA_HIDDEN_ATTRS = ['aria-hidden'];
+const HTML_HIDDEN_ATTRS = ['hidden'];
+function getHtmlAttrValue(attrs, names) {
+    for (const name of names) {
+        if (Object.prototype.hasOwnProperty.call(attrs, name)) {
+            return attrs[name];
+        }
+    }
+    return undefined;
+}
+function hasHtmlAttr(attrs, names) {
+    return names.some((name) => Object.prototype.hasOwnProperty.call(attrs, name));
+}
+function normalizeStyle(style) {
+    return style.toLowerCase().replace(/\s+/g, '');
+}
+function isHiddenStyle(style) {
+    if (!style)
+        return false;
+    const normalized = normalizeStyle(style);
+    return (normalized.includes('display:none') ||
+        normalized.includes('visibility:hidden') ||
+        normalized.includes('visibility:collapse'));
+}
+function isHtmlHidden(node) {
+    if (hasHtmlAttr(node.attrs, HTML_HIDDEN_ATTRS))
+        return true;
+    const ariaHidden = getHtmlAttrValue(node.attrs, HTML_ARIA_HIDDEN_ATTRS);
+    if (typeof ariaHidden === 'string' && ariaHidden.trim().toLowerCase() === 'true') {
+        return true;
+    }
+    const style = node.attrs.style;
+    return isHiddenStyle(style);
+}
+function hasHtmlNonEmptyAriaLabel(node) {
+    const aria = getHtmlAttrValue(node.attrs, HTML_ARIA_LABEL_ATTRS);
+    if (aria === undefined)
+        return false;
+    return aria.trim().length > 0;
+}
+function htmlImgAltPresent(node) {
+    const alt = node.attrs.alt;
+    return typeof alt === 'string' && alt.trim().length > 0;
+}
+function hasHtmlAccessibleText(node, hidden) {
+    if (hidden)
+        return false;
+    if (node.type === 'text') {
+        return node.text.trim().length > 0;
+    }
+    if (node.type === 'element') {
+        const isHidden = hidden || isHtmlHidden(node);
+        if (isHidden)
+            return false;
+        if (node.tagName === 'img') {
+            return htmlImgAltPresent(node);
+        }
+        return node.children.some((child) => hasHtmlAccessibleText(child, isHidden));
+    }
+    return false;
+}
+function hasHtmlAriaLabelledByText(node, idMap) {
+    const labelledBy = getHtmlAttrValue(node.attrs, HTML_ARIA_LABELLEDBY_ATTRS);
+    if (!labelledBy)
+        return false;
+    const ids = labelledBy.trim().split(/\s+/).filter(Boolean);
+    if (!ids.length)
+        return false;
+    for (const id of ids) {
+        const targets = idMap.get(id);
+        if (!targets)
+            continue;
+        for (const target of targets) {
+            if (hasHtmlAccessibleText(target, false))
+                return true;
+        }
+    }
+    return false;
+}
+function getJsxTagName(opening) {
+    return t.isJSXIdentifier(opening.name) ? opening.name.name.toLowerCase() : '';
+}
+function getStaticJsxAttrText(opening, name) {
+    const attr = (0, utils_1.getJsxAttribute)(opening, name);
+    if (!attr)
+        return undefined;
+    if (!attr.value)
+        return '';
+    if (t.isStringLiteral(attr.value))
+        return attr.value.value;
+    if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isStringLiteral(expr))
+            return expr.value;
+        if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
+            const raw = expr.quasis.map((q) => { var _a; return (_a = q.value.cooked) !== null && _a !== void 0 ? _a : q.value.raw; }).join('');
+            return raw;
+        }
+    }
+    return null;
+}
+function isJsxHidden(opening) {
+    const attr = (0, utils_1.getJsxAttribute)(opening, 'hidden');
+    if (!attr)
+        return false;
+    if (!attr.value)
+        return true;
+    if (t.isStringLiteral(attr.value))
+        return true;
+    if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isBooleanLiteral(expr))
+            return expr.value;
+    }
+    return false;
+}
+function isJsxAriaHidden(opening) {
+    const attr = (0, utils_1.getJsxAttribute)(opening, 'aria-hidden');
+    if (!attr)
+        return false;
+    if (!attr.value)
+        return true;
+    if (t.isStringLiteral(attr.value)) {
+        return attr.value.value.trim().toLowerCase() === 'true';
+    }
+    if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isBooleanLiteral(expr))
+            return expr.value;
+        if (t.isStringLiteral(expr)) {
+            return expr.value.trim().toLowerCase() === 'true';
+        }
+    }
+    return false;
+}
+function isJsxStyleHidden(opening) {
+    const attr = (0, utils_1.getJsxAttribute)(opening, 'style');
+    if (!attr || !attr.value)
+        return false;
+    if (t.isStringLiteral(attr.value)) {
+        return isHiddenStyle(attr.value.value);
+    }
+    if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isStringLiteral(expr))
+            return isHiddenStyle(expr.value);
+    }
+    return false;
+}
+function isJsxHiddenFromAT(opening) {
+    return isJsxHidden(opening) || isJsxAriaHidden(opening) || isJsxStyleHidden(opening);
+}
+function mergeStates(states) {
+    if (states.some((s) => s === 'present'))
+        return 'present';
+    if (states.some((s) => s === 'possiblyEmpty'))
+        return 'possiblyEmpty';
+    return 'empty';
+}
+function jsxImgAltState(opening) {
+    const alt = getStaticJsxAttrText(opening, 'alt');
+    if (alt === undefined)
+        return 'empty';
+    if (alt === null)
+        return 'empty';
+    return alt.trim().length > 0 ? 'present' : 'empty';
+}
+function jsxChildTextState(child, hidden) {
+    if (hidden)
+        return 'empty';
+    if (t.isJSXText(child))
+        return child.value.trim().length > 0 ? 'present' : 'empty';
+    if (t.isJSXExpressionContainer(child)) {
+        const expr = child.expression;
+        if (t.isJSXElement(expr))
+            return jsxElementTextState(expr, hidden);
+        if (t.isJSXFragment(expr)) {
+            return mergeStates(expr.children.map((c) => jsxChildTextState(c, hidden)));
+        }
+        return (0, utils_1.getJsxExpressionState)(expr, true);
+    }
+    if (t.isJSXElement(child))
+        return jsxElementTextState(child, hidden);
+    if (t.isJSXFragment(child)) {
+        return mergeStates(child.children.map((c) => jsxChildTextState(c, hidden)));
+    }
+    if (t.isJSXSpreadChild(child))
+        return 'present';
+    return 'empty';
+}
+function jsxElementTextState(node, parentHidden) {
+    const opening = node.openingElement;
+    const isHidden = parentHidden || isJsxHiddenFromAT(opening);
+    if (isHidden)
+        return 'empty';
+    const tag = getJsxTagName(opening);
+    if (tag === 'img') {
+        return jsxImgAltState(opening);
+    }
+    return mergeStates(node.children.map((c) => jsxChildTextState(c, isHidden)));
+}
+function hasJsxAriaLabelledByText(opening, idMap) {
+    const labelledBy = getStaticJsxAttrText(opening, 'aria-labelledby');
+    if (!labelledBy)
+        return false;
+    const ids = labelledBy.trim().split(/\s+/).filter(Boolean);
+    if (!ids.length)
+        return false;
+    for (const id of ids) {
+        const targets = idMap.get(id);
+        if (!targets)
+            continue;
+        for (const target of targets) {
+            const state = jsxElementTextState(target, false);
+            if (state === 'present')
+                return true;
+        }
+    }
+    return false;
+}
 function requireButtonText() {
-    const stack = [];
+    const htmlButtons = [];
+    const htmlIds = new Map();
+    const jsxButtons = [];
+    const jsxIds = new Map();
     return {
         name: 'requireButtonText',
         enterHtml(node) {
-            if (node.type === 'element' && node.tagName === 'button') {
-                const aria = node.attrs['aria-label'];
-                stack.push({ found: !!(aria && aria.trim()), hadEmptyAria: aria !== undefined && !String(aria).trim() });
-            }
-            else if (node.type === 'text') {
-                if (stack.length && node.text.trim())
-                    stack[stack.length - 1].found = true;
-            }
-            return [];
-        },
-        exitHtml(node) {
-            if (node.type === 'element' && node.tagName === 'button') {
-                const info = stack.pop();
-                if (info && !info.found) {
-                    return [{ line: 0, column: 0, message: '<button> missing accessible text', rule: 'requireButtonText' }];
+            if (node.type === 'element') {
+                const id = node.attrs.id;
+                if (id && id.trim().length > 0) {
+                    if (!htmlIds.has(id))
+                        htmlIds.set(id, []);
+                    htmlIds.get(id).push(node);
+                }
+                if (node.tagName === 'button') {
+                    htmlButtons.push({ node });
                 }
             }
             return [];
@@ -63,16 +282,56 @@ function requireButtonText() {
         enterJsx(path) {
             var _a, _b, _c, _d;
             const opening = path.node.openingElement;
-            const tag = t.isJSXIdentifier(opening.name) ? opening.name.name.toLowerCase() : '';
+            const tag = getJsxTagName(opening);
+            const id = getStaticJsxAttrText(opening, 'id');
+            if (typeof id === 'string' && id.trim().length > 0) {
+                if (!jsxIds.has(id))
+                    jsxIds.set(id, []);
+                jsxIds.get(id).push(path.node);
+            }
             if (tag === 'button') {
-                const aria = (0, utils_1.getJsxAttr)(opening, 'aria-label');
-                if (!aria || !aria.trim()) {
-                    const line = ((_b = (_a = opening.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1) - 1;
-                    const column = (_d = (_c = opening.loc) === null || _c === void 0 ? void 0 : _c.start.column) !== null && _d !== void 0 ? _d : 0;
-                    return [{ line, column, message: '<button> missing accessible text', rule: 'requireButtonText' }];
-                }
+                const line = ((_b = (_a = opening.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1) - 1;
+                const column = (_d = (_c = opening.loc) === null || _c === void 0 ? void 0 : _c.start.column) !== null && _d !== void 0 ? _d : 0;
+                jsxButtons.push({ node: path.node, line, column });
             }
             return [];
         },
+        end() {
+            const results = [];
+            for (const { node } of htmlButtons) {
+                if (isHtmlHidden(node))
+                    continue;
+                const hasLabel = hasHtmlNonEmptyAriaLabel(node);
+                const hasLabelledBy = hasHtmlAriaLabelledByText(node, htmlIds);
+                const hasContent = hasHtmlAccessibleText(node, false);
+                if (!hasLabel && !hasLabelledBy && !hasContent) {
+                    results.push({
+                        line: 0,
+                        column: 0,
+                        message: '<button> missing accessible text',
+                        rule: 'requireButtonText',
+                    });
+                }
+            }
+            for (const { node, line, column } of jsxButtons) {
+                const opening = node.openingElement;
+                if (isJsxHiddenFromAT(opening))
+                    continue;
+                const ariaState = (0, utils_1.getJsxAttributeState)(opening, 'aria-label', true);
+                const hasLabel = ariaState === 'present';
+                const hasLabelledBy = hasJsxAriaLabelledByText(opening, jsxIds);
+                const contentState = jsxElementTextState(node, false);
+                const hasContent = contentState === 'present';
+                if (!hasLabel && !hasLabelledBy && !hasContent) {
+                    results.push({
+                        line,
+                        column,
+                        message: '<button> missing accessible text',
+                        rule: 'requireButtonText',
+                    });
+                }
+            }
+            return results;
+        },
     };
 }