eslint-plugin-typefest 1.0.1

package/dist/rules/prefer-type-fest-json-value.js

@@ -0,0 +1,109 @@
+import { isDefined } from "ts-extras";
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeReplacementFix, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix, reportWithTypefestPolicy, } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * Checks whether a key type is compatible with string-indexed JSON records.
+ *
+ * @param node - Type node to inspect.
+ *
+ * @returns `true` for `string` keyword and `'string'` literal key aliases.
+ */
+const isStringLikeKeyType = (node) => node.type === "TSStringKeyword" ||
+    (node.type === "TSLiteralType" &&
+        node.literal.type === "Literal" &&
+        node.literal.value === "string");
+/**
+ * Detects `Record<string, unknown|any>` patterns targeted by this rule.
+ *
+ * @param typeNode - Type reference candidate.
+ *
+ * @returns `true` when the type reference matches a string-keyed record with
+ *   `unknown` or `any` value type.
+ */
+const isRecordLikeUnknownOrAny = (typeNode) => {
+    if (typeNode.typeName.type !== "Identifier" ||
+        typeNode.typeName.name !== "Record" ||
+        typeNode.typeArguments?.params.length !== 2) {
+        return false;
+    }
+    const [keyType, valueType] = typeNode.typeArguments.params;
+    return (isDefined(keyType) &&
+        isDefined(valueType) &&
+        isStringLikeKeyType(keyType) &&
+        (valueType.type === "TSUnknownKeyword" ||
+            valueType.type === "TSAnyKeyword"));
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-json-value`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestJsonValueRule = createTypedRule({
+    create(context) {
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (!isRecordLikeUnknownOrAny(node)) {
+                    return;
+                }
+                const jsonObjectSuggestionFix = createSafeTypeNodeReplacementFix(node, "JsonObject", typeFestDirectImports, TYPE_FEST_MODULE_SOURCE, "suggestion");
+                if (jsonObjectSuggestionFix === null) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: null,
+                        messageId: "preferJsonValue",
+                        node,
+                    });
+                    return;
+                }
+                reportWithTypefestPolicy({
+                    context,
+                    descriptor: {
+                        messageId: "preferJsonValue",
+                        node,
+                        suggest: [
+                            {
+                                fix: jsonObjectSuggestionFix,
+                                messageId: "suggestJsonObject",
+                            },
+                        ],
+                    },
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest JsonObject for string-keyed JSON record contract types in serialization boundaries.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.minimal",
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-json-value",
+        },
+        hasSuggestions: true,
+        messages: {
+            preferJsonValue: "Use `JsonObject` from type-fest for string-keyed JSON record contracts in serialization boundaries instead of Record<string, unknown|any>.",
+            suggestJsonObject: "Replace with `JsonObject` from type-fest (review value constraints, this may narrow accepted shapes).",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-json-value",
+});
+/**
+ * Default export for the `prefer-type-fest-json-value` rule module.
+ */
+export default preferTypeFestJsonValueRule;
+//# sourceMappingURL=prefer-type-fest-json-value.js.map

package/dist/rules/prefer-type-fest-json-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-json-value.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-json-value.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-type-fest-keys-of-union.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-type-fest-keys-of-union`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTypeFestKeysOfUnionRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-type-fest-keys-of-union` rule module.
+ */
+export default preferTypeFestKeysOfUnionRule;
+//# sourceMappingURL=prefer-type-fest-keys-of-union.d.ts.map

package/dist/rules/prefer-type-fest-keys-of-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-keys-of-union.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-keys-of-union.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAM7D;;;;;GAKG;AACH,QAAA,MAAM,6BAA6B,EAAE,UAAU,CAAC,OAAO,eAAe,CAyEhE,CAAC;AAEP;;GAEG;AACH,eAAe,6BAA6B,CAAC"}

package/dist/rules/prefer-type-fest-keys-of-union.js

@@ -0,0 +1,74 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-keys-of-union`.
+ */
+import { collectDirectNamedImportsFromSource, collectImportedTypeAliasMatches, createSafeTypeReferenceReplacementFix, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+const keysOfUnionAliasReplacements = {
+    AllKeys: "KeysOfUnion",
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-keys-of-union`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestKeysOfUnionRule = createTypedRule({
+    create(context) {
+        const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, keysOfUnionAliasReplacements);
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (node.typeName.type !== "Identifier") {
+                    return;
+                }
+                const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+                if (!importedAliasMatch) {
+                    return;
+                }
+                const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    data: {
+                        alias: importedAliasMatch.importedName,
+                        replacement: importedAliasMatch.replacementName,
+                    },
+                    fix: aliasReplacementFix,
+                    messageId: "preferKeysOfUnion",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest KeysOfUnion over imported aliases such as AllKeys.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-keys-of-union",
+        },
+        fixable: "code",
+        messages: {
+            preferKeysOfUnion: "Prefer `{{replacement}}` from type-fest to derive keys from union members instead of legacy alias `{{alias}}`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-keys-of-union",
+});
+/**
+ * Default export for the `prefer-type-fest-keys-of-union` rule module.
+ */
+export default preferTypeFestKeysOfUnionRule;
+//# sourceMappingURL=prefer-type-fest-keys-of-union.js.map

package/dist/rules/prefer-type-fest-keys-of-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-keys-of-union.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-keys-of-union.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,EACH,mCAAmC,EACnC,+BAA+B,EAC/B,qCAAqC,GACxC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,4BAA4B,GAAG;IACjC,OAAO,EAAE,aAAa;CAChB,CAAC;AAEX;;;;;GAKG;AACH,MAAM,6BAA6B,GAC/B,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,oBAAoB,GAAG,+BAA+B,CACxD,OAAO,CAAC,UAAU,EAClB,4BAA4B,CAC/B,CAAC;QACF,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,6CAA6C,CACzC,IAA8B;gBAE9B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;oBACtC,OAAO;gBACX,CAAC;gBAED,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,GAAG,CAC/C,IAAI,CAAC,QAAQ,CAAC,IAAI,CACrB,CAAC;gBACF,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBACtB,OAAO;gBACX,CAAC;gBAED,MAAM,mBAAmB,GACrB,qCAAqC,CACjC,IAAI,EACJ,kBAAkB,CAAC,eAAe,EAClC,qBAAqB,CACxB,CAAC;gBAEN,qBAAqB,CAAC;oBAClB,OAAO;oBACP,IAAI,EAAE;wBACF,KAAK,EAAE,kBAAkB,CAAC,YAAY;wBACtC,WAAW,EAAE,kBAAkB,CAAC,eAAe;qBAClD;oBACD,GAAG,EAAE,mBAAmB;oBACxB,SAAS,EAAE,mBAAmB;oBAC9B,IAAI;iBACP,CAAC,CAAC;YACP,CAAC;SACJ,CAAC;IACN,CAAC;IACD,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACF,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE;YACF,WAAW,EACP,qEAAqE;YACzE,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,kCAAkC;aACrC;YACD,GAAG,EAAE,+FAA+F;SACvG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,iBAAiB,EACb,gHAAgH;SACvH;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,gCAAgC;CACzC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,6BAA6B,CAAC"}

package/dist/rules/prefer-type-fest-literal-union.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-type-fest-literal-union`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTypeFestLiteralUnionRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-type-fest-literal-union` rule module.
+ */
+export default preferTypeFestLiteralUnionRule;
+//# sourceMappingURL=prefer-type-fest-literal-union.d.ts.map

package/dist/rules/prefer-type-fest-literal-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-literal-union.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-literal-union.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAqK7D;;;;;GAKG;AACH,QAAA,MAAM,8BAA8B,EAAE,UAAU,CAAC,OAAO,eAAe,CA4EjE,CAAC;AAEP;;GAEG;AACH,eAAe,8BAA8B,CAAC"}

package/dist/rules/prefer-type-fest-literal-union.js

@@ -0,0 +1,181 @@
+import { arrayFirst, arrayJoin, safeCastTo } from "ts-extras";
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeTextReplacementFix, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * Ordered family candidates evaluated when scanning union members.
+ */
+const literalUnionFamilies = [
+    "bigint",
+    "boolean",
+    "number",
+    "string",
+];
+/**
+ * Checks whether a union member is the primitive keyword for a family.
+ *
+ * @param node - Member node to inspect.
+ * @param family - Primitive family currently being matched.
+ *
+ * @returns `true` when the node is the corresponding keyword type.
+ */
+const isKeywordMemberForFamily = (node, family) => {
+    if (family === "bigint") {
+        return node.type === "TSBigIntKeyword";
+    }
+    if (family === "boolean") {
+        return node.type === "TSBooleanKeyword";
+    }
+    if (family === "number") {
+        return node.type === "TSNumberKeyword";
+    }
+    return node.type === "TSStringKeyword";
+};
+/**
+ * Checks whether a union member is a literal of the requested primitive family.
+ *
+ * @param node - Member node to inspect.
+ * @param family - Primitive family currently being matched.
+ *
+ * @returns `true` when the node is a literal member compatible with the family
+ *   (including bigint parser variants).
+ */
+const isLiteralMemberForFamily = (node, family) => {
+    if (node.type !== "TSLiteralType" || node.literal.type !== "Literal") {
+        return false;
+    }
+    if (family === "bigint") {
+        if (typeof node.literal.value === "bigint") {
+            return true;
+        }
+        const literalWithPotentialBigInt = safeCastTo(node.literal);
+        return typeof literalWithPotentialBigInt.bigint === "string";
+    }
+    if (family === "boolean") {
+        return typeof node.literal.value === "boolean";
+    }
+    if (family === "number") {
+        return typeof node.literal.value === "number";
+    }
+    return typeof node.literal.value === "string";
+};
+/**
+ * Resolves which primitive family a replaceable literal union belongs to.
+ *
+ * @param node - Union node to inspect.
+ *
+ * @returns The matching family when the union has a `LiteralUnion`-compatible
+ *   shape; otherwise `null`.
+ */
+const getLiteralUnionFamily = (node) => {
+    for (const family of literalUnionFamilies) {
+        let allMembersAreFamilyMembers = true;
+        let hasKeywordMember = false;
+        let hasLiteralMember = false;
+        for (const unionMember of node.types) {
+            if (isKeywordMemberForFamily(unionMember, family)) {
+                hasKeywordMember = true;
+                continue;
+            }
+            if (isLiteralMemberForFamily(unionMember, family)) {
+                hasLiteralMember = true;
+                continue;
+            }
+            allMembersAreFamilyMembers = false;
+            break;
+        }
+        if (allMembersAreFamilyMembers &&
+            hasKeywordMember &&
+            hasLiteralMember) {
+            return family;
+        }
+    }
+    return null;
+};
+/**
+ * Builds `LiteralUnion<...>` text for a matched family.
+ *
+ * @param sourceCode - Source code instance used to preserve original literal
+ *   formatting.
+ * @param node - Union node being replaced.
+ * @param family - Primitive family for the replacement's second generic
+ *   argument.
+ *
+ * @returns Replacement text when at least one literal member exists; otherwise
+ *   `null`.
+ */
+const getLiteralUnionReplacementText = (sourceCode, node, family) => {
+    const literalMembers = node.types.filter((member) => isLiteralMemberForFamily(member, family));
+    if (literalMembers.length === 0) {
+        return null;
+    }
+    const literalText = literalMembers.length === 1
+        ? sourceCode.getText(arrayFirst(literalMembers))
+        : arrayJoin(literalMembers.map((member) => sourceCode.getText(member)), " | ");
+    return `LiteralUnion<${literalText}, ${family}>`;
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-literal-union`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestLiteralUnionRule = createTypedRule({
+    create(context) {
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            TSUnionType(node) {
+                const family = getLiteralUnionFamily(node);
+                if (!family) {
+                    return;
+                }
+                const replacementText = getLiteralUnionReplacementText(context.sourceCode, node, family);
+                if (replacementText === null ||
+                    replacementText.length === 0) {
+                    return;
+                }
+                const familyAtReportTime = getLiteralUnionFamily(node);
+                if (familyAtReportTime !== family) {
+                    return;
+                }
+                const replacementFix = createSafeTypeNodeTextReplacementFix(node, "LiteralUnion", replacementText, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: replacementFix,
+                    messageId: "preferLiteralUnion",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest LiteralUnion over unions that combine primitive keywords with same-family literal members.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-literal-union",
+        },
+        fixable: "code",
+        messages: {
+            preferLiteralUnion: "Prefer `LiteralUnion<...>` from type-fest over unions that mix primitive keywords and same-family literal members.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-literal-union",
+});
+/**
+ * Default export for the `prefer-type-fest-literal-union` rule module.
+ */
+export default preferTypeFestLiteralUnionRule;
+//# sourceMappingURL=prefer-type-fest-literal-union.js.map

package/dist/rules/prefer-type-fest-literal-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-literal-union.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-literal-union.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-type-fest-merge-exclusive.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-type-fest-merge-exclusive`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTypeFestMergeExclusiveRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-type-fest-merge-exclusive` rule module.
+ */
+export default preferTypeFestMergeExclusiveRule;
+//# sourceMappingURL=prefer-type-fest-merge-exclusive.d.ts.map

package/dist/rules/prefer-type-fest-merge-exclusive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-merge-exclusive.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-merge-exclusive.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,gCAAgC,EAAE,UAAU,CAAC,OAAO,eAAe,CA6DnE,CAAC;AAEP;;GAEG;AACH,eAAe,gCAAgC,CAAC"}

package/dist/rules/prefer-type-fest-merge-exclusive.js

@@ -0,0 +1,63 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-merge-exclusive`.
+ */
+import { collectDirectNamedImportsFromSource, createSafeTypeReferenceReplacementFix, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-type-fest-merge-exclusive`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestMergeExclusiveRule = createTypedRule({
+    create(context) {
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (node.typeName.type !== "Identifier" ||
+                    node.typeName.name !== "XOR") {
+                    return;
+                }
+                const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, "MergeExclusive", typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: aliasReplacementFix,
+                    messageId: "preferMergeExclusive",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest MergeExclusive over `XOR` aliases.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-merge-exclusive",
+        },
+        fixable: "code",
+        messages: {
+            preferMergeExclusive: "Prefer `MergeExclusive` from type-fest over `XOR`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-merge-exclusive",
+});
+/**
+ * Default export for the `prefer-type-fest-merge-exclusive` rule module.
+ */
+export default preferTypeFestMergeExclusiveRule;
+//# sourceMappingURL=prefer-type-fest-merge-exclusive.js.map

package/dist/rules/prefer-type-fest-merge-exclusive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-merge-exclusive.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-merge-exclusive.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,EACH,mCAAmC,EACnC,qCAAqC,GACxC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,gCAAgC,GAClC,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,6CAA6C,CACzC,IAA8B;gBAE9B,IACI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;oBACnC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,KAAK,EAC9B,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,MAAM,mBAAmB,GACrB,qCAAqC,CACjC,IAAI,EACJ,gBAAgB,EAChB,qBAAqB,CACxB,CAAC;gBAEN,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG,EAAE,mBAAmB;oBACxB,SAAS,EAAE,sBAAsB;oBACjC,IAAI;iBACP,CAAC,CAAC;YACP,CAAC;SACJ,CAAC;IACN,CAAC;IACD,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACF,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE;YACF,WAAW,EACP,qDAAqD;YACzD,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,kCAAkC;aACrC;YACD,GAAG,EAAE,iGAAiG;SACzG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,oBAAoB,EAChB,oDAAoD;SAC3D;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,kCAAkC;CAC3C,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,gCAAgC,CAAC"}

package/dist/rules/prefer-type-fest-non-empty-tuple.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-type-fest-non-empty-tuple`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTypeFestNonEmptyTupleRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-type-fest-non-empty-tuple` rule module.
+ */
+export default preferTypeFestNonEmptyTupleRule;
+//# sourceMappingURL=prefer-type-fest-non-empty-tuple.d.ts.map

package/dist/rules/prefer-type-fest-non-empty-tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-non-empty-tuple.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-non-empty-tuple.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AA6E7D;;;;;GAKG;AACH,QAAA,MAAM,+BAA+B,EAAE,UAAU,CAAC,OAAO,eAAe,CA0FlE,CAAC;AAEP;;GAEG;AACH,eAAe,+BAA+B,CAAC"}

package/dist/rules/prefer-type-fest-non-empty-tuple.js

@@ -0,0 +1,133 @@
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeTextReplacementFixPreservingReadonly, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { areEquivalentTypeNodes } from "../_internal/normalize-expression-text.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * Extracts the required head element type from a tuple member.
+ *
+ * @param element - Tuple element candidate.
+ *
+ * @returns The non-optional, non-rest head type node when present; otherwise
+ *   `null`.
+ */
+const getRequiredTupleElementType = (element) => {
+    if (element.type === "TSNamedTupleMember") {
+        if (element.optional) {
+            return null;
+        }
+        return element.elementType;
+    }
+    if (element.type === "TSOptionalType" || element.type === "TSRestType") {
+        return null;
+    }
+    return element;
+};
+/**
+ * Normalizes rest annotations by unwrapping named tuple members.
+ *
+ * @param annotation - Rest annotation to normalize.
+ *
+ * @returns The underlying type node represented by the annotation.
+ */
+const unwrapRestAnnotation = (annotation) => {
+    if (annotation.type === "TSNamedTupleMember") {
+        return annotation.elementType;
+    }
+    return annotation;
+};
+/**
+ * Extracts `T` from rest elements shaped like `...T[]`.
+ *
+ * @param element - Tuple element candidate.
+ *
+ * @returns The array element type used by a rest tuple element; otherwise
+ *   `null`.
+ */
+const getRestArrayElementType = (element) => {
+    if (element.type !== "TSRestType") {
+        return null;
+    }
+    const restType = unwrapRestAnnotation(element.typeAnnotation);
+    if (restType?.type !== "TSArrayType") {
+        return null;
+    }
+    return restType.elementType;
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-non-empty-tuple`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestNonEmptyTupleRule = createTypedRule({
+    create(context) {
+        const { sourceCode } = context;
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            TSTypeOperator(node) {
+                if (node.operator !== "readonly") {
+                    return;
+                }
+                const tupleType = node.typeAnnotation;
+                if (tupleType?.type !== "TSTupleType") {
+                    return;
+                }
+                if (tupleType.elementTypes.length !== 2) {
+                    return;
+                }
+                const [firstElement, restElement] = tupleType.elementTypes;
+                if (!firstElement || !restElement) {
+                    return;
+                }
+                const firstType = getRequiredTupleElementType(firstElement);
+                if (!firstType) {
+                    return;
+                }
+                const restArrayElementType = getRestArrayElementType(restElement);
+                if (!restArrayElementType) {
+                    return;
+                }
+                if (!areEquivalentTypeNodes(firstType, restArrayElementType)) {
+                    return;
+                }
+                const replacementFix = createSafeTypeNodeTextReplacementFixPreservingReadonly(node, "NonEmptyTuple", `NonEmptyTuple<${sourceCode.getText(firstType)}>`, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: replacementFix,
+                    messageId: "preferNonEmptyTuple",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest NonEmptyTuple over readonly [T, ...T[]] tuple patterns.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-non-empty-tuple",
+        },
+        fixable: "code",
+        messages: {
+            preferNonEmptyTuple: "Prefer `Readonly<NonEmptyTuple<T>>` from type-fest over `readonly [T, ...T[]]`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-non-empty-tuple",
+});
+/**
+ * Default export for the `prefer-type-fest-non-empty-tuple` rule module.
+ */
+export default preferTypeFestNonEmptyTupleRule;
+//# sourceMappingURL=prefer-type-fest-non-empty-tuple.js.map