@hypersolid-dev/eslint-config 5.0.0 → 6.0.0

package/dist/plugins/utils/expressions.js

@@ -8,14 +8,14 @@ const DEFAULT_SELECT_OBJECTS = new Set(['Platform']);
 const isWrapper = (node) => TS_WRAPPERS.has(node.type);
 const isFunction = (node) => FUNCTIONS.has(node.type);
 /** Through `as`, `satisfies`, `!` and `?.`. */
-export function unwrap(node) {
+export const unwrap = (node) => {
     let current = node ?? undefined;
     while (current && isWrapper(current))
         current = current.expression;
     return current;
-}
+};
 /** The name of the memo hook a callee calls (`useMemo`, `React.useMemo`), if it is one. */
-function memoHookName(callee) {
+const memoHookName = (callee) => {
     if (callee.type === AST_NODE_TYPES.Identifier)
         return MEMO_HOOKS.has(callee.name) ? callee.name : undefined;
     if (callee.type === AST_NODE_TYPES.MemberExpression &&
@@ -26,29 +26,27 @@ function memoHookName(callee) {
         return callee.property.name;
     }
     return undefined;
-}
-function findVariable(scope, name) {
+};
+const findVariable = (scope, name) => {
     for (let current = scope; current; current = current.upper) {
         const variable = current.set.get(name);
         if (variable)
             return variable;
     }
     return undefined;
-}
-function bindingOf(context, identifier) {
-    return findVariable(context.sourceCode.getScope(identifier), identifier.name);
-}
+};
+const bindingOf = (context, identifier) => findVariable(context.sourceCode.getScope(identifier), identifier.name);
 /** The declarator a name resolves to, when it is a local with an initialiser; `.init` need not be the name's own value. */
-function localDeclarator(context, identifier) {
+const localDeclarator = (context, identifier) => {
     const definition = bindingOf(context, identifier)?.defs[0];
     return definition?.type === DefinitionType.Variable && definition.node.init ? definition.node : undefined;
-}
+};
 /**
  * A property's key when it is written literally (`a`, `"a"`, `1`, `["a"]`,
  * `[\`a\`]`), else null: a computed key that is a variable, a call or a
  * template with expressions, a spread and a pattern have no key to read.
  */
-export function keyOf(property) {
+export const keyOf = (property) => {
     if (property.type !== AST_NODE_TYPES.Property)
         return null;
     const { key } = property;
@@ -57,13 +55,13 @@ export function keyOf(property) {
     if (key.type === AST_NODE_TYPES.Literal)
         return String(key.value);
     return key.type === AST_NODE_TYPES.TemplateLiteral && key.expressions.length === 0 ? (key.quasis[0]?.value.cooked ?? null) : null;
-}
+};
 /**
  * The expression a destructuring pattern hands to `name`, read off a literal
  * initialiser. A non-literal value, a rest element, a computed key and a spread
  * before the wanted element all give up, since the value is not in this file.
  */
-function picked(pattern, init, name) {
+const picked = (pattern, init, name) => {
     if (pattern.type === AST_NODE_TYPES.Identifier)
         return pattern.name === name ? (init ?? undefined) : undefined;
     // The default only applies when the source has nothing there.
@@ -71,37 +69,44 @@ function picked(pattern, init, name) {
         return picked(pattern.left, init ?? pattern.right, name);
     const source = unwrap(init);
     if (pattern.type === AST_NODE_TYPES.ObjectPattern && source?.type === AST_NODE_TYPES.ObjectExpression) {
-        for (const property of pattern.properties) {
-            const wanted = keyOf(property);
-            if (wanted === null || property.type !== AST_NODE_TYPES.Property)
-                continue;
-            const entry = source.properties.find((candidate) => keyOf(candidate) === wanted);
-            const found = picked(property.value, entry?.type === AST_NODE_TYPES.Property ? entry.value : undefined, name);
-            if (found)
-                return found;
-        }
-        return undefined;
+        return pickedFromObject(pattern, source, name);
     }
     if (pattern.type === AST_NODE_TYPES.ArrayPattern && source?.type === AST_NODE_TYPES.ArrayExpression) {
-        for (const [index, element] of pattern.elements.entries()) {
-            if (!element)
-                continue;
-            const before = source.elements.slice(0, index + 1);
-            if (before.some((entry) => entry?.type === AST_NODE_TYPES.SpreadElement))
-                continue;
-            const found = picked(element, source.elements[index], name);
-            if (found)
-                return found;
-        }
+        return pickedFromArray(pattern, source, name);
+    }
+    return undefined;
+};
+const pickedFromObject = (pattern, source, name) => {
+    for (const property of pattern.properties) {
+        const wanted = keyOf(property);
+        if (wanted === null || property.type !== AST_NODE_TYPES.Property)
+            continue;
+        const entry = source.properties.find((candidate) => keyOf(candidate) === wanted);
+        const found = picked(property.value, entry?.type === AST_NODE_TYPES.Property ? entry.value : undefined, name);
+        if (found)
+            return found;
+    }
+    return undefined;
+};
+const pickedFromArray = (pattern, source, name) => {
+    for (const [index, element] of pattern.elements.entries()) {
+        if (!element)
+            continue;
+        const before = source.elements.slice(0, index + 1);
+        if (before.some((entry) => entry?.type === AST_NODE_TYPES.SpreadElement))
+            continue;
+        const found = picked(element, source.elements[index], name);
+        if (found)
+            return found;
     }
     return undefined;
-}
+};
 /**
  * What a name stands for: a `const`'s own value, or a declared function itself.
  * A `let` or `var` is not followed, and a destructured `const` resolves only
  * when its initialiser is a literal holding the matching entry.
  */
-function boundTo(context, identifier) {
+const boundTo = (context, identifier) => {
     const definition = bindingOf(context, identifier)?.defs[0];
     if (definition?.type === DefinitionType.FunctionName)
         return definition.node;
@@ -111,17 +116,17 @@ function boundTo(context, identifier) {
         return undefined;
     const { id, init } = definition.node;
     return id.type === AST_NODE_TYPES.Identifier ? init : picked(id, init, identifier.name);
-}
-function selectBranches(node, selectObjects) {
+};
+const selectBranches = (node, selectObjects) => {
     const { callee } = node;
     if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed)
         return undefined;
     if (callee.property.name !== 'select' || callee.object.type !== AST_NODE_TYPES.Identifier)
         return undefined;
     return selectObjects.has(callee.object.name) ? node.arguments[0] : undefined;
-}
+};
 /** Every `return` with an argument in a body, including nested blocks but not nested functions. */
-function returnsIn(body) {
+const returnsIn = (body) => {
     const found = [];
     const visit = (value) => {
         if (Array.isArray(value)) {
@@ -146,7 +151,7 @@ function returnsIn(body) {
     };
     visit(body);
     return found;
-}
+};
 /**
  * Every leaf an expression can produce.
  *
@@ -160,7 +165,7 @@ function returnsIn(body) {
  * itself: a name from another file, a `let`, a method call, a computed member,
  * a spread. A cycle yields nothing rather than looping.
  */
-export function leavesOf(context, node, options = {}) {
+export const leavesOf = (context, node, options = {}) => {
     const { names = true, members = true, returns = false, selectObjects = DEFAULT_SELECT_OBJECTS, calls, seen = new Set(), } = options;
     const out = [];
     const walkFunction = (fn) => {
@@ -171,31 +176,38 @@ export function leavesOf(context, node, options = {}) {
         for (const argument of returnsIn(fn.body))
             walk(argument);
     };
+    /** Each branch is a value for whatever slot the call sits in. */
+    const walkSelect = (branches) => {
+        for (const branch of leavesOf(context, branches, { ...options, seen })) {
+            if (branch.type !== AST_NODE_TYPES.ObjectExpression)
+                continue;
+            for (const property of branch.properties) {
+                if (property.type === AST_NODE_TYPES.Property)
+                    walk(property.value);
+            }
+        }
+    };
+    /** A call to a local function is what it returns (a factory); a method call is never followed. */
+    const factoryOf = (call) => {
+        if (!returns || call.callee.type !== AST_NODE_TYPES.Identifier)
+            return undefined;
+        const bound = boundTo(context, call.callee);
+        return bound && isFunction(bound) ? bound : undefined;
+    };
     const didWalkCall = (call) => {
         const branches = selectBranches(call, selectObjects);
         if (branches) {
-            // Each branch is a value for whatever slot the call sits in.
-            for (const branch of leavesOf(context, branches, { ...options, seen })) {
-                if (branch.type !== AST_NODE_TYPES.ObjectExpression)
-                    continue;
-                for (const property of branch.properties) {
-                    if (property.type === AST_NODE_TYPES.Property)
-                        walk(property.value);
-                }
-            }
+            walkSelect(branches);
             return true;
         }
         if (calls?.(call)) {
             walk(call.arguments[0]);
             return true;
         }
-        // A call to a local function is what it returns (a factory); a method call is never followed.
-        if (returns && call.callee.type === AST_NODE_TYPES.Identifier) {
-            const bound = boundTo(context, call.callee);
-            if (bound && isFunction(bound)) {
-                walk(bound);
-                return true;
-            }
+        const factory = factoryOf(call);
+        if (factory) {
+            walk(factory);
+            return true;
         }
         const hook = memoHookName(call.callee);
         const callback = call.arguments.at(0);
@@ -208,6 +220,25 @@ export function leavesOf(context, node, options = {}) {
             walkFunction(callback);
         return true;
     };
+    /** `OBJ.key`'s value when `OBJ` is a local `const` object literal. */
+    const memberEntry = (member) => {
+        if (member.computed || member.object.type !== AST_NODE_TYPES.Identifier)
+            return undefined;
+        const declarator = localDeclarator(context, member.object);
+        // A destructured name is not what the whole initialiser holds.
+        const held = declarator?.id.type === AST_NODE_TYPES.Identifier ? unwrap(declarator.init) : undefined;
+        if (held?.type !== AST_NODE_TYPES.ObjectExpression)
+            return undefined;
+        const key = member.property.name;
+        const entry = held.properties.find((property) => keyOf(property) === key);
+        return entry?.type === AST_NODE_TYPES.Property ? entry.value : undefined;
+    };
+    /** What a name or `OBJ.key` stands for, when the options let it be followed. */
+    const referenced = (node) => {
+        if (node.type === AST_NODE_TYPES.Identifier)
+            return names ? boundTo(context, node) : undefined;
+        return members ? memberEntry(node) : undefined;
+    };
     const walk = (current) => {
         if (!current || seen.has(current))
             return;
@@ -229,26 +260,11 @@ export function leavesOf(context, node, options = {}) {
                 walk(current.left);
                 walk(current.right);
                 return;
-            case AST_NODE_TYPES.Identifier: {
-                const bound = names ? boundTo(context, current) : undefined;
-                if (bound) {
-                    walk(bound);
-                    return;
-                }
-                break;
-            }
+            case AST_NODE_TYPES.Identifier:
             case AST_NODE_TYPES.MemberExpression: {
-                if (!members || current.computed || current.object.type !== AST_NODE_TYPES.Identifier)
-                    break;
-                const declarator = localDeclarator(context, current.object);
-                // A destructured name is not what the whole initialiser holds.
-                const held = declarator?.id.type === AST_NODE_TYPES.Identifier ? unwrap(declarator.init) : undefined;
-                if (held?.type !== AST_NODE_TYPES.ObjectExpression)
-                    break;
-                const key = current.property.name;
-                const entry = held.properties.find((property) => keyOf(property) === key);
-                if (entry?.type === AST_NODE_TYPES.Property) {
-                    walk(entry.value);
+                const target = referenced(current);
+                if (target) {
+                    walk(target);
                     return;
                 }
                 break;
@@ -271,4 +287,4 @@ export function leavesOf(context, node, options = {}) {
     };
     walk(node);
     return out;
-}
+};

package/dist/plugins/utils/types.js

@@ -21,6 +21,18 @@ const UNRESOLVED = TypeFlags.TypeParameter |
     TypeFlags.Conditional |
     TypeFlags.Index |
     TypeFlags.Substitution;
+/**
+ * A callable or constructable type is truthy. Any other object type is only
+ * as good as what the falsy primitives do against it: `{}`, `Object` and
+ * `{ length: number }` all accept `""`, `0` or `false`.
+ */
+const isTruthyObject = (type, checker) => {
+    if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0)
+        return true;
+    if (!checker)
+        return false;
+    return [checker.getStringLiteralType(""), checker.getNumberLiteralType(0), checker.getFalseType()].every((falsy) => !checker.isTypeAssignableTo(falsy, type));
+};
 /**
  * Whether every value of this type is truthy, `undefined` aside.
  *
@@ -50,18 +62,8 @@ export const isSameAsBangBang = (type, checker) => {
     if (type.flags & (TypeFlags.ESSymbolLike | TypeFlags.NonPrimitive)) {
         return true;
     }
-    if (type.flags & TypeFlags.Object) {
-        /**
-         * A callable or constructable type is truthy. Any other object type is only
-         * as good as what the falsy primitives do against it: `{}`, `Object` and
-         * `{ length: number }` all accept `""`, `0` or `false`.
-         */
-        if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0)
-            return true;
-        if (!checker)
-            return false;
-        return [checker.getStringLiteralType(""), checker.getNumberLiteralType(0), checker.getFalseType()].every((falsy) => !checker.isTypeAssignableTo(falsy, type));
-    }
+    if (type.flags & TypeFlags.Object)
+        return isTruthyObject(type, checker);
     // A literal is as truthy as its value: only `""`, `0` and `0n` are falsy.
     if (type.isStringLiteral())
         return type.value !== "";

package/dist/react-native.js

@@ -1,4 +1,5 @@
 import expo from 'eslint-plugin-expo';
+import reactDoctor from 'eslint-plugin-react-doctor';
 import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript';
 import { createNodeResolver } from 'eslint-plugin-import-x';
 import globals from 'globals';
@@ -152,6 +153,33 @@ export default function reactNative() {
                 '@hypersolid-dev/test-id-default': 'error',
             },
         },
+        {
+            // React Doctor's React Native rules, as used in the ESPN Goal pilot.
+            name: '@hypersolid-dev/react-native/react-doctor',
+            files: CODE_FILES,
+            ignores: TEST_FILES,
+            plugins: { 'react-doctor': reactDoctor },
+            rules: {
+                // A state update per scroll event re-renders mid-gesture; track position in a shared value. Bad: `onScroll={(event) => setOffset(event.nativeEvent.contentOffset.y)}`.
+                'react-doctor/rn-no-scroll-state': 'error',
+                // A reaction that only copies one value into another is a `useDerivedValue`. Bad: `useAnimatedReaction(() => x.value, (value) => { y.value = value; })`.
+                'react-doctor/rn-animation-reaction-as-derived': 'error',
+                // A string outside `<Text>` crashes on native. Bad: `<View>Hello</View>`.
+                'react-doctor/rn-no-raw-text': 'error',
+                // A list keys rows from `keyExtractor`; a `key` on the row is ignored. Bad: `renderItem={({ item }) => <Row key={item.id} />}`.
+                'react-doctor/rn-no-renderitem-key': 'error',
+                // A press animation set from `onPressIn` runs on the JS thread. Bad: `onPressIn={() => { scale.value = 0.9; }}`.
+                'react-doctor/rn-pressable-shared-value-mutation': 'error',
+                // `PanResponder` runs on the JS thread; `Gesture.Pan()` runs on the UI thread. Bad: `PanResponder.create({ … })`.
+                'react-doctor/rn-no-panresponder': 'error',
+                // `Dimensions.get()` reads the size once and misses rotation and split screen. Bad: `const { width } = Dimensions.get('window')` (use `useWindowDimensions`).
+                'react-doctor/rn-no-dimensions-get': 'error',
+                // `react-native/Libraries/…` paths are private and move on upgrade. Bad: `import … from 'react-native/Libraries/Image/resolveAssetSource'`.
+                'react-doctor/rn-no-deep-imports': 'error',
+                // Unmaintained Expo-era packages each have a successor. Bad: `import { Audio } from 'expo-av'` (use `expo-audio`).
+                'react-doctor/rn-no-legacy-expo-packages': 'error',
+            },
+        },
         {
             name: '@hypersolid-dev/react-native/json',
             files: ['**/*.json'],

package/dist/shared.d.ts

@@ -31,6 +31,6 @@ export declare const NAMING_CONVENTION: ({
     format: string[];
     modifiers?: undefined;
 })[];
-export declare function raiseWarnings(configs: Linter.Config[]): Linter.Config[];
-export declare function scopeToCode(configs: readonly Linter.Config[]): Linter.Config[];
-export declare function reactConfigs(): Linter.Config[];
+export declare const raiseWarnings: (configs: Linter.Config[]) => Linter.Config[];
+export declare const scopeToCode: (configs: readonly Linter.Config[]) => Linter.Config[];
+export declare const reactConfigs: () => Linter.Config[];