@db-ux/core-eslint-plugin 0.0.0 → 4.4.2-eslint-plugin2-696cb23

package/build/rules/badge/badge-corner-placement-rules.js

@@ -0,0 +1,114 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularFix, createAngularVisitors, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+function getTextContent(node) {
+    if (node.children) {
+        for (const child of node.children) {
+            if (child.type === 'JSXText') {
+                return child.value.trim();
+            }
+            if (child.type === 'Text') {
+                return child.value?.trim() || null;
+            }
+            if (child.type === 'VText') {
+                return child.value?.trim() || null;
+            }
+        }
+    }
+    return null;
+}
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBBadge with corner placement has max 3 characters and label',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#badge-corner-placement-rules'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.BADGE_CORNER_TEXT_TOO_LONG]: MESSAGES.BADGE_CORNER_TEXT_TOO_LONG,
+            [MESSAGE_IDS.BADGE_CORNER_MISSING_LABEL]: MESSAGES.BADGE_CORNER_MISSING_LABEL
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const placement = getAttributeValue(node, 'placement');
+            if (!placement || placement === 'inline')
+                return;
+            const text = getAttributeValue(node, 'text');
+            const children = getTextContent(node);
+            const content = (typeof text === 'string' ? text : children) || '';
+            const label = getAttributeValue(node, 'label');
+            const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+            if (content.length > 3) {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BADGE_CORNER_TEXT_TOO_LONG
+                });
+            }
+            if (!label) {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BADGE_CORNER_MISSING_LABEL,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ` label="${content || 'Badge'}"`);
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBBadge, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkBadge = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBBadge))
+                return;
+            const placement = getAttributeValue(openingElement, 'placement');
+            if (!placement || placement === 'inline')
+                return;
+            const text = getAttributeValue(openingElement, 'text');
+            const children = getTextContent(node);
+            const content = (typeof text === 'string' ? text : children) || '';
+            const label = getAttributeValue(openingElement, 'label');
+            if (content.length > 3) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.BADGE_CORNER_TEXT_TOO_LONG,
+                    fix(fixer) {
+                        const fixes = [];
+                        const shortText = content.slice(0, 3);
+                        if (text && typeof text === 'string') {
+                            const textAttr = openingElement.attributes.find((a) => a.type === 'JSXAttribute' &&
+                                a.name.name === 'text');
+                            if (textAttr) {
+                                fixes.push(fixer.replaceText(textAttr, `text="${shortText}" label="${content}"`));
+                            }
+                        }
+                        else if (children) {
+                            const textChild = node.children.find((c) => c.type === 'JSXText');
+                            if (textChild) {
+                                fixes.push(fixer.replaceText(textChild, shortText));
+                                const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                                const insertPos = lastAttr
+                                    ? lastAttr.range[1]
+                                    : openingElement.name.range[1];
+                                fixes.push(fixer.insertTextAfterRange([insertPos, insertPos], ` label="${content}"`));
+                            }
+                        }
+                        return fixes;
+                    }
+                });
+            }
+            if (!label) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.BADGE_CORNER_MISSING_LABEL
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkBadge, Element: checkBadge }, { JSXElement: checkBadge });
+    }
+};

package/build/rules/badge/badge-no-inline-in-interactive.d.ts

@@ -0,0 +1,17 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        fixable: string;
+        messages: {
+            [MESSAGE_IDS.BADGE_NO_INLINE_IN_INTERACTIVE]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/badge/badge-no-inline-in-interactive.js

@@ -0,0 +1,129 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularFix, createAngularVisitors, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const INTERACTIVE_PARENTS = ['DBButton', 'DBLink', 'button', 'a'];
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent inline placement for DBBadge inside interactive elements',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#badge-no-inline-in-interactive'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.BADGE_NO_INLINE_IN_INTERACTIVE]: MESSAGES.BADGE_NO_INLINE_IN_INTERACTIVE
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const placement = getAttributeValue(node, 'placement');
+            if (placement && placement !== 'inline')
+                return;
+            let parent = node.parent;
+            while (parent) {
+                if (parent.type === 'Element') {
+                    const matchedParent = INTERACTIVE_PARENTS.find((p) => parent.name === p ||
+                        parent.name === p.toLowerCase().replace('db', 'db-'));
+                    if (matchedParent) {
+                        const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                        context.report({
+                            loc,
+                            messageId: MESSAGE_IDS.BADGE_NO_INLINE_IN_INTERACTIVE,
+                            data: { parent: matchedParent },
+                            fix(fixer) {
+                                const fixData = createAngularFix(context, node, ' placement="corner-top-right"');
+                                if (!fixData)
+                                    return null;
+                                return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                            }
+                        });
+                        return;
+                    }
+                }
+                parent = parent.parent;
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBBadge, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkBadge = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBBadge))
+                return;
+            const placement = getAttributeValue(openingElement, 'placement');
+            if (placement && placement !== 'inline')
+                return;
+            let parent = node.parent;
+            while (parent) {
+                if (parent.type === 'JSXElement' ||
+                    parent.type === 'VElement') {
+                    const parentOpening = parent.openingElement || parent;
+                    const parentName = parentOpening.name || parentOpening.rawName;
+                    const name = typeof parentName === 'string'
+                        ? parentName
+                        : parentName.type === 'JSXIdentifier'
+                            ? parentName.name
+                            : null;
+                    if (name) {
+                        const matchedParent = INTERACTIVE_PARENTS.find((p) => name === p ||
+                            name === p.toLowerCase().replace('db', 'db-'));
+                        if (matchedParent) {
+                            context.report({
+                                node: openingElement,
+                                messageId: MESSAGE_IDS.BADGE_NO_INLINE_IN_INTERACTIVE,
+                                data: { parent: matchedParent },
+                                fix(fixer) {
+                                    if (node.openingElement) {
+                                        // JSX
+                                        const placementAttr = openingElement.attributes.find((a) => a.type === 'JSXAttribute' &&
+                                            a.name.name === 'placement');
+                                        if (placementAttr) {
+                                            return fixer.replaceText(placementAttr, 'placement="corner-top-right"');
+                                        }
+                                        else {
+                                            const lastAttr = openingElement.attributes[openingElement.attributes
+                                                .length - 1];
+                                            const insertPos = lastAttr
+                                                ? lastAttr.range[1]
+                                                : openingElement.name.range[1];
+                                            return fixer.insertTextAfterRange([insertPos, insertPos], ' placement="corner-top-right"');
+                                        }
+                                    }
+                                    else {
+                                        // Vue
+                                        const placementAttr = openingElement.startTag.attributes.find((a) => a.key.name === 'placement');
+                                        if (placementAttr) {
+                                            return fixer.replaceText(placementAttr, 'placement="corner-top-right"');
+                                        }
+                                        else {
+                                            const attrs = openingElement.startTag
+                                                .attributes;
+                                            if (attrs.length > 0) {
+                                                const lastAttr = attrs[attrs.length - 1];
+                                                return fixer.insertTextAfterRange([
+                                                    lastAttr.range[1],
+                                                    lastAttr.range[1]
+                                                ], ' placement="corner-top-right"');
+                                            }
+                                            else {
+                                                const insertPos = openingElement.startTag
+                                                    .range[0] +
+                                                    1 +
+                                                    openingElement.rawName
+                                                        .length;
+                                                return fixer.insertTextAfterRange([insertPos, insertPos], ' placement="corner-top-right"');
+                                            }
+                                        }
+                                    }
+                                }
+                            });
+                            return;
+                        }
+                    }
+                }
+                parent = parent.parent;
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkBadge, Element: checkBadge }, { JSXElement: checkBadge });
+    }
+};

package/build/rules/button/button-no-text-requires-tooltip.d.ts

@@ -0,0 +1,18 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        fixable: string;
+        messages: {
+            [MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_ICON]: string;
+            [MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_TOOLTIP]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/button/button-no-text-requires-tooltip.js

@@ -0,0 +1,109 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularVisitors, defineTemplateBodyVisitor, getAttributeValue, hasChildOfType, isDBComponent } from '../../shared/utils.js';
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton with noText has icon and DBTooltip child',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#button-no-text-requires-tooltip'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_ICON]: MESSAGES.BUTTON_NO_TEXT_MISSING_ICON,
+            [MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_TOOLTIP]: MESSAGES.BUTTON_NO_TEXT_MISSING_TOOLTIP
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const noText = getAttributeValue(node, 'noText');
+            if (!noText)
+                return;
+            const icon = getAttributeValue(node, 'icon') ||
+                getAttributeValue(node, 'iconLeading') ||
+                getAttributeValue(node, 'iconTrailing');
+            const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+            if (!icon) {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_ICON
+                });
+            }
+            const hasTooltip = hasChildOfType(node, COMPONENTS.DBTooltip);
+            if (!hasTooltip) {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_TOOLTIP,
+                    fix(fixer) {
+                        const sourceCode = context.sourceCode || context.getSourceCode();
+                        const text = sourceCode.getText();
+                        const startOffset = node.sourceSpan.start.offset;
+                        const endOffset = node.sourceSpan.end.offset;
+                        const tagText = text.substring(startOffset, endOffset);
+                        const closeTagIndex = tagText.lastIndexOf('</db-button>');
+                        if (closeTagIndex === -1)
+                            return null;
+                        const insertPos = startOffset + closeTagIndex;
+                        return fixer.insertTextBeforeRange([insertPos, insertPos], '\n  <db-tooltip>Describe action</db-tooltip>');
+                    }
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBButton, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkButton = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBButton))
+                return;
+            const noText = getAttributeValue(openingElement, 'noText');
+            if (!noText)
+                return;
+            const icon = getAttributeValue(openingElement, 'icon') ||
+                getAttributeValue(openingElement, 'iconLeading') ||
+                getAttributeValue(openingElement, 'iconTrailing');
+            if (!icon) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_ICON
+                });
+            }
+            const hasTooltip = hasChildOfType(node, COMPONENTS.DBTooltip);
+            if (!hasTooltip) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.BUTTON_NO_TEXT_MISSING_TOOLTIP,
+                    fix(fixer) {
+                        if (node.openingElement) {
+                            // JSX
+                            const closingTag = node.closingElement;
+                            if (!closingTag)
+                                return null;
+                            const componentName = openingElement.name.type === 'JSXIdentifier'
+                                ? openingElement.name.name
+                                : 'DBButton';
+                            const tooltipName = componentName.includes('-')
+                                ? 'db-tooltip'
+                                : 'DBTooltip';
+                            return fixer.insertTextBefore(closingTag, `\n  <${tooltipName}>Describe action</${tooltipName}>`);
+                        }
+                        else {
+                            // Vue
+                            if (!node.endTag || !node.startTag?.range)
+                                return null;
+                            const componentName = openingElement.rawName;
+                            const tooltipName = componentName.includes('-')
+                                ? 'db-tooltip'
+                                : 'DBTooltip';
+                            return fixer.insertTextAfterRange([
+                                node.startTag.range[1],
+                                node.startTag.range[1]
+                            ], `\n  <${tooltipName}>Describe action</${tooltipName}>`);
+                        }
+                    }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkButton, Element: checkButton }, { JSXElement: checkButton });
+    }
+};

package/build/rules/button/button-single-icon-attribute.d.ts

@@ -0,0 +1,16 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        messages: {
+            [MESSAGE_IDS.BUTTON_MULTIPLE_ICONS]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/button/button-single-icon-attribute.js

@@ -0,0 +1,49 @@
+import { createAngularVisitors, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton uses only one icon attribute',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#button-single-icon-attribute'
+        },
+        messages: {
+            [MESSAGE_IDS.BUTTON_MULTIPLE_ICONS]: MESSAGES.BUTTON_MULTIPLE_ICONS
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const icon = getAttributeValue(node, 'icon');
+            const iconLeading = getAttributeValue(node, 'iconLeading');
+            const iconTrailing = getAttributeValue(node, 'iconTrailing');
+            const iconCount = [icon, iconLeading, iconTrailing].filter(Boolean).length;
+            if (iconCount > 1) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BUTTON_MULTIPLE_ICONS
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBButton, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkButton = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBButton))
+                return;
+            const icon = getAttributeValue(openingElement, 'icon');
+            const iconLeading = getAttributeValue(openingElement, 'iconLeading');
+            const iconTrailing = getAttributeValue(openingElement, 'iconTrailing');
+            const iconCount = [icon, iconLeading, iconTrailing].filter(Boolean).length;
+            if (iconCount > 1) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.BUTTON_MULTIPLE_ICONS
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkButton, Element: checkButton }, { JSXElement: checkButton });
+    }
+};

package/build/rules/button/button-type-required.d.ts

@@ -0,0 +1,17 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        fixable: string;
+        messages: {
+            [MESSAGE_IDS.BUTTON_TYPE_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/button/button-type-required.js

@@ -0,0 +1,58 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularFix, createAngularVisitors, createJsxVueFix, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton has explicit type attribute',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#button-type-required'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.BUTTON_TYPE_REQUIRED]: MESSAGES.BUTTON_TYPE_REQUIRED
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const type = getAttributeValue(node, 'type');
+            if (!type) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.BUTTON_TYPE_REQUIRED,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ' type="button"');
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBButton, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkButton = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBButton))
+                return;
+            const type = getAttributeValue(openingElement, 'type');
+            if (type)
+                return;
+            const hasClickHandler = getAttributeValue(openingElement, 'onClick') ||
+                getAttributeValue(openingElement, '(click)') ||
+                getAttributeValue(openingElement, '@click');
+            const typeValue = hasClickHandler ? 'button' : 'submit';
+            context.report({
+                node: openingElement,
+                messageId: MESSAGE_IDS.BUTTON_TYPE_REQUIRED,
+                fix(fixer) {
+                    const fixData = createJsxVueFix(node, openingElement, ` type="${typeValue}"`);
+                    return fixer.insertTextAfterRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                }
+            });
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkButton, Element: checkButton }, { JSXElement: checkButton });
+    }
+};

package/build/rules/close-button/close-button-text-required.d.ts

@@ -0,0 +1,16 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        messages: {
+            [MESSAGE_IDS.CLOSE_BUTTON_TEXT_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/close-button/close-button-text-required.js

@@ -0,0 +1,38 @@
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+import { MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+const COMPONENTS_WITH_CLOSE_BUTTON = {
+    DBNotification: 'closeButtonText',
+    DBDrawer: 'closeButtonText',
+    DBCustomSelect: 'mobileCloseButtonText'
+};
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure components have close button text for accessibility',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#close-button-text-required'
+        },
+        messages: {
+            [MESSAGE_IDS.CLOSE_BUTTON_TEXT_REQUIRED]: MESSAGES.CLOSE_BUTTON_TEXT_REQUIRED
+        },
+        schema: []
+    },
+    create(context) {
+        const checkComponent = (node) => {
+            const openingElement = node.openingElement || node;
+            const component = Object.keys(COMPONENTS_WITH_CLOSE_BUTTON).find((comp) => isDBComponent(openingElement, comp));
+            if (!component)
+                return;
+            const attribute = COMPONENTS_WITH_CLOSE_BUTTON[component];
+            const value = getAttributeValue(openingElement, attribute);
+            if (!value) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.CLOSE_BUTTON_TEXT_REQUIRED,
+                    data: { component, attribute }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkComponent, Element: checkComponent }, { JSXElement: checkComponent });
+    }
+};

package/build/rules/content/text-or-children-required.d.ts

@@ -0,0 +1,16 @@
+import { MESSAGE_IDS } from '../../shared/constants.js';
+declare const _default: {
+    meta: {
+        type: string;
+        docs: {
+            description: string;
+            url: string;
+        };
+        messages: {
+            [MESSAGE_IDS.TEXT_OR_CHILDREN_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/content/text-or-children-required.js

@@ -0,0 +1,47 @@
+import { MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const COMPONENTS_REQUIRING_CONTENT = [
+    'DBAccordionItem',
+    'DBButton',
+    'DBLink',
+    'DBIcon',
+    'DBInfotext',
+    'DBNavigationItem',
+    'DBNotification'
+];
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure components have text property or children content',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#text-or-children-required'
+        },
+        messages: {
+            [MESSAGE_IDS.TEXT_OR_CHILDREN_REQUIRED]: MESSAGES.TEXT_OR_CHILDREN_REQUIRED
+        },
+        schema: []
+    },
+    create(context) {
+        const checkComponent = (node) => {
+            const openingElement = node.openingElement || node;
+            const component = COMPONENTS_REQUIRING_CONTENT.find((comp) => isDBComponent(openingElement, comp));
+            if (!component)
+                return;
+            const text = getAttributeValue(openingElement, 'text');
+            const hasChildren = node.children?.some((child) => (child.type === 'JSXText' && child.value.trim() !== '') ||
+                (child.type === 'VText' && child.value.trim() !== '') ||
+                child.type === 'JSXElement' ||
+                child.type === 'VElement' ||
+                child.type === 'JSXExpressionContainer' ||
+                child.type === 'VExpressionContainer');
+            if (!text && !hasChildren) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.TEXT_OR_CHILDREN_REQUIRED,
+                    data: { component }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkComponent, Element: checkComponent }, { JSXElement: checkComponent });
+    }
+};