ts-codemod-lib 3.5.0 → 4.0.0

package/src/functions/ast-transformers/readonly-transformer-helpers/group-union-types.mts

@@ -22,6 +22,11 @@ import {
  * member that `Readonly` still means something to (see `staysOutsideReadonly`):
  * taking such a member out of the `Readonly` it was written under would drop
  * its readonly-ness.
+ *
+ * `keptUnwrapped` names the further type literals the caller leaves unwrapped
+ * (one with a property of an ignored prefix, such as `mut_`), which stay out of
+ * that group as one with a call or construct signature does — except under a
+ * `Readonly` intersection with a member that may be an array.
  */
 export const groupUnionIntersectionTypes = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -30,10 +35,13 @@ export const groupUnionIntersectionTypes = (
     operator,
     underReadonly,
     deepReadonlyTypeName,
+    keptUnwrapped = () => false,
   }: Readonly<{
     operator: '&' | '|';
     underReadonly: boolean;
     deepReadonlyTypeName: string;
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    keptUnwrapped?: (node: tsm.TypeLiteralNode) => boolean;
   }>,
 ): Readonly<{
   primitives:
@@ -109,6 +117,28 @@ export const groupUnionIntersectionTypes = (
     others: undefined,
   };
 
+  // Taking a literal out of `Readonly<A & { mut_x: X }>` leaves
+  // `Readonly<A> & { mut_x: X }`, which is another type when `A` may be an
+  // array (see `isMergeableReadonlyTypeReferenceNode`). So `keptUnwrapped` is
+  // honoured under `Readonly<... & ...>` only when every member that stays
+  // under it is an object type.
+  const honoursKeptUnwrapped =
+    !underReadonly ||
+    operator === '|' ||
+    types.every((t_) => {
+      const t = removeParentheses(t_);
+
+      return (
+        isAtomicTypeNode(t) ||
+        t.isKind(tsm.SyntaxKind.ArrayType) ||
+        t.isKind(tsm.SyntaxKind.TupleType) ||
+        isReadonlyTupleOrArrayTypeNode(t) ||
+        t.isKind(tsm.SyntaxKind.TypeLiteral) ||
+        isMergeableReadonlyTypeReferenceNode(t, operator) ||
+        staysOutsideReadonly(t, deepReadonlyTypeName)
+      );
+    });
+
   for (const [i, t_] of types.entries()) {
     const t = removeParentheses(t_);
 
@@ -143,14 +173,15 @@ export const groupUnionIntersectionTypes = (
       continue;
     }
 
-    // A type literal that declares a call or construct signature is deliberately
-    // not grouped here: this group is joined and wrapped in a single
-    // `Readonly<...>`, which such a literal does not survive. It falls through
-    // to `others`, which leaves it as written. See
+    // A type literal that declares a call or construct signature, or one the
+    // caller keeps unwrapped, is deliberately not grouped here: this group is
+    // joined and wrapped in a single `Readonly<...>`, which such a literal does
+    // not survive. It falls through to `others`, which leaves it as written. See
     // `hasCallOrConstructSignature`.
     if (
       (t.isKind(tsm.SyntaxKind.TypeLiteral) &&
-        !hasCallOrConstructSignature(t)) ||
+        !hasCallOrConstructSignature(t) &&
+        !(honoursKeptUnwrapped && keptUnwrapped(t))) ||
       isMergeableReadonlyTypeReferenceNode(t, operator) ||
       (underReadonly && !staysOutsideReadonly(t, deepReadonlyTypeName))
     ) {

package/src/functions/constants/index.mts

@@ -1 +1,2 @@
 export * from './ignore-comment-text.mjs';
+export * from './mutable-prefixes.mjs';

package/src/functions/constants/mutable-prefixes.mts

@@ -0,0 +1,28 @@
+/**
+ * The default `mutableVariablePrefixes` and `mutablePropertyPrefixes` of the
+ * transformers: a name that starts with one of these is left mutable. A
+ * private name (`#mut_x`) is matched with or after its `#`.
+ *
+ * The ESLint counterpart is `ignoredMutablePattern` in
+ * `libs/eslint-config-typed/src/rules/eslint-functional-rules.mts` (and, for a
+ * property, the `ignoreAccessorPattern` of `functional/immutable-data` there);
+ * `libs/eslint-config-typed/src/rules/eslint-functional-rules.test.mts` fails
+ * when the two differ; it reads this package's `dist/`, so build first.
+ */
+export const DEFAULT_MUTABLE_PREFIXES: readonly string[] = Object.freeze([
+  'mut_',
+]);
+
+/**
+ * The default `mutableTypePrefixes` of the transformers: a type alias, an
+ * interface or a class whose name starts with one of these is left mutable,
+ * and `append-as-const` adds no `as const` where the value has to be
+ * assignable to it (an annotated variable, `satisfies`, an arrow's return).
+ * `Mutable` suits the PascalCase of type names; `mut_` is accepted as for
+ * variables. No ESLint rule reads type names, so there is no counterpart to
+ * keep in step.
+ */
+export const DEFAULT_MUTABLE_TYPE_PREFIXES: readonly string[] = Object.freeze([
+  'Mutable',
+  'mut_',
+]);