eslint-rule-forge 0.1.0 → 0.3.0

package/dist/type-wrappers.d.mts

@@ -1,5 +1,6 @@
-import { type TSESTree } from '@typescript-eslint/utils';
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 import type { DeepReadonly, RelaxedExtract } from 'ts-type-forge';
+import type * as ts from 'typescript';
 /**
  * The four expressions that change a value's type and nothing else: `x as T`,
  * `x!`, `x satisfies T` and `<T>x`.
@@ -41,4 +42,19 @@ export declare const skipTypeWrappers: <N extends DeepReadonly<TSESTree.Node>>(n
  * layer too.
  */
 export declare const typeWrapperLayers: <N extends DeepReadonly<TSESTree.Node>>(node: N) => readonly (N | WrappedExpression<N>)[];
+/**
+ * Whether `node`, read through its type wrappers, is the identifier `name`:
+ * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
+ */
+export declare const isIdentifierNamed: (node: DeepReadonly<TSESTree.Node>, name: string) => boolean;
+/**
+ * Whether `holds` is true of the type of every layer of type wrappers around
+ * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
+ * without type information. A widening cast (`s as string | number`) is the
+ * author saying the value may be more than it is, and is respected; a
+ * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
+ * value's own type does not, and the fix, which keeps the wrapper, has to
+ * type-check at every layer too.
+ */
+export declare const typeHoldsAtEveryLayer: (sourceCode: TSESLint.SourceCode, node: TSESTree.Node, holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean) => boolean;
 //# sourceMappingURL=type-wrappers.d.mts.map

package/dist/type-wrappers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"type-wrappers.d.mts","sourceRoot":"","sources":["../src/type-wrappers.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,WAAW,GACnB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,mBAAmB,GAC5B,QAAQ,CAAC,qBAAqB,GAC9B,QAAQ,CAAC,eAAe,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,cAAc,CAC/C,CAAC,EACD,YAAY,CAAC,WAAW,CAAC,GAAG,WAAW,CACxC,CAAC,YAAY,CAAC,CAAC;AAEhB;;;GAGG;AACH,eAAO,MAAM,aAAa,SAClB,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAChC,IAAI,IAAI,YAAY,CAAC,WAAW,CAAC,GAAG,WACT,CAAC;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAC9D,CAAC,KACN,CAAC,GAAG,iBAAiB,CAAC,CAAC,CACsC,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAC/D,CAAC,KACN,SAAS,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAGf,CAAC"}
+{"version":3,"file":"type-wrappers.d.mts","sourceRoot":"","sources":["../src/type-wrappers.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC;;;GAGG;AACH,MAAM,MAAM,WAAW,GACnB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,mBAAmB,GAC5B,QAAQ,CAAC,qBAAqB,GAC9B,QAAQ,CAAC,eAAe,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,cAAc,CAC/C,CAAC,EACD,YAAY,CAAC,WAAW,CAAC,GAAG,WAAW,CACxC,CAAC,YAAY,CAAC,CAAC;AAEhB;;;GAGG;AACH,eAAO,MAAM,aAAa,SAClB,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAChC,IAAI,IAAI,YAAY,CAAC,WAAW,CAAC,GAAG,WACT,CAAC;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAC9D,CAAC,KACN,CAAC,GAAG,iBAAiB,CAAC,CAAC,CACsC,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAC/D,CAAC,KACN,SAAS,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAGf,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,iBAAiB,SACtB,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAC3B,MAAM,KACX,OAMF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,eAEpB,QAAQ,CAAC,UAAU,QAEzB,QAAQ,CAAC,IAAI,SAEZ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,WAAW,KAAK,OAAO,KAC7D,OAgBF,CAAC"}

package/dist/type-wrappers.mjs

@@ -1,4 +1,4 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
 
 
 
@@ -30,6 +30,40 @@ export const skipTypeWrappers = (node) => isTypeWrapper(node) ? skipTypeWrappers
 export const typeWrapperLayers = (node) => isTypeWrapper(node)
     ? [node, ...typeWrapperLayers(node.expression)]
     : [node];
+
+
+
+
+export const isIdentifierNamed = (node, name) => {
+    const unwrapped = skipTypeWrappers(node);
+    return (unwrapped.type === AST_NODE_TYPES.Identifier && unwrapped.name === name);
+};
+
+
+
+
+
+
+
+
+
+export const typeHoldsAtEveryLayer = (
+
+sourceCode, 
+
+node, 
+
+holds) => {
+    const services = sourceCode.parserServices;
+    const checker = services?.program?.getTypeChecker();
+    if (checker === undefined) {
+        return false;
+    }
+    return typeWrapperLayers(node).every((layer) => {
+        const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
+        return (tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker));
+    });
+};
 const TYPE_WRAPPERS = new Set([
     AST_NODE_TYPES.TSAsExpression,
     AST_NODE_TYPES.TSNonNullExpression,

package/dist/type-wrappers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"type-wrappers.mjs","sourceRoot":"","sources":["../src/type-wrappers.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAiB,MAAM,0BAA0B,CAAC;AAwBzE;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,IAAiC,EACgB,EAAE,CACnD,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,IAAO,EACmB,EAAE,CAC5B,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,IAAO,EACgC,EAAE,CACzC,aAAa,CAAC,IAAI,CAAC;IACjB,CAAC,CAAE,CAAC,IAAI,EAAE,GAAG,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAW;IAC1D,CAAC,CAAE,CAAC,IAAI,CAAW,CAAC;AAExB,MAAM,aAAa,GAAgC,IAAI,GAAG,CAAC;IACzD,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,qBAAqB;IACpC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC"}
+{"version":3,"file":"type-wrappers.mjs","sourceRoot":"","sources":["../src/type-wrappers.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,0BAA0B,CAAC;AAyBlC;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,IAAiC,EACgB,EAAE,CACnD,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,IAAO,EACmB,EAAE,CAC5B,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,IAAO,EACgC,EAAE,CACzC,aAAa,CAAC,IAAI,CAAC;IACjB,CAAC,CAAE,CAAC,IAAI,EAAE,GAAG,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAW;IAC1D,CAAC,CAAE,CAAC,IAAI,CAAW,CAAC;AAExB;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,IAAiC,EACjC,IAAY,EACH,EAAE;IACX,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAEzC,OAAO,CACL,SAAS,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CACxE,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;AACnC,8EAA8E;AAC9E,UAA+B;AAC/B,8EAA8E;AAC9E,IAAmB;AACnB,8EAA8E;AAC9E,KAA8D,EACrD,EAAE;IACX,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,CAAC;IAE3C,MAAM,OAAO,GAAG,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IAEpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7C,MAAM,MAAM,GAAG,QAAQ,EAAE,qBAAqB,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QAE3D,OAAO,CACL,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAC1E,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,aAAa,GAAgC,IAAI,GAAG,CAAC;IACzD,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,qBAAqB;IACpC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-rule-forge",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "private": false,
   "description": "Helpers for writing typescript-eslint rules that see through type wrappers and parentheses, and resolve what a file imports.",
   "keywords": [
@@ -41,13 +41,13 @@
     "@typescript-eslint/rule-tester": "8.71.1",
     "dedent": "1.7.2",
     "eslint": "10.12.0",
-    "eslint-config-typed": "5.17.4",
-    "eslint-plugin-ts-fortress": "1.3.3",
-    "eslint-plugin-ts-type-forge": "0.8.8",
+    "eslint-config-typed": "5.19.1",
+    "eslint-plugin-ts-fortress": "1.3.6",
+    "eslint-plugin-ts-type-forge": "0.8.11",
     "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "ts-data-forge": "14.7.1",
+    "ts-data-forge": "14.9.0",
     "ts-repo-utils": "10.7.1"
   },
   "peerDependencies": {
@@ -65,15 +65,15 @@
   "scripts": {
     "build": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts",
     "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-ext.mts",
-    "check:lint": "oxlint . && eslint .",
-    "check:test": "pnpm run z:vitest run",
-    "check:test:cov": "pnpm run z:vitest run --coverage",
-    "check:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "check:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . && eslint .",
+    "check:test": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run",
+    "check:test:cov": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run --coverage",
+    "check:types": "node ../../tools/scripts/cmd/assert-deps-built.mts && node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "doc": "pnpm run gen:readme",
     "fix:fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
     "fix:fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
     "fix:fmt:full": "pnpm run z:prettier .",
-    "fix:lint": "oxlint . --fix && eslint . --fix",
+    "fix:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . --fix && eslint . --fix",
     "fmt": "pnpm run fix:fmt",
     "gen": "run-s gen:index gen:readme",
     "gen:index": "run-s gen:index:src fix:fmt",

package/src/index.mts

@@ -1,4 +1,6 @@
 export * from './bindings.mjs';
 export * from './imports.mjs';
+export * from './negation.mjs';
 export * from './parentheses.mjs';
+export * from './rules/index.mjs';
 export * from './type-wrappers.mjs';

package/src/negation.mts

@@ -0,0 +1,356 @@
+import {
+  AST_NODE_TYPES,
+  type ParserServicesWithTypeInformation,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import type { DeepReadonly, StrictPick } from 'ts-type-forge';
+import * as ts from 'typescript';
+import { typeWrapperLayers } from './type-wrappers.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+/** Each comparison operator, and the one that is true exactly when it is not. */
+export const INVERTED_COMPARISON_OPERATOR = {
+  '===': '!==',
+  '!==': '===',
+  '==': '!=',
+  '!=': '==',
+  '<': '>=',
+  '>=': '<',
+  '>': '<=',
+  '<=': '>',
+} as const;
+
+export type ComparisonOperator = keyof typeof INVERTED_COMPARISON_OPERATOR;
+
+export type ComparisonExpression = DeepReadonly<TSESTree.BinaryExpression> &
+  Readonly<{ operator: ComparisonOperator }>;
+
+/**
+ * The type of a node at each of its type-wrapper layers, outermost first (see
+ * {@link typeWrapperLayers}).
+ */
+export type GetLayerTypes = (
+  node: DeepReadonly<TSESTree.Node>,
+) => readonly ts.Type[];
+
+/**
+ * Builds a {@link GetLayerTypes}: `x as A` gives the types of `x as A` and of
+ * `x`.
+ *
+ * A conclusion a rule draws from a type is drawn only when it holds for every
+ * one of them. A widening `as` (`b as boolean | number`) is then the author
+ * saying the value may be something else, and is respected, while a narrowing
+ * one (`n as unknown as boolean`) leaves the value's own type to decide.
+ */
+export const createGetLayerTypes =
+  (
+    services: StrictPick<
+      ParserServicesWithTypeInformation,
+      'esTreeNodeToTSNodeMap' | 'program'
+    >,
+  ): GetLayerTypes =>
+  (node) => {
+    const checker = services.program.getTypeChecker();
+
+    return typeWrapperLayers(node).map((layer) =>
+      checker.getTypeAtLocation(
+        services.esTreeNodeToTSNodeMap.get(asNode(layer)),
+      ),
+    );
+  };
+
+export const isComparison = (
+  node: DeepReadonly<TSESTree.Node>,
+): node is ComparisonExpression =>
+  node.type === AST_NODE_TYPES.BinaryExpression &&
+  Object.hasOwn(INVERTED_COMPARISON_OPERATOR, node.operator);
+
+/**
+ * Whether inverting the operator gives exactly the negation.
+ *
+ * An equality always does. A relational comparison does unless an operand
+ * converts to `NaN`: every relational comparison with `NaN` is `false`, so
+ * `!(a < b)` is `true` there while `a >= b` is `false`. It cannot when both
+ * sides are strings (compared as strings), or both are numeric values that are
+ * never `NaN` — number literals, `bigint`, booleans, and number brands that
+ * declare `NaNValue: false` (`ValidNumber`, `Int`, `FiniteNumber`, …).
+ *
+ * `getLayerTypes` gives an operand's type at each of its type-wrapper layers,
+ * and every one of them has to say so: `(v as number) < 1` may be `NaN` even
+ * when `v` is a `ValidNumber`, and `(n as ValidNumber) < 1` still may when `n`
+ * is a `number`.
+ */
+export const isExactlyInvertible = (
+  node: ComparisonExpression,
+  getLayerTypes: GetLayerTypes,
+  checker: ts.TypeChecker,
+): boolean => {
+  if (!RELATIONAL_OPERATORS.has(node.operator)) {
+    return true;
+  }
+
+  const sides = [
+    ...getLayerTypes(node.left),
+    ...getLayerTypes(node.right),
+  ].flatMap(constituentsOf);
+
+  return (
+    sides.every((type) => (type.flags & ts.TypeFlags.StringLike) !== 0) ||
+    sides.every((type) => isNeverNaN(type, checker))
+  );
+};
+
+/**
+ * The source of `node` with its operator inverted, and everything else —
+ * operands, comments, line breaks — as written.
+ */
+export const invertedComparisonText = (
+  node: ComparisonExpression,
+  sourceCode: DeepReadonly<TSESLint.SourceCode>,
+): string => {
+  const text = sourceCode.getText(asNode(node));
+
+  const operator = sourceCode.getFirstTokenBetween(
+    asNode(node.left),
+    asNode(node.right),
+    (token) => token.value === node.operator,
+  );
+
+  if (operator === null) {
+    return `${sourceCode.getText(asNode(node.left))} ${INVERTED_COMPARISON_OPERATOR[node.operator]} ${sourceCode.getText(asNode(node.right))}`;
+  }
+
+  const [start] = node.range;
+
+  return [
+    text.slice(0, operator.range[0] - start),
+    INVERTED_COMPARISON_OPERATOR[node.operator],
+    text.slice(operator.range[1] - start),
+  ].join('');
+};
+
+/** What {@link negationOf} needs to know about the code it negates. */
+export type NegationContext = Readonly<{
+  sourceCode: DeepReadonly<TSESLint.SourceCode>;
+  checker: ts.TypeChecker;
+  getLayerTypes: GetLayerTypes;
+  /**
+   * Whether `node`'s value is a boolean, so that the negation of `!node` may
+   * be `node` itself. Where only the truthiness of the negation is read — the
+   * test of an `if` — any value will do, and this may answer `true` for every
+   * node.
+   */
+  isBoolean: (node: DeepReadonly<TSESTree.Expression>) => boolean;
+}>;
+
+/**
+ * The negation of `node`, written the short way, as the source text of an
+ * operand of `operandOf` (parenthesized if need be), or of a whole expression
+ * when `operandOf` is `undefined`:
+ *
+ * | `node`             | negation          | when                                  |
+ * | :----------------- | :---------------- | :------------------------------------ |
+ * | `!a`               | `a`               | `a` is a boolean (`context.isBoolean`) |
+ * | `a === b`          | `a !== b`         | always                                |
+ * | `a < b`            | `a >= b`          | no operand can be `NaN`               |
+ * | `a && b`, `a \|\| b` | `!a \|\| !b`, `!a && !b` | always, each side negated the same way |
+ * | anything else      | `!a`, `!(a)`      | always                                |
+ *
+ * `undefined` when the first two rows' condition does not hold: then the only
+ * exact negation is `!!a` or `!(a < b)`, and a caller decides whether to
+ * write it (with {@link prefixedNegationOf}) or to give up. Inside `&&` and
+ * `||`, a side with no short negation is written with `!`.
+ *
+ * The node is taken as written: a comparison under a type wrapper is not
+ * looked into, since inverting it would drop the wrapper.
+ */
+export const negationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  context: NegationContext,
+  operandOf: '&&' | '||' | undefined,
+): string | undefined => {
+  const negation = shortNegationOf(node, context);
+
+  return negation === undefined ? undefined : asOperand(negation, operandOf);
+};
+
+/**
+ * `!node`, with `node` parenthesized unless `!` already binds to all of it:
+ * `!a`, `!f(x)`, `!(a === b)`.
+ */
+export const prefixedNegationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  sourceCode: DeepReadonly<TSESLint.SourceCode>,
+): string => {
+  const text = sourceCode.getText(asNode(node));
+
+  return BINDS_AS_TIGHT_AS_UNARY.has(node.type) ? `!${text}` : `!(${text})`;
+};
+
+/**
+ * Whether `node`, written as an operand of `operator`, needs parentheses to
+ * stay one operand: `a || b` under `&&`, `a ?? b` under either, and anything
+ * binding looser than both (`a ? b : c`, `a = b`, …).
+ */
+export const needsParenthesesAsOperandOf = (
+  node: DeepReadonly<TSESTree.Node>,
+  operator: '&&' | '||',
+): boolean => isLooserThan(precedenceOf(node), operator);
+
+/**
+ * How tightly an expression binds, as far as putting it under `&&` or `||` is
+ * concerned.
+ */
+type Precedence = '&&' | '||' | 'looser' | 'tighter';
+
+type Negation = Readonly<{
+  text: string;
+  precedence: Precedence;
+}>;
+
+const shortNegationOf = (
+  node: DeepReadonly<TSESTree.Expression>,
+  context: NegationContext,
+): Negation | undefined => {
+  if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '!') {
+    return context.isBoolean(node.argument)
+      ? {
+          text: context.sourceCode.getText(asNode(node.argument)),
+          precedence: precedenceOf(node.argument),
+        }
+      : undefined;
+  }
+
+  if (isComparison(node)) {
+    return isExactlyInvertible(node, context.getLayerTypes, context.checker)
+      ? {
+          text: invertedComparisonText(node, context.sourceCode),
+          precedence: 'tighter',
+        }
+      : undefined;
+  }
+
+  if (
+    node.type === AST_NODE_TYPES.LogicalExpression &&
+    node.operator !== '??'
+  ) {
+    const operator = node.operator === '&&' ? '||' : '&&';
+
+    const side = (operand: DeepReadonly<TSESTree.Expression>): string =>
+      asOperand(
+        shortNegationOf(operand, context) ?? {
+          text: prefixedNegationOf(operand, context.sourceCode),
+          precedence: 'tighter',
+        },
+        operator,
+      );
+
+    return {
+      text: `${side(node.left)} ${operator} ${side(node.right)}`,
+      precedence: operator,
+    };
+  }
+
+  return {
+    text: prefixedNegationOf(node, context.sourceCode),
+    precedence: 'tighter',
+  };
+};
+
+const asOperand = (
+  negation: Negation,
+  operator: '&&' | '||' | undefined,
+): string =>
+  operator !== undefined && isLooserThan(negation.precedence, operator)
+    ? (`(${negation.text})` as const)
+    : negation.text;
+
+const isLooserThan = (precedence: Precedence, operator: '&&' | '||'): boolean =>
+  precedence === 'looser' || (operator === '&&' && precedence === '||');
+
+const precedenceOf = (node: DeepReadonly<TSESTree.Node>): Precedence => {
+  if (node.type === AST_NODE_TYPES.LogicalExpression) {
+    // `??` cannot be mixed with `&&` or `||` without parentheses.
+    return node.operator === '??' ? 'looser' : node.operator;
+  }
+
+  return LOOSER_THAN_LOGICAL.has(node.type) ? 'looser' : 'tighter';
+};
+
+const LOOSER_THAN_LOGICAL: ReadonlySet<AST_NODE_TYPES> = new Set([
+  AST_NODE_TYPES.ArrowFunctionExpression,
+  AST_NODE_TYPES.AssignmentExpression,
+  AST_NODE_TYPES.ConditionalExpression,
+  AST_NODE_TYPES.SequenceExpression,
+  AST_NODE_TYPES.YieldExpression,
+]);
+
+/** Expressions `!` can be put in front of without parentheses. */
+const BINDS_AS_TIGHT_AS_UNARY: ReadonlySet<AST_NODE_TYPES> = new Set([
+  AST_NODE_TYPES.ArrayExpression,
+  AST_NODE_TYPES.AwaitExpression,
+  AST_NODE_TYPES.CallExpression,
+  AST_NODE_TYPES.ChainExpression,
+  AST_NODE_TYPES.Identifier,
+  AST_NODE_TYPES.Literal,
+  AST_NODE_TYPES.MemberExpression,
+  AST_NODE_TYPES.MetaProperty,
+  AST_NODE_TYPES.NewExpression,
+  AST_NODE_TYPES.ObjectExpression,
+  AST_NODE_TYPES.TaggedTemplateExpression,
+  AST_NODE_TYPES.TemplateLiteral,
+  AST_NODE_TYPES.ThisExpression,
+  AST_NODE_TYPES.TSNonNullExpression,
+  AST_NODE_TYPES.UnaryExpression,
+]);
+
+const RELATIONAL_OPERATORS: ReadonlySet<ComparisonOperator> =
+  new Set<ComparisonOperator>(['<', '<=', '>', '>=']);
+
+const constituentsOf = (type: ts.Type): readonly ts.Type[] =>
+  type.isUnion() ? type.types : ([type] as const);
+
+const isNeverNaN = (type: ts.Type, checker: ts.TypeChecker): boolean => {
+  // Read `ts.TypeFlags` here, not at module scope: every importer of this
+  // package's index evaluates the module, and a `typescript` without the JS
+  // API (7.x) would fail the import even for rules that never get here.
+  const neverNaNFlags =
+    ts.TypeFlags.NumberLiteral |
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.Null;
+
+  if ((type.flags & neverNaNFlags) !== 0) {
+    return true;
+  }
+
+  if (!type.isIntersection()) {
+    return false;
+  }
+
+  const brand = checker.getPropertyOfType(type, 'NaNValue');
+
+  if (brand === undefined) {
+    return false;
+  }
+
+  const brandType = checker.getTypeOfSymbol(brand);
+
+  return (
+    type.types.some(
+      (member) => (member.flags & ts.TypeFlags.NumberLike) !== 0,
+    ) &&
+    (brandType.flags & ts.TypeFlags.BooleanLiteral) !== 0 &&
+    checker.typeToString(brandType) === 'false'
+  );
+};
+
+/**
+ * The parser's node, which the source code and the token store take as
+ * mutable, for one that this package only reads.
+ */
+const asNode = <T extends TSESTree.Node>(node: DeepReadonly<T>): T =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  node as T;

package/src/rules/index.mts

@@ -0,0 +1,5 @@
+export * from './no-side-effect-import.mjs';
+export * from './prefer-array-is-array.mjs';
+export * from './prefer-is-non-null-object.mjs';
+export * from './prefer-is-record-and-has-key.mjs';
+export * from './prefer-safe-parse.mjs';

package/src/rules/no-side-effect-import.mts

@@ -0,0 +1,68 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+/**
+ * Builds a rule that removes `import '<moduleName>';`, an import that binds no
+ * name. The rule matches the bare specifier exactly, so a subpath such as
+ * `<moduleName>/global` and every other module are left alone.
+ *
+ * Why such an import is wrong depends on the module — one with
+ * `sideEffects: false` loads for nothing, one with no runtime entry point fails
+ * to resolve — so the caller says it, in `description` and `message`, and
+ * chooses `type` accordingly.
+ */
+export const createNoSideEffectImport = ({
+  moduleName,
+  type,
+  description,
+  message,
+}: Readonly<{
+  moduleName: string;
+  type: TSESLint.RuleMetaData<string, unknown>['type'];
+  description: string;
+  message: string;
+}>): TSESLint.RuleModule<'removeSideEffectImport', readonly []> =>
+  ({
+    meta: {
+      type,
+      docs: { description },
+      fixable: 'code',
+      schema: [],
+      messages: { removeSideEffectImport: message },
+    },
+
+    create: (context) => ({
+      ImportDeclaration: (node) => {
+        if (node.source.value !== moduleName || node.specifiers.length > 0) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: 'removeSideEffectImport',
+          fix: (fixer) => removeStatement(fixer, context.sourceCode, node),
+        });
+      },
+    }),
+    defaultOptions: [],
+  }) as const;
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+/**
+ * Removes a statement along with the rest of its line, so that deleting it does
+ * not leave a blank line where it was.
+ */
+const removeStatement = (
+  fixer: TSESLint.RuleFixer,
+  sourceCode: TSESLint.SourceCode,
+  node: TSESTree.Node,
+): TSESLint.RuleFix => {
+  const restOfLine = /^[^\S\n]*\n/u.exec(
+    sourceCode.getText().slice(node.range[1]),
+  );
+
+  return fixer.removeRange([
+    node.range[0],
+    node.range[1] + (restOfLine?.[0].length ?? 0),
+  ]);
+};