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

package/build/rules/form/form-label-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.FORM_LABEL_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

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

@@ -0,0 +1,45 @@
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+import { MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+const FORM_COMPONENTS = [
+    'DBInput',
+    'DBTextarea',
+    'DBSelect',
+    'DBCustomSelect',
+    'DBCheckbox',
+    'DBRadio',
+    'DBSwitch'
+];
+const COMPONENTS_WITH_CHILDREN_LABEL = ['DBCheckbox', 'DBRadio', 'DBSwitch'];
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure form components have a label attribute for accessibility',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#form-label-required'
+        },
+        messages: {
+            [MESSAGE_IDS.FORM_LABEL_REQUIRED]: MESSAGES.FORM_LABEL_REQUIRED
+        },
+        schema: []
+    },
+    create(context) {
+        const checkFormComponent = (node) => {
+            const openingElement = node.openingElement || node;
+            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() !== '') ||
+                (child.type === 'VText' && child.value.trim() !== ''));
+            const canUseChildren = COMPONENTS_WITH_CHILDREN_LABEL.includes(component);
+            if (!label && !(canUseChildren && hasChildren)) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.FORM_LABEL_REQUIRED,
+                    data: { component }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkFormComponent, Element: checkFormComponent }, { JSXElement: checkFormComponent });
+    }
+};

package/build/rules/form/form-validation-message-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.FORM_VALIDATION_MESSAGE_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

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

@@ -0,0 +1,91 @@
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+import { MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+const FORM_COMPONENTS = [
+    'DBInput',
+    'DBTextarea',
+    'DBSelect',
+    'DBCustomSelect',
+    'DBCheckbox'
+];
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure form components with validation have invalidMessage',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#form-validation-message-required'
+        },
+        messages: {
+            [MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED]: MESSAGES.FORM_VALIDATION_MESSAGE_REQUIRED
+        },
+        schema: []
+    },
+    create(context) {
+        const checkFormComponent = (node) => {
+            const openingElement = node.openingElement || node;
+            const component = FORM_COMPONENTS.find((comp) => isDBComponent(openingElement, comp));
+            if (!component)
+                return;
+            const invalidMessage = getAttributeValue(openingElement, 'invalidMessage');
+            if (invalidMessage)
+                return;
+            const required = getAttributeValue(openingElement, 'required');
+            if (required) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                    data: { component, attribute: 'required' }
+                });
+                return;
+            }
+            if (component === 'DBInput' || component === 'DBTextarea') {
+                const maxLength = getAttributeValue(openingElement, 'maxLength');
+                const minLength = getAttributeValue(openingElement, 'minLength');
+                if (maxLength) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                        data: { component, attribute: 'maxLength' }
+                    });
+                    return;
+                }
+                if (minLength) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                        data: { component, attribute: 'minLength' }
+                    });
+                    return;
+                }
+            }
+            if (component === 'DBInput') {
+                const min = getAttributeValue(openingElement, 'min');
+                const max = getAttributeValue(openingElement, 'max');
+                const pattern = getAttributeValue(openingElement, 'pattern');
+                if (min) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                        data: { component, attribute: 'min' }
+                    });
+                    return;
+                }
+                if (max) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                        data: { component, attribute: 'max' }
+                    });
+                    return;
+                }
+                if (pattern) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.FORM_VALIDATION_MESSAGE_REQUIRED,
+                        data: { component, attribute: 'pattern' }
+                    });
+                }
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkFormComponent, Element: checkFormComponent }, { JSXElement: checkFormComponent });
+    }
+};

package/build/rules/header/header-burger-menu-label-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.HEADER_MISSING_BURGER_MENU_LABEL]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

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

@@ -0,0 +1,43 @@
+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 DBHeader has burgerMenuLabel for accessibility',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#header-burger-menu-label-required'
+        },
+        messages: {
+            [MESSAGE_IDS.HEADER_MISSING_BURGER_MENU_LABEL]: MESSAGES.HEADER_MISSING_BURGER_MENU_LABEL
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const burgerMenuLabel = getAttributeValue(node, 'burgerMenuLabel');
+            if (!burgerMenuLabel) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.HEADER_MISSING_BURGER_MENU_LABEL
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBHeader, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkHeader = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBHeader))
+                return;
+            const burgerMenuLabel = getAttributeValue(openingElement, 'burgerMenuLabel');
+            if (!burgerMenuLabel) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.HEADER_MISSING_BURGER_MENU_LABEL
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkHeader, Element: checkHeader }, { JSXElement: checkHeader });
+    }
+};

package/build/rules/icon/prefer-icon-attribute.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.ICON_PREFER_ATTRIBUTE]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/build/rules/icon/prefer-icon-attribute.js

@@ -0,0 +1,82 @@
+import { MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+const COMPONENTS_WITH_ICON_ATTR = [
+    'DBInput',
+    'DBBrand',
+    'DBButton',
+    'DBCustomSelectListItem',
+    'DBCustomSelect',
+    'DBInfotext',
+    'DBLink',
+    'DBNavigationItem',
+    'DBNotification',
+    'DBSelect',
+    'DBSwitch',
+    'DBTabItem',
+    'DBTag'
+];
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer icon attribute over DBIcon child component',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#prefer-icon-attribute'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.ICON_PREFER_ATTRIBUTE]: MESSAGES.ICON_PREFER_ATTRIBUTE
+        },
+        schema: []
+    },
+    create(context) {
+        const checkComponent = (node) => {
+            const openingElement = node.openingElement || node;
+            const component = COMPONENTS_WITH_ICON_ATTR.find((comp) => isDBComponent(openingElement, comp));
+            if (!component)
+                return;
+            const iconChild = node.children?.find((child) => (child.type === 'JSXElement' ||
+                child.type === 'VElement') &&
+                isDBComponent(child.openingElement || child, 'DBIcon'));
+            if (iconChild) {
+                const iconChildOpening = iconChild.openingElement || iconChild;
+                const iconValue = getAttributeValue(iconChildOpening, 'icon');
+                context.report({
+                    node: iconChild,
+                    messageId: MESSAGE_IDS.ICON_PREFER_ATTRIBUTE,
+                    data: { component },
+                    fix(fixer) {
+                        if (!iconValue || typeof iconValue !== 'string')
+                            return null;
+                        const fixes = [];
+                        fixes.push(fixer.remove(iconChild));
+                        if (node.openingElement) {
+                            // JSX
+                            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}"`));
+                        }
+                        else {
+                            // Vue
+                            const attrs = openingElement.startTag.attributes;
+                            if (attrs.length > 0) {
+                                const lastAttr = attrs[attrs.length - 1];
+                                const insertPos = lastAttr.range[1];
+                                fixes.push(fixer.insertTextAfterRange([insertPos, insertPos], ` icon="${iconValue}"`));
+                            }
+                            else {
+                                const insertPos = openingElement.startTag.range[0] +
+                                    1 +
+                                    openingElement.rawName.length;
+                                fixes.push(fixer.insertTextAfterRange([insertPos, insertPos], ` icon="${iconValue}"`));
+                            }
+                        }
+                        return fixes;
+                    }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkComponent, Element: checkComponent }, { JSXElement: checkComponent });
+    }
+};

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

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

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

@@ -0,0 +1,50 @@
+import { defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure DBInput file type has accept and validate file-only attributes',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#input-file-type-validation'
+        },
+        messages: {
+            [MESSAGE_IDS.INPUT_FILE_MISSING_ACCEPT]: MESSAGES.INPUT_FILE_MISSING_ACCEPT,
+            [MESSAGE_IDS.INPUT_INVALID_MULTIPLE]: MESSAGES.INPUT_INVALID_MULTIPLE,
+            [MESSAGE_IDS.INPUT_INVALID_ACCEPT]: MESSAGES.INPUT_INVALID_ACCEPT
+        },
+        schema: []
+    },
+    create(context) {
+        const checkInput = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBInput))
+                return;
+            const type = getAttributeValue(openingElement, 'type');
+            const accept = getAttributeValue(openingElement, 'accept');
+            const multiple = getAttributeValue(openingElement, 'multiple');
+            if (type === 'file') {
+                if (!accept) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.INPUT_FILE_MISSING_ACCEPT
+                    });
+                }
+            }
+            else {
+                if (multiple) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.INPUT_INVALID_MULTIPLE
+                    });
+                }
+                if (accept) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.INPUT_INVALID_ACCEPT
+                    });
+                }
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkInput, Element: checkInput }, { JSXElement: checkInput });
+    }
+};

package/build/rules/input/input-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.INPUT_TYPE_REQUIRED]: string;
+        };
+        schema: never[];
+    };
+    create(context: any): any;
+};
+export default _default;

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

@@ -0,0 +1,54 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularFix, createAngularVisitors, createJsxVueFix, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure DBInput has type attribute for better developer experience',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#input-type-required'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.INPUT_TYPE_REQUIRED]: MESSAGES.INPUT_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.INPUT_TYPE_REQUIRED,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ' type="text"');
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBInput, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkInput = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBInput))
+                return;
+            const type = getAttributeValue(openingElement, 'type');
+            if (!type) {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.INPUT_TYPE_REQUIRED,
+                    fix(fixer) {
+                        const fixData = createJsxVueFix(node, openingElement, ' type="text"');
+                        return fixer.insertTextAfterRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkInput, Element: checkInput }, { JSXElement: checkInput });
+    }
+};

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

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

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

@@ -0,0 +1,166 @@
+import { COMPONENTS, MESSAGES, MESSAGE_IDS } from '../../shared/constants.js';
+import { createAngularFix, createAngularVisitors, defineTemplateBodyVisitor, getAttributeValue, isDBComponent } from '../../shared/utils.js';
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure external links have proper security attributes',
+            url: 'https://github.com/db-ux-design-system/core-web/blob/main/packages/eslint-plugin/README.md#link-external-security'
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_IDS.LINK_MISSING_TARGET_BLANK]: MESSAGES.LINK_MISSING_TARGET_BLANK,
+            [MESSAGE_IDS.LINK_MISSING_REFERRER_POLICY]: MESSAGES.LINK_MISSING_REFERRER_POLICY,
+            [MESSAGE_IDS.LINK_MISSING_CONTENT_EXTERNAL]: MESSAGES.LINK_MISSING_CONTENT_EXTERNAL
+        },
+        schema: []
+    },
+    create(context) {
+        const angularHandler = (node, parserServices) => {
+            const content = getAttributeValue(node, 'content');
+            const target = getAttributeValue(node, 'target');
+            const referrerPolicy = getAttributeValue(node, 'referrerPolicy');
+            const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+            if (content === 'external' && target !== '_blank') {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.LINK_MISSING_TARGET_BLANK,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ' target="_blank"');
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+            if (content === 'external' && !referrerPolicy) {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.LINK_MISSING_REFERRER_POLICY,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ' referrerPolicy="no-referrer"');
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+            if (target === '_blank' && content !== 'external') {
+                context.report({
+                    loc,
+                    messageId: MESSAGE_IDS.LINK_MISSING_CONTENT_EXTERNAL,
+                    fix(fixer) {
+                        const fixData = createAngularFix(context, node, ' content="external"');
+                        if (!fixData)
+                            return null;
+                        return fixer.insertTextBeforeRange([fixData.insertPos, fixData.insertPos], fixData.attributeText);
+                    }
+                });
+            }
+        };
+        const angularVisitors = createAngularVisitors(context, COMPONENTS.DBLink, angularHandler);
+        if (angularVisitors)
+            return angularVisitors;
+        const checkLink = (node) => {
+            const openingElement = node.openingElement || node;
+            if (!isDBComponent(openingElement, COMPONENTS.DBLink))
+                return;
+            const content = getAttributeValue(openingElement, 'content');
+            const target = getAttributeValue(openingElement, 'target');
+            const referrerPolicy = getAttributeValue(openingElement, 'referrerPolicy');
+            if (content === 'external') {
+                if (target !== '_blank') {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.LINK_MISSING_TARGET_BLANK,
+                        fix(fixer) {
+                            if (node.openingElement) {
+                                const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                                const insertPos = lastAttr
+                                    ? lastAttr.range[1]
+                                    : openingElement.name.range[1];
+                                return fixer.insertTextAfterRange([insertPos, insertPos], ' target="_blank"');
+                            }
+                            else {
+                                const attrs = openingElement.startTag.attributes;
+                                if (attrs.length > 0) {
+                                    return fixer.insertTextAfterRange([
+                                        attrs[attrs.length - 1].range[1],
+                                        attrs[attrs.length - 1].range[1]
+                                    ], ' target="_blank"');
+                                }
+                                else {
+                                    const insertPos = openingElement.startTag.range[0] +
+                                        1 +
+                                        openingElement.rawName.length;
+                                    return fixer.insertTextAfterRange([insertPos, insertPos], ' target="_blank"');
+                                }
+                            }
+                        }
+                    });
+                }
+                if (!referrerPolicy) {
+                    context.report({
+                        node: openingElement,
+                        messageId: MESSAGE_IDS.LINK_MISSING_REFERRER_POLICY,
+                        fix(fixer) {
+                            if (node.openingElement) {
+                                const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                                const insertPos = lastAttr
+                                    ? lastAttr.range[1]
+                                    : openingElement.name.range[1];
+                                return fixer.insertTextAfterRange([insertPos, insertPos], ' referrerPolicy="no-referrer"');
+                            }
+                            else {
+                                const attrs = openingElement.startTag.attributes;
+                                if (attrs.length > 0) {
+                                    return fixer.insertTextAfterRange([
+                                        attrs[attrs.length - 1].range[1],
+                                        attrs[attrs.length - 1].range[1]
+                                    ], ' referrerPolicy="no-referrer"');
+                                }
+                                else {
+                                    const insertPos = openingElement.startTag.range[0] +
+                                        1 +
+                                        openingElement.rawName.length;
+                                    return fixer.insertTextAfterRange([insertPos, insertPos], ' referrerPolicy="no-referrer"');
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+            if (target === '_blank' && content !== 'external') {
+                context.report({
+                    node: openingElement,
+                    messageId: MESSAGE_IDS.LINK_MISSING_CONTENT_EXTERNAL,
+                    fix(fixer) {
+                        if (node.openingElement) {
+                            const lastAttr = openingElement.attributes[openingElement.attributes.length - 1];
+                            const insertPos = lastAttr
+                                ? lastAttr.range[1]
+                                : openingElement.name.range[1];
+                            return fixer.insertTextAfterRange([insertPos, insertPos], ' content="external"');
+                        }
+                        else {
+                            const attrs = openingElement.startTag.attributes;
+                            if (attrs.length > 0) {
+                                return fixer.insertTextAfterRange([
+                                    attrs[attrs.length - 1].range[1],
+                                    attrs[attrs.length - 1].range[1]
+                                ], ' content="external"');
+                            }
+                            else {
+                                const insertPos = openingElement.startTag.range[0] +
+                                    1 +
+                                    openingElement.rawName.length;
+                                return fixer.insertTextAfterRange([insertPos, insertPos], ' content="external"');
+                            }
+                        }
+                    }
+                });
+            }
+        };
+        return defineTemplateBodyVisitor(context, { VElement: checkLink, Element: checkLink }, { JSXElement: checkLink });
+    }
+};