eslint-config-typed 5.0.0 → 5.1.0

package/dist/plugins/ts-data-forge/rules/import-utils.d.mts

@@ -2,5 +2,29 @@ import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 import { type DeepReadonly } from 'ts-type-forge';
 export declare const getTsDataForgeImport: (program: TSESTree.Program) => TSESTree.ImportDeclaration | undefined;
 export declare const getNamedImports: (node: DeepReadonly<TSESTree.ImportDeclaration> | undefined) => readonly string[];
+/**
+ * Returns the in-scope local name a given canonical export is imported as
+ * (handling aliases such as `import { isX as y }` → `'y'`), or `undefined` when
+ * it is not imported. Used so autofixes reference the binding that actually
+ * exists rather than the canonical name.
+ */
+export declare const getImportedLocalName: (node: DeepReadonly<TSESTree.ImportDeclaration> | undefined, importedName: string) => string | undefined;
+type ResolvedCallee = Readonly<{
+    /** The canonical (imported) ts-data-forge name, regardless of local alias. */
+    canonicalName: string;
+    /** The identifier node to rewrite when replacing the callee name. */
+    propertyNode: TSESTree.Node;
+    /** Whether the call was made through a namespace import (`tf.isX(...)`). */
+    isNamespace: boolean;
+}>;
+/**
+ * Builds a resolver that maps a call expression's callee to the canonical
+ * ts-data-forge function it refers to. Handles named imports (including aliases
+ * such as `import { isX as y }`) and namespace imports (`import * as tf` →
+ * `tf.isX(...)`). Returns `undefined` for any callee that does not reference the
+ * given ts-data-forge import.
+ */
+export declare const buildCalleeResolver: (importDecl: TSESTree.ImportDeclaration | undefined) => ((callee: DeepReadonly<TSESTree.Expression>) => ResolvedCallee | undefined);
 export declare const buildImportFixes: (fixer: TSESLint.RuleFixer, program: TSESTree.Program, _tsDataForgeImport: TSESTree.ImportDeclaration | undefined, requiredNames: readonly string[]) => readonly TSESLint.RuleFix[];
+export {};
 //# sourceMappingURL=import-utils.d.mts.map

package/dist/plugins/ts-data-forge/rules/import-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"import-utils.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/import-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,eAAO,MAAM,oBAAoB,GAC/B,SAAS,QAAQ,CAAC,OAAO,KACxB,QAAQ,CAAC,iBAAiB,GAAG,SAK7B,CAAC;AAEJ,eAAO,MAAM,eAAe,GAC1B,MAAM,YAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,SAAS,KACzD,SAAS,MAAM,EAejB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,QAAQ,CAAC,SAAS,EACzB,SAAS,QAAQ,CAAC,OAAO,EACzB,oBAAoB,QAAQ,CAAC,iBAAiB,GAAG,SAAS,EAC1D,eAAe,SAAS,MAAM,EAAE,KAC/B,SAAS,QAAQ,CAAC,OAAO,EAa3B,CAAC"}
+{"version":3,"file":"import-utils.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/import-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,eAAO,MAAM,oBAAoB,GAC/B,SAAS,QAAQ,CAAC,OAAO,KACxB,QAAQ,CAAC,iBAAiB,GAAG,SAK7B,CAAC;AAEJ,eAAO,MAAM,eAAe,GAC1B,MAAM,YAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,SAAS,KACzD,SAAS,MAAM,EAejB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,YAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,SAAS,EAC1D,cAAc,MAAM,KACnB,MAAM,GAAG,SAOG,CAAC;AAEhB,KAAK,cAAc,GAAG,QAAQ,CAAC;IAC7B,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC5B,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,QAAQ,CAAC,iBAAiB,GAAG,SAAS,KACjD,CAAC,CACF,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KACtC,cAAc,GAAG,SAAS,CAsD9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,QAAQ,CAAC,SAAS,EACzB,SAAS,QAAQ,CAAC,OAAO,EACzB,oBAAoB,QAAQ,CAAC,iBAAiB,GAAG,SAAS,EAC1D,eAAe,SAAS,MAAM,EAAE,KAC/B,SAAS,QAAQ,CAAC,OAAO,EAa3B,CAAC"}

package/dist/plugins/ts-data-forge/rules/import-utils.mjs

@@ -16,6 +16,64 @@ const getNamedImports = (node) => {
         })()
         : []);
 };
+/**
+ * Returns the in-scope local name a given canonical export is imported as
+ * (handling aliases such as `import { isX as y }` → `'y'`), or `undefined` when
+ * it is not imported. Used so autofixes reference the binding that actually
+ * exists rather than the canonical name.
+ */
+const getImportedLocalName = (node, importedName) => node?.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+    (specifier.imported.type === AST_NODE_TYPES.Identifier
+        ? specifier.imported.name
+        : specifier.imported.value) === importedName)?.local.name;
+/**
+ * Builds a resolver that maps a call expression's callee to the canonical
+ * ts-data-forge function it refers to. Handles named imports (including aliases
+ * such as `import { isX as y }`) and namespace imports (`import * as tf` →
+ * `tf.isX(...)`). Returns `undefined` for any callee that does not reference the
+ * given ts-data-forge import.
+ */
+const buildCalleeResolver = (importDecl) => {
+    const specifiers = importDecl?.specifiers ?? [];
+    const namespaceName = specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)?.local.name;
+    const localToCanonical = new Map(specifiers.flatMap((specifier) => {
+        if (specifier.type !== AST_NODE_TYPES.ImportSpecifier)
+            return [];
+        const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier
+            ? specifier.imported.name
+            : specifier.imported.value;
+        return typeof importedName === 'string'
+            ? [[specifier.local.name, importedName]]
+            : [];
+    }));
+    return (callee) => {
+        if (callee.type === AST_NODE_TYPES.Identifier) {
+            const canonicalName = localToCanonical.get(callee.name);
+            return canonicalName === undefined
+                ? undefined
+                : {
+                    canonicalName,
+                    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                    propertyNode: callee,
+                    isNamespace: false,
+                };
+        }
+        if (callee.type === AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === AST_NODE_TYPES.Identifier &&
+            namespaceName !== undefined &&
+            callee.object.name === namespaceName &&
+            callee.property.type === AST_NODE_TYPES.Identifier) {
+            return {
+                canonicalName: callee.property.name,
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                propertyNode: callee.property,
+                isNamespace: true,
+            };
+        }
+        return undefined;
+    };
+};
 const buildImportFixes = (fixer, program, _tsDataForgeImport, requiredNames) => {
     const specifierText = requiredNames.join(', ');
     const importStatement = `import { ${specifierText} } from '${TS_DATA_FORGE_MODULE}';`;
@@ -27,5 +85,5 @@ const buildImportFixes = (fixer, program, _tsDataForgeImport, requiredNames) =>
 };
 /* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */
 
-export { buildImportFixes, getNamedImports, getTsDataForgeImport };
+export { buildCalleeResolver, buildImportFixes, getImportedLocalName, getNamedImports, getTsDataForgeImport };
 //# sourceMappingURL=import-utils.mjs.map

package/dist/plugins/ts-data-forge/rules/import-utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"import-utils.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/import-utils.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;AAEO,MAAM,oBAAoB,GAAG,CAClC,OAAyB,KAEzB,OAAO,CAAC,IAAI,CAAC,IAAI,CACf,CAAC,IAAI,KACH,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB;AAC9C,IAAA,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,oBAAoB;AAGzC,MAAM,eAAe,GAAG,CAC7B,IAA0D,KACrC;IACrB,IAAI,IAAI,KAAK,SAAS;AAAE,QAAA,OAAO,EAAE;AAEjC,IAAA,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,KACvC,SAAS,CAAC,IAAI,KAAK,cAAc,CAAC;UAC9B,CAAC,MAAK;YACJ,MAAM,YAAY,GAChB,SAAS,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC;AACzC,kBAAE,SAAS,CAAC,QAAQ,CAAC;AACrB,kBAAE,SAAS,CAAC,QAAQ,CAAC,KAAK;AAE9B,YAAA,OAAO,OAAO,YAAY,KAAK,QAAQ,GAAG,CAAC,YAAY,CAAC,GAAG,EAAE;AAC/D,QAAA,CAAC;UACD,EAAE,CACP;AACH;AAEO,MAAM,gBAAgB,GAAG,CAC9B,KAAyB,EACzB,OAAyB,EACzB,kBAA0D,EAC1D,aAAgC,KACD;IAC/B,MAAM,aAAa,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;AAE9C,IAAA,MAAM,eAAe,GACnB,CAAA,SAAA,EAAY,aAAa,CAAA,SAAA,EAAY,oBAAoB,IAAa;IAExE,MAAM,OAAO,GAAG,IAAI;AAEpB,IAAA,MAAM,aAAa,GAAG,CAAA,EAAG,eAAe,CAAA,EAAG,OAAO,EAAW;;;IAI7D,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;AACzD;AACA;;;;"}
+{"version":3,"file":"import-utils.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/import-utils.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-data-forge/rules/no-unnecessary-type-guard.d.mts

@@ -0,0 +1,10 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        ignore?: readonly string[];
+    }>?
+];
+type MessageIds = 'alwaysTrue' | 'alwaysFalse' | 'replaceTypeGuard';
+export declare const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=no-unnecessary-type-guard.d.mts.map

package/dist/plugins/ts-data-forge/rules/no-unnecessary-type-guard.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-type-guard.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/no-unnecessary-type-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAUlC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,YAAY,GAAG,aAAa,GAAG,kBAAkB,CAAC;AAyFpE,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAgRhE,CAAC"}

package/dist/plugins/ts-data-forge/rules/no-unnecessary-type-guard.mjs

@@ -0,0 +1,335 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { getTsDataForgeImport, buildCalleeResolver, getImportedLocalName, buildImportFixes } from './import-utils.mjs';
+
+/**
+ * Internal marker property attached to every `ts-type-forge` branded type. Its
+ * presence (together with the brand key) lets us recognize a `NonEmptyString`
+ * without holding a reference to the type itself.
+ */
+const BRAND_MARKER_PROPERTY = 'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3';
+const NON_EMPTY_STRING_BRAND_KEY = 'NonEmptyString';
+const NULLISH_REPLACEMENTS_EXCLUDE = {
+    undefined: 'isNotUndefined',
+    null: 'isNotNull',
+};
+const NULLISH_REPLACEMENTS_NARROW = {
+    undefined: 'isUndefined',
+    null: 'isNull',
+};
+const GUARD_SPECS = {
+    isUndefined: { kind: 'narrowTo', atoms: ['undefined'] },
+    isNotUndefined: { kind: 'excludeFrom', atoms: ['undefined'] },
+    isNull: { kind: 'narrowTo', atoms: ['null'] },
+    isNotNull: { kind: 'excludeFrom', atoms: ['null'] },
+    isBoolean: { kind: 'narrowTo', atoms: ['boolean'] },
+    isNotBoolean: { kind: 'excludeFrom', atoms: ['boolean'] },
+    isNumber: { kind: 'narrowTo', atoms: ['number'] },
+    isNotNumber: { kind: 'excludeFrom', atoms: ['number'] },
+    isString: { kind: 'narrowTo', atoms: ['string'] },
+    isNotString: { kind: 'excludeFrom', atoms: ['string'] },
+    isBigint: { kind: 'narrowTo', atoms: ['bigint'] },
+    isNotBigint: { kind: 'excludeFrom', atoms: ['bigint'] },
+    isSymbol: { kind: 'narrowTo', atoms: ['symbol'] },
+    isNotSymbol: { kind: 'excludeFrom', atoms: ['symbol'] },
+    isNullish: {
+        kind: 'narrowTo',
+        atoms: ['null', 'undefined'],
+        replacements: NULLISH_REPLACEMENTS_NARROW,
+    },
+    isNonNullish: {
+        kind: 'excludeFrom',
+        atoms: ['null', 'undefined'],
+        replacements: NULLISH_REPLACEMENTS_EXCLUDE,
+    },
+    isNonEmptyString: { kind: 'nonEmptyString' },
+};
+const DEFERRED_OR_OPAQUE_FLAGS = ts.TypeFlags.Any |
+    ts.TypeFlags.Unknown |
+    ts.TypeFlags.Never |
+    ts.TypeFlags.TypeParameter |
+    ts.TypeFlags.IndexedAccess |
+    ts.TypeFlags.Conditional |
+    ts.TypeFlags.Substitution;
+const noUnnecessaryTypeGuard = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignore: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Names of ts-data-forge guard functions to skip checking.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            alwaysTrue: 'Unnecessary `{{name}}` call: the argument type guarantees it always returns `true`. Replace the call with `true`.',
+            alwaysFalse: 'Unnecessary `{{name}}` call: the argument type guarantees it always returns `false`. Replace the call with `false`.',
+            replaceTypeGuard: 'Unnecessary `{{from}}` call: the argument can only be narrowed by `{{to}}`. Use `{{to}}` instead.',
+        },
+    },
+    create: (context) => {
+        const options = context.options[0];
+        const parserServices = ESLintUtils.getParserServices(context);
+        const compilerOptions = parserServices.program.getCompilerOptions();
+        // Without `strictNullChecks`, `null` / `undefined` are erased from the type
+        // system, so reasoning about nullish narrowing is unsound. Disable entirely.
+        const strictNullChecks = compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;
+        if (!strictNullChecks)
+            return {};
+        const checker = parserServices.program.getTypeChecker();
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const ignored = new Set(options?.ignore);
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const resolveGuard = buildCalleeResolver(tsDataForgeImport);
+        const buildReplaceFix = (isNamespace, 
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        propertyNode, replacement) => (fixer) => {
+            // A namespace member access (`tf.isX`) exposes every export, so the
+            // canonical name is always in scope.
+            if (isNamespace) {
+                return [fixer.replaceText(propertyNode, replacement)];
+            }
+            // If the replacement guard is already imported (possibly under an
+            // alias), rename to its in-scope local name. Otherwise add a new
+            // import and rename to the canonical name.
+            const localName = getImportedLocalName(tsDataForgeImport, replacement);
+            if (localName !== undefined) {
+                return [fixer.replaceText(propertyNode, localName)];
+            }
+            return [
+                ...buildImportFixes(fixer, program, tsDataForgeImport, [
+                    replacement,
+                ]),
+                fixer.replaceText(propertyNode, replacement),
+            ];
+        };
+        const reportConstant = (node, name, value, argument) => {
+            // Replacing the call with a literal drops the argument expression, so only
+            // autofix when evaluating it cannot have observable side effects.
+            const canFix = isSideEffectFreeArg(argument);
+            context.report({
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                node: node,
+                messageId: value ? 'alwaysTrue' : 'alwaysFalse',
+                data: { name },
+                fix: canFix
+                    ? (fixer) => fixer.replaceText(
+                    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                    node, value ? 'true' : 'false')
+                    : undefined,
+            });
+        };
+        const reportReplace = (node, from, to, isNamespace, 
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        propertyNode) => {
+            context.report({
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                node: node,
+                messageId: 'replaceTypeGuard',
+                data: { from, to },
+                fix: buildReplaceFix(isNamespace, propertyNode, to),
+            });
+        };
+        return {
+            CallExpression: (node) => {
+                if (node.arguments.length !== 1)
+                    return;
+                const argument = node.arguments[0];
+                if (argument === undefined ||
+                    argument.type === AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const resolved = resolveGuard(node.callee);
+                if (resolved === undefined)
+                    return;
+                const { canonicalName, propertyNode, isNamespace } = resolved;
+                if (ignored.has(canonicalName))
+                    return;
+                const spec = GUARD_SPECS[canonicalName];
+                if (spec === undefined)
+                    return;
+                const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);
+                const argType = checker.getTypeAtLocation(argTsNode);
+                const parts = collectUnionParts(argType);
+                if (parts === undefined)
+                    return; // opaque / generic → bail conservatively
+                const inputAtoms = new Set(parts.map(classifyAtom));
+                const hasMemberOutsideTarget = (atoms) => {
+                    const targetSet = new Set(atoms);
+                    return parts.some((p) => !targetSet.has(classifyAtom(p)));
+                };
+                switch (spec.kind) {
+                    case 'excludeFrom': {
+                        const removable = spec.atoms.filter((a) => inputAtoms.has(a));
+                        if (removable.length === 0) {
+                            // Nothing to exclude → the guard always holds.
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        else if (!hasMemberOutsideTarget(spec.atoms)) {
+                            // Every member is excluded → the guard never holds.
+                            reportConstant(node, canonicalName, false, argument);
+                        }
+                        else if (removable.length < spec.atoms.length) {
+                            const replacement = spec.replacements?.[joinAtoms(removable)];
+                            if (replacement !== undefined) {
+                                reportReplace(node, canonicalName, replacement, isNamespace, propertyNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 'narrowTo': {
+                        const present = spec.atoms.filter((a) => inputAtoms.has(a));
+                        if (present.length === 0) {
+                            // No member is in the target set → the guard never holds.
+                            reportConstant(node, canonicalName, false, argument);
+                        }
+                        else if (!hasMemberOutsideTarget(spec.atoms)) {
+                            // Input ⊆ target → the guard always holds and narrows nothing.
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        else if (present.length < spec.atoms.length) {
+                            const replacement = spec.replacements?.[joinAtoms(present)];
+                            if (replacement !== undefined) {
+                                reportReplace(node, canonicalName, replacement, isNamespace, propertyNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 'nonEmptyString': {
+                        const hasNullish = inputAtoms.has('undefined') || inputAtoms.has('null');
+                        const nonNullishParts = parts.filter((p) => {
+                            const atom = classifyAtom(p);
+                            return atom !== 'undefined' && atom !== 'null';
+                        });
+                        if (!nonNullishParts.some(couldBeNonEmptyString)) {
+                            // No member can be a non-empty string → the guard never holds.
+                            reportConstant(node, canonicalName, false, argument);
+                            break;
+                        }
+                        if (!nonNullishParts.every(isGuaranteedNonEmptyString)) {
+                            break; // still does real string/empty work
+                        }
+                        if (hasNullish) {
+                            reportReplace(node, canonicalName, 'isNonNullish', isNamespace, propertyNode);
+                        }
+                        else {
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        break;
+                    }
+                }
+            },
+        };
+    },
+    defaultOptions: [{}],
+};
+/**
+ * Decomposes a type into its union members. Returns `undefined` when any member
+ * is opaque (`any` / `unknown` / `never`) or deferred (type parameter, indexed
+ * access, …), signalling that the rule should not draw conclusions.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const collectUnionParts = (type) => {
+    const parts = type.isUnion() ? type.types : [type];
+    for (const part of parts) {
+        if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0)
+            return undefined;
+    }
+    return parts;
+};
+/** Classifies a single (non-union) type into a primitive {@link Atom}. */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const classifyAtom = (type) => {
+    const { flags } = type;
+    if ((flags & ts.TypeFlags.Undefined) !== 0)
+        return 'undefined';
+    if ((flags & ts.TypeFlags.Null) !== 0)
+        return 'null';
+    if ((flags & ts.TypeFlags.BooleanLike) !== 0)
+        return 'boolean';
+    if ((flags & ts.TypeFlags.NumberLike) !== 0)
+        return 'number';
+    if ((flags & ts.TypeFlags.StringLike) !== 0)
+        return 'string';
+    if ((flags & ts.TypeFlags.BigIntLike) !== 0)
+        return 'bigint';
+    if ((flags & ts.TypeFlags.ESSymbolLike) !== 0)
+        return 'symbol';
+    // Branded primitives (e.g. `NonEmptyString = string & {...}`) are
+    // intersections; classify them by their underlying primitive constituent.
+    if (type.isIntersection()) {
+        for (const constituent of type.types) {
+            const atom = classifyAtom(constituent);
+            if (atom !== 'other')
+                return atom;
+        }
+    }
+    return 'other';
+};
+const ATOM_ORDER = [
+    'undefined',
+    'null',
+    'boolean',
+    'number',
+    'string',
+    'bigint',
+    'symbol',
+];
+/** A stable key for a set of atoms, used to look up replacement guards. */
+const joinAtoms = (atoms) => ATOM_ORDER.filter((atom) => atoms.includes(atom)).join('|');
+/**
+ * Returns `true` when the type is guaranteed to be a non-empty string: either a
+ * non-empty string literal or a value branded as `NonEmptyString`.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isGuaranteedNonEmptyString = (type) => {
+    if (type.isStringLiteral())
+        return type.value !== '';
+    return (type.getProperty(NON_EMPTY_STRING_BRAND_KEY) !== undefined &&
+        type.getProperty(BRAND_MARKER_PROPERTY) !== undefined);
+};
+/**
+ * Returns `true` when the type can possibly be a non-empty string (a general
+ * `string`, a branded string, or a non-empty string literal). The empty string
+ * literal and non-string types cannot.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const couldBeNonEmptyString = (type) => {
+    if (type.isStringLiteral())
+        return type.value !== '';
+    return classifyAtom(type) === 'string';
+};
+/**
+ * Returns `true` when evaluating the expression cannot have observable side
+ * effects, so replacing the surrounding call with a literal is safe. Limited to
+ * simple references (identifiers, `this`, literals, and member-access chains).
+ */
+const isSideEffectFreeArg = (node) => {
+    // `node.type` is one of 130+ AST kinds; only a handful are relevant here.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (node.type) {
+        case AST_NODE_TYPES.Identifier:
+        case AST_NODE_TYPES.ThisExpression:
+        case AST_NODE_TYPES.Literal:
+            return true;
+        case AST_NODE_TYPES.MemberExpression:
+            return (isSideEffectFreeArg(node.object) &&
+                (!node.computed || isSideEffectFreeArg(node.property)));
+        default:
+            return false;
+    }
+};
+
+export { noUnnecessaryTypeGuard };
+//# sourceMappingURL=no-unnecessary-type-guard.mjs.map

package/dist/plugins/ts-data-forge/rules/no-unnecessary-type-guard.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-type-guard.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/no-unnecessary-type-guard.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'preferComparison';
+export declare const preferComparisonOverNullishGuard: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-comparison-over-nullish-guard.d.mts.map

package/dist/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-comparison-over-nullish-guard.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAIlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,kBAAkB,CAAC;AA8DrC,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,UAAU,CAChE,UAAU,EACV,OAAO,CAkEC,CAAC"}

package/dist/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.mjs

@@ -0,0 +1,101 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { buildCalleeResolver, getTsDataForgeImport } from './import-utils.mjs';
+
+/**
+ * The nullish guards that are meant for point-free use (e.g.
+ * `xs.filter(isNotUndefined)`). When called with an explicit argument a direct
+ * comparison is clearer, so map each to its equivalent operator and literal.
+ */
+const COMPARISON_GUARDS = {
+    isUndefined: { op: '===', literal: 'undefined' },
+    isNotUndefined: { op: '!==', literal: 'undefined' },
+    isNull: { op: '===', literal: 'null' },
+    isNotNull: { op: '!==', literal: 'null' },
+};
+/**
+ * Argument expression kinds whose precedence is lower than equality, so they
+ * must be parenthesized when placed on the left of `===` / `!==`.
+ */
+const ARG_NEEDS_PARENS = new Set([
+    AST_NODE_TYPES.LogicalExpression,
+    AST_NODE_TYPES.ConditionalExpression,
+    AST_NODE_TYPES.AssignmentExpression,
+    AST_NODE_TYPES.SequenceExpression,
+    AST_NODE_TYPES.ArrowFunctionExpression,
+    AST_NODE_TYPES.YieldExpression,
+]);
+/**
+ * Returns `true` when the comparison must be wrapped in parentheses to preserve
+ * the original grouping given the call expression's parent context.
+ */
+const needsWrappingInParent = (node) => {
+    const { parent } = node;
+    // `parent.type` is one of 130+ AST kinds; only a handful need wrapping.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (parent.type) {
+        case AST_NODE_TYPES.UnaryExpression:
+        case AST_NODE_TYPES.AwaitExpression:
+        case AST_NODE_TYPES.BinaryExpression:
+        case AST_NODE_TYPES.TSNonNullExpression:
+            return true;
+        case AST_NODE_TYPES.MemberExpression:
+            return parent.object === node;
+        case AST_NODE_TYPES.CallExpression:
+        case AST_NODE_TYPES.NewExpression:
+            return parent.callee === node;
+        default:
+            return false;
+    }
+};
+const preferComparisonOverNullishGuard = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer a direct `=== null` / `!== undefined` comparison over calling `isNull`, `isNotNull`, `isUndefined`, or `isNotUndefined` with an explicit argument (those guards are intended for point-free use such as `xs.filter(isNotUndefined)`).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferComparison: 'Prefer `{{comparison}}` over calling `{{name}}` with an explicit argument.',
+        },
+    },
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const resolveGuard = buildCalleeResolver(getTsDataForgeImport(sourceCode.ast));
+        return {
+            CallExpression: (node) => {
+                if (node.arguments.length !== 1)
+                    return;
+                const argument = node.arguments[0];
+                if (argument === undefined ||
+                    argument.type === AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const resolved = resolveGuard(node.callee);
+                if (resolved === undefined)
+                    return;
+                const spec = COMPARISON_GUARDS[resolved.canonicalName];
+                if (spec === undefined)
+                    return;
+                const argRaw = sourceCode.getText(argument);
+                const argText = ARG_NEEDS_PARENS.has(argument.type)
+                    ? `(${argRaw})`
+                    : argRaw;
+                const comparison = `${argText} ${spec.op} ${spec.literal}`;
+                const replacement = needsWrappingInParent(node)
+                    ? `(${comparison})`
+                    : comparison;
+                context.report({
+                    node,
+                    messageId: 'preferComparison',
+                    data: { comparison, name: resolved.canonicalName },
+                    fix: (fixer) => fixer.replaceText(node, replacement),
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+};
+
+export { preferComparisonOverNullishGuard };
+//# sourceMappingURL=prefer-comparison-over-nullish-guard.mjs.map

package/dist/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-comparison-over-nullish-guard.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-comparison-over-nullish-guard.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-data-forge/rules/rules.d.mts

@@ -8,5 +8,9 @@ export declare const tsDataForgeRules: {
     readonly 'prefer-is-non-null-object': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNonNullObject", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-range-for-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useRangeForLoop", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'no-unnecessary-type-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"alwaysTrue" | "alwaysFalse" | "replaceTypeGuard", readonly [(Readonly<{
+        ignore?: readonly string[];
+    }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-comparison-over-nullish-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferComparison", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 //# sourceMappingURL=rules.d.mts.map

package/dist/plugins/ts-data-forge/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAWA,eAAO,MAAM,gBAAgB;;;;;;;;;;CAUa,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAaA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CAYa,CAAC"}

package/dist/plugins/ts-data-forge/rules/rules.mjs

@@ -1,9 +1,11 @@
+import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
 import { preferArrIsArrayAtLeastLength } from './prefer-arr-is-array-at-least-length.mjs';
 import { preferArrIsArrayOfLength } from './prefer-arr-is-array-of-length.mjs';
 import { preferArrIsArray } from './prefer-arr-is-array.mjs';
 import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
 import { preferArrSum } from './prefer-arr-sum.mjs';
 import { preferAsInt } from './prefer-as-int.mjs';
+import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
 import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
 import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
@@ -18,6 +20,8 @@ const tsDataForgeRules = {
     'prefer-is-non-null-object': preferIsNonNullObject,
     'prefer-range-for-loop': preferRangeForLoop,
     'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
+    'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
+    'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
 };
 
 export { tsDataForgeRules };