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

package/build/rules/form/form-label-required.d.ts

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

package/build/rules/form/form-label-required.js

@@ -0,0 +1,47 @@
+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 FORM_COMPONENTS = [
+    'DBInput',
+    'DBTextarea',
+    'DBSelect',
+    'DBCustomSelect',
+    'DBCheckbox',
+    'DBRadio',
+    'DBSwitch'
+];
+const COMPONENTS_WITH_CHILDREN_LABEL = ['DBCheckbox', 'DBRadio', 'DBSwitch'];
+export default createRule({
+    name: 'form-label-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure form components have a label attribute for accessibility'
+        },
+        messages: {
+            missingLabel: '{{component}} must have a label attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                const component = FORM_COMPONENTS.find((comp) => isDBComponent(openingElement, comp));
+                if (!component)
+                    return;
+                const label = getAttributeValue(openingElement, 'label');
+                const hasChildren = node.children.some((child) => child.type === 'JSXText' && child.value.trim() !== '');
+                const canUseChildren = COMPONENTS_WITH_CHILDREN_LABEL.includes(component);
+                if (!label && !(canUseChildren && hasChildren)) {
+                    context.report({
+                        node: openingElement,
+                        messageId: 'missingLabel',
+                        data: { component }
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/form/form-validation-message-required.d.ts

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

package/build/rules/form/form-validation-message-required.js

@@ -0,0 +1,93 @@
+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 FORM_COMPONENTS = [
+    'DBInput',
+    'DBTextarea',
+    'DBSelect',
+    'DBCustomSelect',
+    'DBCheckbox'
+];
+export default createRule({
+    name: 'form-validation-message-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure form components with validation have invalidMessage'
+        },
+        messages: {
+            missingInvalidMessage: '{{component}} with {{attribute}} must have invalidMessage attribute'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const component = FORM_COMPONENTS.find((comp) => isDBComponent(node.openingElement, comp));
+                if (!component)
+                    return;
+                const invalidMessage = getAttributeValue(node.openingElement, 'invalidMessage');
+                if (invalidMessage)
+                    return;
+                const required = getAttributeValue(node.openingElement, 'required');
+                if (required) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingInvalidMessage',
+                        data: { component, attribute: 'required' }
+                    });
+                    return;
+                }
+                if (component === 'DBInput' || component === 'DBTextarea') {
+                    const maxLength = getAttributeValue(node.openingElement, 'maxLength');
+                    const minLength = getAttributeValue(node.openingElement, 'minLength');
+                    if (maxLength) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingInvalidMessage',
+                            data: { component, attribute: 'maxLength' }
+                        });
+                        return;
+                    }
+                    if (minLength) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingInvalidMessage',
+                            data: { component, attribute: 'minLength' }
+                        });
+                        return;
+                    }
+                }
+                if (component === 'DBInput') {
+                    const min = getAttributeValue(node.openingElement, 'min');
+                    const max = getAttributeValue(node.openingElement, 'max');
+                    const pattern = getAttributeValue(node.openingElement, 'pattern');
+                    if (min) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingInvalidMessage',
+                            data: { component, attribute: 'min' }
+                        });
+                        return;
+                    }
+                    if (max) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingInvalidMessage',
+                            data: { component, attribute: 'max' }
+                        });
+                        return;
+                    }
+                    if (pattern) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingInvalidMessage',
+                            data: { component, attribute: 'pattern' }
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

package/build/rules/header/header-burger-menu-label-required.d.ts

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

package/build/rules/header/header-burger-menu-label-required.js

@@ -0,0 +1,32 @@
+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: 'header-burger-menu-label-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBHeader has burgerMenuLabel for accessibility'
+        },
+        messages: {
+            missingBurgerMenuLabel: 'DBHeader must have burgerMenuLabel attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBHeader'))
+                    return;
+                const burgerMenuLabel = getAttributeValue(node.openingElement, 'burgerMenuLabel');
+                if (!burgerMenuLabel) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingBurgerMenuLabel'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/icon/prefer-icon-attribute.d.ts

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

package/build/rules/icon/prefer-icon-attribute.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 COMPONENTS_WITH_ICON_ATTR = [
+    'DBInput',
+    'DBBrand',
+    'DBButton',
+    'DBCustomSelectListItem',
+    'DBCustomSelect',
+    'DBInfotext',
+    'DBLink',
+    'DBNavigationItem',
+    'DBNotification',
+    'DBSelect',
+    'DBSwitch',
+    'DBTabItem',
+    'DBTag'
+];
+export default createRule({
+    name: 'prefer-icon-attribute',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer icon attribute over DBIcon child component'
+        },
+        fixable: 'code',
+        messages: {
+            preferAttribute: 'Use icon attribute instead of DBIcon child in {{component}}'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                const component = COMPONENTS_WITH_ICON_ATTR.find((comp) => isDBComponent(openingElement, comp));
+                if (!component)
+                    return;
+                const iconChild = node.children.find((child) => child.type === 'JSXElement' &&
+                    isDBComponent(child.openingElement, 'DBIcon'));
+                if (iconChild) {
+                    const iconValue = getAttributeValue(iconChild.openingElement, 'icon');
+                    context.report({
+                        node: iconChild,
+                        messageId: 'preferAttribute',
+                        data: { component },
+                        fix(fixer) {
+                            if (!iconValue || typeof iconValue !== 'string')
+                                return null;
+                            const fixes = [];
+                            // Remove DBIcon child
+                            fixes.push(fixer.remove(iconChild));
+                            // Add icon attribute to parent
+                            const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                            const insertPos = lastAttr
+                                ? lastAttr.range[1]
+                                : openingElement.name.range[1];
+                            fixes.push(fixer.insertTextAfterRange([insertPos, insertPos], ` icon="${iconValue}"`));
+                            return fixes;
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/input/input-file-type-validation.d.ts

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

package/build/rules/input/input-file-type-validation.js

@@ -0,0 +1,52 @@
+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: 'input-file-type-validation',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBInput file type has accept and validate file-only attributes'
+        },
+        messages: {
+            missingAccept: 'DBInput with type="file" should have accept attribute',
+            invalidMultiple: 'DBInput multiple attribute is only valid for type="file"',
+            invalidAccept: 'DBInput accept attribute is only valid for type="file"'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBInput'))
+                    return;
+                const type = getAttributeValue(node.openingElement, 'type');
+                const accept = getAttributeValue(node.openingElement, 'accept');
+                const multiple = getAttributeValue(node.openingElement, 'multiple');
+                if (type === 'file') {
+                    if (!accept) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingAccept'
+                        });
+                    }
+                }
+                else {
+                    if (multiple) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'invalidMultiple'
+                        });
+                    }
+                    if (accept) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'invalidAccept'
+                        });
+                    }
+                }
+            }
+        };
+    }
+});

package/build/rules/input/input-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/input/input-type-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}`);
+export default createRule({
+    name: 'input-type-required',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure DBInput has type attribute for better developer experience'
+        },
+        fixable: 'code',
+        messages: {
+            missingType: 'DBInput should have type attribute for better developer experience'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBInput'))
+                    return;
+                const type = getAttributeValue(node.openingElement, 'type');
+                if (!type) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingType',
+                        fix(fixer) {
+                            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], ' type="text"');
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/link/link-external-security.d.ts

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

package/build/rules/link/link-external-security.js

@@ -0,0 +1,50 @@
+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: 'link-external-security',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure external links have proper security attributes'
+        },
+        messages: {
+            missingTargetBlank: 'DBLink with content="external" should have target="_blank"',
+            missingReferrerPolicy: 'DBLink with content="external" should have referrerPolicy attribute',
+            missingContentExternal: 'DBLink with target="_blank" should have content="external"'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBLink'))
+                    return;
+                const content = getAttributeValue(node.openingElement, 'content');
+                const target = getAttributeValue(node.openingElement, 'target');
+                const referrerPolicy = getAttributeValue(node.openingElement, 'referrerPolicy');
+                if (content === 'external') {
+                    if (target !== '_blank') {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingTargetBlank'
+                        });
+                    }
+                    if (!referrerPolicy) {
+                        context.report({
+                            node: node.openingElement,
+                            messageId: 'missingReferrerPolicy'
+                        });
+                    }
+                }
+                if (target === '_blank' && content !== 'external') {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingContentExternal'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/navigation/navigation-item-back-button-text-required.d.ts

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

package/build/rules/navigation/navigation-item-back-button-text-required.js

@@ -0,0 +1,32 @@
+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: 'navigation-item-back-button-text-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBNavigationItem has backButtonText for accessibility'
+        },
+        messages: {
+            missingBackButtonText: 'DBNavigationItem must have backButtonText attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBNavigationItem'))
+                    return;
+                const backButtonText = getAttributeValue(node.openingElement, 'backButtonText');
+                if (!backButtonText) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingBackButtonText'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/select/custom-select-tags-remove-text-required.d.ts

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

package/build/rules/select/custom-select-tags-remove-text-required.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: 'custom-select-tags-remove-text-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBCustomSelect with selectedType="tag" has removeTagsTexts'
+        },
+        messages: {
+            missingRemoveTagsTexts: 'DBCustomSelect with selectedType="tag" must have removeTagsTexts attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBCustomSelect'))
+                    return;
+                const selectedType = getAttributeValue(node.openingElement, 'selectedType');
+                if (selectedType !== 'tag')
+                    return;
+                const removeTagsTexts = getAttributeValue(node.openingElement, 'removeTagsTexts');
+                if (!removeTagsTexts) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingRemoveTagsTexts'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/select/select-requires-options.d.ts

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

package/build/rules/select/select-requires-options.js

@@ -0,0 +1,44 @@
+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 hasOptionChildren(node) {
+    return node.children.some((child) => {
+        if (child.type === 'JSXElement') {
+            const name = child.openingElement.name;
+            if (name.type === 'JSXIdentifier') {
+                return name.name === 'option';
+            }
+        }
+        return false;
+    });
+}
+export default createRule({
+    name: 'select-requires-options',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBSelect has options property or option children'
+        },
+        messages: {
+            missingOptions: 'DBSelect must have either an options property or <option> children'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBSelect'))
+                    return;
+                const options = getAttributeValue(node.openingElement, 'options');
+                const hasChildren = hasOptionChildren(node);
+                if (!options && !hasChildren) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingOptions'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/tag/tag-removable-remove-button-required.d.ts

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

package/build/rules/tag/tag-removable-remove-button-required.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: 'tag-removable-remove-button-required',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBTag with behavior="removable" has removeButton'
+        },
+        messages: {
+            missingRemoveButton: 'DBTag with behavior="removable" must have removeButton attribute for accessibility'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXElement(node) {
+                if (!isDBComponent(node.openingElement, 'DBTag'))
+                    return;
+                const behavior = getAttributeValue(node.openingElement, 'behavior');
+                if (behavior !== 'removable')
+                    return;
+                const removeButton = getAttributeValue(node.openingElement, 'removeButton');
+                if (!removeButton) {
+                    context.report({
+                        node: node.openingElement,
+                        messageId: 'missingRemoveButton'
+                    });
+                }
+            }
+        };
+    }
+});

package/build/rules/tooltip/no-interactive-tooltip-content.d.ts

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