@hypersolid-dev/eslint-config 5.0.0 → 6.0.0

package/dist/plugins/react-native-a11y/rules/no-ineffective-accessibility-props.js

@@ -31,46 +31,44 @@ const noIneffectiveAccessibilityProps = createRule({
         },
         schema: [],
     },
-    create(context) {
-        return {
-            JSXOpeningElement(node) {
-                const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
-                if (role === "listitem") {
-                    context.report({ node, messageId: "listItemRole" });
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
+            if (role === "listitem") {
+                context.report({ node, messageId: "listItemRole" });
+            }
+            if (role === "alert") {
+                context.report({ node, messageId: "alertRole" });
+            }
+            const isHidden = isDefinitelyHidden(node);
+            if (isHidden && hasLabelProperty(node)) {
+                context.report({ node, messageId: "hiddenWithLabel" });
+            }
+            if (getLiteralPropertyValue(node, "accessible") === false) {
+                const name = getElementName(node);
+                if (isHidden) {
+                    context.report({ node, messageId: "hiddenWithAccessibleFalse" });
                 }
-                if (role === "alert") {
-                    context.report({ node, messageId: "alertRole" });
-                }
-                const isHidden = isDefinitelyHidden(node);
-                if (isHidden && hasLabelProperty(node)) {
-                    context.report({ node, messageId: "hiddenWithLabel" });
-                }
-                if (getLiteralPropertyValue(node, "accessible") === false) {
-                    const name = getElementName(node);
-                    if (isHidden) {
-                        context.report({ node, messageId: "hiddenWithAccessibleFalse" });
-                    }
-                    else if (name !== undefined &&
-                        DEFAULTS_TO_INACCESSIBLE.has(name) &&
-                        // A spread may carry the `accessible` this one is overriding.
-                        !hasSpreadProps(node)) {
-                        context.report({
-                            node,
-                            messageId: "accessibleFalseIsDefault",
-                            data: { name },
-                        });
-                    }
-                }
-                const labelledBy = getProperty(node, LABELLED_BY_PROPS);
-                if (labelledBy && !hasLabelProperty(node)) {
+                else if (name !== undefined &&
+                    DEFAULTS_TO_INACCESSIBLE.has(name) &&
+                    // A spread may carry the `accessible` this one is overriding.
+                    !hasSpreadProps(node)) {
                     context.report({
                         node,
-                        messageId: "labelledByWithoutLabel",
-                        data: { prop: labelledBy.name.name },
+                        messageId: "accessibleFalseIsDefault",
+                        data: { name },
                     });
                 }
-            },
-        };
-    },
+            }
+            const labelledBy = getProperty(node, LABELLED_BY_PROPS);
+            if (labelledBy && !hasLabelProperty(node)) {
+                context.report({
+                    node,
+                    messageId: "labelledByWithoutLabel",
+                    data: { prop: labelledBy.name.name },
+                });
+            }
+        },
+    }),
 });
 export default noIneffectiveAccessibilityProps;

package/dist/plugins/react-native-a11y/rules/no-invalid-accessibility-state.js

@@ -44,39 +44,37 @@ const noInvalidAccessibilityState = createRule({
         },
         schema: [],
     },
-    create(context) {
-        return {
-            JSXOpeningElement(node) {
-                const attribute = getProperty(node, "accessibilityState");
-                if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
-                    return;
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            const attribute = getProperty(node, "accessibilityState");
+            if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+                return;
+            }
+            const { expression } = attribute.value;
+            // An object literal here is already rejected by the React Native types
+            if (expression.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const resolved = resolveObjectBinding(context.sourceCode.getScope(expression), expression);
+            if (!resolved) {
+                return;
+            }
+            for (const property of resolved.properties) {
+                if (property.type !== AST_NODE_TYPES.Property ||
+                    property.key.type !== AST_NODE_TYPES.Identifier ||
+                    ACCESSIBILITY_STATE_KEYS.includes(property.key.name)) {
+                    continue;
                 }
-                const { expression } = attribute.value;
-                // An object literal here is already rejected by the React Native types
-                if (expression.type !== AST_NODE_TYPES.Identifier) {
-                    return;
-                }
-                const resolved = resolveObjectBinding(context.sourceCode.getScope(expression), expression);
-                if (!resolved) {
-                    return;
-                }
-                for (const property of resolved.properties) {
-                    if (property.type !== AST_NODE_TYPES.Property ||
-                        property.key.type !== AST_NODE_TYPES.Identifier ||
-                        ACCESSIBILITY_STATE_KEYS.includes(property.key.name)) {
-                        continue;
-                    }
-                    context.report({
-                        node: property,
-                        messageId: "invalidStateKey",
-                        data: {
-                            key: property.key.name,
-                            supported: ACCESSIBILITY_STATE_KEYS.join(", "),
-                        },
-                    });
-                }
-            },
-        };
-    },
+                context.report({
+                    node: property,
+                    messageId: "invalidStateKey",
+                    data: {
+                        key: property.key.name,
+                        supported: ACCESSIBILITY_STATE_KEYS.join(", "),
+                    },
+                });
+            }
+        },
+    }),
 });
 export default noInvalidAccessibilityState;

package/dist/plugins/react-native-a11y/rules/no-nested-focus-stops.js

@@ -30,7 +30,7 @@ const noNestedFocusStops = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         // The touchables plus whatever this project wraps them in
         const components = getComponents({
             context,
@@ -44,7 +44,7 @@ const noNestedFocusStops = createRule({
                 hasTouchHandler(node));
         };
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined ||
                     !isDefinitelyGrouped(node) ||

package/dist/plugins/react-native-a11y/rules/no-press-in-activation.js

@@ -29,13 +29,13 @@ const noPressInActivation = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({
             context,
             defaultComponents: TOUCHABLES,
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/react-native-a11y/rules/no-unnamed-interactive.js

@@ -38,10 +38,10 @@ const noUnnamedInteractive = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({ context });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/react-native-a11y/rules/require-invert-colors-opt-out.js

@@ -29,7 +29,7 @@ const requireInvertColorsOptOut = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         /**
          * Matched on the element name, so an image from expo-image or a wrapper
          * named through additionalComponents is checked the same way. Deliberately
@@ -41,7 +41,7 @@ const requireInvertColorsOptOut = createRule({
             defaultComponents: IMAGES,
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/react-native-a11y/rules/require-modal-a11y-on-sheets.js

@@ -27,7 +27,7 @@ const requireModalA11yOnSheets = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         /**
          * No default list: a sheet is whatever this project calls one, and
          * hardcoding one library's component names would fire on a codebase that
@@ -35,7 +35,7 @@ const requireModalA11yOnSheets = createRule({
          */
         const components = getComponents({ context });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/react-native-a11y/utils/get-amount-of-text-children.js

@@ -32,6 +32,20 @@ const branchesOf = (expression) => {
 };
 const isJsxChild = (expression) => expression.type === AST_NODE_TYPES.JSXElement ||
     expression.type === AST_NODE_TYPES.JSXFragment;
+const countExpressionText = (expression, amount) => {
+    if (expression.type === AST_NODE_TYPES.Literal ||
+        expression.type === AST_NODE_TYPES.TemplateLiteral) {
+        return amount + 1;
+    }
+    /**
+     * JSX inside an expression renders like any other child, and a branch
+     * that renders text still names the control
+     */
+    const rendered = (isJsxChild(expression) ? [expression] : branchesOf(expression)).filter(isJsxChild);
+    return rendered.length > 0
+        ? getAmountOfTextChildren(rendered, amount)
+        : amount;
+};
 /**
  * Counts children that render visible text, which is what makes an
  * `accessibilityLabel` redundant. Whitespace between JSX tags is not text, and
@@ -42,19 +56,7 @@ const getAmountOfTextChildren = (children, oldAmount = 0) => children.reduce((am
         return child.value.trim().length > 0 ? amount + 1 : amount;
     }
     if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
-        const { expression } = child;
-        if (expression.type === AST_NODE_TYPES.Literal ||
-            expression.type === AST_NODE_TYPES.TemplateLiteral) {
-            return amount + 1;
-        }
-        /**
-         * JSX inside an expression renders like any other child, and a branch
-         * that renders text still names the control
-         */
-        const rendered = (isJsxChild(expression) ? [expression] : branchesOf(expression)).filter(isJsxChild);
-        return rendered.length > 0
-            ? getAmountOfTextChildren(rendered, amount)
-            : amount;
+        return countExpressionText(child.expression, amount);
     }
     if (child.type === AST_NODE_TYPES.JSXFragment) {
         return getAmountOfTextChildren(child.children, amount);

package/dist/plugins/rules/boolean-guard.js

@@ -69,7 +69,7 @@ const booleanGuard = createRule({
             preferBangBang: "`!== undefined` is `!!` for this type. Write `!!{{condition}} && …`.",
         },
     },
-    create(context) {
+    create: (context) => {
         const services = ESLintUtils.getParserServices(context, true);
         if (!services.program)
             return {};
@@ -99,7 +99,7 @@ const booleanGuard = createRule({
             return reads.every((reference) => isInRenderPosition(reference.identifier));
         };
         return {
-            ConditionalExpression(node) {
+            ConditionalExpression: (node) => {
                 // The shape is what proves a `const` holding this is a guard.
                 const isConsequentGuarded = isRenderable(node.consequent) && isNothing(node.alternate);
                 const isAlternateGuarded = isRenderable(node.alternate) && isNothing(node.consequent);
@@ -122,7 +122,7 @@ const booleanGuard = createRule({
                     data: { condition: isAlternateGuarded ? `!${nameOf(node.test)}` : nameOf(node.test) },
                 });
             },
-            LogicalExpression(node) {
+            LogicalExpression: (node) => {
                 if (node.operator !== "&&")
                     return;
                 if (!isInRenderPosition(node))

package/dist/plugins/rules/comment-style.js

@@ -74,7 +74,7 @@ export default createRule({
             tooLong: "This comment line is {{length}} characters. Keep it to {{max}}.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         const maxLength = context.options[0]?.maxLength;
         const isTooLong = (comment) => Boolean(maxLength) && lineLength(comment) > (maxLength ?? 0);
@@ -86,7 +86,7 @@ export default createRule({
             });
         };
         return {
-            "Program:exit"() {
+            "Program:exit": () => {
                 let run = [];
                 const doesContinue = (comment) => {
                     const last = run.at(-1);
@@ -108,48 +108,57 @@ export default createRule({
                     }
                     run = [];
                 };
-                for (const comment of sourceCode.getAllComments()) {
-                    if (comment.type === AST_TOKEN_TYPES.Block) {
-                        const rows = comment.loc.end.line - comment.loc.start.line + 1;
-                        // A JSX comment's `{` is syntax, so a row holding only `{/* … */}` starts its row.
-                        const isOwnRow = isRowStart(sourceCode, comment) ||
-                            (isJsxComment(sourceCode, comment) &&
-                                !sourceCode.lines[comment.loc.start.line - 1]
-                                    ?.slice(0, Math.max(0, comment.loc.start.column - 1))
-                                    .trim());
-                        if (!isJsdoc(comment) && rows === 1 && isOwnRow) {
-                            if (!doesContinue(comment))
-                                flush();
-                            run.push(comment);
-                            continue;
-                        }
-                        flush();
-                        if (isJsdoc(comment)) {
-                            if (isTooLong(comment))
-                                reportTooLong(comment);
-                            continue;
-                        }
-                        if (rows > 1) {
-                            context.report({
-                                loc: comment.loc,
-                                messageId: isJsxComment(sourceCode, comment) ? "jsxBlock" : "blockRun",
-                                data: { rows: String(rows) },
-                            });
-                        }
-                        else if (isTooLong(comment)) {
+                /** A JSX comment's `{` is syntax, so a row holding only a braced JSX comment starts its row. */
+                const isOwnRow = (comment) => isRowStart(sourceCode, comment) ||
+                    (isJsxComment(sourceCode, comment) &&
+                        !sourceCode.lines[comment.loc.start.line - 1]
+                            ?.slice(0, Math.max(0, comment.loc.start.column - 1))
+                            .trim());
+                /** A block comment that is not part of a run: JSDoc, multi-row, or sharing its row with code. */
+                const checkLoneBlock = (comment, rows) => {
+                    if (isJsdoc(comment)) {
+                        if (isTooLong(comment))
                             reportTooLong(comment);
-                        }
-                        continue;
+                        return;
+                    }
+                    if (rows > 1) {
+                        context.report({
+                            loc: comment.loc,
+                            messageId: isJsxComment(sourceCode, comment) ? "jsxBlock" : "blockRun",
+                            data: { rows: String(rows) },
+                        });
                     }
+                    else if (isTooLong(comment)) {
+                        reportTooLong(comment);
+                    }
+                };
+                const visitBlock = (comment) => {
+                    const rows = comment.loc.end.line - comment.loc.start.line + 1;
+                    if (!isJsdoc(comment) && rows === 1 && isOwnRow(comment)) {
+                        if (!doesContinue(comment))
+                            flush();
+                        run.push(comment);
+                        return;
+                    }
+                    flush();
+                    checkLoneBlock(comment, rows);
+                };
+                const visitLine = (comment) => {
                     if (!doesContinue(comment))
                         flush();
                     if (!isRowStart(sourceCode, comment)) {
                         flush();
                         if (isTooLong(comment))
                             reportTooLong(comment);
-                        continue;
+                        return;
                     }
                     run.push(comment);
+                };
+                for (const comment of sourceCode.getAllComments()) {
+                    if (comment.type === AST_TOKEN_TYPES.Block)
+                        visitBlock(comment);
+                    else
+                        visitLine(comment);
                 }
                 flush();
             },

package/dist/plugins/rules/effect-takes-callback.js

@@ -48,7 +48,7 @@ const effectTakesCallback = createRule({
             callbackFirst: "`{{name}}` ends in Effect but its first parameter is not a callback. Take the callback first, or drop the Effect suffix.",
         },
     },
-    create(context) {
+    create: (context) => {
         const services = context.sourceCode.parserServices;
         const checker = services?.program ? services.program.getTypeChecker() : undefined;
         /** Whether a value of this type can be called, once `undefined` is set aside. */

package/dist/plugins/rules/jsdoc-for-props.js

@@ -28,7 +28,7 @@ export default createRule({
             form: "Write this as a JSDoc block, not `{{ form }}`. A member's comment is what an editor shows when someone hovers it elsewhere, and only JSDoc reaches there.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         const check = (node) => {
             // A directive neither documents the member nor separates it from the comment above.

package/dist/plugins/rules/no-callback-payload.js

@@ -2,6 +2,18 @@ import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import createRule from "../utils/create-rule.js";
 import { componentName, isWrapperCall } from "../utils/component-name.js";
 const CALLBACK_PATTERN = /^on[A-Z]/;
+/** Adds each identifier an object pattern binds to `props`, and its rest binding to `objects` too. */
+const addPatternBindings = (pattern, props, objects) => {
+    for (const property of pattern.properties) {
+        const value = property.type === AST_NODE_TYPES.RestElement ? property.argument : property.value;
+        const binding = value.type === AST_NODE_TYPES.AssignmentPattern ? value.left : value;
+        if (binding.type !== AST_NODE_TYPES.Identifier)
+            continue;
+        props.add(binding);
+        if (property.type === AST_NODE_TYPES.RestElement)
+            objects.add(binding);
+    }
+};
 /** The first parameter's bindings: each prop it destructures, and the props object itself or a rest of it. */
 const propertyBindings = (parameter) => {
     const props = new Set();
@@ -11,17 +23,8 @@ const propertyBindings = (parameter) => {
         props.add(target);
         objects.add(target);
     }
-    if (target?.type === AST_NODE_TYPES.ObjectPattern) {
-        for (const property of target.properties) {
-            const value = property.type === AST_NODE_TYPES.RestElement ? property.argument : property.value;
-            const binding = value.type === AST_NODE_TYPES.AssignmentPattern ? value.left : value;
-            if (binding.type !== AST_NODE_TYPES.Identifier)
-                continue;
-            props.add(binding);
-            if (property.type === AST_NODE_TYPES.RestElement)
-                objects.add(binding);
-        }
-    }
+    if (target?.type === AST_NODE_TYPES.ObjectPattern)
+        addPatternBindings(target, props, objects);
     return { props, objects };
 };
 /**
@@ -53,7 +56,7 @@ const noCallbackPayload = createRule({
             payload: "`{{ callback }}` is called with values `{{ component }}` only received from its parent. Let the parent bind them where it passes `{{ callback }}`, and call it with what this component itself knows (or nothing), so the component stays free of the payload's domain shape.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         const exported = new Set();
         const pending = [];
@@ -173,7 +176,7 @@ const noCallbackPayload = createRule({
             ArrowFunctionExpression: check,
             FunctionDeclaration: check,
             FunctionExpression: check,
-            ExportDefaultDeclaration(node) {
+            ExportDefaultDeclaration: (node) => {
                 // `export default memo(Row)` exports `Row`, however many wrappers it is under.
                 let declaration = node.declaration;
                 while (isWrapperCall(declaration))
@@ -187,7 +190,7 @@ const noCallbackPayload = createRule({
                     exported.add(declaration.id.name);
                 }
             },
-            ExportNamedDeclaration(node) {
+            ExportNamedDeclaration: (node) => {
                 for (const specifier of node.specifiers) {
                     if (specifier.local.type === AST_NODE_TYPES.Identifier)
                         exported.add(specifier.local.name);
@@ -202,7 +205,7 @@ const noCallbackPayload = createRule({
                     }
                 }
             },
-            "Program:exit"() {
+            "Program:exit": () => {
                 for (const { node, data } of pending) {
                     if (exported.has(data.component))
                         context.report({ node, messageId: "payload", data });

package/dist/plugins/rules/no-markup-variable.js

@@ -63,7 +63,45 @@ const noMarkupVariable = createRule({
             inline: "`{{ name }}` holds JSX that `{{ component }}` reads only once. Write it where it is rendered.",
         },
     },
-    create(context) {
+    create: (context) => {
+        /** Read once, never reassigned, and that read is a JSX child rather than an attribute value. */
+        const isRenderedOnceInline = (declarator) => {
+            const variable = context.sourceCode.getDeclaredVariables(declarator).at(0);
+            const references = variable?.references ?? [];
+            const reads = references.filter((ref) => ref.isRead());
+            const isReassigned = references.some((ref) => ref.isWrite() && ref.identifier !== declarator.id);
+            const container = reads.at(0)?.identifier.parent;
+            return (reads.length === 1 &&
+                !isReassigned &&
+                container?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+                container.parent.type !== AST_NODE_TYPES.JSXAttribute);
+        };
+        const checkDeclarator = (declarator, component) => {
+            if (declarator.id.type !== AST_NODE_TYPES.Identifier)
+                return;
+            const jsx = drawnJsx(declarator.init);
+            if (jsx.length === 0)
+                return;
+            if (jsx.some(hasStyledElement)) {
+                context.report({
+                    node: declarator.id,
+                    messageId: "extract",
+                    data: {
+                        name: declarator.id.name,
+                        component,
+                        suggestion: `${component}${toComponentName(declarator.id.name)}`,
+                    },
+                });
+                return;
+            }
+            if (isRenderedOnceInline(declarator)) {
+                context.report({
+                    node: declarator.id,
+                    messageId: "inline",
+                    data: { name: declarator.id.name, component },
+                });
+            }
+        };
         const check = (fn) => {
             const component = componentName(fn);
             if (!component || fn.body.type !== AST_NODE_TYPES.BlockStatement)
@@ -71,40 +109,8 @@ const noMarkupVariable = createRule({
             for (const statement of fn.body.body) {
                 if (statement.type !== AST_NODE_TYPES.VariableDeclaration)
                     continue;
-                for (const declarator of statement.declarations) {
-                    if (declarator.id.type !== AST_NODE_TYPES.Identifier)
-                        continue;
-                    const jsx = drawnJsx(declarator.init);
-                    if (jsx.length === 0)
-                        continue;
-                    if (!jsx.some(hasStyledElement)) {
-                        const variable = context.sourceCode.getDeclaredVariables(declarator).at(0);
-                        const references = variable?.references ?? [];
-                        const reads = references.filter((ref) => ref.isRead());
-                        const isReassigned = references.some((ref) => ref.isWrite() && ref.identifier !== declarator.id);
-                        const container = reads.at(0)?.identifier.parent;
-                        if (reads.length === 1 &&
-                            !isReassigned &&
-                            container?.type === AST_NODE_TYPES.JSXExpressionContainer &&
-                            container.parent.type !== AST_NODE_TYPES.JSXAttribute) {
-                            context.report({
-                                node: declarator.id,
-                                messageId: "inline",
-                                data: { name: declarator.id.name, component },
-                            });
-                        }
-                        continue;
-                    }
-                    context.report({
-                        node: declarator.id,
-                        messageId: "extract",
-                        data: {
-                            name: declarator.id.name,
-                            component,
-                            suggestion: `${component}${toComponentName(declarator.id.name)}`,
-                        },
-                    });
-                }
+                for (const declarator of statement.declarations)
+                    checkDeclarator(declarator, component);
             }
         };
         return {

package/dist/plugins/rules/no-unnecessary-use-callback.js

@@ -84,10 +84,10 @@ const noUnnecessaryUseCallback = createRule({
             unnecessary: "This callback captures no render-local values. Use an existing function or define it at module scope, unless a proven per-instance identity contract requires memoization; explain that contract in a scoped suppression.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         return {
-            CallExpression(node) {
+            CallExpression: (node) => {
                 if (!isUseCallback(sourceCode, node.callee))
                     return;
                 const [callback, dependencies] = [node.arguments.at(0), node.arguments.at(1)];

package/dist/plugins/rules/regex-pattern-const.js

@@ -64,7 +64,7 @@ export default createRule({
             rename: "Rename `{{name}}` to end in `_PATTERN` (SCREAMING_SNAKE_CASE), so the name says it is a regular expression.",
         },
     },
-    create(context) {
+    create: (context) => {
         const check = (node) => {
             if (!isRegex(node))
                 return;