eslint-rule-forge 0.1.0 → 0.3.0

package/README.md

@@ -23,15 +23,18 @@ dependencies.
 
 `x as T`, `x!`, `x satisfies T` and `<T>x` change a type and never a value.
 
-| Helper              | What it gives                                                                         |
-| :------------------ | :------------------------------------------------------------------------------------ |
-| `isTypeWrapper`     | whether a node is one of the four                                                     |
-| `skipTypeWrappers`  | the expression inside every wrapper around a node: judge syntax on this               |
-| `typeWrapperLayers` | the node and every expression inside its wrappers, outermost first: ask types of each |
-| `TypeWrapper`       | the four node types                                                                   |
-
-All of them take a readonly (`DeepReadonly<TSESTree.Node>`) or a mutable node
-and give back the same kind.
+| Helper                  | What it gives                                                                         |
+| :---------------------- | :------------------------------------------------------------------------------------ |
+| `isTypeWrapper`         | whether a node is one of the four                                                     |
+| `skipTypeWrappers`      | the expression inside every wrapper around a node: judge syntax on this               |
+| `typeWrapperLayers`     | the node and every expression inside its wrappers, outermost first: ask types of each |
+| `TypeWrapper`           | the four node types                                                                   |
+| `isIdentifierNamed`     | whether a node, read through its wrappers, is the identifier of a given name          |
+| `typeHoldsAtEveryLayer` | whether a check holds of the type at every layer, `false` without type information    |
+
+All of them but `typeHoldsAtEveryLayer` take a readonly
+(`DeepReadonly<TSESTree.Node>`) or a mutable node, and those that return a node
+give back the same kind.
 
 Judge syntax on what `skipTypeWrappers` returns, and write the fix from the
 original node, so that the wrapper is kept:
@@ -87,6 +90,27 @@ assertion (`x as string | null`) then makes the rule more cautious, and a
 narrowing one (`x!`, `v as string` on an `unknown`), which the checker cannot
 verify, changes nothing.
 
+## Negation
+
+Writing the negation of a condition the short way, as a fix that removes a
+ternary or turns a filter into a loop has to.
+
+| Helper                        | What it gives                                                                                                             |
+| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------ |
+| `negationOf`                  | `a !== b` for `a === b`, `!a && !b` for `a \|\| b`, `a` for `!a` (when a boolean), else `!a`; parenthesized as an operand |
+| `prefixedNegationOf`          | `!a`, `!f(x)`, `!(a === b)`: a `!` in front, with parentheses only when it needs them                                     |
+| `isComparison`                | whether a node is an equality or a relational comparison                                                                  |
+| `isExactlyInvertible`         | whether inverting a comparison's operator is its exact negation: always for an equality, for `<` only without `NaN`       |
+| `invertedComparisonText`      | the comparison's source with its operator inverted                                                                        |
+| `needsParenthesesAsOperandOf` | whether a node needs parentheses as an operand of `&&` or `\|\|`                                                          |
+| `createGetLayerTypes`         | a function giving a node's type at every type-wrapper layer, which the checks above ask                                   |
+
+`negationOf` gives `undefined` when the only exact negation is `!!a` (for an
+`a` that may not be a boolean) or `!(a < b)` (for operands that may be `NaN`),
+so that a rule can choose between `prefixedNegationOf` and giving up. Where
+only the truthiness of the negation is read, such as the test of an `if`, its
+context may call every node a boolean.
+
 ## Parentheses
 
 The range and the text of a node leave out the parentheses written around it.
@@ -186,6 +210,22 @@ export const preferIsNullish: TSESLint.RuleModule<'preferIsNullish'> = {
 } as const;
 ```
 
+## Rule factories
+
+Rules that several plugins carry, differing only in the module whose functions
+the fix writes. Each factory takes the module name (and the namespace the
+function is reached through, where there is one) and returns a complete rule,
+so that a fix to the rule reaches every plugin that builds it.
+
+| Factory                         | The rule it builds                                                                                        |
+| :------------------------------ | :-------------------------------------------------------------------------------------------------------- |
+| `createPreferIsNonNullObject`   | `typeof u === 'object' && u !== null` → `isNonNullObject(u)`                                              |
+| `createPreferIsRecordAndHasKey` | `Object.hasOwn(obj, key)` and `key in obj` → `isRecord(obj) && hasKey(obj, key)`, or `hasKey` on a record |
+| `createPreferArrayIsArray`      | `Array.isArray` → `<namespace>.isArray`                                                                   |
+| `createPreferSafeParseInt`      | `parseInt(x)`, `parseInt(x, 10)` → `Result.unwrapOkOr(<namespace>.<method>(x), Number.NaN)`               |
+| `createPreferSafeParseFloat`    | `parseFloat(x)`, `Number.parseFloat(x)`, `Number(x)` → the same, for a `string` `x`                       |
+| `createNoSideEffectImport`      | removes `import '<module>';`, with the reason the caller gives                                            |
+
 ## License
 
 [Apache-2.0](https://github.com/noshiro-pf/mono/blob/main/libs/eslint-rule-forge/LICENSE)

package/dist/index.d.mts

@@ -1,5 +1,7 @@
 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';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}

package/dist/index.mjs

@@ -1,5 +1,7 @@
 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';
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}

package/dist/negation.d.mts

@@ -0,0 +1,102 @@
+import { type ParserServicesWithTypeInformation, type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import type { DeepReadonly, StrictPick } from 'ts-type-forge';
+import * as ts from 'typescript';
+/** Each comparison operator, and the one that is true exactly when it is not. */
+export declare const INVERTED_COMPARISON_OPERATOR: {
+    readonly '===': '!==';
+    readonly '!==': '===';
+    readonly '==': '!=';
+    readonly '!=': '==';
+    readonly '<': '>=';
+    readonly '>=': '<';
+    readonly '>': '<=';
+    readonly '<=': '>';
+};
+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 declare const createGetLayerTypes: (services: StrictPick<ParserServicesWithTypeInformation, 'esTreeNodeToTSNodeMap' | 'program'>) => GetLayerTypes;
+export declare const isComparison: (node: DeepReadonly<TSESTree.Node>) => node is ComparisonExpression;
+/**
+ * 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 declare const isExactlyInvertible: (node: ComparisonExpression, getLayerTypes: GetLayerTypes, checker: ts.TypeChecker) => boolean;
+/**
+ * The source of `node` with its operator inverted, and everything else —
+ * operands, comments, line breaks — as written.
+ */
+export declare const invertedComparisonText: (node: ComparisonExpression, sourceCode: DeepReadonly<TSESLint.SourceCode>) => string;
+/** 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 declare const negationOf: (node: DeepReadonly<TSESTree.Expression>, context: NegationContext, operandOf: '&&' | '||' | undefined) => string | undefined;
+/**
+ * `!node`, with `node` parenthesized unless `!` already binds to all of it:
+ * `!a`, `!f(x)`, `!(a === b)`.
+ */
+export declare const prefixedNegationOf: (node: DeepReadonly<TSESTree.Expression>, sourceCode: DeepReadonly<TSESLint.SourceCode>) => string;
+/**
+ * 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 declare const needsParenthesesAsOperandOf: (node: DeepReadonly<TSESTree.Node>, operator: '&&' | '||') => boolean;
+//# sourceMappingURL=negation.d.mts.map

package/dist/negation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negation.d.mts","sourceRoot":"","sources":["../src/negation.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iCAAiC,EACtC,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC,iFAAiF;AACjF,eAAO,MAAM,4BAA4B;aACvC,KAAK,EAAE,KAAK;aACZ,KAAK,EAAE,KAAK;aACZ,IAAI,EAAE,IAAI;aACV,IAAI,EAAE,IAAI;aACV,GAAG,EAAE,IAAI;aACT,IAAI,EAAE,GAAG;aACT,GAAG,EAAE,IAAI;aACT,IAAI,EAAE,GAAG;CACD,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,4BAA4B,CAAC;AAE3E,MAAM,MAAM,oBAAoB,GAAG,YAAY,CAAC,QAAQ,CAAC,gBAAgB,CAAC,GACxE,QAAQ,CAAC;IAAE,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAC9B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,aAElB,UAAU,CAClB,iCAAiC,EACjC,uBAAuB,GAAG,SAAS,CACpC,KACA,aASF,CAAC;AAEJ,eAAO,MAAM,YAAY,SACjB,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAChC,IAAI,IAAI,oBAEiD,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,SACxB,oBAAoB,iBACX,aAAa,WACnB,EAAE,CAAC,WAAW,KACtB,OAcF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,SAC3B,oBAAoB,cACd,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAC5C,MAoBF,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC9C,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;;OAKG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC;CACjE,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,SACf,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,WAC9B,eAAe,aACb,IAAI,GAAG,IAAI,GAAG,SAAS,KACjC,MAAM,GAAG,SAIX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,SACvB,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,cAC3B,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KAC5C,MAIF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,SAChC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,YACvB,IAAI,GAAG,IAAI,KACpB,OAAqD,CAAC"}

package/dist/negation.mjs

@@ -0,0 +1,215 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { typeWrapperLayers } from './type-wrappers.mjs';
+
+
+export const INVERTED_COMPARISON_OPERATOR = {
+    '===': '!==',
+    '!==': '===',
+    '==': '!=',
+    '!=': '==',
+    '<': '>=',
+    '>=': '<',
+    '>': '<=',
+    '<=': '>',
+};
+
+
+
+
+
+
+
+
+
+export const createGetLayerTypes = (services) => (node) => {
+    const checker = services.program.getTypeChecker();
+    return typeWrapperLayers(node).map((layer) => checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(asNode(layer))));
+};
+export const isComparison = (node) => node.type === AST_NODE_TYPES.BinaryExpression &&
+    Object.hasOwn(INVERTED_COMPARISON_OPERATOR, node.operator);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isExactlyInvertible = (node, getLayerTypes, checker) => {
+    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)));
+};
+
+
+
+
+export const invertedComparisonText = (node, sourceCode) => {
+    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('');
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const negationOf = (node, context, operandOf) => {
+    const negation = shortNegationOf(node, context);
+    return negation === undefined ? undefined : asOperand(negation, operandOf);
+};
+
+
+
+
+export const prefixedNegationOf = (node, sourceCode) => {
+    const text = sourceCode.getText(asNode(node));
+    return BINDS_AS_TIGHT_AS_UNARY.has(node.type) ? `!${text}` : `!(${text})`;
+};
+
+
+
+
+
+export const needsParenthesesAsOperandOf = (node, operator) => isLooserThan(precedenceOf(node), operator);
+const shortNegationOf = (node, context) => {
+    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) => 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, operator) => operator !== undefined && isLooserThan(negation.precedence, operator)
+    ? `(${negation.text})`
+    : negation.text;
+const isLooserThan = (precedence, operator) => precedence === 'looser' || (operator === '&&' && precedence === '||');
+const precedenceOf = (node) => {
+    if (node.type === AST_NODE_TYPES.LogicalExpression) {
+
+        return node.operator === '??' ? 'looser' : node.operator;
+    }
+    return LOOSER_THAN_LOGICAL.has(node.type) ? 'looser' : 'tighter';
+};
+const LOOSER_THAN_LOGICAL = new Set([
+    AST_NODE_TYPES.ArrowFunctionExpression,
+    AST_NODE_TYPES.AssignmentExpression,
+    AST_NODE_TYPES.ConditionalExpression,
+    AST_NODE_TYPES.SequenceExpression,
+    AST_NODE_TYPES.YieldExpression,
+]);
+
+const BINDS_AS_TIGHT_AS_UNARY = 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 = new Set(['<', '<=', '>', '>=']);
+const constituentsOf = (type) => type.isUnion() ? type.types : [type];
+const isNeverNaN = (type, checker) => {
+
+
+
+    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');
+};
+
+
+
+
+const asNode = (node) => 
+
+node;
+//# sourceMappingURL=negation.mjs.map

package/dist/negation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"negation.mjs","sourceRoot":"","sources":["../src/negation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAIf,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,uEAAuE;AAEvE,iFAAiF;AACjF,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,KAAK,EAAE,KAAK;IACZ,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,IAAI;IACV,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,GAAG;IACT,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,GAAG;CACD,CAAC;AAeX;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B,CACE,QAGC,EACc,EAAE,CACnB,CAAC,IAAI,EAAE,EAAE;IACP,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;IAElD,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,OAAO,CAAC,iBAAiB,CACvB,QAAQ,CAAC,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAClD,CACF,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,IAAiC,EACH,EAAE,CAChC,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;IAC7C,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,IAA0B,EAC1B,aAA4B,EAC5B,OAAuB,EACd,EAAE;IACX,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG;QACZ,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAC3B,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;KAC7B,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAE1B,OAAO,CACL,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CACjD,CAAC;AACJ,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,IAA0B,EAC1B,UAA6C,EACrC,EAAE;IACV,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9C,MAAM,QAAQ,GAAG,UAAU,CAAC,oBAAoB,CAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EACjB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAClB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,QAAQ,CACzC,CAAC;IAEF,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,4BAA4B,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;IAC7I,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;IAE3B,OAAO;QACL,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QACxC,4BAA4B,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;KACtC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACb,CAAC,CAAC;AAgBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,IAAuC,EACvC,OAAwB,EACxB,SAAkC,EACd,EAAE;IACtB,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAEhD,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,IAAuC,EACvC,UAA6C,EACrC,EAAE;IACV,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9C,OAAO,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC;AAC5E,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,IAAiC,EACjC,QAAqB,EACZ,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AAazD,MAAM,eAAe,GAAG,CACtB,IAAuC,EACvC,OAAwB,EACF,EAAE;IACxB,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;QAC1E,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;YACrC,CAAC,CAAC;gBACE,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACvD,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC;aACxC;YACH,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,OAAO,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC;YACtE,CAAC,CAAC;gBACE,IAAI,EAAE,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC;gBACtD,UAAU,EAAE,SAAS;aACtB;YACH,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED,IACE,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB;QAC9C,IAAI,CAAC,QAAQ,KAAK,IAAI,EACtB,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAEtD,MAAM,IAAI,GAAG,CAAC,OAA0C,EAAU,EAAE,CAClE,SAAS,CACP,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI;YACnC,IAAI,EAAE,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;YACrD,UAAU,EAAE,SAAS;SACtB,EACD,QAAQ,CACT,CAAC;QAEJ,OAAO;YACL,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC1D,UAAU,EAAE,QAAQ;SACrB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC;QAClD,UAAU,EAAE,SAAS;KACtB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,CAChB,QAAkB,EAClB,QAAiC,EACzB,EAAE,CACV,QAAQ,KAAK,SAAS,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IACnE,CAAC,CAAE,IAAI,QAAQ,CAAC,IAAI,GAAa;IACjC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;AAEpB,MAAM,YAAY,GAAG,CAAC,UAAsB,EAAE,QAAqB,EAAW,EAAE,CAC9E,UAAU,KAAK,QAAQ,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,UAAU,KAAK,IAAI,CAAC,CAAC;AAExE,MAAM,YAAY,GAAG,CAAC,IAAiC,EAAc,EAAE;IACrE,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB,EAAE,CAAC;QACnD,8DAA8D;QAC9D,OAAO,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC3D,CAAC;IAED,OAAO,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAgC,IAAI,GAAG,CAAC;IAC/D,cAAc,CAAC,uBAAuB;IACtC,cAAc,CAAC,oBAAoB;IACnC,cAAc,CAAC,qBAAqB;IACpC,cAAc,CAAC,kBAAkB;IACjC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC;AAEH,kEAAkE;AAClE,MAAM,uBAAuB,GAAgC,IAAI,GAAG,CAAC;IACnE,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,UAAU;IACzB,cAAc,CAAC,OAAO;IACtB,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,YAAY;IAC3B,cAAc,CAAC,aAAa;IAC5B,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,wBAAwB;IACvC,cAAc,CAAC,eAAe;IAC9B,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC;AAEH,MAAM,oBAAoB,GACxB,IAAI,GAAG,CAAqB,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AAEtD,MAAM,cAAc,GAAG,CAAC,IAAa,EAAsB,EAAE,CAC3D,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,IAAI,CAAW,CAAC;AAElD,MAAM,UAAU,GAAG,CAAC,IAAa,EAAE,OAAuB,EAAW,EAAE;IACrE,wEAAwE;IACxE,0EAA0E;IAC1E,sEAAsE;IACtE,MAAM,aAAa,GACjB,EAAE,CAAC,SAAS,CAAC,aAAa;QAC1B,EAAE,CAAC,SAAS,CAAC,UAAU;QACvB,EAAE,CAAC,SAAS,CAAC,WAAW;QACxB,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC;IAEpB,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAE1D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAEjD,OAAO,CACL,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAC3D;QACD,CAAC,SAAS,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC,KAAK,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,OAAO,CAC5C,CAAC;AACJ,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,GAAG,CAA0B,IAAqB,EAAK,EAAE;AACnE,oEAAoE;AACpE,IAAS,CAAC"}

package/dist/rules/index.d.mts

@@ -0,0 +1,6 @@
+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';
+//# sourceMappingURL=index.d.mts.map

package/dist/rules/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/rules/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

package/dist/rules/index.mjs

@@ -0,0 +1,6 @@
+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';
+//# sourceMappingURL=index.mjs.map

package/dist/rules/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/rules/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

package/dist/rules/no-side-effect-import.d.mts

@@ -0,0 +1,18 @@
+import type { TSESLint } 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 declare const createNoSideEffectImport: ({ moduleName, type, description, message, }: Readonly<{
+    moduleName: string;
+    type: TSESLint.RuleMetaData<string, unknown>['type'];
+    description: string;
+    message: string;
+}>) => TSESLint.RuleModule<'removeSideEffectImport', readonly []>;
+//# sourceMappingURL=no-side-effect-import.d.mts.map

package/dist/rules/no-side-effect-import.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-side-effect-import.d.mts","sourceRoot":"","sources":["../../src/rules/no-side-effect-import.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,gDAKlC,QAAQ,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,KAAG,QAAQ,CAAC,UAAU,CAAC,wBAAwB,EAAE,SAAS,EAAE,CAwBjD,CAAC"}

package/dist/rules/no-side-effect-import.mjs

@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+
+
+
+export const createNoSideEffectImport = ({ moduleName, type, description, message, }) => ({
+    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: [],
+});
+
+
+
+
+
+const removeStatement = (fixer, sourceCode, node) => {
+    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),
+    ]);
+};
+//# sourceMappingURL=no-side-effect-import.mjs.map

package/dist/rules/no-side-effect-import.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-side-effect-import.mjs","sourceRoot":"","sources":["../../src/rules/no-side-effect-import.mts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,EACvC,UAAU,EACV,IAAI,EACJ,WAAW,EACX,OAAO,GAMP,EAA8D,EAAE,CAChE,CAAC;IACC,IAAI,EAAE;QACJ,IAAI;QACJ,IAAI,EAAE,EAAE,WAAW,EAAE;QACrB,OAAO,EAAE,MAAM;QACf,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE;KAC9C;IAED,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACpB,iBAAiB,EAAE,CAAC,IAAI,EAAE,EAAE;YAC1B,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACnE,OAAO;YACT,CAAC;YAED,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI;gBACJ,SAAS,EAAE,wBAAwB;gBACnC,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC;aACjE,CAAC,CAAC;QACL,CAAC;KACF,CAAC;IACF,cAAc,EAAE,EAAE;CACnB,CAAU,CAAC;AAEd,uEAAuE;AAEvE;;;GAGG;AACH,MAAM,eAAe,GAAG,CACtB,KAAyB,EACzB,UAA+B,EAC/B,IAAmB,EACD,EAAE;IACpB,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CACpC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAC1C,CAAC;IAEF,OAAO,KAAK,CAAC,WAAW,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACb,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC;KAC9C,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/rules/prefer-array-is-array.d.mts

@@ -0,0 +1,13 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+/**
+ * Builds a rule that replaces `Array.isArray` with `<namespace>.isArray`
+ * imported from `moduleName`. Only the callee is rewritten; the arguments stay
+ * as written.
+ */
+export declare const createPreferArrayIsArray: ({ moduleName, namespace, }: Readonly<{
+    /** The module that exports `namespace`. */
+    moduleName: string;
+    /** The exported namespace whose `isArray` replaces `Array.isArray`. */
+    namespace: string;
+}>) => TSESLint.RuleModule<'useIsArray', readonly []>;
+//# sourceMappingURL=prefer-array-is-array.d.mts.map

package/dist/rules/prefer-array-is-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-array-is-array.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-array-is-array.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AASlC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,+BAGlC,QAAQ,CAAC;IACV,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IAEnB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,KAAG,QAAQ,CAAC,UAAU,CAAC,YAAY,EAAE,SAAS,EAAE,CAuEjD,CAAC"}

package/dist/rules/prefer-array-is-array.mjs

@@ -0,0 +1,81 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { buildNamedImportFix, getImportDeclarations, getNamedImports, } from '../imports.mjs';
+import { getRangeWithParens } from '../parentheses.mjs';
+import { isIdentifierNamed, skipTypeWrappers } from '../type-wrappers.mjs';
+
+
+
+
+
+export const createPreferArrayIsArray = ({ moduleName, namespace, }) => {
+    const replacement = `${namespace}.isArray`;
+    const text = `Replace \`Array.isArray\` with \`${replacement}\` from ${moduleName}.`;
+    return {
+        meta: {
+            type: 'suggestion',
+            docs: { description: text },
+            fixable: 'code',
+            schema: [],
+            messages: { useIsArray: text },
+        },
+        create: (context) => {
+            const sourceCode = context.sourceCode;
+            const program = sourceCode.ast;
+            const moduleImports = getImportDeclarations(program, moduleName);
+            const mut_nodesToFix = [];
+            return {
+                CallExpression: (node) => {
+                    if (!isArrayIsArrayCall(node)) {
+                        return;
+                    }
+                    mut_nodesToFix.push(node);
+                },
+                'Program:exit': () => {
+                    const hasNamespaceImport = getNamedImports(moduleImports).includes(namespace);
+
+
+
+
+
+                    for (const [index, node] of mut_nodesToFix.entries()) {
+                        context.report({
+                            node,
+                            messageId: 'useIsArray',
+                            fix: (fixer) => {
+                                const importFixes = index === 0 && !hasNamespaceImport
+                                    ? buildNamedImportFix(fixer, program, moduleName, [
+                                        namespace,
+                                    ])
+                                    : [];
+
+
+
+                                return [
+                                    ...importFixes,
+                                    fixer.replaceTextRange(getRangeWithParens(sourceCode, node.callee), replacement),
+                                ];
+                            },
+                        });
+                    }
+                },
+            };
+        },
+        defaultOptions: [],
+    };
+};
+
+
+
+
+
+const isArrayIsArrayCall = (
+
+node) => {
+    const callee = skipTypeWrappers(node.callee);
+    return (callee.type === AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        isIdentifierNamed(callee.object, 'Array') &&
+        callee.property.type === AST_NODE_TYPES.Identifier &&
+        callee.property.name === 'isArray');
+};
+//# sourceMappingURL=prefer-array-is-array.mjs.map

package/dist/rules/prefer-array-is-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-array-is-array.mjs","sourceRoot":"","sources":["../../src/rules/prefer-array-is-array.mts"],"names":[],"mappings":"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"}