@db-ux/core-eslint-plugin 0.0.0 → 4.4.2-eslint-plugin-28ea614

package/build/index.d.ts

@@ -0,0 +1,99 @@
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'button-no-text-requires-tooltip': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingIcon" | "missingTooltip", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'button-type-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingType", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'button-single-icon-attribute': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"multipleIcons", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'form-label-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingLabel", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'form-validation-message-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingInvalidMessage", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'prefer-icon-attribute': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"preferAttribute", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'text-or-children-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingContent", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'no-interactive-tooltip-content': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noInteractive", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'tooltip-requires-interactive-parent': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"requiresInteractive", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'no-nested-accordion': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noNested", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'badge-corner-placement-rules': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"textTooLong" | "missingLabel", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'badge-no-inline-in-interactive': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noInline", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'link-external-security': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingTargetBlank" | "missingReferrerPolicy" | "missingContentExternal", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'select-requires-options': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingOptions", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'custom-select-tags-remove-text-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingRemoveTagsTexts", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'close-button-text-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingCloseButtonText", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'header-burger-menu-label-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingBurgerMenuLabel", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'navigation-item-back-button-text-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingBackButtonText", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'tag-removable-remove-button-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingRemoveButton", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'input-type-required': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingType", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+        'input-file-type-validation': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"missingAccept" | "invalidMultiple" | "invalidAccept", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+            name: string;
+        };
+    };
+    configs: {
+        recommended: {
+            rules: {
+                'db-ux/button-no-text-requires-tooltip': string;
+                'db-ux/button-type-required': string;
+                'db-ux/button-single-icon-attribute': string;
+                'db-ux/form-label-required': string;
+                'db-ux/form-validation-message-required': string;
+                'db-ux/prefer-icon-attribute': string;
+                'db-ux/text-or-children-required': string;
+                'db-ux/no-interactive-tooltip-content': string;
+                'db-ux/tooltip-requires-interactive-parent': string;
+                'db-ux/no-nested-accordion': string;
+                'db-ux/badge-corner-placement-rules': string;
+                'db-ux/badge-no-inline-in-interactive': string;
+                'db-ux/link-external-security': string;
+                'db-ux/select-requires-options': string;
+                'db-ux/custom-select-tags-remove-text-required': string;
+                'db-ux/close-button-text-required': string;
+                'db-ux/header-burger-menu-label-required': string;
+                'db-ux/navigation-item-back-button-text-required': string;
+                'db-ux/tag-removable-remove-button-required': string;
+                'db-ux/input-type-required': string;
+                'db-ux/input-file-type-validation': string;
+            };
+        };
+    };
+};
+export default plugin;

package/build/index.js

@@ -0,0 +1,79 @@
+import noNestedAccordion from './rules/accordion/no-nested-accordion.js';
+import badgeCornerPlacementRules from './rules/badge/badge-corner-placement-rules.js';
+import badgeNoInlineInInteractive from './rules/badge/badge-no-inline-in-interactive.js';
+import buttonNoTextRequiresTooltip from './rules/button/button-no-text-requires-tooltip.js';
+import buttonSingleIconAttribute from './rules/button/button-single-icon-attribute.js';
+import buttonTypeRequired from './rules/button/button-type-required.js';
+import closeButtonTextRequired from './rules/close-button/close-button-text-required.js';
+import textOrChildrenRequired from './rules/content/text-or-children-required.js';
+import formLabelRequired from './rules/form/form-label-required.js';
+import formValidationMessageRequired from './rules/form/form-validation-message-required.js';
+import headerBurgerMenuLabelRequired from './rules/header/header-burger-menu-label-required.js';
+import preferIconAttribute from './rules/icon/prefer-icon-attribute.js';
+import inputFileTypeValidation from './rules/input/input-file-type-validation.js';
+import inputTypeRequired from './rules/input/input-type-required.js';
+import linkExternalSecurity from './rules/link/link-external-security.js';
+import navigationItemBackButtonTextRequired from './rules/navigation/navigation-item-back-button-text-required.js';
+import customSelectTagsRemoveTextRequired from './rules/select/custom-select-tags-remove-text-required.js';
+import selectRequiresOptions from './rules/select/select-requires-options.js';
+import tagRemovableRemoveButtonRequired from './rules/tag/tag-removable-remove-button-required.js';
+import noInteractiveTooltipContent from './rules/tooltip/no-interactive-tooltip-content.js';
+import tooltipRequiresInteractiveParent from './rules/tooltip/tooltip-requires-interactive-parent.js';
+const recommended = {
+    rules: {
+        'db-ux/button-no-text-requires-tooltip': 'error',
+        'db-ux/button-type-required': 'error',
+        'db-ux/button-single-icon-attribute': 'error',
+        'db-ux/form-label-required': 'error',
+        'db-ux/form-validation-message-required': 'error',
+        'db-ux/prefer-icon-attribute': 'warn',
+        'db-ux/text-or-children-required': 'error',
+        'db-ux/no-interactive-tooltip-content': 'error',
+        'db-ux/tooltip-requires-interactive-parent': 'error',
+        'db-ux/no-nested-accordion': 'error',
+        'db-ux/badge-corner-placement-rules': 'error',
+        'db-ux/badge-no-inline-in-interactive': 'error',
+        'db-ux/link-external-security': 'warn',
+        'db-ux/select-requires-options': 'error',
+        'db-ux/custom-select-tags-remove-text-required': 'error',
+        'db-ux/close-button-text-required': 'error',
+        'db-ux/header-burger-menu-label-required': 'error',
+        'db-ux/navigation-item-back-button-text-required': 'error',
+        'db-ux/tag-removable-remove-button-required': 'error',
+        'db-ux/input-type-required': 'warn',
+        'db-ux/input-file-type-validation': 'error'
+    }
+};
+const plugin = {
+    meta: {
+        name: '@db-ux/eslint-plugin',
+        version: '0.0.1'
+    },
+    rules: {
+        'button-no-text-requires-tooltip': buttonNoTextRequiresTooltip,
+        'button-type-required': buttonTypeRequired,
+        'button-single-icon-attribute': buttonSingleIconAttribute,
+        'form-label-required': formLabelRequired,
+        'form-validation-message-required': formValidationMessageRequired,
+        'prefer-icon-attribute': preferIconAttribute,
+        'text-or-children-required': textOrChildrenRequired,
+        'no-interactive-tooltip-content': noInteractiveTooltipContent,
+        'tooltip-requires-interactive-parent': tooltipRequiresInteractiveParent,
+        'no-nested-accordion': noNestedAccordion,
+        'badge-corner-placement-rules': badgeCornerPlacementRules,
+        'badge-no-inline-in-interactive': badgeNoInlineInInteractive,
+        'link-external-security': linkExternalSecurity,
+        'select-requires-options': selectRequiresOptions,
+        'custom-select-tags-remove-text-required': customSelectTagsRemoveTextRequired,
+        'close-button-text-required': closeButtonTextRequired,
+        'header-burger-menu-label-required': headerBurgerMenuLabelRequired,
+        'navigation-item-back-button-text-required': navigationItemBackButtonTextRequired,
+        'tag-removable-remove-button-required': tagRemovableRemoveButtonRequired,
+        'input-type-required': inputTypeRequired,
+        'input-file-type-validation': inputFileTypeValidation
+    },
+    configs: {
+        recommended
+    }
+};
+export default plugin;

package/build/rules/accordion/no-nested-accordion.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"noNested", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/build/rules/accordion/no-nested-accordion.js

@@ -0,0 +1,37 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+export default createRule({
+    name: 'no-nested-accordion',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent nesting DBAccordion components'
+        },
+        messages: {
+            noNested: 'DBAccordion must not be nested inside another DBAccordion as it confuses users'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBAccordion'))
+                    return;
+                let parent = node.parent;
+                while (parent) {
+                    if (parent.type === 'JSXElement' &&
+                        isDBComponent(parent.openingElement, 'DBAccordion')) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'noNested'
+                        });
+                        return;
+                    }
+                    parent = parent.parent;
+                }
+            }
+        };
+    }
+});

package/build/rules/badge/badge-corner-placement-rules.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"textTooLong" | "missingLabel", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,76 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+function getTextContent(node) {
+    const textChild = node.children.find((child) => child.type === 'JSXText');
+    return textChild && textChild.type === 'JSXText'
+        ? textChild.value.trim()
+        : null;
+}
+export default createRule({
+    name: 'badge-corner-placement-rules',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBBadge with corner placement has max 3 characters and label'
+        },
+        fixable: 'code',
+        messages: {
+            textTooLong: 'DBBadge with corner placement must have max 3 characters in text/children',
+            missingLabel: 'DBBadge with corner placement must have a label attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBBadge'))
+                    return;
+                const placement = getAttributeValue(node.openingElement, 'placement');
+                if (!placement || placement === 'inline')
+                    return;
+                const text = getAttributeValue(node.openingElement, 'text');
+                const children = getTextContent(node);
+                const content = (typeof text === 'string' ? text : children) || '';
+                const label = getAttributeValue(node.openingElement, 'label');
+                if (content.length > 3) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'textTooLong',
+                        fix(fixer) {
+                            const fixes = [];
+                            const shortText = content.slice(0, 3);
+                            if (text && typeof text === 'string') {
+                                const textAttr = node.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 = node.openingElement.attributes[node.openingElement.attributes
+                                        .length - 1];
+                                    const insertPos = lastAttr
+                                        ? lastAttr.range[1]
+                                        : node.openingElement.name.range[1];
+                                    fixes.push(fixer.insertTextAfterRange([insertPos, insertPos], ` label="${content}"`));
+                                }
+                            }
+                            return fixes;
+                        }
+                    });
+                }
+                if (!label) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingLabel'
+                    });
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"noInline", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,67 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+const INTERACTIVE_PARENTS = ['DBButton', 'DBLink', 'button', 'a'];
+export default createRule({
+    name: 'badge-no-inline-in-interactive',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent inline placement for DBBadge inside interactive elements'
+        },
+        fixable: 'code',
+        messages: {
+            noInline: 'DBBadge inside {{parent}} cannot have placement="inline". Use corner placement instead'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBBadge'))
+                    return;
+                const placement = getAttributeValue(node.openingElement, 'placement');
+                if (placement && placement !== 'inline')
+                    return;
+                let parent = node.parent;
+                while (parent) {
+                    if (parent.type === 'JSXElement') {
+                        const parentName = parent.openingElement.name;
+                        if (parentName.type === 'JSXIdentifier') {
+                            const name = parentName.name;
+                            const matchedParent = INTERACTIVE_PARENTS.find((p) => name === p ||
+                                name ===
+                                    p.toLowerCase().replace('db', 'db-'));
+                            if (matchedParent) {
+                                context.report({
+                                    node: node.openingElement,
+                                    messageId: 'noInline',
+                                    data: { parent: matchedParent },
+                                    fix(fixer) {
+                                        const placementAttr = node.openingElement.attributes.find((a) => a.type === 'JSXAttribute' &&
+                                            a.name.name === 'placement');
+                                        if (placementAttr) {
+                                            return fixer.replaceText(placementAttr, 'placement="corner-top-right"');
+                                        }
+                                        else {
+                                            const lastAttr = node.openingElement.attributes[node.openingElement
+                                                .attributes.length - 1];
+                                            const insertPos = lastAttr
+                                                ? lastAttr.range[1]
+                                                : node.openingElement.name
+                                                    .range[1];
+                                            return fixer.insertTextAfterRange([insertPos, insertPos], ' placement="corner-top-right"');
+                                        }
+                                    }
+                                });
+                                return;
+                            }
+                        }
+                    }
+                    parent = parent.parent;
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"missingIcon" | "missingTooltip", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,59 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, hasChildOfType, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+export default createRule({
+    name: 'button-no-text-requires-tooltip',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton with noText has icon and DBTooltip child'
+        },
+        fixable: 'code',
+        messages: {
+            missingIcon: 'DBButton with noText must have an icon prop',
+            missingTooltip: 'DBButton with noText must have a DBTooltip child for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (!isDBComponent(openingElement, '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: 'missingIcon'
+                    });
+                }
+                const hasTooltip = hasChildOfType(node, 'DBTooltip');
+                if (!hasTooltip) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingTooltip',
+                        fix(fixer) {
+                            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}>`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"multipleIcons", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,35 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+export default createRule({
+    name: 'button-single-icon-attribute',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton uses only one icon attribute'
+        },
+        messages: {
+            multipleIcons: 'DBButton can only use one of: icon, iconLeading, or iconTrailing'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBButton'))
+                    return;
+                const icon = getAttributeValue(node.openingElement, 'icon');
+                const iconLeading = getAttributeValue(node.openingElement, 'iconLeading');
+                const iconTrailing = getAttributeValue(node.openingElement, 'iconTrailing');
+                const iconCount = [icon, iconLeading, iconTrailing].filter(Boolean).length;
+                if (iconCount > 1) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'multipleIcons'
+                    });
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"missingType", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,45 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+export default createRule({
+    name: 'button-type-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBButton has explicit type attribute'
+        },
+        fixable: 'code',
+        messages: {
+            missingType: 'DBButton must have an explicit type attribute (submit, button, or reset)'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (!isDBComponent(openingElement, 'DBButton'))
+                    return;
+                const type = getAttributeValue(openingElement, 'type');
+                if (!type) {
+                    const hasClickHandler = getAttributeValue(openingElement, 'onClick') ||
+                        getAttributeValue(openingElement, '(click)') ||
+                        getAttributeValue(openingElement, '@click');
+                    const typeValue = hasClickHandler ? 'button' : 'submit';
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingType',
+                        fix(fixer) {
+                            const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                            const insertPos = lastAttr
+                                ? lastAttr.range[1]
+                                : openingElement.name.range[1];
+                            return fixer.insertTextAfterRange([insertPos, insertPos], ` type="${typeValue}"`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"missingCloseButtonText", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,40 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+const COMPONENTS_WITH_CLOSE_BUTTON = {
+    DBNotification: 'closeButtonText',
+    DBDrawer: 'closeButtonText',
+    DBCustomSelect: 'mobileCloseButtonText'
+};
+export default createRule({
+    name: 'close-button-text-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure components have close button text for accessibility'
+        },
+        messages: {
+            missingCloseButtonText: '{{component}} must have {{attribute}} attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const component = Object.keys(COMPONENTS_WITH_CLOSE_BUTTON).find((comp) => isDBComponent(node.openingElement, comp));
+                if (!component)
+                    return;
+                const attribute = COMPONENTS_WITH_CLOSE_BUTTON[component];
+                const value = getAttributeValue(node.openingElement, attribute);
+                if (!value) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingCloseButtonText',
+                        data: { component, attribute }
+                    });
+                }
+            }
+        };
+    }
+});

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

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"missingContent", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,49 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#${name}`);
+const COMPONENTS_REQUIRING_CONTENT = [
+    'DBAccordionItem',
+    'DBBadge',
+    'DBButton',
+    'DBLink',
+    'DBIcon',
+    'DBInfotext',
+    'DBNavigationItem',
+    'DBNotification'
+];
+export default createRule({
+    name: 'text-or-children-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure components have text property or children content'
+        },
+        messages: {
+            missingContent: '{{component}} must have either a text property or children content'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                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 === 'JSXElement' ||
+                    child.type === 'JSXExpressionContainer');
+                if (!text && !hasChildren) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingContent',
+                        data: { component }
+                    });
+                }
+            }
+        };
+    }
+});