eslint-plugin-ziloen 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,257 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils.ts
+var import_utils = require("@typescript-eslint/utils");
+var createEslintRule = import_utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
+
+// src/rules/generic-spacing.ts
+var RULE_NAME = "generic-spacing";
+var 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
+        }
+      }
+    });
+  }
+}
+var genericSpacing = createEslintRule({
+  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];
+        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
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var generic_spacing_default = genericSpacing;
+
+// src/rules/jsx-strict-logical-expressions.ts
+var import_utils3 = require("@typescript-eslint/utils");
+var import_typescript2 = require("typescript");
+
+// src/tsutils.ts
+var import_typescript = require("typescript");
+function isUnionType(type) {
+  return (type.flags & import_typescript.TypeFlags.Union) !== 0;
+}
+function unionTypeParts(type) {
+  return isUnionType(type) ? type.types : [type];
+}
+function isFlagSet(obj, flag) {
+  return (obj.flags & flag) !== 0;
+}
+var isTypeFlagSet = isFlagSet;
+function getConstrainedTypeAtLocation(checker, node) {
+  const nodeType = checker.getTypeAtLocation(node);
+  const constrained = checker.getBaseConstraintOfType(nodeType);
+  return constrained ?? nodeType;
+}
+
+// src/rules/jsx-strict-logical-expressions.ts
+var RULE_NAME2 = "jsx-strict-logical-expressions";
+var jsxStrictLogicalExpressions = createEslintRule({
+  name: RULE_NAME2,
+  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 = import_utils3.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, import_typescript2.TypeFlags.StringLike) && (!type.isStringLiteral() || type.value === "")
+      );
+      if (!options.allowString && hasPotentiallyFalseyString) {
+        return "conditionErrorFalseyString";
+      }
+      const hasPotentiallyFalseyNumber = types.some(
+        (type) => isTypeFlagSet(
+          type,
+          import_typescript2.TypeFlags.NumberLike | import_typescript2.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 === import_utils3.TSESTree.AST_NODE_TYPES.ChainExpression) {
+        nodeToEvaluate = nodeToEvaluate.expression;
+      }
+      if (nodeToEvaluate.type === import_utils3.TSESTree.AST_NODE_TYPES.MemberExpression && nodeToEvaluate.property.type !== import_utils3.TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
+        nodeToEvaluate = nodeToEvaluate.property;
+      }
+      return nodeToEvaluate;
+    }
+    function checkLogicalExpression(expressionNode, checkRightNode) {
+      const leftNode = determineNode(expressionNode.left);
+      if (leftNode.type === import_utils3.TSESTree.AST_NODE_TYPES.LogicalExpression) {
+        checkLogicalExpression(leftNode, true);
+      } else if (leftNode.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
+        checkAndReportIdentifier(leftNode, expressionNode.left);
+      }
+      if (checkRightNode) {
+        const rightNode = determineNode(expressionNode.right);
+        if (rightNode.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
+          checkAndReportIdentifier(rightNode, expressionNode.right);
+        }
+      }
+    }
+    function checkJSXExpression(node) {
+      if (node.expression.type === import_utils3.TSESTree.AST_NODE_TYPES.LogicalExpression && node.expression.operator === "&&") {
+        checkLogicalExpression(node.expression, false);
+      }
+    }
+    return {
+      JSXExpressionContainer: checkJSXExpression
+    };
+  }
+});
+var jsx_strict_logical_expressions_default = jsxStrictLogicalExpressions;
+
+// src/index.ts
+var ziloen = {
+  meta: {
+    name: "ziloen"
+  },
+  rules: {
+    "generic-spacing": generic_spacing_default,
+    "jsx-strict-logical-expressions": jsx_strict_logical_expressions_default
+  }
+};
+var src_default = ziloen;

package/dist/index.mjs

@@ -0,0 +1,234 @@
+// src/utils.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+var createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
+
+// src/rules/generic-spacing.ts
+var RULE_NAME = "generic-spacing";
+var 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
+        }
+      }
+    });
+  }
+}
+var genericSpacing = createEslintRule({
+  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];
+        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
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var generic_spacing_default = genericSpacing;
+
+// src/rules/jsx-strict-logical-expressions.ts
+import { ESLintUtils as ESLintUtils2, TSESTree } from "@typescript-eslint/utils";
+import { TypeFlags as TypeFlags2 } from "typescript";
+
+// src/tsutils.ts
+import { TypeFlags } from "typescript";
+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;
+}
+var isTypeFlagSet = isFlagSet;
+function getConstrainedTypeAtLocation(checker, node) {
+  const nodeType = checker.getTypeAtLocation(node);
+  const constrained = checker.getBaseConstraintOfType(nodeType);
+  return constrained ?? nodeType;
+}
+
+// src/rules/jsx-strict-logical-expressions.ts
+var RULE_NAME2 = "jsx-strict-logical-expressions";
+var jsxStrictLogicalExpressions = createEslintRule({
+  name: RULE_NAME2,
+  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 = ESLintUtils2.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, TypeFlags2.StringLike) && (!type.isStringLiteral() || type.value === "")
+      );
+      if (!options.allowString && hasPotentiallyFalseyString) {
+        return "conditionErrorFalseyString";
+      }
+      const hasPotentiallyFalseyNumber = types.some(
+        (type) => isTypeFlagSet(
+          type,
+          TypeFlags2.NumberLike | TypeFlags2.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
+    };
+  }
+});
+var jsx_strict_logical_expressions_default = jsxStrictLogicalExpressions;
+
+// src/index.ts
+var ziloen = {
+  meta: {
+    name: "ziloen"
+  },
+  rules: {
+    "generic-spacing": generic_spacing_default,
+    "jsx-strict-logical-expressions": jsx_strict_logical_expressions_default
+  }
+};
+var src_default = ziloen;
+export {
+  src_default as default
+};

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "eslint-plugin-ziloen",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "rimraf dist && tsup src/index.ts --format esm,cjs --clean",
     "release": "pnpm run build && bumpp --commit --no-push && npm publish"

package/.vscode/settings.json

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

package/build.config.ts

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

package/src/index.ts

@@ -1,14 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,159 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-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

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

package/tsconfig.json

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