@hypersolid-dev/eslint-config 5.0.0 → 6.0.0

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

@@ -31,24 +31,20 @@ 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`. */
-function kebab(name) {
-    return name.replaceAll(LOWER_TO_UPPER_PATTERN, '-').replaceAll(ACRONYM_END_PATTERN, '-').toLowerCase();
-}
+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. */
-function componentName(filename) {
+const componentName = (filename) => {
     const name = path.basename(filename).replace(EXTENSION_PATTERN, '').replace(PLATFORM_PATTERN, '');
     return name === 'index' ? path.basename(path.dirname(filename)) : name;
-}
-function isHoc(callee) {
+};
+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);
-}
-function isFunction(node) {
-    return Boolean(node && FUNCTION_TYPES.has(node.type));
-}
+};
+const isFunction = (node) => Boolean(node && FUNCTION_TYPES.has(node.type));
 /** Through `memo(…)`, `forwardRef(…)` and type assertions, to the component inside. */
-function unwrapComponent(node) {
+const unwrapComponent = (node) => {
     let current = node ?? undefined;
     while (current) {
         if (TS_WRAPPERS.has(current.type))
@@ -59,31 +55,31 @@ function unwrapComponent(node) {
             return current;
     }
     return current;
-}
+};
 /** What a function is held by, out through the calls and assertions it is declared behind. */
-function heldBy(fn) {
+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. */
-function isComponent(fn, component) {
+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. */
-function testIdProperty(pattern) {
+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`. */
-function propsNames(fn) {
+const propsNames = (fn) => {
     const first = fn.params.at(0);
     if (first?.type === AST_NODE_TYPES.Identifier)
         return [first.name];
@@ -91,15 +87,15 @@ function propsNames(fn) {
         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. */
-function ownComponentAround(node, component) {
+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: {
@@ -113,7 +109,7 @@ const testIdDefault = createRule({
             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) {
+    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))
@@ -146,7 +142,7 @@ const testIdDefault = createRule({
                 check(testIdProperty(node.params[0]));
         };
         return {
-            VariableDeclarator(node) {
+            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);
@@ -157,20 +153,20 @@ const testIdDefault = createRule({
                 if (node.id.type === AST_NODE_TYPES.Identifier)
                     checkFunction(unwrapComponent(node.init), node.id.name);
             },
-            FunctionDeclaration(node) {
+            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) {
+            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) {
+            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)

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

@@ -29,34 +29,30 @@ 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`. */
-function kebab(value) {
-    return value
-        .replaceAll(LOWER_TO_UPPER_PATTERN, '-')
-        .replaceAll(ACRONYM_END_PATTERN, '-')
-        .replaceAll(NON_ALPHANUMERIC_RUN_PATTERN, '-')
-        .replaceAll(EDGE_DASHES_PATTERN, '')
-        .toLowerCase();
-}
+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`. */
-function kebabFragment(value) {
+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. */
-function isInside(outer, inner) {
-    return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
-}
+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. */
-function writtenString(node) {
+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: {
@@ -68,7 +64,7 @@ const testIdFormat = createRule({
             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) {
+    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);
@@ -101,7 +97,7 @@ const testIdFormat = createRule({
             }
         };
         return {
-            JSXAttribute(node) {
+            JSXAttribute: (node) => {
                 if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== TEST_ID)
                     return;
                 const { value } = node;
@@ -111,7 +107,7 @@ const testIdFormat = createRule({
                     checkExpression(value.expression);
             },
             // A `testID` default, and a `testID:` in an options or fixture object.
-            Property(node) {
+            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);

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

@@ -23,11 +23,9 @@ import { leavesOf } from '../utils/expressions.js';
  */
 const TEST_ID = 'testID';
 /** A value spelled out where it stands, rather than reached for. */
-function isWritten(node) {
-    return (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') || (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0);
-}
+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. */
-function readsAName(context, node) {
+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:
@@ -41,26 +39,26 @@ function readsAName(context, node) {
         case AST_NODE_TYPES.TemplateLiteral:
             return node.expressions.length > 0 && node.quasis[0]?.value.cooked === '';
         case AST_NODE_TYPES.ConditionalExpression:
-            return readsAName(context, node.consequent) || readsAName(context, node.alternate);
+            return isReadingAName(context, node.consequent) || isReadingAName(context, node.alternate);
         case AST_NODE_TYPES.LogicalExpression:
-            return readsAName(context, node.left) || readsAName(context, node.right);
+            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 readsAName(context, node.expression);
+            return isReadingAName(context, node.expression);
         default:
             return false;
     }
-}
+};
 /** How to name the offending id: a name is followed to the string behind it. */
-function writtenValue(context, node) {
+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: {
@@ -73,22 +71,20 @@ const testIdFromProps = createRule({
             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) {
-        return {
-            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 && readsAName(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) } });
-            },
-        };
-    },
+    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.js

@@ -35,13 +35,13 @@ const undefinedCheck = createRule({
             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) {
+    create: (context) => {
         const services = ESLintUtils.getParserServices(context, true);
         if (!services.program)
             return {};
         const checker = services.program.getTypeChecker();
         return {
-            BinaryExpression(node) {
+            BinaryExpression: (node) => {
                 if (!isCondition(node))
                     return;
                 const compared = undefinedComparison(node);

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

@@ -23,7 +23,7 @@ const SOURCE = 'react-native-webview';
 const WEBVIEW = 'WebView';
 const HANDLER = 'onShouldStartLoadWithRequest';
 /** Whether a JSX name resolves to the library's `WebView` import. */
-function isWebView(context, name) {
+const isWebView = (context, name) => {
     const identifier = name.type === AST_NODE_TYPES.JSXMemberExpression ? name.object : name;
     if (identifier.type !== AST_NODE_TYPES.JSXIdentifier)
         return false;
@@ -44,9 +44,9 @@ function isWebView(context, name) {
         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. */
-function canBeAbsent(expression) {
+const canBeAbsent = (expression) => {
     switch (expression.type) {
         case AST_NODE_TYPES.JSXEmptyExpression:
             return true;
@@ -61,18 +61,16 @@ function canBeAbsent(expression) {
         default:
             return false;
     }
-}
-function attribute(opening, name) {
-    return opening.attributes.find((item) => item.type === AST_NODE_TYPES.JSXAttribute && item.name.name === name);
-}
+};
+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 `"*"`. */
-function holdsWildcard(property) {
+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: {
@@ -88,22 +86,20 @@ const webviewAllowList = createRule({
             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) {
-        return {
-            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 (!holdsWildcard(whitelist))
-                    context.report({ node: whitelist, messageId: 'narrowWhitelist', data: { handler: HANDLER } });
-            },
-        };
-    },
+    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/expressions.d.ts

@@ -28,13 +28,13 @@ export type LeavesOptions = {
     seen?: Set<Node>;
 };
 /** Through `as`, `satisfies`, `!` and `?.`. */
-export declare function unwrap(node: Node | null | undefined): Node | undefined;
+export declare const unwrap: (node: Node | null | undefined) => 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 declare function keyOf(property: Node): string | null;
+export declare const keyOf: (property: Node) => string | null;
 /**
  * Every leaf an expression can produce.
  *
@@ -48,5 +48,5 @@ export declare function keyOf(property: Node): string | null;
  * itself: a name from another file, a `let`, a method call, a computed member,
  * a spread. A cycle yields nothing rather than looping.
  */
-export declare function leavesOf(context: ScopeContext, node: Node | null | undefined, options?: LeavesOptions): Node[];
+export declare const leavesOf: (context: ScopeContext, node: Node | null | undefined, options?: LeavesOptions) => Node[];
 export {};