eslint-plugin-typefest 1.2.1 → 1.2.2

package/dist/plugin.cjs

@@ -34,13 +34,13 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_parser3 = __toESM(require("@typescript-eslint/parser"), 1);
-var import_ts_extras41 = require("ts-extras");
+var import_ts_extras43 = require("ts-extras");
 
 // package.json
 var package_default = {
   $schema: "https://www.schemastore.org/package.json",
   name: "eslint-plugin-typefest",
-  version: "1.2.1",
+  version: "1.2.2",
   private: false,
   description: "ESLint rules for adopting type-fest and ts-extras conventions.",
   keywords: [
@@ -218,6 +218,7 @@ var package_default = {
     "release:verify": "cross-env NODE_OPTIONS= npm run build && cross-env NODE_OPTIONS= npm run lint:nocache && cross-env NODE_OPTIONS= npm run typecheck && cross-env NODE_OPTIONS= VITEST_TYPECHECK=false npm run test && cross-env NODE_OPTIONS= npm run sync:readme-rules-table && cross-env NODE_OPTIONS= npm run sync:presets-rules-matrix && cross-env NODE_OPTIONS= npm run docs:check-links && cross-env NODE_OPTIONS= npm run lint:package:strict",
     "remark:fix": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail --quiet --output -- "*.{md,mdx}" "docs/**/*.{md,mdx}"',
     "remark:test-config": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail "README.md"',
+    size: "size-limit",
     "sync:node-version-files": "node scripts/sync-node-version-files.mjs",
     "sync:peer-eslint-range": "node scripts/sync-peer-eslint-range.mjs",
     "sync:presets-rules-matrix": "node scripts/sync-presets-rules-matrix.mjs",
@@ -259,19 +260,19 @@ var package_default = {
     "@typescript-eslint/parser": "^8.58.2",
     "@typescript-eslint/type-utils": "^8.58.2",
     "@typescript-eslint/utils": "^8.58.2",
-    "ts-extras": "^0.19.0",
-    "type-fest": "^5.5.0"
+    "ts-extras": "^1.0.0",
+    "type-fest": "^5.6.0"
   },
   devDependencies: {
     "@arethetypeswrong/cli": "^0.18.2",
     "@csstools/stylelint-formatter-github": "^2.0.0",
     "@docusaurus/eslint-plugin": "^3.10.0",
     "@double-great/remark-lint-alt-text": "^1.1.1",
-    "@double-great/stylelint-a11y": "^3.4.9",
+    "@double-great/stylelint-a11y": "^3.4.10",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
     "@eslint-react/eslint-plugin": "^4.2.3",
     "@eslint/config-helpers": "^0.5.5",
-    "@eslint/config-inspector": "^1.5.0",
+    "@eslint/config-inspector": "^2.0.0",
     "@eslint/css": "^1.1.0",
     "@eslint/js": "^10.0.1",
     "@eslint/json": "^1.2.0",
@@ -293,6 +294,7 @@ var package_default = {
     "@secretlint/secretlint-rule-privatekey": "^11.7.1",
     "@secretlint/secretlint-rule-secp256k1-privatekey": "^11.7.1",
     "@secretlint/types": "^11.7.1",
+    "@size-limit/file": "^12.1.0",
     "@softonus/prettier-plugin-duplicate-remover": "^1.1.2",
     "@stryker-ignorer/console-all": "^0.3.2",
     "@stryker-mutator/core": "^9.6.1",
@@ -319,7 +321,7 @@ var package_default = {
     "@typescript-eslint/rule-tester": "^8.58.2",
     "@typpi/eslint-plugin-vite": "^1.0.12",
     "@vitest/coverage-v8": "^4.1.4",
-    "@vitest/eslint-plugin": "^1.6.15",
+    "@vitest/eslint-plugin": "^1.6.16",
     "@vitest/ui": "^4.1.4",
     actionlint: "^2.0.6",
     "all-contributors-cli": "^6.26.1",
@@ -329,20 +331,20 @@ var package_default = {
     "cross-env": "^10.1.0",
     depcheck: "^1.4.7",
     "detect-secrets": "^1.0.6",
-    eslint: "^10.2.0",
+    eslint: "^10.2.1",
     "eslint-config-flat-gitignore": "^2.3.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-formatter-unix": "^9.0.1",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-array-func": "^5.1.1",
     "eslint-plugin-canonical": "^5.1.3",
-    "eslint-plugin-case-police": "^2.2.0",
+    "eslint-plugin-case-police": "^2.2.1",
     "eslint-plugin-comment-length": "^2.3.0",
     "eslint-plugin-copilot": "^1.0.8",
     "eslint-plugin-css-modules": "^2.12.0",
     "eslint-plugin-de-morgan": "^2.1.1",
     "eslint-plugin-depend": "^1.5.0",
-    "eslint-plugin-docusaurus-2": "^0.1.3",
+    "eslint-plugin-docusaurus-2": "^0.1.4",
     "eslint-plugin-eslint-plugin": "^7.3.2",
     "eslint-plugin-etc-misc": "^1.0.6",
     "eslint-plugin-file-progress-2": "^5.0.1",
@@ -374,21 +376,21 @@ var package_default = {
     "eslint-plugin-require-jsdoc": "^1.0.4",
     "eslint-plugin-sdl-2": "^1.0.6",
     "eslint-plugin-security": "^4.0.0",
-    "eslint-plugin-sonarjs": "^4.0.2",
-    "eslint-plugin-stylelint-2": "^1.0.11",
+    "eslint-plugin-sonarjs": "^4.0.3",
+    "eslint-plugin-stylelint-2": "^1.0.14",
     "eslint-plugin-testing-library": "^7.16.2",
     "eslint-plugin-toml": "^1.3.1",
     "eslint-plugin-tsdoc": "^0.5.2",
     "eslint-plugin-tsdoc-require-2": "^1.0.9",
     "eslint-plugin-typedoc": "^1.1.4",
-    "eslint-plugin-typefest": "^1.2.0",
+    "eslint-plugin-typefest": "^1.2.1",
     "eslint-plugin-undefined-css-classes": "^0.1.5",
     "eslint-plugin-unicorn": "^64.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
     "eslint-plugin-write-good-comments-2": "^1.0.6",
     "eslint-plugin-yml": "^3.3.1",
     "eslint-rule-benchmark": "^0.8.0",
-    "fast-check": "^4.6.0",
+    "fast-check": "^4.7.0",
     "git-cliff": "^2.12.0",
     "gitleaks-secret-scanner": "^2.1.1",
     globals: "^17.5.0",
@@ -399,10 +401,10 @@ var package_default = {
     leasot: "^14.4.0",
     madge: "^8.0.0",
     "markdown-link-check": "^3.14.2",
-    "npm-check-updates": "^21.0.0",
+    "npm-check-updates": "^21.0.2",
     "npm-package-json-lint": "^10.2.1",
     picocolors: "^1.1.1",
-    postcss: "^8.5.9",
+    postcss: "^8.5.10",
     "postcss-assets": "^6.0.0",
     "postcss-clamp": "^4.1.0",
     "postcss-combine-duplicated-selectors": "^10.0.3",
@@ -419,7 +421,7 @@ var package_default = {
     "postcss-styled-jsx": "^1.0.1",
     "postcss-styled-syntax": "^0.7.1",
     "postcss-viewport-height-correction": "^1.1.1",
-    prettier: "^3.8.2",
+    prettier: "^3.8.3",
     "prettier-plugin-ini": "^1.3.0",
     "prettier-plugin-interpolated-html-tags": "^2.0.1",
     "prettier-plugin-jsdoc": "^1.8.0",
@@ -540,15 +542,16 @@ var package_default = {
     "remark-wiki-link": "^2.0.1",
     rimraf: "^6.1.3",
     secretlint: "^11.7.1",
+    "size-limit": "^12.1.0",
     sloc: "^0.3.2",
     "sort-package-json": "^3.6.1",
-    stylelint: "^17.7.0",
+    stylelint: "^17.8.0",
     "stylelint-actions-formatters": "^16.3.1",
     "stylelint-checkstyle-formatter": "^0.1.2",
     "stylelint-codeframe-formatter": "^1.2.0",
     "stylelint-config-alphabetical-order": "^2.0.0",
     "stylelint-config-idiomatic-order": "^10.0.0",
-    "stylelint-config-inspector": "^2.0.3",
+    "stylelint-config-inspector": "^2.1.1",
     "stylelint-config-recess-order": "^7.7.0",
     "stylelint-config-recommended": "^18.0.0",
     "stylelint-config-sass-guidelines": "^13.0.0",
@@ -572,6 +575,7 @@ var package_default = {
     "stylelint-no-unsupported-browser-features": "^8.1.1",
     "stylelint-order": "^8.1.1",
     "stylelint-plugin-defensive-css": "^2.9.0",
+    "stylelint-plugin-docusaurus": "^1.0.2",
     "stylelint-plugin-logical-css": "^2.1.0",
     "stylelint-plugin-use-baseline": "^1.4.1",
     "stylelint-prettier": "^5.0.3",
@@ -583,7 +587,7 @@ var package_default = {
     "toml-eslint-parser": "^1.0.3",
     "ts-unused-exports": "^11.0.1",
     typedoc: "^0.28.19",
-    typescript: "^6.0.2",
+    typescript: "^6.0.3",
     "typescript-eslint": "^8.58.2",
     typesync: "^0.14.3",
     vfile: "^6.0.3",
@@ -594,7 +598,7 @@ var package_default = {
     "yamllint-js": "^0.2.4"
   },
   peerDependencies: {
-    eslint: "^9.0.0 || ^10.2.0",
+    eslint: "^9.0.0 || ^10.2.1",
     typescript: "^5.0.0 || ^6.0.2"
   },
   packageManager: "npm@11.12.1",
@@ -2385,7 +2389,13 @@ var orderedRuleNames = [
   "prefer-type-fest-unwrap-tagged",
   "prefer-type-fest-value-of",
   "prefer-type-fest-writable",
-  "prefer-type-fest-writable-deep"
+  "prefer-type-fest-writable-deep",
+  "prefer-type-fest-absolute",
+  "prefer-type-fest-non-nullable-deep",
+  "prefer-type-fest-union-length",
+  "prefer-ts-extras-assert-never",
+  "prefer-ts-extras-is-property-defined",
+  "prefer-ts-extras-is-property-present"
 ];
 var toRuleCatalogId = (ruleNumber) => `R${String(ruleNumber).padStart(3, "0")}`;
 var isTypefestRuleNamePattern2 = (ruleName) => ruleName.startsWith("prefer-");
@@ -3635,6 +3645,101 @@ var preferTsExtrasAssertErrorRule = createTypedRule({
 });
 var prefer_ts_extras_assert_error_default = preferTsExtrasAssertErrorRule;
 
+// dist/rules/prefer-ts-extras-assert-never.js
+var preferTsExtrasAssertNeverRule = createTypedRule({
+  create(context) {
+    const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+    return {
+      VariableDeclaration(node) {
+        if (node.kind !== "const" || node.declarations.length !== 1) {
+          return;
+        }
+        const [declarator] = node.declarations;
+        if (declarator?.id.type !== "Identifier") {
+          return;
+        }
+        const { typeAnnotation } = declarator.id;
+        if (typeAnnotation?.typeAnnotation.type !== "TSNeverKeyword") {
+          return;
+        }
+        const { init } = declarator;
+        if (!init) {
+          return;
+        }
+        const initArgumentText = getFunctionCallArgumentText({
+          argumentNode: init,
+          sourceCode: context.sourceCode
+        });
+        if (initArgumentText === null) {
+          reportWithOptionalFix({
+            context,
+            fix: null,
+            messageId: "preferTsExtrasAssertNever",
+            node
+          });
+          return;
+        }
+        const replacementFix = createSafeValueNodeTextReplacementFix({
+          context,
+          importedName: "assertNever",
+          imports: tsExtrasImports,
+          replacementTextFactory: (replacementName) => `${replacementName}(${initArgumentText})`,
+          reportFixIntent: "suggestion",
+          sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+          targetNode: node
+        });
+        if (replacementFix === null) {
+          reportWithOptionalFix({
+            context,
+            fix: null,
+            messageId: "preferTsExtrasAssertNever",
+            node
+          });
+          return;
+        }
+        reportWithTypefestPolicy({
+          context,
+          descriptor: {
+            messageId: "preferTsExtrasAssertNever",
+            node,
+            suggest: [
+              {
+                fix: replacementFix,
+                messageId: "suggestTsExtrasAssertNever"
+              }
+            ]
+          }
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require ts-extras assertNever over manual `const _: never = value` exhaustiveness checks.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.ts-extras/type-guards"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-assert-never"
+    },
+    hasSuggestions: true,
+    messages: {
+      preferTsExtrasAssertNever: "Prefer `assertNever` from `ts-extras` over a manual `const _: never` exhaustiveness assertion.",
+      suggestTsExtrasAssertNever: "Replace this manual exhaustiveness check with `assertNever(...)` from `ts-extras`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-ts-extras-assert-never"
+});
+var prefer_ts_extras_assert_never_default = preferTsExtrasAssertNeverRule;
+
 // dist/rules/prefer-ts-extras-assert-present.js
 var isNullExpression = (node) => node.type === "Literal" && node.value === null;
 var isUndefinedExpression2 = ({ context, node }) => {
@@ -5354,6 +5459,177 @@ var preferTsExtrasIsPresentRule = createTypedRule({
 });
 var prefer_ts_extras_is_present_default = preferTsExtrasIsPresentRule;
 
+// dist/rules/prefer-ts-extras-is-property-defined.js
+var extractTypeofPropertyDefinedCheck = (typeofSide, stringSide, operator, paramName) => {
+  if (operator !== "!==") {
+    return null;
+  }
+  if (typeofSide.type !== "UnaryExpression" || typeofSide.operator !== "typeof") {
+    return null;
+  }
+  const { argument } = typeofSide;
+  if (argument.type !== "MemberExpression" || argument.computed || argument.object.type !== "Identifier" || argument.object.name !== paramName || argument.property.type !== "Identifier") {
+    return null;
+  }
+  if (stringSide.type !== "Literal" || stringSide.value !== "undefined") {
+    return null;
+  }
+  return argument.property.name;
+};
+var extractPropertyDefinedGuardBody = (context, body, paramName) => {
+  if (body.type !== "BinaryExpression") {
+    return null;
+  }
+  const { left, operator, right } = body;
+  if (operator !== "!==" && operator !== "!=") {
+    return null;
+  }
+  const typeofLeftResult = extractTypeofPropertyDefinedCheck(left, right, operator, paramName);
+  if (typeofLeftResult !== null) {
+    return typeofLeftResult;
+  }
+  const typeofRightResult = extractTypeofPropertyDefinedCheck(right, left, operator, paramName);
+  if (typeofRightResult !== null) {
+    return typeofRightResult;
+  }
+  if (left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === paramName && left.property.type === "Identifier" && isGlobalUndefinedIdentifier(context, right)) {
+    return left.property.name;
+  }
+  if (right.type === "MemberExpression" && !right.computed && right.object.type === "Identifier" && right.object.name === paramName && right.property.type === "Identifier" && isGlobalUndefinedIdentifier(context, left)) {
+    return right.property.name;
+  }
+  return null;
+};
+var preferTsExtrasIsPropertyDefinedRule = createTypedRule({
+  create(context) {
+    const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+    return {
+      'CallExpression[callee.type="MemberExpression"][callee.property.type="Identifier"][callee.property.name="filter"]'(node) {
+        const callbackMatch = getSingleParameterExpressionArrowFilterCallback(node);
+        if (!callbackMatch) {
+          return;
+        }
+        const { callback, parameter } = callbackMatch;
+        const propName = extractPropertyDefinedGuardBody(context, callback.body, parameter.name);
+        if (propName === null) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: createSafeValueNodeTextReplacementFix({
+            context,
+            importedName: "isPropertyDefined",
+            imports: tsExtrasImports,
+            replacementTextFactory: (localName) => `${localName}(${JSON.stringify(propName)})`,
+            reportFixIntent: "autofix",
+            sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+            targetNode: callback
+          }),
+          messageId: "preferTsExtrasIsPropertyDefined",
+          node: callback
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require ts-extras isPropertyDefined in Array.filter callbacks instead of inline property-undefined checks.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.minimal",
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.ts-extras/type-guards"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-property-defined"
+    },
+    fixable: "code",
+    messages: {
+      preferTsExtrasIsPropertyDefined: "Prefer `isPropertyDefined` from `ts-extras` over an inline property-undefined filter callback."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-ts-extras-is-property-defined"
+});
+var prefer_ts_extras_is_property_defined_default = preferTsExtrasIsPropertyDefinedRule;
+
+// dist/rules/prefer-ts-extras-is-property-present.js
+var extractPropertyPresentGuardBody = (body, paramName) => {
+  if (body.type !== "BinaryExpression" || body.operator !== "!=") {
+    return null;
+  }
+  const { left, right } = body;
+  if (left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === paramName && left.property.type === "Identifier" && right.type === "Literal" && right.value === null) {
+    return left.property.name;
+  }
+  if (right.type === "MemberExpression" && !right.computed && right.object.type === "Identifier" && right.object.name === paramName && right.property.type === "Identifier" && left.type === "Literal" && left.value === null) {
+    return right.property.name;
+  }
+  return null;
+};
+var preferTsExtrasIsPropertyPresentRule = createTypedRule({
+  create(context) {
+    const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+    return {
+      'CallExpression[callee.type="MemberExpression"][callee.property.type="Identifier"][callee.property.name="filter"]'(node) {
+        const callbackMatch = getSingleParameterExpressionArrowFilterCallback(node);
+        if (!callbackMatch) {
+          return;
+        }
+        const { callback, parameter } = callbackMatch;
+        const propName = extractPropertyPresentGuardBody(callback.body, parameter.name);
+        if (propName === null) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: createSafeValueNodeTextReplacementFix({
+            context,
+            importedName: "isPropertyPresent",
+            imports: tsExtrasImports,
+            replacementTextFactory: (localName) => `${localName}(${JSON.stringify(propName)})`,
+            reportFixIntent: "autofix",
+            sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+            targetNode: callback
+          }),
+          messageId: "preferTsExtrasIsPropertyPresent",
+          node: callback
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require ts-extras isPropertyPresent in Array.filter callbacks instead of inline property-nullish checks.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.minimal",
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.ts-extras/type-guards"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-property-present"
+    },
+    fixable: "code",
+    messages: {
+      preferTsExtrasIsPropertyPresent: "Prefer `isPropertyPresent` from `ts-extras` over an inline property-nullish filter callback."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-ts-extras-is-property-present"
+});
+var prefer_ts_extras_is_property_present_default = preferTsExtrasIsPropertyPresentRule;
+
 // dist/rules/prefer-ts-extras-is-safe-integer.js
 var preferTsExtrasIsSafeIntegerRule = createTypedRule({
   create(context) {
@@ -6611,8 +6887,59 @@ var preferTsExtrasStringSplitRule = createTypedRule({
 });
 var prefer_ts_extras_string_split_default = preferTsExtrasStringSplitRule;
 
-// dist/rules/prefer-type-fest-abstract-constructor.js
+// dist/rules/prefer-type-fest-absolute.js
 var import_ts_extras32 = require("ts-extras");
+var ABSOLUTE_ALIAS_NAMES = /* @__PURE__ */ new Set([
+  "Abs",
+  "AbsoluteValue"
+]);
+var preferTypeFestAbsoluteRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        if (node.typeName.type !== "Identifier" || !(0, import_ts_extras32.setHas)(ABSOLUTE_ALIAS_NAMES, node.typeName.name)) {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, "Absolute", typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          data: { aliasName: node.typeName.name },
+          fix: aliasReplacementFix,
+          messageId: "preferAbsolute",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest `Absolute` over common `Abs` or `AbsoluteValue` 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-absolute"
+    },
+    fixable: "code",
+    messages: {
+      preferAbsolute: "Prefer `Absolute` from type-fest over `{{aliasName}}`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-absolute"
+});
+var prefer_type_fest_absolute_default = preferTypeFestAbsoluteRule;
+
+// dist/rules/prefer-type-fest-abstract-constructor.js
+var import_ts_extras33 = require("ts-extras");
 var preferTypeFestAbstractConstructorRule = createTypedRule({
   create(context) {
     const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
@@ -6622,7 +6949,7 @@ var preferTypeFestAbstractConstructorRule = createTypedRule({
         if (!node.abstract) {
           return;
         }
-        const replacementFix = !(0, import_ts_extras32.isDefined)(node.typeParameters) && (0, import_ts_extras32.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "AbstractConstructor", `AbstractConstructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras32.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
+        const replacementFix = !(0, import_ts_extras33.isDefined)(node.typeParameters) && (0, import_ts_extras33.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "AbstractConstructor", `AbstractConstructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras33.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
         reportWithOptionalFix({
           context,
           fix: replacementFix,
@@ -7309,7 +7636,7 @@ var preferTypeFestConditionalPickRule = createTypedRule({
 var prefer_type_fest_conditional_pick_default = preferTypeFestConditionalPickRule;
 
 // dist/rules/prefer-type-fest-constructor.js
-var import_ts_extras33 = require("ts-extras");
+var import_ts_extras34 = require("ts-extras");
 var preferTypeFestConstructorRule = createTypedRule({
   create(context) {
     const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
@@ -7319,7 +7646,7 @@ var preferTypeFestConstructorRule = createTypedRule({
         if (node.abstract) {
           return;
         }
-        const replacementFix = !(0, import_ts_extras33.isDefined)(node.typeParameters) && (0, import_ts_extras33.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "Constructor", `Constructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras33.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
+        const replacementFix = !(0, import_ts_extras34.isDefined)(node.typeParameters) && (0, import_ts_extras34.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "Constructor", `Constructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras34.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
         reportWithOptionalFix({
           context,
           fix: replacementFix,
@@ -7940,14 +8267,14 @@ var preferTypeFestJsonPrimitiveRule = createTypedRule({
 var prefer_type_fest_json_primitive_default = preferTypeFestJsonPrimitiveRule;
 
 // dist/rules/prefer-type-fest-json-value.js
-var import_ts_extras34 = require("ts-extras");
+var import_ts_extras35 = require("ts-extras");
 var isStringLikeKeyType = (node) => node.type === "TSStringKeyword" || node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === "string";
 var 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 (0, import_ts_extras34.isDefined)(keyType) && (0, import_ts_extras34.isDefined)(valueType) && isStringLikeKeyType(keyType) && (valueType.type === "TSUnknownKeyword" || valueType.type === "TSAnyKeyword");
+  return (0, import_ts_extras35.isDefined)(keyType) && (0, import_ts_extras35.isDefined)(valueType) && isStringLikeKeyType(keyType) && (valueType.type === "TSUnknownKeyword" || valueType.type === "TSAnyKeyword");
 };
 var preferTypeFestJsonValueRule = createTypedRule({
   create(context) {
@@ -8297,7 +8624,7 @@ var preferTypeFestLessThanRule = createTypedRule({
 var prefer_type_fest_less_than_default = preferTypeFestLessThanRule;
 
 // dist/rules/prefer-type-fest-literal-union.js
-var import_ts_extras35 = require("ts-extras");
+var import_ts_extras36 = require("ts-extras");
 var literalUnionFamilies = [
   "bigint",
   "boolean",
@@ -8324,7 +8651,7 @@ var isLiteralMemberForFamily = (node, family) => {
     if (typeof node.literal.value === "bigint") {
       return true;
     }
-    const literalWithPotentialBigInt = (0, import_ts_extras35.safeCastTo)(node.literal);
+    const literalWithPotentialBigInt = (0, import_ts_extras36.safeCastTo)(node.literal);
     return typeof literalWithPotentialBigInt.bigint === "string";
   }
   if (family === "boolean") {
@@ -8363,7 +8690,7 @@ var getLiteralUnionReplacementText = (sourceCode, node, family) => {
   if (literalMembers.length === 0) {
     return null;
   }
-  const literalText = literalMembers.length === 1 ? sourceCode.getText((0, import_ts_extras35.arrayFirst)(literalMembers)) : (0, import_ts_extras35.arrayJoin)(literalMembers.map((member) => sourceCode.getText(member)), " | ");
+  const literalText = literalMembers.length === 1 ? sourceCode.getText((0, import_ts_extras36.arrayFirst)(literalMembers)) : (0, import_ts_extras36.arrayJoin)(literalMembers.map((member) => sourceCode.getText(member)), " | ");
   return `LiteralUnion<${literalText}, ${family}>`;
 };
 var preferTypeFestLiteralUnionRule = createTypedRule({
@@ -8629,6 +8956,51 @@ var preferTypeFestNonEmptyTupleRule = createTypedRule({
 });
 var prefer_type_fest_non_empty_tuple_default = preferTypeFestNonEmptyTupleRule;
 
+// dist/rules/prefer-type-fest-non-nullable-deep.js
+var preferTypeFestNonNullableDeepRule = 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 !== "DeepNonNullable") {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, "NonNullableDeep", typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix: aliasReplacementFix,
+          messageId: "preferNonNullableDeep",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest `NonNullableDeep` over `DeepNonNullable` 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-non-nullable-deep"
+    },
+    fixable: "code",
+    messages: {
+      preferNonNullableDeep: "Prefer `NonNullableDeep` from type-fest over `DeepNonNullable`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-non-nullable-deep"
+});
+var prefer_type_fest_non_nullable_deep_default = preferTypeFestNonNullableDeepRule;
+
 // dist/rules/prefer-type-fest-omit-index-signature.js
 var omitIndexSignatureAliasReplacements = {
   RemoveIndexSignature: "OmitIndexSignature"
@@ -8687,7 +9059,7 @@ var preferTypeFestOmitIndexSignatureRule = createTypedRule({
 var prefer_type_fest_omit_index_signature_default = preferTypeFestOmitIndexSignatureRule;
 
 // dist/rules/prefer-type-fest-optional.js
-var import_ts_extras36 = require("ts-extras");
+var import_ts_extras37 = require("ts-extras");
 var OPTIONAL_TYPE_NAME = "Optional";
 var EXCLUDE_TYPE_NAME = "Exclude";
 var NON_NULLABLE_TYPE_NAME = "NonNullable";
@@ -8741,8 +9113,8 @@ var preferTypeFestOptionalRule = createTypedRule({
         if (node.types.length !== 2) {
           return;
         }
-        const firstMember = (0, import_ts_extras36.arrayFirst)(node.types);
-        const secondMember = (0, import_ts_extras36.arrayAt)(node.types, 1);
+        const firstMember = (0, import_ts_extras37.arrayFirst)(node.types);
+        const secondMember = (0, import_ts_extras37.arrayAt)(node.types, 1);
         if (!firstMember || !secondMember) {
           return;
         }
@@ -8916,16 +9288,16 @@ var preferTypeFestPartialDeepRule = createTypedRule({
 var prefer_type_fest_partial_deep_default = preferTypeFestPartialDeepRule;
 
 // dist/rules/prefer-type-fest-pick-index-signature.js
-var import_ts_extras37 = require("ts-extras");
+var import_ts_extras38 = require("ts-extras");
 var isEmptyObjectTypeLiteral = (node) => node.type === "TSTypeLiteral" && node.members.length === 0;
 var hasPickIndexSignatureMappedTypeShape = (node) => {
   if (node.key.type !== "Identifier") {
     return false;
   }
-  if (node.readonly !== false && (0, import_ts_extras37.isDefined)(node.readonly)) {
+  if (node.readonly !== false && (0, import_ts_extras38.isDefined)(node.readonly)) {
     return false;
   }
-  if (node.optional !== false && (0, import_ts_extras37.isDefined)(node.optional)) {
+  if (node.optional !== false && (0, import_ts_extras38.isDefined)(node.optional)) {
     return false;
   }
   const constraint = node.constraint;
@@ -9063,7 +9435,7 @@ var preferTypeFestPrimitiveRule = createTypedRule({
 var prefer_type_fest_primitive_default = preferTypeFestPrimitiveRule;
 
 // dist/rules/prefer-type-fest-promisable.js
-var import_ts_extras38 = require("ts-extras");
+var import_ts_extras39 = require("ts-extras");
 var PROMISABLE_TYPE_NAME = "Promisable";
 var PROMISE_TYPE_NAME = "Promise";
 var promisableAliasReplacements = {
@@ -9079,10 +9451,10 @@ var getPromiseInnerType = (node) => {
     return null;
   }
   const typeArguments = node.typeArguments?.params;
-  if (!(0, import_ts_extras38.isDefined)(typeArguments)) {
+  if (!(0, import_ts_extras39.isDefined)(typeArguments)) {
     return null;
   }
-  return (0, import_ts_extras38.arrayFirst)(typeArguments) ?? null;
+  return (0, import_ts_extras39.arrayFirst)(typeArguments) ?? null;
 };
 var preferTypeFestPromisableRule = createTypedRule({
   create(context, [options] = defaultOptions3) {
@@ -9935,12 +10307,12 @@ var preferTypeFestSimplifyRule = createTypedRule({
 var prefer_type_fest_simplify_default = preferTypeFestSimplifyRule;
 
 // dist/rules/prefer-type-fest-stringified.js
-var import_ts_extras39 = require("ts-extras");
+var import_ts_extras40 = require("ts-extras");
 var hasStringifiedMappedTypeShape = (node) => {
-  if (node.readonly !== false && (0, import_ts_extras39.isDefined)(node.readonly)) {
+  if (node.readonly !== false && (0, import_ts_extras40.isDefined)(node.readonly)) {
     return false;
   }
-  if (node.optional !== false && (0, import_ts_extras39.isDefined)(node.optional)) {
+  if (node.optional !== false && (0, import_ts_extras40.isDefined)(node.optional)) {
     return false;
   }
   if (node.nameType !== null) {
@@ -10234,8 +10606,64 @@ var preferTypeFestTupleOfRule = createTypedRule({
 });
 var prefer_type_fest_tuple_of_default = preferTypeFestTupleOfRule;
 
+// dist/rules/prefer-type-fest-union-length.js
+var import_ts_extras41 = require("ts-extras");
+var preferTypeFestUnionLengthRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      TSIndexedAccessType(node) {
+        const { indexType, objectType } = node;
+        if (objectType.type !== "TSTypeReference" || objectType.typeName.type !== "Identifier" || objectType.typeName.name !== "UnionToTuple") {
+          return;
+        }
+        if (indexType.type !== "TSLiteralType" || indexType.literal.type !== "Literal" || indexType.literal.value !== "length") {
+          return;
+        }
+        const typeParams = objectType.typeArguments?.params;
+        if (typeParams?.length !== 1) {
+          return;
+        }
+        const typeArgText = context.sourceCode.getText((0, import_ts_extras41.arrayFirst)(typeParams));
+        const replacementText = `UnionLength<${typeArgText}>`;
+        const replacementFix = createSafeTypeNodeTextReplacementFix(node, "UnionLength", replacementText, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix: replacementFix,
+          messageId: "preferUnionLength",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest `UnionLength` over `UnionToTuple<T>['length']`.",
+      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-union-length"
+    },
+    fixable: "code",
+    messages: {
+      preferUnionLength: "Prefer `UnionLength<T>` from type-fest over `UnionToTuple<T>['length']`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-union-length"
+});
+var prefer_type_fest_union_length_default = preferTypeFestUnionLengthRule;
+
 // dist/rules/prefer-type-fest-union-member.js
-var import_ts_extras40 = require("ts-extras");
+var import_ts_extras42 = require("ts-extras");
 var UNION_MEMBER_TYPE_NAME = "UnionMember";
 var UNION_TO_INTERSECTION_TYPE_NAME = "UnionToIntersection";
 var IS_NEVER_TYPE_NAME = "IsNever";
@@ -10266,7 +10694,7 @@ var getUnionArgumentTextFromExtractor = ({ node, sourceCode }) => {
   if (!isIdentifierTypeReferenceNamed(node.checkType, UNION_TO_INTERSECTION_TYPE_NAME)) {
     return null;
   }
-  const extractorArgument = (0, import_ts_extras40.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  const extractorArgument = (0, import_ts_extras42.arrayFirst)(node.checkType.typeArguments?.params ?? []);
   if (!extractorArgument) {
     return null;
   }
@@ -10301,7 +10729,7 @@ var getUnionMemberEquivalentArgumentText = ({ node, sourceCode }) => {
   if (!isIdentifierTypeReferenceNamed(node.checkType, IS_NEVER_TYPE_NAME) || !isBooleanLiteralType(node.extendsType, true) || node.trueType.type !== "TSNeverKeyword") {
     return null;
   }
-  const guardedArgument = (0, import_ts_extras40.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  const guardedArgument = (0, import_ts_extras42.arrayFirst)(node.checkType.typeArguments?.params ?? []);
   if (!guardedArgument) {
     return null;
   }
@@ -11035,6 +11463,7 @@ var typefestRuleRegistry = {
   "prefer-ts-extras-as-writable": prefer_ts_extras_as_writable_default,
   "prefer-ts-extras-assert-defined": prefer_ts_extras_assert_defined_default,
   "prefer-ts-extras-assert-error": prefer_ts_extras_assert_error_default,
+  "prefer-ts-extras-assert-never": prefer_ts_extras_assert_never_default,
   "prefer-ts-extras-assert-present": prefer_ts_extras_assert_present_default,
   "prefer-ts-extras-is-defined": prefer_ts_extras_is_defined_default,
   "prefer-ts-extras-is-defined-filter": prefer_ts_extras_is_defined_filter_default,
@@ -11045,6 +11474,8 @@ var typefestRuleRegistry = {
   "prefer-ts-extras-is-integer": prefer_ts_extras_is_integer_default,
   "prefer-ts-extras-is-present": prefer_ts_extras_is_present_default,
   "prefer-ts-extras-is-present-filter": prefer_ts_extras_is_present_filter_default,
+  "prefer-ts-extras-is-property-defined": prefer_ts_extras_is_property_defined_default,
+  "prefer-ts-extras-is-property-present": prefer_ts_extras_is_property_present_default,
   "prefer-ts-extras-is-safe-integer": prefer_ts_extras_is_safe_integer_default,
   "prefer-ts-extras-key-in": prefer_ts_extras_key_in_default,
   "prefer-ts-extras-not": prefer_ts_extras_not_default,
@@ -11058,6 +11489,7 @@ var typefestRuleRegistry = {
   "prefer-ts-extras-safe-cast-to": prefer_ts_extras_safe_cast_to_default,
   "prefer-ts-extras-set-has": prefer_ts_extras_set_has_default,
   "prefer-ts-extras-string-split": prefer_ts_extras_string_split_default,
+  "prefer-type-fest-absolute": prefer_type_fest_absolute_default,
   "prefer-type-fest-abstract-constructor": prefer_type_fest_abstract_constructor_default,
   "prefer-type-fest-and-all": prefer_type_fest_and_all_default,
   "prefer-type-fest-array-length": prefer_type_fest_array_length_default,
@@ -11085,6 +11517,7 @@ var typefestRuleRegistry = {
   "prefer-type-fest-merge": prefer_type_fest_merge_default,
   "prefer-type-fest-merge-exclusive": prefer_type_fest_merge_exclusive_default,
   "prefer-type-fest-non-empty-tuple": prefer_type_fest_non_empty_tuple_default,
+  "prefer-type-fest-non-nullable-deep": prefer_type_fest_non_nullable_deep_default,
   "prefer-type-fest-omit-index-signature": prefer_type_fest_omit_index_signature_default,
   "prefer-type-fest-optional": prefer_type_fest_optional_default,
   "prefer-type-fest-or-all": prefer_type_fest_or_all_default,
@@ -11108,6 +11541,7 @@ var typefestRuleRegistry = {
   "prefer-type-fest-stringified": prefer_type_fest_stringified_default,
   "prefer-type-fest-tagged-brands": prefer_type_fest_tagged_brands_default,
   "prefer-type-fest-tuple-of": prefer_type_fest_tuple_of_default,
+  "prefer-type-fest-union-length": prefer_type_fest_union_length_default,
   "prefer-type-fest-union-member": prefer_type_fest_union_member_default,
   "prefer-type-fest-union-to-intersection": prefer_type_fest_union_to_intersection_default,
   "prefer-type-fest-union-to-tuple": prefer_type_fest_union_to_tuple_default,
@@ -11132,7 +11566,7 @@ function getPackageVersion(pkg) {
   const version = Reflect.get(pkg, "version");
   return typeof version === "string" ? version : "0.0.0";
 }
-var packageJsonValue = (0, import_ts_extras41.safeCastTo)(package_default);
+var packageJsonValue = (0, import_ts_extras43.safeCastTo)(package_default);
 var typeScriptParserValue = import_parser3.default;
 var defaultParserOptions = {
   ecmaVersion: "latest",
@@ -11140,10 +11574,10 @@ var defaultParserOptions = {
 };
 var normalizeParserOptions = (parserOptions) => parserOptions !== null && typeof parserOptions === "object" && !Array.isArray(parserOptions) ? { ...parserOptions } : { ...defaultParserOptions };
 var typefestEslintRules = typefestRules;
-var isTypefestRuleName = (value) => (0, import_ts_extras41.objectHasIn)(typefestRules, value);
+var isTypefestRuleName = (value) => (0, import_ts_extras43.objectHasIn)(typefestRules, value);
 var typefestRuleEntries = (() => {
   const entries = [];
-  for (const [ruleName] of (0, import_ts_extras41.objectEntries)(typefestRules)) {
+  for (const [ruleName] of (0, import_ts_extras43.objectEntries)(typefestRules)) {
     if (!isTypefestRuleName(ruleName)) {
       continue;
     }
@@ -11170,7 +11604,7 @@ var derivePresetRuleNamesByConfig = () => {
   const presetRuleNamesByConfig2 = createEmptyPresetRuleMap();
   for (const [ruleName] of typefestRuleEntries) {
     const configNames = rulePresetMembership[ruleName];
-    if (!(0, import_ts_extras41.isDefined)(configNames) || (0, import_ts_extras41.isEmpty)(configNames)) {
+    if (!(0, import_ts_extras43.isDefined)(configNames) || (0, import_ts_extras43.isEmpty)(configNames)) {
       throw new TypeError(`Rule '${ruleName}' is missing preset membership metadata.`);
     }
     for (const configName of configNames) {
@@ -11198,7 +11632,7 @@ function errorRulesFor(ruleNames) {
 var presetRuleNamesByConfig = derivePresetRuleNamesByConfig();
 var recommendedRuleNames = [];
 for (const ruleName of presetRuleNamesByConfig.recommended) {
-  if ((0, import_ts_extras41.setHas)(typeCheckedRuleNames, ruleName)) {
+  if ((0, import_ts_extras43.setHas)(typeCheckedRuleNames, ruleName)) {
     continue;
   }
   recommendedRuleNames.push(ruleName);
@@ -11220,7 +11654,7 @@ function withTypefestPlugin(config, plugin, options) {
   const existingLanguageOptions = config.languageOptions ?? {};
   const existingParserOptions = existingLanguageOptions["parserOptions"];
   const parserOptions = normalizeParserOptions(existingParserOptions);
-  if (options.requiresTypeChecking && !(0, import_ts_extras41.objectHasIn)(parserOptions, "projectService")) {
+  if (options.requiresTypeChecking && !(0, import_ts_extras43.objectHasIn)(parserOptions, "projectService")) {
     Reflect.set(parserOptions, "projectService", true);
   }
   const languageOptions = {