eslint-plugin-typefest 1.0.1

package/dist/rules/prefer-type-fest-unknown-record.js

@@ -0,0 +1,77 @@
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeReplacementFix, } 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";
+/**
+ * Detects `Record<string, unknown>` references.
+ *
+ * @param node - Type reference candidate.
+ *
+ * @returns `true` when the node is a two-argument `Record` with `string` keys
+ *   and `unknown` values.
+ */
+const isRecordStringUnknown = (node) => {
+    if (node.typeName.type !== "Identifier" ||
+        node.typeName.name !== "Record" ||
+        node.typeArguments?.params.length !== 2) {
+        return false;
+    }
+    const [keyType, valueType] = node.typeArguments.params;
+    return (keyType?.type === "TSStringKeyword" &&
+        valueType?.type === "TSUnknownKeyword");
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-unknown-record`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestUnknownRecordRule = createTypedRule({
+    create(context) {
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (!isRecordStringUnknown(node)) {
+                    return;
+                }
+                const replacementFix = createSafeTypeNodeReplacementFix(node, "UnknownRecord", typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: replacementFix,
+                    messageId: "preferUnknownRecord",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest UnknownRecord over Record<string, unknown> in architecture-critical layers.",
+            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-unknown-record",
+        },
+        fixable: "code",
+        messages: {
+            preferUnknownRecord: "Prefer `UnknownRecord` from type-fest over `Record<string, unknown>` for clearer intent and stronger shared typing conventions.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-unknown-record",
+});
+/**
+ * Default export for the `prefer-type-fest-unknown-record` rule module.
+ */
+export default preferTypeFestUnknownRecordRule;
+//# sourceMappingURL=prefer-type-fest-unknown-record.js.map

package/dist/rules/prefer-type-fest-unknown-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-unknown-record.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-unknown-record.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,mCAAmC,EACnC,gCAAgC,GACnC,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;;;;;;;GAOG;AAEH,MAAM,qBAAqB,GAAG,CAC1B,IAAwC,EACjC,EAAE;IACT,IACI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;QACnC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ;QAC/B,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EACzC,CAAC;QACC,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;IACvD,OAAO,CACH,OAAO,EAAE,IAAI,KAAK,iBAAiB;QACnC,SAAS,EAAE,IAAI,KAAK,kBAAkB,CACzC,CAAC;AACN,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,+BAA+B,GACjC,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,6CAA6C,CAAC,IAAI;gBAC9C,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC/B,OAAO;gBACX,CAAC;gBAED,MAAM,cAAc,GAAG,gCAAgC,CACnD,IAAI,EACJ,eAAe,EACf,qBAAqB,CACxB,CAAC;gBAEF,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG,EAAE,cAAc;oBACnB,SAAS,EAAE,qBAAqB;oBAChC,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,8FAA8F;YAClG,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,0BAA0B;gBAC1B,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,kCAAkC;aACrC;YACD,GAAG,EAAE,gGAAgG;SACxG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,mBAAmB,EACf,iIAAiI;SACxI;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,iCAAiC;CAC1C,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,+BAA+B,CAAC"}

package/dist/rules/prefer-type-fest-unknown-set.d.ts

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

package/dist/rules/prefer-type-fest-unknown-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-unknown-set.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-unknown-set.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AA6B7D;;;;;GAKG;AACH,QAAA,MAAM,4BAA4B,EAAE,UAAU,CAAC,OAAO,eAAe,CA+D/D,CAAC;AAEP;;GAEG;AACH,eAAe,4BAA4B,CAAC"}

package/dist/rules/prefer-type-fest-unknown-set.js

@@ -0,0 +1,81 @@
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeTextReplacementFixPreservingReadonly, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { isIdentifierTypeReference } from "../_internal/type-reference-node.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/** Built-in set alias targeted by this rule. */
+const READONLY_SET_TYPE_NAME = "ReadonlySet";
+/** Preferred TypeFest alias for readonly sets of unknown values. */
+const UNKNOWN_SET_TYPE_NAME = "UnknownSet";
+/**
+ * Checks whether a generic type reference has exactly one `unknown` argument.
+ *
+ * @param node - Type reference candidate.
+ *
+ * @returns `true` when the reference shape is `<unknown>`.
+ */
+const hasSingleUnknownTypeArgument = (node) => {
+    const typeArguments = node.typeArguments?.params ?? [];
+    if (typeArguments.length !== 1) {
+        return false;
+    }
+    const [firstTypeArgument] = typeArguments;
+    return firstTypeArgument?.type === "TSUnknownKeyword";
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-unknown-set`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestUnknownSetRule = createTypedRule({
+    create(context) {
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (!isIdentifierTypeReference(node, READONLY_SET_TYPE_NAME)) {
+                    return;
+                }
+                if (!hasSingleUnknownTypeArgument(node)) {
+                    return;
+                }
+                const replacementFix = createSafeTypeNodeTextReplacementFixPreservingReadonly(node, UNKNOWN_SET_TYPE_NAME, UNKNOWN_SET_TYPE_NAME, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: replacementFix,
+                    messageId: "preferUnknownSet",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest UnknownSet over ReadonlySet<unknown> 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-unknown-set",
+        },
+        fixable: "code",
+        messages: {
+            preferUnknownSet: "Prefer `Readonly<UnknownSet>` from type-fest over `ReadonlySet<unknown>`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-unknown-set",
+});
+/**
+ * Default export for the `prefer-type-fest-unknown-set` rule module.
+ */
+export default preferTypeFestUnknownSetRule;
+//# sourceMappingURL=prefer-type-fest-unknown-set.js.map

package/dist/rules/prefer-type-fest-unknown-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-unknown-set.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-unknown-set.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,mCAAmC,EACnC,sDAAsD,GACzD,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,gDAAgD;AAChD,MAAM,sBAAsB,GAAG,aAAa,CAAC;AAE7C,oEAAoE;AACpE,MAAM,qBAAqB,GAAG,YAAY,CAAC;AAE3C;;;;;;GAMG;AAEH,MAAM,4BAA4B,GAAG,CACjC,IAAwC,EACjC,EAAE;IACT,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,IAAI,EAAE,CAAC;IAEvD,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,iBAAiB,CAAC,GAAG,aAAa,CAAC;IAC1C,OAAO,iBAAiB,EAAE,IAAI,KAAK,kBAAkB,CAAC;AAC1D,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,4BAA4B,GAC9B,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,6CAA6C,CAAC,IAAI;gBAC9C,IACI,CAAC,yBAAyB,CAAC,IAAI,EAAE,sBAAsB,CAAC,EAC1D,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;oBACtC,OAAO;gBACX,CAAC;gBAED,MAAM,cAAc,GAChB,sDAAsD,CAClD,IAAI,EACJ,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,CACxB,CAAC;gBAEN,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG,EAAE,cAAc;oBACnB,SAAS,EAAE,kBAAkB;oBAC7B,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,gEAAgE;YACpE,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,6FAA6F;SACrG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,gBAAgB,EACZ,2EAA2E;SAClF;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,8BAA8B;CACvC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,4BAA4B,CAAC"}

package/dist/rules/prefer-type-fest-unwrap-tagged.d.ts

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

package/dist/rules/prefer-type-fest-unwrap-tagged.d.ts.map

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

package/dist/rules/prefer-type-fest-unwrap-tagged.js

@@ -0,0 +1,74 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-unwrap-tagged`.
+ */
+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 unwrapTaggedAliasReplacements = {
+    UnwrapOpaque: "UnwrapTagged",
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-unwrap-tagged`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestUnwrapTaggedRule = createTypedRule({
+    create(context) {
+        const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, unwrapTaggedAliasReplacements);
+        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: "preferUnwrapTagged",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest UnwrapTagged over imported aliases such as UnwrapOpaque.",
+            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-unwrap-tagged",
+        },
+        fixable: "code",
+        messages: {
+            preferUnwrapTagged: "Prefer `{{replacement}}` from type-fest to unwrap Tagged/Opaque values instead of legacy alias `{{alias}}`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-unwrap-tagged",
+});
+/**
+ * Default export for the `prefer-type-fest-unwrap-tagged` rule module.
+ */
+export default preferTypeFestUnwrapTaggedRule;
+//# sourceMappingURL=prefer-type-fest-unwrap-tagged.js.map

package/dist/rules/prefer-type-fest-unwrap-tagged.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-unwrap-tagged.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-unwrap-tagged.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,6BAA6B,GAAG;IAClC,YAAY,EAAE,cAAc;CACtB,CAAC;AAEX;;;;;GAKG;AACH,MAAM,8BAA8B,GAChC,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,oBAAoB,GAAG,+BAA+B,CACxD,OAAO,CAAC,UAAU,EAClB,6BAA6B,CAChC,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,oBAAoB;oBAC/B,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,2EAA2E;YAC/E,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,kBAAkB,EACd,6GAA6G;SACpH;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,gCAAgC;CACzC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,8BAA8B,CAAC"}

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

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

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

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

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

@@ -0,0 +1,74 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-value-of`.
+ */
+import { collectDirectNamedImportsFromSource, createSafeTypeNodeTextReplacementFix, } 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";
+/**
+ * ESLint rule definition for `prefer-type-fest-value-of`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestValueOfRule = createTypedRule({
+    create(context) {
+        const { sourceCode } = context;
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            TSIndexedAccessType(node) {
+                if (node.indexType.type !== "TSTypeOperator" ||
+                    node.indexType.operator !== "keyof") {
+                    return;
+                }
+                const keyOfTargetType = node.indexType.typeAnnotation;
+                /* v8 ignore start */
+                if (!keyOfTargetType) {
+                    return;
+                }
+                /* v8 ignore stop */
+                if (!areEquivalentTypeNodes(node.objectType, keyOfTargetType)) {
+                    return;
+                }
+                const fix = createSafeTypeNodeTextReplacementFix(node, "ValueOf", `ValueOf<${sourceCode.getText(node.objectType)}>`, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix,
+                    messageId: "preferValueOf",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest ValueOf over direct T[keyof T] indexed-access unions for object value extraction.",
+            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-value-of",
+        },
+        fixable: "code",
+        messages: {
+            preferValueOf: "Prefer `ValueOf<T>` from type-fest over `T[keyof T]` for object value unions.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-value-of",
+});
+/**
+ * Default export for the `prefer-type-fest-value-of` rule module.
+ */
+export default preferTypeFestValueOfRule;
+//# sourceMappingURL=prefer-type-fest-value-of.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-value-of.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-value-of.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACH,mCAAmC,EACnC,oCAAoC,GACvC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,yBAAyB,GAC3B,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QAC/B,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,UAAU,EACV,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,mBAAmB,CAAC,IAAI;gBACpB,IACI,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,gBAAgB;oBACxC,IAAI,CAAC,SAAS,CAAC,QAAQ,KAAK,OAAO,EACrC,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;gBACtD,qBAAqB;gBACrB,IAAI,CAAC,eAAe,EAAE,CAAC;oBACnB,OAAO;gBACX,CAAC;gBACD,oBAAoB;gBAEpB,IACI,CAAC,sBAAsB,CACnB,IAAI,CAAC,UAAU,EACf,eAAe,CAClB,EACH,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,MAAM,GAAG,GAAG,oCAAoC,CAC5C,IAAI,EACJ,SAAS,EACT,WAAW,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EACjD,qBAAqB,CACxB,CAAC;gBAEF,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG;oBACH,SAAS,EAAE,eAAe;oBAC1B,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,oGAAoG;YACxG,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,0FAA0F;SAClG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,aAAa,EACT,+EAA+E;SACtF;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,2BAA2B;CACpC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,yBAAyB,CAAC"}

package/dist/rules/prefer-type-fest-writable-deep.d.ts

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

package/dist/rules/prefer-type-fest-writable-deep.d.ts.map

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

package/dist/rules/prefer-type-fest-writable-deep.js

@@ -0,0 +1,64 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-writable-deep`.
+ */
+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-writable-deep`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestWritableDeepRule = 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 !== "DeepMutable" &&
+                        node.typeName.name !== "MutableDeep")) {
+                    return;
+                }
+                const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, "WritableDeep", typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    fix: aliasReplacementFix,
+                    messageId: "preferWritableDeep",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest WritableDeep over `DeepMutable` and `MutableDeep` 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-writable-deep",
+        },
+        fixable: "code",
+        messages: {
+            preferWritableDeep: "Prefer `WritableDeep` from type-fest over `DeepMutable`/`MutableDeep`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-writable-deep",
+});
+/**
+ * Default export for the `prefer-type-fest-writable-deep` rule module.
+ */
+export default preferTypeFestWritableDeepRule;
+//# sourceMappingURL=prefer-type-fest-writable-deep.js.map

package/dist/rules/prefer-type-fest-writable-deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-writable-deep.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-writable-deep.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,8BAA8B,GAChC,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,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa;wBACjC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,EAC3C,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,MAAM,mBAAmB,GACrB,qCAAqC,CACjC,IAAI,EACJ,cAAc,EACd,qBAAqB,CACxB,CAAC;gBAEN,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG,EAAE,mBAAmB;oBACxB,SAAS,EAAE,oBAAoB;oBAC/B,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,6EAA6E;YACjF,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,kBAAkB,EACd,wEAAwE;SAC/E;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,gCAAgC;CACzC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,8BAA8B,CAAC"}

package/dist/rules/prefer-type-fest-writable.d.ts

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

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

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

package/dist/rules/prefer-type-fest-writable.js

@@ -0,0 +1,129 @@
+import { collectDirectNamedImportsFromSource, collectImportedTypeAliasMatches, createSafeTypeReferenceReplacementFix, } 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";
+/** Legacy alias names normalized by this rule to `Writable`. */
+const writableAliasReplacements = {
+    Mutable: "Writable",
+};
+/**
+ * Detects mapped types equivalent to `Writable<T>`.
+ *
+ * @param node - Mapped type node to inspect.
+ *
+ * @returns `true` when the mapped type removes `readonly` via `-readonly` and
+ *   preserves property optionality and values as `T[K]`.
+ */
+const hasWritableMappedTypeShape = (node) => {
+    if (node.readonly !== "-") {
+        return false;
+    }
+    if (node.optional !== false) {
+        return false;
+    }
+    if (node.nameType !== null) {
+        return false;
+    }
+    const { constraint } = node;
+    if (constraint?.type !== "TSTypeOperator") {
+        return false;
+    }
+    if (constraint.operator !== "keyof") {
+        return false;
+    }
+    const baseType = constraint.typeAnnotation;
+    if (!baseType) {
+        return false;
+    }
+    const { typeAnnotation } = node;
+    if (typeAnnotation?.type !== "TSIndexedAccessType") {
+        return false;
+    }
+    if (!areEquivalentTypeNodes(typeAnnotation.objectType, baseType)) {
+        return false;
+    }
+    const { indexType } = typeAnnotation;
+    if (indexType.type !== "TSTypeReference" ||
+        indexType.typeName.type !== "Identifier") {
+        return false;
+    }
+    return (node.key.type === "Identifier" &&
+        indexType.typeName.name === node.key.name);
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-writable`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestWritableRule = createTypedRule({
+    create(context) {
+        const { sourceCode } = context;
+        const importedAliasMatches = collectImportedTypeAliasMatches(sourceCode, writableAliasReplacements);
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            TSMappedType(node) {
+                if (!hasWritableMappedTypeShape(node)) {
+                    return;
+                }
+                reportWithOptionalFix({
+                    context,
+                    fix: null,
+                    messageId: "preferWritable",
+                    node,
+                });
+            },
+            '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: "preferWritableAlias",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest Writable over manual mapped types that strip readonly with -readonly.",
+            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-writable",
+        },
+        fixable: "code",
+        messages: {
+            preferWritable: "Prefer `Writable<T>` from type-fest over `{-readonly [K in keyof T]: T[K]}`.",
+            preferWritableAlias: "Prefer `{{replacement}}` from type-fest to remove readonly modifiers from selected keys instead of legacy alias `{{alias}}`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-writable",
+});
+/**
+ * Default export for the `prefer-type-fest-writable` rule module.
+ */
+export default preferTypeFestWritableRule;
+//# sourceMappingURL=prefer-type-fest-writable.js.map

package/dist/rules/prefer-type-fest-writable.js.map

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