eslint-plugin-ziloen 0.0.109 → 0.1.0

package/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "prettier.enable": false,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true,
+    "source.sortImports": true
+  }
+}

package/build.config.ts

@@ -0,0 +1,12 @@
+import { defineBuildConfig } from "unbuild"
+
+export default defineBuildConfig({
+  entries: [
+    "src/index"
+  ],
+  declaration: false,
+  clean: true,
+  rollup: {
+    emitCJS: true
+  }
+})

package/package.json

@@ -1,28 +1,21 @@
 {
   "name": "eslint-plugin-ziloen",
-  "version": "0.0.109",
-  "author": "ziloen",
-  "license": "MIT",
-  "homepage": "https://github.com/ziloen/eslint-config",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "@typescript-eslint/utils": "^6.7.3",
-    "typescript": "^5.2.2"
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "rimraf dist && tsup src/index.ts --format esm,cjs --clean",
+    "release": "pnpm run build && bumpp --commit --no-push && npm publish"
   },
-  "devDependencies": {
-    "@types/node": "^20.7.1",
-    "@typescript-eslint/rule-tester": "^6.7.3",
+  "dependencies": {
+    "@types/eslint": "^8.44.6",
+    "@types/node": "^20.8.7",
+    "@typescript-eslint/rule-tester": "^6.8.0",
+    "@typescript-eslint/utils": "^6.8.0",
+    "bumpp": "^9.2.0",
+    "eslint": "^8.52.0",
     "rimraf": "^5.0.5",
-    "unbuild": "^2.0.0",
-    "vitest": "^0.34.5"
-  },
-  "scripts": {
-    "build": "rimraf dist && unbuild",
-    "stub": "unbuild --stub",
-    "test": "vitest"
+    "tsup": "^7.2.0",
+    "typescript": "^5.2.2",
+    "unbuild": "^2.0.0"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+import genericSpacing from './rules/generic-spacing'
+import jsxStrictLogicalExpressions from './rules/jsx-strict-logical-expressions'
+
+const ziloen = {
+  meta: {
+    name: "ziloen"
+  },
+  rules: {
+    'generic-spacing': genericSpacing,
+    'jsx-strict-logical-expressions': jsxStrictLogicalExpressions,
+  }
+}
+
+export default ziloen

package/src/rules/generic-spacing.test.ts

@@ -0,0 +1,40 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import rule, { RULE_NAME, messageId } from './generic-spacing'
+
+const valid = [
+  `type Foo<T, K> = T`,
+  `type Foo<
+  T,
+  K,
+> = T`,
+  `type Foo<T, K> = Record<T, K>`,
+  `type Foo<T, K> = Record<
+  T,
+  K
+>`
+]
+
+const invalid = [
+  [`type Foo< T, K > = T`, `type Foo<T, K> = T`, 2],
+  [`type Foo<T, K> = Record< T, K >`, `type Foo<T, K> = Record<T, K>`, 2],
+  [`type Foo<   T, K > = Record< T, K >`, `type Foo<T, K> = Record<T, K>`, 4],
+  [`type Foo<
+T, K
+> = Record< T, K >`, `type Foo<
+T, K
+> = Record<T, K>`, 2],
+  [`type Foo<T=any, K=any> = T`, `type Foo<T = any, K = any> = T`, 2]
+] as const
+
+const ruleTester: RuleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser')
+})
+
+ruleTester.run(RULE_NAME, rule, {
+  valid,
+  invalid: invalid.map(i => ({
+    code: i[0],
+    output: i[1].trim(),
+    errors: Array.from({ length: i[2] || 1 }, () => ({ messageId }))
+  }))
+})

package/src/rules/generic-spacing.ts

@@ -0,0 +1,118 @@
+import type { TSESTree } from '@typescript-eslint/utils'
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'
+import { createEslintRule } from '../utils'
+
+
+export const RULE_NAME = 'generic-spacing'
+export type MessageIds = 'genericSpacingMismatch'
+export type Options = []
+
+export const messageId = 'genericSpacingMismatch'
+
+function removeSpaceAround(
+  node: TSESTree.TSTypeParameterInstantiation | TSESTree.TSTypeParameterDeclaration,
+  context: Readonly<RuleContext<MessageIds, []>>
+) {
+  const params = node.params
+  if (!params.length) return
+
+  const sourceCode = context.sourceCode
+
+  const start = node.range[0] + 1
+  const end = node.range[1] - 1
+
+  const startNode = params[0]
+  const endNode = params.at(-1)!
+
+  const textBeforeFirst = sourceCode.text.slice(start, startNode.range[0])
+  const textAfterLast = sourceCode.text.slice(endNode.range[1], end)
+
+  // if same line, remove spaces
+  if (textBeforeFirst.length && !textBeforeFirst.includes('\n')) {
+    context.report({
+      node,
+      messageId,
+      *fix(fixer) {
+        yield fixer.replaceTextRange([start, startNode.range[0]], '')
+      },
+      loc: {
+        start: {
+          column: node.loc.start.column + 1,
+          line: node.loc.start.line
+        },
+        end: startNode.loc.start
+      }
+    })
+  }
+
+  // if same line, remove spaces
+  if (textAfterLast.length && !textAfterLast.includes('\n')) {
+    context.report({
+      node,
+      messageId,
+      *fix(fixer) {
+        yield fixer.replaceTextRange([endNode.range[1], end], '')
+      },
+      loc: {
+        start: endNode.loc.end,
+        end: {
+          column: node.loc.end.column - 1,
+          line: node.loc.end.line
+        }
+      }
+    })
+  }
+}
+
+const genericSpacing = createEslintRule<Options, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: 'layout',
+    docs: {
+      description: '',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      genericSpacingMismatch: 'spacing mismatch'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode
+
+    return {
+      // type T<"K, S"> = any
+      TSTypeParameterDeclaration: node => removeSpaceAround(node, context),
+      // type T = Record<"K, S">
+      TSTypeParameterInstantiation: node => removeSpaceAround(node, context),
+      // type T<"K = any", "S = any"> = any
+      TSTypeParameter(node) {
+        if (!node.default) return
+        const startNode = node.constraint ?? node.name
+        const endNode = node.default
+
+        const start = startNode.range[1]
+        const end = endNode.range[0]
+
+        // replace all content between name and default with " = "
+        if (sourceCode.text.slice(start, end) !== ' = ') {
+          context.report({
+            node,
+            messageId,
+            *fix(fixer) {
+              yield fixer.replaceTextRange([start, end], ' = ')
+            },
+            loc: {
+              start: startNode.loc.end,
+              end: endNode.loc.start
+            }
+          })
+        }
+      }
+    }
+  }
+})
+
+export default genericSpacing

package/src/rules/jsx-strict-logical-expressions.ts

@@ -0,0 +1,159 @@
+/**
+ * Copied from https://github.com/hluisson/eslint-plugin-jsx-expressions
+ */
+
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils'
+import { TypeFlags } from 'typescript'
+import { getConstrainedTypeAtLocation, isTypeFlagSet, unionTypeParts } from '../tsutils'
+import { createEslintRule } from '../utils'
+
+type Options = [
+  {
+    allowString?: boolean
+    allowNumber?: boolean
+  }
+]
+
+type MessageIds = 'conditionErrorFalseyString' | 'conditionErrorFalseyNumber'
+
+export const RULE_NAME = 'jsx-strict-logical-expressions'
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const jsxStrictLogicalExpressions = createEslintRule<Options, MessageIds>({
+  name: RULE_NAME,
+  defaultOptions: [{ allowString: false, allowNumber: false }],
+  meta: {
+    docs: {
+      description: 'Forbid non-boolean falsey values in inline expressions',
+      recommended: 'strict',
+    },
+    fixable: 'code',
+    type: 'problem',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowString: { type: 'boolean' },
+          allowNumber: { type: 'boolean' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      conditionErrorFalseyString:
+        'Potentially falsey string in logical AND expression. Please use boolean.',
+      conditionErrorFalseyNumber:
+        'Potentially falsey number in logical AND expression. Please use boolean.',
+    },
+  },
+
+  create(context, [options]) {
+    const parserServices = ESLintUtils.getParserServices(context)
+    const typeChecker = parserServices.program.getTypeChecker()
+
+    function checkIdentifier(
+      node: TSESTree.Identifier
+    ): MessageIds | undefined {
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node)
+      const types = unionTypeParts(
+        getConstrainedTypeAtLocation(typeChecker, tsNode)
+      )
+
+      const hasPotentiallyFalseyString = types.some(
+        type =>
+          isTypeFlagSet(type, TypeFlags.StringLike) &&
+          (!type.isStringLiteral() || type.value === '')
+      )
+
+      if (!options.allowString && hasPotentiallyFalseyString) {
+        return 'conditionErrorFalseyString'
+      }
+
+      const hasPotentiallyFalseyNumber = types.some(
+        type =>
+          isTypeFlagSet(
+            type,
+            TypeFlags.NumberLike | TypeFlags.BigIntLike
+          ) &&
+          (!type.isNumberLiteral() || type.value === 0)
+      )
+
+      if (!options.allowNumber && hasPotentiallyFalseyNumber) {
+        return 'conditionErrorFalseyNumber'
+      }
+
+      return
+    }
+
+    function checkAndReportIdentifier(
+      node: TSESTree.Identifier,
+      fixNode: TSESTree.Expression
+    ) {
+      const errorId = checkIdentifier(node)
+      if (errorId) {
+        context.report({
+          node,
+          messageId: errorId,
+          fix: fixer => fixer.insertTextBefore(fixNode, '!!'),
+        })
+      }
+    }
+
+    // Return the core identifier or expression
+    function determineNode(originalNode: TSESTree.Expression) {
+      let nodeToEvaluate = originalNode
+      if (nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.ChainExpression) {
+        nodeToEvaluate = nodeToEvaluate.expression
+      }
+
+      if (
+        nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+        nodeToEvaluate.property.type !==
+          TSESTree.AST_NODE_TYPES.PrivateIdentifier
+      ) {
+        nodeToEvaluate = nodeToEvaluate.property
+      }
+
+      return nodeToEvaluate
+    }
+
+    function checkLogicalExpression(
+      expressionNode: TSESTree.LogicalExpression,
+      checkRightNode: boolean
+    ) {
+      const leftNode = determineNode(expressionNode.left)
+
+      if (leftNode.type === TSESTree.AST_NODE_TYPES.LogicalExpression) {
+        checkLogicalExpression(leftNode, true)
+      } else if (leftNode.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        checkAndReportIdentifier(leftNode, expressionNode.left)
+      }
+
+      if (checkRightNode) {
+        const rightNode = determineNode(expressionNode.right)
+
+        if (rightNode.type === TSESTree.AST_NODE_TYPES.Identifier) {
+          checkAndReportIdentifier(rightNode, expressionNode.right)
+        }
+      }
+    }
+
+    function checkJSXExpression(node: TSESTree.JSXExpressionContainer) {
+      if (
+        node.expression.type === TSESTree.AST_NODE_TYPES.LogicalExpression &&
+        node.expression.operator === '&&'
+      ) {
+        checkLogicalExpression(node.expression, false)
+      }
+    }
+
+    return {
+      JSXExpressionContainer: checkJSXExpression,
+    }
+  },
+})
+
+export default jsxStrictLogicalExpressions

package/src/tsutils.ts

@@ -0,0 +1,33 @@
+import { TypeFlags, type Node, type Type, type TypeChecker, type UnionType } from 'typescript'
+
+
+export function isUnionType(type: Type): type is UnionType {
+  return (type.flags & TypeFlags.Union) !== 0
+}
+
+/** Returns all types of a union type or an array containing `type` itself if it's no union type. */
+export function unionTypeParts(type: Type): Type[] {
+  return isUnionType(type) ? type.types : [type]
+}
+
+
+function isFlagSet(obj: { flags: number }, flag: number) {
+  return (obj.flags & flag) !== 0
+}
+
+export const isTypeFlagSet: (type: Type, flag: TypeFlags) => boolean = isFlagSet
+
+
+
+/**
+ * Resolves the given node's type. Will resolve to the type's generic constraint, if it has one.
+ */
+export function getConstrainedTypeAtLocation(
+  checker: TypeChecker,
+  node: Node
+): Type {
+  const nodeType = checker.getTypeAtLocation(node)
+  const constrained = checker.getBaseConstraintOfType(nodeType)
+
+  return constrained ?? nodeType
+}

package/src/utils.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils'
+
+export const createEslintRule = ESLintUtils.RuleCreator(ruleName => ruleName)

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [
+      "ESNext"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src"
+  ]
+}

package/dist/index.cjs

@@ -1,221 +0,0 @@
-'use strict';
-
-const utils = require('@typescript-eslint/utils');
-const typescript = require('typescript');
-
-const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
-
-const RULE_NAME$1 = "generic-spacing";
-const messageId = "genericSpacingMismatch";
-function removeSpaceAround(node, context) {
-  const params = node.params;
-  if (!params.length)
-    return;
-  const sourceCode = context.sourceCode;
-  const start = node.range[0] + 1;
-  const end = node.range[1] - 1;
-  const startNode = params[0];
-  const endNode = params.at(-1);
-  const textBeforeFirst = sourceCode.text.slice(start, startNode.range[0]);
-  const textAfterLast = sourceCode.text.slice(endNode.range[1], end);
-  if (textBeforeFirst.length && !textBeforeFirst.includes("\n")) {
-    context.report({
-      node,
-      messageId,
-      *fix(fixer) {
-        yield fixer.replaceTextRange([start, startNode.range[0]], "");
-      },
-      loc: {
-        start: {
-          column: node.loc.start.column + 1,
-          line: node.loc.start.line
-        },
-        end: startNode.loc.start
-      }
-    });
-  }
-  if (textAfterLast.length && !textAfterLast.includes("\n")) {
-    context.report({
-      node,
-      messageId,
-      *fix(fixer) {
-        yield fixer.replaceTextRange([endNode.range[1], end], "");
-      },
-      loc: {
-        start: endNode.loc.end,
-        end: {
-          column: node.loc.end.column - 1,
-          line: node.loc.end.line
-        }
-      }
-    });
-  }
-}
-const genericSpacing = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      genericSpacingMismatch: "spacing mismatch"
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    return {
-      // type T<"K, S"> = any
-      TSTypeParameterDeclaration: (node) => removeSpaceAround(node, context),
-      // type T = Record<"K, S">
-      TSTypeParameterInstantiation: (node) => removeSpaceAround(node, context),
-      // type T<"K = any", "S = any"> = any
-      TSTypeParameter(node) {
-        if (!node.default)
-          return;
-        const startNode = node.constraint || node.name;
-        const endNode = node.default;
-        const start = startNode.range[1];
-        const end = endNode.range[0];
-        if (sourceCode.text.slice(start, end) !== " = ") {
-          context.report({
-            node,
-            messageId,
-            *fix(fixer) {
-              yield fixer.replaceTextRange([start, end], " = ");
-            },
-            loc: {
-              start: startNode.loc.end,
-              end: endNode.loc.start
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-function isUnionType(type) {
-  return (type.flags & typescript.TypeFlags.Union) !== 0;
-}
-function unionTypeParts(type) {
-  return isUnionType(type) ? type.types : [type];
-}
-function isFlagSet(obj, flag) {
-  return (obj.flags & flag) !== 0;
-}
-const isTypeFlagSet = isFlagSet;
-function getConstrainedTypeAtLocation(checker, node) {
-  const nodeType = checker.getTypeAtLocation(node);
-  const constrained = checker.getBaseConstraintOfType(nodeType);
-  return constrained ?? nodeType;
-}
-
-const RULE_NAME = "jsx-strict-logical-expressions";
-const jsxStrictLogicalExpressions = createEslintRule({
-  name: RULE_NAME,
-  defaultOptions: [{ allowString: false, allowNumber: false }],
-  meta: {
-    docs: {
-      description: "Forbid non-boolean falsey values in inline expressions",
-      recommended: "strict"
-    },
-    fixable: "code",
-    type: "problem",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allowString: { type: "boolean" },
-          allowNumber: { type: "boolean" }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      conditionErrorFalseyString: "Potentially falsey string in logical AND expression. Please use boolean.",
-      conditionErrorFalseyNumber: "Potentially falsey number in logical AND expression. Please use boolean."
-    }
-  },
-  create(context, [options]) {
-    const parserServices = utils.ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-    function checkIdentifier(node) {
-      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-      const types = unionTypeParts(
-        getConstrainedTypeAtLocation(typeChecker, tsNode)
-      );
-      const hasPotentiallyFalseyString = types.some(
-        (type) => isTypeFlagSet(type, typescript.TypeFlags.StringLike) && (!type.isStringLiteral() || type.value === "")
-      );
-      if (!options.allowString && hasPotentiallyFalseyString) {
-        return "conditionErrorFalseyString";
-      }
-      const hasPotentiallyFalseyNumber = types.some(
-        (type) => isTypeFlagSet(
-          type,
-          typescript.TypeFlags.NumberLike | typescript.TypeFlags.BigIntLike
-        ) && (!type.isNumberLiteral() || type.value === 0)
-      );
-      if (!options.allowNumber && hasPotentiallyFalseyNumber) {
-        return "conditionErrorFalseyNumber";
-      }
-      return;
-    }
-    function checkAndReportIdentifier(node, fixNode) {
-      const errorId = checkIdentifier(node);
-      if (errorId) {
-        context.report({
-          node,
-          messageId: errorId,
-          fix: (fixer) => fixer.insertTextBefore(fixNode, "!!")
-        });
-      }
-    }
-    function determineNode(originalNode) {
-      let nodeToEvaluate = originalNode;
-      if (nodeToEvaluate.type === utils.TSESTree.AST_NODE_TYPES.ChainExpression) {
-        nodeToEvaluate = nodeToEvaluate.expression;
-      }
-      if (nodeToEvaluate.type === utils.TSESTree.AST_NODE_TYPES.MemberExpression && nodeToEvaluate.property.type !== utils.TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
-        nodeToEvaluate = nodeToEvaluate.property;
-      }
-      return nodeToEvaluate;
-    }
-    function checkLogicalExpression(expressionNode, checkRightNode) {
-      const leftNode = determineNode(expressionNode.left);
-      if (leftNode.type === utils.TSESTree.AST_NODE_TYPES.LogicalExpression) {
-        checkLogicalExpression(leftNode, true);
-      } else if (leftNode.type === utils.TSESTree.AST_NODE_TYPES.Identifier) {
-        checkAndReportIdentifier(leftNode, expressionNode.left);
-      }
-      if (checkRightNode) {
-        const rightNode = determineNode(expressionNode.right);
-        if (rightNode.type === utils.TSESTree.AST_NODE_TYPES.Identifier) {
-          checkAndReportIdentifier(rightNode, expressionNode.right);
-        }
-      }
-    }
-    function checkJSXExpression(node) {
-      if (node.expression.type === utils.TSESTree.AST_NODE_TYPES.LogicalExpression && node.expression.operator === "&&") {
-        checkLogicalExpression(node.expression, false);
-      }
-    }
-    return {
-      JSXExpressionContainer: checkJSXExpression
-    };
-  }
-});
-
-const index = {
-  rules: {
-    "generic-spacing": genericSpacing,
-    "jsx-strict-logical-expressions": jsxStrictLogicalExpressions
-  }
-};
-
-module.exports = index;

package/dist/index.mjs

@@ -1,219 +0,0 @@
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import { TypeFlags } from 'typescript';
-
-const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
-
-const RULE_NAME$1 = "generic-spacing";
-const messageId = "genericSpacingMismatch";
-function removeSpaceAround(node, context) {
-  const params = node.params;
-  if (!params.length)
-    return;
-  const sourceCode = context.sourceCode;
-  const start = node.range[0] + 1;
-  const end = node.range[1] - 1;
-  const startNode = params[0];
-  const endNode = params.at(-1);
-  const textBeforeFirst = sourceCode.text.slice(start, startNode.range[0]);
-  const textAfterLast = sourceCode.text.slice(endNode.range[1], end);
-  if (textBeforeFirst.length && !textBeforeFirst.includes("\n")) {
-    context.report({
-      node,
-      messageId,
-      *fix(fixer) {
-        yield fixer.replaceTextRange([start, startNode.range[0]], "");
-      },
-      loc: {
-        start: {
-          column: node.loc.start.column + 1,
-          line: node.loc.start.line
-        },
-        end: startNode.loc.start
-      }
-    });
-  }
-  if (textAfterLast.length && !textAfterLast.includes("\n")) {
-    context.report({
-      node,
-      messageId,
-      *fix(fixer) {
-        yield fixer.replaceTextRange([endNode.range[1], end], "");
-      },
-      loc: {
-        start: endNode.loc.end,
-        end: {
-          column: node.loc.end.column - 1,
-          line: node.loc.end.line
-        }
-      }
-    });
-  }
-}
-const genericSpacing = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      genericSpacingMismatch: "spacing mismatch"
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    return {
-      // type T<"K, S"> = any
-      TSTypeParameterDeclaration: (node) => removeSpaceAround(node, context),
-      // type T = Record<"K, S">
-      TSTypeParameterInstantiation: (node) => removeSpaceAround(node, context),
-      // type T<"K = any", "S = any"> = any
-      TSTypeParameter(node) {
-        if (!node.default)
-          return;
-        const startNode = node.constraint || node.name;
-        const endNode = node.default;
-        const start = startNode.range[1];
-        const end = endNode.range[0];
-        if (sourceCode.text.slice(start, end) !== " = ") {
-          context.report({
-            node,
-            messageId,
-            *fix(fixer) {
-              yield fixer.replaceTextRange([start, end], " = ");
-            },
-            loc: {
-              start: startNode.loc.end,
-              end: endNode.loc.start
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-function isUnionType(type) {
-  return (type.flags & TypeFlags.Union) !== 0;
-}
-function unionTypeParts(type) {
-  return isUnionType(type) ? type.types : [type];
-}
-function isFlagSet(obj, flag) {
-  return (obj.flags & flag) !== 0;
-}
-const isTypeFlagSet = isFlagSet;
-function getConstrainedTypeAtLocation(checker, node) {
-  const nodeType = checker.getTypeAtLocation(node);
-  const constrained = checker.getBaseConstraintOfType(nodeType);
-  return constrained ?? nodeType;
-}
-
-const RULE_NAME = "jsx-strict-logical-expressions";
-const jsxStrictLogicalExpressions = createEslintRule({
-  name: RULE_NAME,
-  defaultOptions: [{ allowString: false, allowNumber: false }],
-  meta: {
-    docs: {
-      description: "Forbid non-boolean falsey values in inline expressions",
-      recommended: "strict"
-    },
-    fixable: "code",
-    type: "problem",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allowString: { type: "boolean" },
-          allowNumber: { type: "boolean" }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      conditionErrorFalseyString: "Potentially falsey string in logical AND expression. Please use boolean.",
-      conditionErrorFalseyNumber: "Potentially falsey number in logical AND expression. Please use boolean."
-    }
-  },
-  create(context, [options]) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-    function checkIdentifier(node) {
-      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-      const types = unionTypeParts(
-        getConstrainedTypeAtLocation(typeChecker, tsNode)
-      );
-      const hasPotentiallyFalseyString = types.some(
-        (type) => isTypeFlagSet(type, TypeFlags.StringLike) && (!type.isStringLiteral() || type.value === "")
-      );
-      if (!options.allowString && hasPotentiallyFalseyString) {
-        return "conditionErrorFalseyString";
-      }
-      const hasPotentiallyFalseyNumber = types.some(
-        (type) => isTypeFlagSet(
-          type,
-          TypeFlags.NumberLike | TypeFlags.BigIntLike
-        ) && (!type.isNumberLiteral() || type.value === 0)
-      );
-      if (!options.allowNumber && hasPotentiallyFalseyNumber) {
-        return "conditionErrorFalseyNumber";
-      }
-      return;
-    }
-    function checkAndReportIdentifier(node, fixNode) {
-      const errorId = checkIdentifier(node);
-      if (errorId) {
-        context.report({
-          node,
-          messageId: errorId,
-          fix: (fixer) => fixer.insertTextBefore(fixNode, "!!")
-        });
-      }
-    }
-    function determineNode(originalNode) {
-      let nodeToEvaluate = originalNode;
-      if (nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.ChainExpression) {
-        nodeToEvaluate = nodeToEvaluate.expression;
-      }
-      if (nodeToEvaluate.type === TSESTree.AST_NODE_TYPES.MemberExpression && nodeToEvaluate.property.type !== TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
-        nodeToEvaluate = nodeToEvaluate.property;
-      }
-      return nodeToEvaluate;
-    }
-    function checkLogicalExpression(expressionNode, checkRightNode) {
-      const leftNode = determineNode(expressionNode.left);
-      if (leftNode.type === TSESTree.AST_NODE_TYPES.LogicalExpression) {
-        checkLogicalExpression(leftNode, true);
-      } else if (leftNode.type === TSESTree.AST_NODE_TYPES.Identifier) {
-        checkAndReportIdentifier(leftNode, expressionNode.left);
-      }
-      if (checkRightNode) {
-        const rightNode = determineNode(expressionNode.right);
-        if (rightNode.type === TSESTree.AST_NODE_TYPES.Identifier) {
-          checkAndReportIdentifier(rightNode, expressionNode.right);
-        }
-      }
-    }
-    function checkJSXExpression(node) {
-      if (node.expression.type === TSESTree.AST_NODE_TYPES.LogicalExpression && node.expression.operator === "&&") {
-        checkLogicalExpression(node.expression, false);
-      }
-    }
-    return {
-      JSXExpressionContainer: checkJSXExpression
-    };
-  }
-});
-
-const index = {
-  rules: {
-    "generic-spacing": genericSpacing,
-    "jsx-strict-logical-expressions": jsxStrictLogicalExpressions
-  }
-};
-
-export { index as default };