@hypersolid-dev/eslint-config 4.0.0 → 6.0.0

package/dist/plugins/rules/test-id-default.js

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import createRule from '../utils/create-rule.js';
+/**
+ * A component's `testID` prop defaults to the component's own name, kebab-cased.
+ *
+ * Undefaulted, `testID` exists only when a caller passes one, so every derived
+ * child needs an `undefined` guard. With a default it is a string inside the
+ * component and a child is `` `${testID}-photo` ``. The default is a floor, not
+ * a guarantee of uniqueness.
+ *
+ * Only the file's own component is asked: `Crest` in `Crest.tsx` (or in
+ * `Crest/index.tsx`), through `memo`/`forwardRef`, plus an anonymous default
+ * export. A platform suffix (`Crest.ios.tsx`) is dropped. A file whose name is
+ * not PascalCase (`home.tsx`, a route) is skipped.
+ *
+ * Reported: `missing` (destructured with no default, in the parameter or as
+ * `const { testID } = props`), `wrong` (a default that is not the kebab-cased
+ * name), `readsProp` (`props.testID` read off the props object or its rest).
+ *
+ * Limits: a `testID` passed through `{...props}`, a copied props object, and a
+ * component whose name does not match its file are not seen.
+ */
+const HOC_NAMES = new Set(['memo', 'forwardRef']);
+const FUNCTION_TYPES = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
+const TS_WRAPPERS = new Set(['TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression']);
+// The platform suffix on a source file names the build, not the component.
+const PLATFORM_PATTERN = /\.(?:native|ios|android|androidtv|tv|tvos|web)$/;
+const EXTENSION_PATTERN = /\.[jt]sx?$/;
+const PASCAL_CASE_PATTERN = /^[A-Z]/;
+const LOWER_TO_UPPER_PATTERN = /(?<=[a-z0-9])(?=[A-Z])/g;
+const ACRONYM_END_PATTERN = /(?<=[A-Z])(?=[A-Z][a-z])/g;
+/** `CompetitionLogo` -> `competition-logo`, `AdSlotURLBar` -> `ad-slot-url-bar`. */
+const kebab = (name) => name.replaceAll(LOWER_TO_UPPER_PATTERN, '-').replaceAll(ACRONYM_END_PATTERN, '-').toLowerCase();
+/** The component a file is named for: its basename, or its folder's for an `index` file. */
+const componentName = (filename) => {
+    const name = path.basename(filename).replace(EXTENSION_PATTERN, '').replace(PLATFORM_PATTERN, '');
+    return name === 'index' ? path.basename(path.dirname(filename)) : name;
+};
+const isHoc = (callee) => {
+    if (callee.type === AST_NODE_TYPES.Identifier)
+        return HOC_NAMES.has(callee.name);
+    return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && HOC_NAMES.has(callee.property.name);
+};
+const isFunction = (node) => Boolean(node && FUNCTION_TYPES.has(node.type));
+/** Through `memo(…)`, `forwardRef(…)` and type assertions, to the component inside. */
+const unwrapComponent = (node) => {
+    let current = node ?? undefined;
+    while (current) {
+        if (TS_WRAPPERS.has(current.type))
+            current = current.expression;
+        else if (current.type === AST_NODE_TYPES.CallExpression && isHoc(current.callee))
+            current = current.arguments[0];
+        else
+            return current;
+    }
+    return current;
+};
+/** What a function is held by, out through the calls and assertions it is declared behind. */
+const heldBy = (fn) => {
+    let held = fn.parent;
+    while (held && (held.type === AST_NODE_TYPES.CallExpression || TS_WRAPPERS.has(held.type)))
+        held = held.parent;
+    return held;
+};
+/** Whether a function is the file's own component: named `component`, or an anonymous default export. */
+const isComponent = (fn, component) => {
+    if (fn.type === AST_NODE_TYPES.FunctionDeclaration)
+        return !fn.id || fn.id.name === component;
+    const held = heldBy(fn);
+    if (held?.type === AST_NODE_TYPES.ExportDefaultDeclaration)
+        return true;
+    return held?.type === AST_NODE_TYPES.VariableDeclarator && held.id.type === AST_NODE_TYPES.Identifier && held.id.name === component;
+};
+/** The `testID` property of a destructured parameter or declarator. */
+const testIdProperty = (pattern) => {
+    if (pattern?.type !== AST_NODE_TYPES.ObjectPattern)
+        return undefined;
+    return pattern.properties.find((property) => property.type === AST_NODE_TYPES.Property && !property.computed && property.key.type === AST_NODE_TYPES.Identifier && property.key.name === 'testID');
+};
+/** The names a component's props object goes by: the first parameter, or the rest of a destructured one without `testID`. */
+const propsNames = (fn) => {
+    const first = fn.params.at(0);
+    if (first?.type === AST_NODE_TYPES.Identifier)
+        return [first.name];
+    if (first?.type !== AST_NODE_TYPES.ObjectPattern || testIdProperty(first))
+        return [];
+    const rest = first.properties.find((property) => property.type === AST_NODE_TYPES.RestElement);
+    return rest?.argument.type === AST_NODE_TYPES.Identifier ? [rest.argument.name] : [];
+};
+/** The file's own component that `node` sits in, however deep in callbacks. */
+const ownComponentAround = (node, component) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (isFunction(current) && isComponent(current, component))
+            return current;
+    }
+    return undefined;
+};
+const testIdDefault = createRule({
+    name: 'test-id-default',
+    meta: {
+        defaultOptions: [],
+        type: 'problem',
+        docs: { description: "A component's `testID` prop defaults to its own name in kebab-case." },
+        schema: [],
+        messages: {
+            missing: 'Default this to `"{{ expected }}"`: an undefaulted `testID` is a handle that exists only when a caller passes one, so every derived child needs an `undefined` guard beside it. With the default, `testID` is a string inside the component and a child is `` `${testID}-photo` ``.',
+            readsProp: 'Destructure `testID` with the default `"{{ expected }}"` instead of reading `{{ object }}.testID`: an undefaulted `testID` is a handle that exists only when a caller passes one, and a `??` at the use site is that guard written one place at a time.',
+            wrong: 'Default this to `"{{ expected }}"`, not `{{ actual }}`: the default is the component\'s own name in kebab-case, so a reader can predict the id without opening the file.',
+        },
+    },
+    create: (context) => {
+        const component = componentName(context.filename);
+        // The file's own component only; anything else in here is private to it.
+        if (!PASCAL_CASE_PATTERN.test(component))
+            return {};
+        const expected = kebab(component);
+        const check = (property) => {
+            if (!property)
+                return;
+            if (property.value.type !== AST_NODE_TYPES.AssignmentPattern) {
+                context.report({ node: property, messageId: 'missing', data: { expected } });
+                return;
+            }
+            const { right } = property.value;
+            // A substitution-free template is a string written the long way, as `test-id-format` accepts.
+            let written;
+            if (right.type === AST_NODE_TYPES.Literal)
+                written = String(right.value);
+            else if (right.type === AST_NODE_TYPES.TemplateLiteral && right.expressions.length === 0)
+                written = right.quasis[0]?.value.cooked ?? undefined;
+            if (written === expected)
+                return;
+            context.report({
+                node: right,
+                messageId: 'wrong',
+                data: { expected, actual: written === undefined ? 'this' : `"${written}"` },
+            });
+        };
+        const checkFunction = (node, name) => {
+            if (isFunction(node) && name === component)
+                check(testIdProperty(node.params[0]));
+        };
+        return {
+            VariableDeclarator: (node) => {
+                // `const { testID } = props` inside the file's own component reads the same prop.
+                if (node.id.type === AST_NODE_TYPES.ObjectPattern && node.init?.type === AST_NODE_TYPES.Identifier) {
+                    const fn = ownComponentAround(node, component);
+                    if (fn && propsNames(fn).includes(node.init.name))
+                        check(testIdProperty(node.id));
+                    return;
+                }
+                if (node.id.type === AST_NODE_TYPES.Identifier)
+                    checkFunction(unwrapComponent(node.init), node.id.name);
+            },
+            FunctionDeclaration: (node) => {
+                if (node.id)
+                    checkFunction(node, node.id.name);
+                else if (node.parent.type === AST_NODE_TYPES.ExportDefaultDeclaration)
+                    checkFunction(node, component);
+            },
+            // `export default memo(({ testID }) => …)`: the anonymous component.
+            ExportDefaultDeclaration: (node) => {
+                const init = unwrapComponent(node.declaration);
+                if (init?.type !== AST_NODE_TYPES.FunctionDeclaration)
+                    checkFunction(init, component);
+            },
+            // `props.testID` read inside the component, with no default anywhere.
+            MemberExpression: (node) => {
+                if (node.computed || node.property.type !== AST_NODE_TYPES.Identifier || node.property.name !== 'testID')
+                    return;
+                if (node.object.type !== AST_NODE_TYPES.Identifier)
+                    return;
+                const fn = ownComponentAround(node, component);
+                if (!fn || !propsNames(fn).includes(node.object.name))
+                    return;
+                context.report({ node, messageId: 'readsProp', data: { expected, object: node.object.name } });
+            },
+        };
+    },
+});
+export default testIdDefault;

package/dist/plugins/rules/test-id-format.d.ts

@@ -0,0 +1,4 @@
+declare const testIdFormat: import("@typescript-eslint/utils/ts-eslint").RuleModule<"format", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default testIdFormat;

package/dist/plugins/rules/test-id-format.js

@@ -0,0 +1,118 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import createRule from '../utils/create-rule.js';
+import { leavesOf } from '../utils/expressions.js';
+/**
+ * A `testID` written out in full is lowercase kebab-case: `crest`,
+ * `vote-input`, `top-scorers-card-home-crest`.
+ *
+ * One alphabet, one separator. Test tools match ids case-sensitively, and
+ * Maestro matches `id:` as a regular expression where `.` is a wildcard, so a
+ * dash is the one separator that survives. Depth is a dash too, which lets a
+ * component derive a child (`` `${testID}-photo` ``) the same way at every level.
+ *
+ * Reported (`format`, with a suggested spelling): a written string in a JSX
+ * `testID` attribute, a `testID` default in a destructuring, or a `testID:`
+ * property of an object, read through ternaries, logicals, type wrappers,
+ * `Platform.select` and local `const`s. The written pieces of an interpolated id
+ * are checked as fragments, which may begin or end on the joining dash.
+ *
+ * Limits: a runtime value (`slug(name)`, `"Home" + "_Crest"`) is not read.
+ */
+const FORMAT_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+// A piece between substitutions: may start or end on a join dash, or be only dashes.
+const FRAGMENT_PATTERN = /^(?:-+|-?[a-z0-9]+(?:-[a-z0-9]+)*-?)$/;
+const LOWER_TO_UPPER_PATTERN = /(?<=[a-z0-9])(?=[A-Z])/g;
+const ACRONYM_END_PATTERN = /(?<=[A-Z])(?=[A-Z][a-z])/g;
+const NON_ALPHANUMERIC_RUN_PATTERN = /[^A-Za-z0-9]+/g;
+const EDGE_DASHES_PATTERN = /^-+|-+$/g;
+const LEADING_SEPARATOR_PATTERN = /^[^A-Za-z0-9]/;
+const TRAILING_SEPARATOR_PATTERN = /[^A-Za-z0-9]$/;
+const TEST_ID = 'testID';
+/** `Match.playerItem_photo` -> `match-player-item-photo`. */
+const kebab = (value) => value
+    .replaceAll(LOWER_TO_UPPER_PATTERN, '-')
+    .replaceAll(ACRONYM_END_PATTERN, '-')
+    .replaceAll(NON_ALPHANUMERIC_RUN_PATTERN, '-')
+    .replaceAll(EDGE_DASHES_PATTERN, '')
+    .toLowerCase();
+/** A piece between substitutions keeps a separator where it meets one: `_photo` becomes `-photo`. */
+const kebabFragment = (value) => {
+    const core = kebab(value);
+    const lead = LEADING_SEPARATOR_PATTERN.test(value) ? '-' : '';
+    const trail = TRAILING_SEPARATOR_PATTERN.test(value) ? '-' : '';
+    return core ? `${lead}${core}${trail}` : '-';
+};
+/** Whether `inner` is written inside `outer`, rather than elsewhere in the file. */
+const isInside = (outer, inner) => inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+/** The written string an expression is, or `undefined` when it is not one. */
+const writtenString = (node) => {
+    if (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string')
+        return node.value;
+    // A template with nothing substituted is a literal written the long way.
+    if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? undefined;
+    return undefined;
+};
+const testIdFormat = createRule({
+    name: 'test-id-format',
+    meta: {
+        defaultOptions: [],
+        type: 'problem',
+        docs: { description: 'A written `testID` is lowercase kebab-case.' },
+        schema: [],
+        messages: {
+            format: 'Write this `testID` as `{{ suggestion }}`, not "{{ value }}": an id is lowercase kebab-case throughout, depth included. A dot is a wildcard in Maestro\'s `id:` matcher, and a capital is one shift key away from a flake — so a child derives with a dash, `` `${testID}-remote-image` ``, at every level.',
+        },
+    },
+    create: (context) => {
+        // Reported on the string when it sits inside the expression, else on the expression a name led from.
+        const check = (expression, leaf) => {
+            const value = writtenString(leaf);
+            if (value === undefined || FORMAT_PATTERN.test(value))
+                return;
+            context.report({
+                node: isInside(expression, leaf) ? leaf : expression,
+                messageId: 'format',
+                data: { value, suggestion: kebab(value) },
+            });
+        };
+        const checkFragments = (expression, leaf) => {
+            if (leaf.type !== AST_NODE_TYPES.TemplateLiteral || leaf.expressions.length === 0)
+                return;
+            for (const quasi of leaf.quasis) {
+                const text = quasi.value.cooked;
+                if (!text || FRAGMENT_PATTERN.test(text))
+                    continue;
+                context.report({
+                    node: isInside(expression, quasi) ? quasi : expression,
+                    messageId: 'format',
+                    data: { value: text, suggestion: kebabFragment(text) },
+                });
+            }
+        };
+        const checkExpression = (expression) => {
+            for (const leaf of leavesOf(context, expression)) {
+                check(expression, leaf);
+                checkFragments(expression, leaf);
+            }
+        };
+        return {
+            JSXAttribute: (node) => {
+                if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== TEST_ID)
+                    return;
+                const { value } = node;
+                if (value?.type === AST_NODE_TYPES.Literal)
+                    check(value, value);
+                if (value?.type === AST_NODE_TYPES.JSXExpressionContainer)
+                    checkExpression(value.expression);
+            },
+            // A `testID` default, and a `testID:` in an options or fixture object.
+            Property: (node) => {
+                if (node.computed || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== TEST_ID)
+                    return;
+                checkExpression(node.value.type === AST_NODE_TYPES.AssignmentPattern ? node.value.right : node.value);
+            },
+        };
+    },
+});
+export default testIdFormat;

package/dist/plugins/rules/test-id-from-props.d.ts

@@ -0,0 +1,4 @@
+declare const testIdFromProps: import("@typescript-eslint/utils/ts-eslint").RuleModule<"static" | "prefixed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default testIdFromProps;

package/dist/plugins/rules/test-id-from-props.js

@@ -0,0 +1,90 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import createRule from '../utils/create-rule.js';
+import { leavesOf } from '../utils/expressions.js';
+/**
+ * A component's `testID` comes from its props, never a string it writes itself.
+ *
+ * A static id is the same string on every instance, so two in one tree become
+ * one ambiguous query, and on the root it silently wins over the id a parent
+ * passes. The root takes `testID`; anything below derives with a template.
+ *
+ * Reported on a JSX `testID` attribute:
+ *
+ * - `static`: a string literal, a substitution-free template, or a local name
+ *   that resolves to one.
+ * - `prefixed`: a template that interpolates but opens with written text.
+ *
+ * Accepted: a derived value however it is built (a template starting with a
+ * substitution, a call, a member read, a conditional or logical with a name on
+ * either side, a parameter, an import). The rule does not prove a name is a prop.
+ *
+ * Limits: an imported constant, a call returning a fixed string, a ternary with
+ * a prop on one side and a `let` all pass; only the `testID` attribute is read.
+ */
+const TEST_ID = 'testID';
+/** A value spelled out where it stands, rather than reached for. */
+const isWritten = (node) => (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') || (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0);
+/** Whether an expression reaches outside itself for its value. */
+const isReadingAName = (context, node) => {
+    switch (node.type) {
+        // A local name bound to a written string is that string; anything unresolved is trusted.
+        case AST_NODE_TYPES.Identifier:
+        case AST_NODE_TYPES.MemberExpression: {
+            const leaves = leavesOf(context, node);
+            return leaves.length === 0 || !leaves.every(isWritten);
+        }
+        case AST_NODE_TYPES.CallExpression:
+            return true;
+        // The id has to start from something a caller gave: `${testID}-row`.
+        case AST_NODE_TYPES.TemplateLiteral:
+            return node.expressions.length > 0 && node.quasis[0]?.value.cooked === '';
+        case AST_NODE_TYPES.ConditionalExpression:
+            return isReadingAName(context, node.consequent) || isReadingAName(context, node.alternate);
+        case AST_NODE_TYPES.LogicalExpression:
+            return isReadingAName(context, node.left) || isReadingAName(context, node.right);
+        case AST_NODE_TYPES.TSAsExpression:
+        case AST_NODE_TYPES.TSSatisfiesExpression:
+        case AST_NODE_TYPES.TSNonNullExpression:
+            return isReadingAName(context, node.expression);
+        default:
+            return false;
+    }
+};
+/** How to name the offending id: a name is followed to the string behind it. */
+const writtenValue = (context, node) => {
+    if (node?.type === AST_NODE_TYPES.Literal && typeof node.value === 'string')
+        return `"${node.value}"`;
+    const strings = (node ? leavesOf(context, node) : [])
+        .filter(isWritten)
+        .map((leaf) => (leaf.type === AST_NODE_TYPES.Literal ? leaf.value : leaf.quasis[0]?.value.cooked));
+    return strings.length === 1 ? `"${String(strings[0])}"` : 'a fixed value';
+};
+const testIdFromProps = createRule({
+    name: 'test-id-from-props',
+    meta: {
+        defaultOptions: [],
+        type: 'problem',
+        docs: { description: "A component's `testID` comes from its props, never a string it writes itself." },
+        schema: [],
+        messages: {
+            static: 'Derive this `testID` from a prop instead of writing {{ value }}: a fixed id is the same string on every instance, so two of these in one tree become one ambiguous query and a caller cannot tell them apart. The root takes `testID`, which every component defaults to its own name, and a node below it suffixes that.',
+            prefixed: 'Start this `testID` from the `testID` prop rather than the written "{{ prefix }}": what follows it may differ per instance, but the prefix spells out a name the prop already carries, so a caller cannot scope or rename it. Write `` `${testID}-…` ``.',
+        },
+    },
+    create: (context) => ({
+        JSXAttribute: (node) => {
+            if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== TEST_ID)
+                return;
+            const { value } = node;
+            const expression = value?.type === AST_NODE_TYPES.JSXExpressionContainer ? value.expression : (value ?? undefined);
+            if (value?.type === AST_NODE_TYPES.JSXExpressionContainer && isReadingAName(context, value.expression))
+                return;
+            if (expression?.type === AST_NODE_TYPES.TemplateLiteral && expression.expressions.length > 0) {
+                context.report({ node, messageId: 'prefixed', data: { prefix: expression.quasis[0]?.value.cooked } });
+                return;
+            }
+            context.report({ node, messageId: 'static', data: { value: writtenValue(context, expression) } });
+        },
+    }),
+});
+export default testIdFromProps;

package/dist/plugins/rules/undefined-check.d.ts

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

package/dist/plugins/rules/undefined-check.js

@@ -0,0 +1,64 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import { isSameAsBangBang, undefinedComparison } from "../utils/types.js";
+/** The slots where a value is being asked whether it is there. */
+const isCondition = (node) => {
+    const { parent } = node;
+    if (!parent)
+        return false;
+    if (parent.type === AST_NODE_TYPES.IfStatement ||
+        parent.type === AST_NODE_TYPES.WhileStatement ||
+        parent.type === AST_NODE_TYPES.DoWhileStatement ||
+        parent.type === AST_NODE_TYPES.ConditionalExpression ||
+        parent.type === AST_NODE_TYPES.ForStatement) {
+        return parent.test === node;
+    }
+    /**
+     * A `&&` or `||` is a condition only where the whole expression is one:
+     * `const isReady = user !== undefined && loaded` is a value.
+     */
+    if (parent.type === AST_NODE_TYPES.LogicalExpression) {
+        return (parent.operator === "&&" || parent.operator === "||") && isCondition(parent);
+    }
+    return parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "!";
+};
+const undefinedCheck = createRule({
+    name: "undefined-check",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "Disallow a comparison against `undefined` that the value's own truthiness already makes.",
+        },
+        schema: [],
+        messages: {
+            redundant: "`{{ text }}` is `{{ suggestion }}` for this type: `undefined` is the only falsy value it admits, so the comparison draws no line. Write the value.",
+        },
+    },
+    create: (context) => {
+        const services = ESLintUtils.getParserServices(context, true);
+        if (!services.program)
+            return {};
+        const checker = services.program.getTypeChecker();
+        return {
+            BinaryExpression: (node) => {
+                if (!isCondition(node))
+                    return;
+                const compared = undefinedComparison(node);
+                if (!compared)
+                    return;
+                if (!isSameAsBangBang(services.getTypeAtLocation(compared.value), checker))
+                    return;
+                const text = context.sourceCode.getText(compared.value);
+                // `=== undefined` is the negation, so it keeps its `!`.
+                const suggestion = compared.isPresent ? text : `!${text}`;
+                context.report({
+                    node,
+                    messageId: "redundant",
+                    data: { text: context.sourceCode.getText(node), suggestion },
+                });
+            },
+        };
+    },
+});
+export default undefinedCheck;

package/dist/plugins/rules/webview-allow-list.d.ts

@@ -0,0 +1,5 @@
+import { TSESLint } from '@typescript-eslint/utils';
+declare const webviewAllowList: TSESLint.RuleModule<"missingHandler" | "missingWhitelist" | "narrowWhitelist", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default webviewAllowList;

package/dist/plugins/rules/webview-allow-list.js

@@ -0,0 +1,105 @@
+import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
+import createRule from '../utils/create-rule.js';
+import { unwrap } from '../utils/expressions.js';
+/**
+ * A `react-native-webview` `WebView` sends every navigation through its
+ * `onShouldStartLoadWithRequest`, so that handler is the allow-list.
+ *
+ * The library checks `originWhitelist` first and hands a URL outside it to
+ * `Linking.openURL` without asking the handler. The default list is
+ * `["http://*", "https://*"]`, so a page's `tel:`, `sms:` or `intent:` link opens
+ * another app however strict the handler is. `["*"]` is the one value that
+ * leaves every decision to the handler.
+ *
+ * Reports a `WebView` without an always-present `onShouldStartLoadWithRequest`,
+ * without `originWhitelist`, or whose `originWhitelist` is not an inline array
+ * holding `"*"`.
+ *
+ * Limits: matched through its import from `react-native-webview` (default,
+ * named or namespace), so a re-export or wrapper escapes; a spread is not read.
+ */
+const { DefinitionType } = TSESLint.Scope;
+const SOURCE = 'react-native-webview';
+const WEBVIEW = 'WebView';
+const HANDLER = 'onShouldStartLoadWithRequest';
+/** Whether a JSX name resolves to the library's `WebView` import. */
+const isWebView = (context, name) => {
+    const identifier = name.type === AST_NODE_TYPES.JSXMemberExpression ? name.object : name;
+    if (identifier.type !== AST_NODE_TYPES.JSXIdentifier)
+        return false;
+    let scope = context.sourceCode.getScope(name);
+    while (scope && !scope.set.has(identifier.name))
+        scope = scope.upper;
+    const definition = scope?.set.get(identifier.name)?.defs[0];
+    if (definition?.type !== DefinitionType.ImportBinding || definition.parent.type !== AST_NODE_TYPES.ImportDeclaration)
+        return false;
+    if (definition.parent.source.value !== SOURCE)
+        return false;
+    const { node } = definition;
+    if (name.type === AST_NODE_TYPES.JSXMemberExpression)
+        return node.type === AST_NODE_TYPES.ImportNamespaceSpecifier && name.property.name === WEBVIEW;
+    if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier)
+        return true;
+    if (node.type !== AST_NODE_TYPES.ImportSpecifier)
+        return false;
+    const imported = node.imported.type === AST_NODE_TYPES.Identifier ? node.imported.name : node.imported.value;
+    return imported === WEBVIEW;
+};
+/** `undefined`, `null`, or a branch that can be one: the prop is set and still absent. */
+const canBeAbsent = (expression) => {
+    switch (expression.type) {
+        case AST_NODE_TYPES.JSXEmptyExpression:
+            return true;
+        case AST_NODE_TYPES.Identifier:
+            return expression.name === 'undefined';
+        case AST_NODE_TYPES.Literal:
+            return expression.value === null;
+        case AST_NODE_TYPES.ConditionalExpression:
+            return canBeAbsent(expression.consequent) || canBeAbsent(expression.alternate);
+        case AST_NODE_TYPES.LogicalExpression:
+            return expression.operator === '&&' || canBeAbsent(expression.right);
+        default:
+            return false;
+    }
+};
+const attribute = (opening, name) => opening.attributes.find((item) => item.type === AST_NODE_TYPES.JSXAttribute && item.name.name === name);
+/** Whether the prop's value is an inline array literal holding the string `"*"`. */
+const isHoldingWildcard = (property) => {
+    const expression = unwrap(property.value?.type === AST_NODE_TYPES.JSXExpressionContainer ? property.value.expression : undefined);
+    if (expression?.type !== AST_NODE_TYPES.ArrayExpression)
+        return false;
+    return expression.elements.some((element) => (element?.type === AST_NODE_TYPES.Literal && element.value === '*') ||
+        (element?.type === AST_NODE_TYPES.TemplateLiteral && element.expressions.length === 0 && element.quasis[0]?.value.cooked === '*'));
+};
+const webviewAllowList = createRule({
+    name: 'webview-allow-list',
+    meta: {
+        defaultOptions: [],
+        type: 'problem',
+        docs: {
+            description: 'A WebView allows every origin and decides each navigation in its load-request handler.',
+        },
+        schema: [],
+        messages: {
+            missingHandler: 'Give this WebView an always-present `{{ handler }}` that allows only the hosts and schemes it trusts; without one every navigation a page starts loads.',
+            missingWhitelist: 'Set `originWhitelist={["*"]}`: the default `["http://*", "https://*"]` sends a page\'s `tel:`, `sms:` or `intent:` link straight to `Linking.openURL`, past `{{ handler }}`.',
+            narrowWhitelist: 'Make `originWhitelist` the inline `["*"]`: a URL outside the list skips `{{ handler }}` and the library opens it in another app, so the handler is the only allow-list that holds.',
+        },
+    },
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            if (!isWebView(context, node.name))
+                return;
+            const handler = attribute(node, HANDLER);
+            if (handler?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer || canBeAbsent(handler.value.expression)) {
+                context.report({ node, messageId: 'missingHandler', data: { handler: HANDLER } });
+            }
+            const whitelist = attribute(node, 'originWhitelist');
+            if (!whitelist)
+                context.report({ node, messageId: 'missingWhitelist', data: { handler: HANDLER } });
+            else if (!isHoldingWildcard(whitelist))
+                context.report({ node: whitelist, messageId: 'narrowWhitelist', data: { handler: HANDLER } });
+        },
+    }),
+});
+export default webviewAllowList;

package/dist/plugins/utils/comments.d.ts

@@ -0,0 +1,15 @@
+import { type TSESLint, type TSESTree } from "@typescript-eslint/utils";
+/** A `/**` JSDoc block. ESLint strips the fences, so the value starts with `*`; a bare `/*` does not. */
+export declare const isJsdoc: (comment: TSESTree.Comment) => boolean;
+/**
+ * A directive's text is dictated by the tool that reads it, not by the author.
+ *
+ * What counts: `eslint-disable`/`-enable`/`-env` (and their `-next-line` forms),
+ * an `eslint rule-name: …` config comment, `prettier-…`, `@ts-…`, a `global`
+ * list of identifiers, and the coverage ignores `istanbul`, `c8` and `v8`.
+ * Prose that merely starts with one of those words is not: `// eslint is slow`
+ * and `// global cache, cleared on logout` are the author's. A `TODO` is prose.
+ */
+export declare const DIRECTIVE_PATTERN: RegExp;
+/** True when nothing but whitespace precedes the comment on its row. */
+export declare const isRowStart: (sourceCode: Readonly<TSESLint.SourceCode>, comment: TSESTree.Comment) => boolean;

package/dist/plugins/utils/comments.js

@@ -0,0 +1,15 @@
+import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+/** A `/**` JSDoc block. ESLint strips the fences, so the value starts with `*`; a bare `/*` does not. */
+export const isJsdoc = (comment) => comment.type === AST_TOKEN_TYPES.Block && comment.value.startsWith("*");
+/**
+ * A directive's text is dictated by the tool that reads it, not by the author.
+ *
+ * What counts: `eslint-disable`/`-enable`/`-env` (and their `-next-line` forms),
+ * an `eslint rule-name: …` config comment, `prettier-…`, `@ts-…`, a `global`
+ * list of identifiers, and the coverage ignores `istanbul`, `c8` and `v8`.
+ * Prose that merely starts with one of those words is not: `// eslint is slow`
+ * and `// global cache, cleared on logout` are the author's. A `TODO` is prose.
+ */
+export const DIRECTIVE_PATTERN = /^\s*(eslint-(disable|enable|env)|eslint\s+[@\w/-]+\s*:|prettier-|@ts-|globals?\s+[\w$]+(\s*:\s*\w+)?(\s*,\s*[\w$]+(\s*:\s*\w+)?)*\s*$|istanbul\s|c8\s|v8\s)/;
+/** True when nothing but whitespace precedes the comment on its row. */
+export const isRowStart = (sourceCode, comment) => !sourceCode.lines[comment.loc.start.line - 1]?.slice(0, comment.loc.start.column).trim();

package/dist/plugins/utils/component-name.d.ts

@@ -0,0 +1,11 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+export type FunctionNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
+/** A `memo(…)`/`forwardRef(…)` call, also as `React.memo(…)`. */
+export declare const isWrapperCall: (node: TSESTree.Node | null | undefined) => node is TSESTree.CallExpression;
+/**
+ * The name a function is a component under, if it is one: a capitalised
+ * function declaration or named function expression (`memo(function Row() {})`),
+ * or a capitalised const holding the function directly or through any nesting
+ * of `memo`/`forwardRef` (`memo(forwardRef(…))`).
+ */
+export declare const componentName: (fn: FunctionNode) => string | undefined;