@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.d.ts

@@ -0,0 +1,97 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { ShorthandContext, SupportedProperty } from "./types.js";
+/**
+ * Checks whether a property can remain in shorthand form after replacement.
+ * @param context Property shorthand decision context.
+ * @returns True when shorthand syntax remains valid.
+ * @example
+ * ```typescript
+ * const keepShorthand = canUseShorthand(context);
+ * ```
+ */
+declare function canUseShorthand(context: ShorthandContext): boolean;
+/**
+ * Resolves the expression returned by the mock factory.
+ * @param factoryArgument Mock factory function expression.
+ * @returns Returned expression when one is present.
+ * @example
+ * ```typescript
+ * const returnExpression = getFactoryReturnExpression(factoryArgument);
+ * ```
+ */
+declare function getFactoryReturnExpression(factoryArgument: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression): TSESTree.Expression | undefined;
+/**
+ * Extracts the module specifier from a mock call argument.
+ * @param moduleArgument Import expression or string literal argument.
+ * @returns Static module specifier when it can be determined.
+ * @example
+ * ```typescript
+ * const moduleSpecifier = getModuleSpecifier(moduleArgument);
+ * ```
+ */
+declare function getModuleSpecifier(moduleArgument: TSESTree.Expression): string | undefined;
+/**
+ * Converts an object property key node into a stable string name.
+ * @param propertyKey Property key node from the object literal.
+ * @returns Property name when the key is statically known.
+ * @example
+ * ```typescript
+ * const propertyName = getPropertyName(property.key);
+ * ```
+ */
+declare function getPropertyName(propertyKey: TSESTree.PropertyName): string | undefined;
+/**
+ * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
+ * @param expression Expression to inspect.
+ * @returns True when at least one cast in the chain uses unknown or any as the type annotation.
+ * @example
+ * ```typescript
+ * const isEscapeHatch = hasEscapeHatchCast(expression);
+ * ```
+ */
+declare function hasEscapeHatchCast(expression: TSESTree.Expression): boolean;
+/**
+ * Narrows object literal elements to the subset the fixer can rewrite safely.
+ * @param property Object literal element to inspect.
+ * @returns True when the property is supported by the fixer.
+ * @example
+ * ```typescript
+ * const supported = isSupportedProperty(property);
+ * ```
+ */
+declare function isSupportedProperty(property: TSESTree.ObjectLiteralElement): property is SupportedProperty;
+/**
+ * Detects `vi.mock(...)` and `vi.doMock(...)` calls.
+ * @param node Call expression being inspected.
+ * @returns True when the call targets a Vitest mock factory.
+ * @example
+ * ```typescript
+ * const isMockCall = isVitestMockCall(callExpression);
+ * ```
+ */
+declare function isVitestMockCall(node: TSESTree.CallExpression): boolean;
+/**
+ * Determines whether the fixed object literal must be parenthesized.
+ * @param factoryArgument Mock factory function expression.
+ * @param returnExpression Expression returned by the factory.
+ * @param objectExpression Object literal being rewritten.
+ * @returns True when parentheses are required around the object literal.
+ * @example
+ * ```typescript
+ * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);
+ * ```
+ */
+declare function shouldWrapImplicitObject(factoryArgument: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression, returnExpression: TSESTree.Expression, objectExpression: TSESTree.ObjectExpression): boolean;
+/**
+ * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
+ * Removes surrounding cast wrappers from an expression.
+ * @param expression Expression to unwrap.
+ * @returns The innermost non-cast expression.
+ * @example
+ * ```typescript
+ * const baseExpression = unwrapExpression(expression);
+ * ```
+ */
+declare function unwrapExpression(expression: TSESTree.Expression): TSESTree.Expression;
+export { canUseShorthand, getFactoryReturnExpression, getModuleSpecifier, getPropertyName, hasEscapeHatchCast, isSupportedProperty, isVitestMockCall, shouldWrapImplicitObject, unwrapExpression, };
+//# sourceMappingURL=ast-helpers.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/ast-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;GAQG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAU3D;AAED;;;;;;;;GAQG;AACH,iBAAS,0BAA0B,CACjC,eAAe,EACX,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,kBAAkB,GAC9B,QAAQ,CAAC,UAAU,GAAG,SAAS,CAYjC;AAED;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CACzB,cAAc,EAAE,QAAQ,CAAC,UAAU,GAClC,MAAM,GAAG,SAAS,CAkBpB;AAED;;;;;;;;GAQG;AACH,iBAAS,eAAe,CACtB,WAAW,EAAE,QAAQ,CAAC,YAAY,GACjC,MAAM,GAAG,SAAS,CAapB;AAED;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,GAAG,OAAO,CAoBpE;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAC1B,QAAQ,EAAE,QAAQ,CAAC,oBAAoB,GACtC,QAAQ,IAAI,iBAAiB,CAQ/B;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,cAAc,GAAG,OAAO,CAahE;AAED;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,eAAe,EACX,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,kBAAkB,EAC/B,gBAAgB,EAAE,QAAQ,CAAC,UAAU,EACrC,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB,GAC1C,OAAO,CAMT;AAED;;;;;;;;;GASG;AACH,iBAAS,gBAAgB,CACvB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAC9B,QAAQ,CAAC,UAAU,CAYrB;AAED,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,GACjB,CAAC"}

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.js

@@ -0,0 +1,174 @@
+import { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Checks whether a property can remain in shorthand form after replacement.
+ * @param context Property shorthand decision context.
+ * @returns True when shorthand syntax remains valid.
+ * @example
+ * ```typescript
+ * const keepShorthand = canUseShorthand(context);
+ * ```
+ */
+function canUseShorthand(context) {
+    const { baseValue, keyName, needsCast, property } = context;
+    return (!needsCast &&
+        baseValue.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        property.key.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        property.key.name === keyName &&
+        baseValue.name === keyName);
+}
+/**
+ * Resolves the expression returned by the mock factory.
+ * @param factoryArgument Mock factory function expression.
+ * @returns Returned expression when one is present.
+ * @example
+ * ```typescript
+ * const returnExpression = getFactoryReturnExpression(factoryArgument);
+ * ```
+ */
+function getFactoryReturnExpression(factoryArgument) {
+    if (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement) {
+        return factoryArgument.body;
+    }
+    const returnStatement = factoryArgument.body.body.find((statement) => statement.type === TSESTree.AST_NODE_TYPES.ReturnStatement &&
+        statement.argument !== null);
+    return returnStatement?.argument ?? void 0;
+}
+/**
+ * Extracts the module specifier from a mock call argument.
+ * @param moduleArgument Import expression or string literal argument.
+ * @returns Static module specifier when it can be determined.
+ * @example
+ * ```typescript
+ * const moduleSpecifier = getModuleSpecifier(moduleArgument);
+ * ```
+ */
+function getModuleSpecifier(moduleArgument) {
+    if (moduleArgument.type === TSESTree.AST_NODE_TYPES.ImportExpression) {
+        const { source } = moduleArgument;
+        if (source.type === TSESTree.AST_NODE_TYPES.Literal &&
+            typeof source.value === "string") {
+            return source.value;
+        }
+        return void 0;
+    }
+    return moduleArgument.type === TSESTree.AST_NODE_TYPES.Literal &&
+        typeof moduleArgument.value === "string"
+        ? moduleArgument.value
+        : void 0;
+}
+/**
+ * Converts an object property key node into a stable string name.
+ * @param propertyKey Property key node from the object literal.
+ * @returns Property name when the key is statically known.
+ * @example
+ * ```typescript
+ * const propertyName = getPropertyName(property.key);
+ * ```
+ */
+function getPropertyName(propertyKey) {
+    if (propertyKey.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        return propertyKey.name;
+    }
+    if (propertyKey.type === TSESTree.AST_NODE_TYPES.Literal) {
+        return typeof propertyKey.value === "string" ||
+            typeof propertyKey.value === "number"
+            ? String(propertyKey.value)
+            : void 0;
+    }
+    return void 0;
+}
+/**
+ * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
+ * @param expression Expression to inspect.
+ * @returns True when at least one cast in the chain uses unknown or any as the type annotation.
+ * @example
+ * ```typescript
+ * const isEscapeHatch = hasEscapeHatchCast(expression);
+ * ```
+ */
+function hasEscapeHatchCast(expression) {
+    let current = expression;
+    while (current.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||
+        current.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion ||
+        current.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression) {
+        if (current.typeAnnotation.type ===
+            TSESTree.AST_NODE_TYPES.TSUnknownKeyword ||
+            current.typeAnnotation.type === TSESTree.AST_NODE_TYPES.TSAnyKeyword) {
+            return true;
+        }
+        current = current.expression;
+    }
+    return false;
+}
+/**
+ * Narrows object literal elements to the subset the fixer can rewrite safely.
+ * @param property Object literal element to inspect.
+ * @returns True when the property is supported by the fixer.
+ * @example
+ * ```typescript
+ * const supported = isSupportedProperty(property);
+ * ```
+ */
+function isSupportedProperty(property) {
+    return (property.type === TSESTree.AST_NODE_TYPES.Property &&
+        !property.computed &&
+        property.kind === "init" &&
+        !property.method &&
+        property.value.type !== TSESTree.AST_NODE_TYPES.AssignmentPattern);
+}
+/**
+ * Detects `vi.mock(...)` and `vi.doMock(...)` calls.
+ * @param node Call expression being inspected.
+ * @returns True when the call targets a Vitest mock factory.
+ * @example
+ * ```typescript
+ * const isMockCall = isVitestMockCall(callExpression);
+ * ```
+ */
+function isVitestMockCall(node) {
+    if (node.callee.type !== TSESTree.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const { object, property } = node.callee;
+    return (object.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        object.name === "vi" &&
+        property.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        (property.name === "mock" || property.name === "doMock"));
+}
+/**
+ * Determines whether the fixed object literal must be parenthesized.
+ * @param factoryArgument Mock factory function expression.
+ * @param returnExpression Expression returned by the factory.
+ * @param objectExpression Object literal being rewritten.
+ * @returns True when parentheses are required around the object literal.
+ * @example
+ * ```typescript
+ * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);
+ * ```
+ */
+function shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression) {
+    return (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement &&
+        (returnExpression.range[0] !== objectExpression.range[0] ||
+            returnExpression.range[1] !== objectExpression.range[1]));
+}
+/**
+ * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
+ * Removes surrounding cast wrappers from an expression.
+ * @param expression Expression to unwrap.
+ * @returns The innermost non-cast expression.
+ * @example
+ * ```typescript
+ * const baseExpression = unwrapExpression(expression);
+ * ```
+ */
+function unwrapExpression(expression) {
+    let currentExpression = expression;
+    while (currentExpression.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||
+        currentExpression.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression ||
+        currentExpression.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion) {
+        currentExpression = currentExpression.expression;
+    }
+    return currentExpression;
+}
+export { canUseShorthand, getFactoryReturnExpression, getModuleSpecifier, getPropertyName, hasEscapeHatchCast, isSupportedProperty, isVitestMockCall, shouldWrapImplicitObject, unwrapExpression, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ast-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/ast-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { TSESTree } from \"@typescript-eslint/utils\";\r\n\r\nimport type { ShorthandContext, SupportedProperty } from \"./types\";\r\n\r\n/**\r\n * Checks whether a property can remain in shorthand form after replacement.\r\n * @param context Property shorthand decision context.\r\n * @returns True when shorthand syntax remains valid.\r\n * @example\r\n * ```typescript\r\n * const keepShorthand = canUseShorthand(context);\r\n * ```\r\n */\r\nfunction canUseShorthand(context: ShorthandContext): boolean {\r\n  const { baseValue, keyName, needsCast, property } = context;\r\n\r\n  return (\r\n    !needsCast &&\r\n    baseValue.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    property.key.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    property.key.name === keyName &&\r\n    baseValue.name === keyName\r\n  );\r\n}\r\n\r\n/**\r\n * Resolves the expression returned by the mock factory.\r\n * @param factoryArgument Mock factory function expression.\r\n * @returns Returned expression when one is present.\r\n * @example\r\n * ```typescript\r\n * const returnExpression = getFactoryReturnExpression(factoryArgument);\r\n * ```\r\n */\r\nfunction getFactoryReturnExpression(\r\n  factoryArgument:\r\n    | TSESTree.ArrowFunctionExpression\r\n    | TSESTree.FunctionExpression,\r\n): TSESTree.Expression | undefined {\r\n  if (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement) {\r\n    return factoryArgument.body;\r\n  }\r\n\r\n  const returnStatement = factoryArgument.body.body.find(\r\n    (statement): statement is TSESTree.ReturnStatement =>\r\n      statement.type === TSESTree.AST_NODE_TYPES.ReturnStatement &&\r\n      statement.argument !== null,\r\n  );\r\n\r\n  return returnStatement?.argument ?? void 0;\r\n}\r\n\r\n/**\r\n * Extracts the module specifier from a mock call argument.\r\n * @param moduleArgument Import expression or string literal argument.\r\n * @returns Static module specifier when it can be determined.\r\n * @example\r\n * ```typescript\r\n * const moduleSpecifier = getModuleSpecifier(moduleArgument);\r\n * ```\r\n */\r\nfunction getModuleSpecifier(\r\n  moduleArgument: TSESTree.Expression,\r\n): string | undefined {\r\n  if (moduleArgument.type === TSESTree.AST_NODE_TYPES.ImportExpression) {\r\n    const { source } = moduleArgument;\r\n\r\n    if (\r\n      source.type === TSESTree.AST_NODE_TYPES.Literal &&\r\n      typeof source.value === \"string\"\r\n    ) {\r\n      return source.value;\r\n    }\r\n\r\n    return void 0;\r\n  }\r\n\r\n  return moduleArgument.type === TSESTree.AST_NODE_TYPES.Literal &&\r\n    typeof moduleArgument.value === \"string\"\r\n    ? moduleArgument.value\r\n    : void 0;\r\n}\r\n\r\n/**\r\n * Converts an object property key node into a stable string name.\r\n * @param propertyKey Property key node from the object literal.\r\n * @returns Property name when the key is statically known.\r\n * @example\r\n * ```typescript\r\n * const propertyName = getPropertyName(property.key);\r\n * ```\r\n */\r\nfunction getPropertyName(\r\n  propertyKey: TSESTree.PropertyName,\r\n): string | undefined {\r\n  if (propertyKey.type === TSESTree.AST_NODE_TYPES.Identifier) {\r\n    return propertyKey.name;\r\n  }\r\n\r\n  if (propertyKey.type === TSESTree.AST_NODE_TYPES.Literal) {\r\n    return typeof propertyKey.value === \"string\" ||\r\n      typeof propertyKey.value === \"number\"\r\n      ? String(propertyKey.value)\r\n      : void 0;\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.\r\n * @param expression Expression to inspect.\r\n * @returns True when at least one cast in the chain uses unknown or any as the type annotation.\r\n * @example\r\n * ```typescript\r\n * const isEscapeHatch = hasEscapeHatchCast(expression);\r\n * ```\r\n */\r\nfunction hasEscapeHatchCast(expression: TSESTree.Expression): boolean {\r\n  let current: TSESTree.Expression = expression;\r\n\r\n  while (\r\n    current.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||\r\n    current.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion ||\r\n    current.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression\r\n  ) {\r\n    if (\r\n      current.typeAnnotation.type ===\r\n        TSESTree.AST_NODE_TYPES.TSUnknownKeyword ||\r\n      current.typeAnnotation.type === TSESTree.AST_NODE_TYPES.TSAnyKeyword\r\n    ) {\r\n      return true;\r\n    }\r\n\r\n    current = current.expression;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\n/**\r\n * Narrows object literal elements to the subset the fixer can rewrite safely.\r\n * @param property Object literal element to inspect.\r\n * @returns True when the property is supported by the fixer.\r\n * @example\r\n * ```typescript\r\n * const supported = isSupportedProperty(property);\r\n * ```\r\n */\r\nfunction isSupportedProperty(\r\n  property: TSESTree.ObjectLiteralElement,\r\n): property is SupportedProperty {\r\n  return (\r\n    property.type === TSESTree.AST_NODE_TYPES.Property &&\r\n    !property.computed &&\r\n    property.kind === \"init\" &&\r\n    !property.method &&\r\n    property.value.type !== TSESTree.AST_NODE_TYPES.AssignmentPattern\r\n  );\r\n}\r\n\r\n/**\r\n * Detects `vi.mock(...)` and `vi.doMock(...)` calls.\r\n * @param node Call expression being inspected.\r\n * @returns True when the call targets a Vitest mock factory.\r\n * @example\r\n * ```typescript\r\n * const isMockCall = isVitestMockCall(callExpression);\r\n * ```\r\n */\r\nfunction isVitestMockCall(node: TSESTree.CallExpression): boolean {\r\n  if (node.callee.type !== TSESTree.AST_NODE_TYPES.MemberExpression) {\r\n    return false;\r\n  }\r\n\r\n  const { object, property } = node.callee;\r\n\r\n  return (\r\n    object.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    object.name === \"vi\" &&\r\n    property.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    (property.name === \"mock\" || property.name === \"doMock\")\r\n  );\r\n}\r\n\r\n/**\r\n * Determines whether the fixed object literal must be parenthesized.\r\n * @param factoryArgument Mock factory function expression.\r\n * @param returnExpression Expression returned by the factory.\r\n * @param objectExpression Object literal being rewritten.\r\n * @returns True when parentheses are required around the object literal.\r\n * @example\r\n * ```typescript\r\n * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);\r\n * ```\r\n */\r\nfunction shouldWrapImplicitObject(\r\n  factoryArgument:\r\n    | TSESTree.ArrowFunctionExpression\r\n    | TSESTree.FunctionExpression,\r\n  returnExpression: TSESTree.Expression,\r\n  objectExpression: TSESTree.ObjectExpression,\r\n): boolean {\r\n  return (\r\n    factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement &&\r\n    (returnExpression.range[0] !== objectExpression.range[0] ||\r\n      returnExpression.range[1] !== objectExpression.range[1])\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.\r\n * Removes surrounding cast wrappers from an expression.\r\n * @param expression Expression to unwrap.\r\n * @returns The innermost non-cast expression.\r\n * @example\r\n * ```typescript\r\n * const baseExpression = unwrapExpression(expression);\r\n * ```\r\n */\r\nfunction unwrapExpression(\r\n  expression: TSESTree.Expression,\r\n): TSESTree.Expression {\r\n  let currentExpression = expression;\r\n\r\n  while (\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression ||\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion\r\n  ) {\r\n    currentExpression = currentExpression.expression;\r\n  }\r\n\r\n  return currentExpression;\r\n}\r\n\r\nexport {\r\n  canUseShorthand,\r\n  getFactoryReturnExpression,\r\n  getModuleSpecifier,\r\n  getPropertyName,\r\n  hasEscapeHatchCast,\r\n  isSupportedProperty,\r\n  isVitestMockCall,\r\n  shouldWrapImplicitObject,\r\n  unwrapExpression,\r\n};\r\n"]}

package/dist/domain/testing/prefer-vitest-incremental-casts/index.d.ts

@@ -0,0 +1,2 @@
+export { preferVitestIncrementalCastsRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/prefer-vitest-incremental-casts/index.js

@@ -0,0 +1,2 @@
+export { preferVitestIncrementalCastsRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvcHJlZmVyLXZpdGVzdC1pbmNyZW1lbnRhbC1jYXN0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBwcmVmZXJWaXRlc3RJbmNyZW1lbnRhbENhc3RzUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

package/dist/domain/testing/prefer-vitest-incremental-casts/match-input.d.ts

@@ -0,0 +1,14 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { FactoryMatchInput } from "./types.js";
+/**
+ * Extracts the mock-factory inputs needed for a rewrite attempt.
+ * @param callExpression Call expression to inspect.
+ * @returns Normalized factory input when the call is supported.
+ * @example
+ * ```typescript
+ * const factoryInput = getFactoryMatchInput(callExpression);
+ * ```
+ */
+declare function getFactoryMatchInput(callExpression: TSESTree.CallExpression): FactoryMatchInput | undefined;
+export { getFactoryMatchInput };
+//# sourceMappingURL=match-input.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/match-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-input.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/match-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAEV,iBAAiB,EAElB,MAAM,SAAS,CAAC;AAgDjB;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAC3B,cAAc,EAAE,QAAQ,CAAC,cAAc,GACtC,iBAAiB,GAAG,SAAS,CAU/B;AA+CD,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/domain/testing/prefer-vitest-incremental-casts/match-input.js

@@ -0,0 +1,84 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { getFactoryReturnExpression, getModuleSpecifier, hasEscapeHatchCast, isVitestMockCall, unwrapExpression, } from "./ast-helpers.js";
+/**
+ * Builds normalized match input from a supported factory call.
+ * @param mockArguments Supported mock-call arguments.
+ * @returns Normalized factory input when the returned value is an object literal.
+ * @example
+ * ```typescript
+ * const factoryInput = buildFactoryMatchInput(mockArguments);
+ * ```
+ */
+function buildFactoryMatchInput(mockArguments) {
+    const { factoryArgument, moduleArgument } = mockArguments;
+    const moduleSpecifier = getModuleSpecifier(moduleArgument);
+    const returnExpression = getFactoryReturnExpression(factoryArgument);
+    if (moduleSpecifier === void 0 || returnExpression === void 0) {
+        return void 0;
+    }
+    const objectExpression = unwrapExpression(returnExpression);
+    if (objectExpression.type !== TSESTree.AST_NODE_TYPES.ObjectExpression ||
+        (returnExpression !== objectExpression &&
+            !hasEscapeHatchCast(returnExpression))) {
+        return void 0;
+    }
+    return {
+        factoryArgument,
+        moduleSpecifier,
+        objectExpression,
+        returnExpression,
+    };
+}
+/**
+ * Extracts the mock-factory inputs needed for a rewrite attempt.
+ * @param callExpression Call expression to inspect.
+ * @returns Normalized factory input when the call is supported.
+ * @example
+ * ```typescript
+ * const factoryInput = getFactoryMatchInput(callExpression);
+ * ```
+ */
+function getFactoryMatchInput(callExpression) {
+    if (!isVitestMockCall(callExpression)) {
+        return void 0;
+    }
+    const mockArguments = getMockFactoryArguments(callExpression.arguments);
+    return mockArguments === void 0
+        ? void 0
+        : buildFactoryMatchInput(mockArguments);
+}
+/**
+ * Extracts valid mock-factory arguments from a call expression.
+ * @param argumentsList Arguments supplied to the mock call.
+ * @returns Normalized arguments when the call shape is supported.
+ * @example
+ * ```typescript
+ * const mockArguments = getMockFactoryArguments(callExpression.arguments);
+ * ```
+ */
+function getMockFactoryArguments(argumentsList) {
+    const [moduleArgument, factoryArgument] = argumentsList;
+    if (moduleArgument === void 0 ||
+        factoryArgument === void 0 ||
+        moduleArgument.type === TSESTree.AST_NODE_TYPES.SpreadElement ||
+        factoryArgument.type === TSESTree.AST_NODE_TYPES.SpreadElement ||
+        !isFactoryFunctionExpression(factoryArgument)) {
+        return void 0;
+    }
+    return { factoryArgument, moduleArgument };
+}
+/**
+ * Determines whether an expression is a supported mock factory function.
+ * @param expression Expression to inspect.
+ * @returns True when the expression is a function compatible with the fixer.
+ * @example
+ * ```typescript
+ * const supported = isFactoryFunctionExpression(expression);
+ * ```
+ */
+function isFactoryFunctionExpression(expression) {
+    return (expression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ||
+        expression.type === TSESTree.AST_NODE_TYPES.FunctionExpression);
+}
+export { getFactoryMatchInput };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/prefer-vitest-incremental-casts/match.d.ts

@@ -0,0 +1,13 @@
+import type { CollectMatchContext, MatchResult } from "./types.js";
+/**
+ * Collects a fix match for a supported Vitest mock factory call.
+ * @param context Match collection context.
+ * @returns Match result when the object literal can be safely rewritten.
+ * @example
+ * ```typescript
+ * const match = collectMatch(context);
+ * ```
+ */
+declare function collectMatch(context: CollectMatchContext): MatchResult | undefined;
+export { collectMatch };
+//# sourceMappingURL=match.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,mBAAmB,EAEnB,WAAW,EAKZ,MAAM,SAAS,CAAC;AA2GjB;;;;;;;;GAQG;AACH,iBAAS,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,WAAW,GAAG,SAAS,CA+C3E;AAkHD,OAAO,EAAE,YAAY,EAAE,CAAC"}