ts-codemod-lib 3.3.3 → 3.4.1

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.test.mts

@@ -391,6 +391,96 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('positions judged through parentheses and type wrappers', () => {
+    test.each([
+      {
+        name: 'a parenthesized read is still asserted',
+        source: 'console.log((xs[0]).toFixed());',
+        expected: 'console.log((xs[0]!).toFixed());',
+      },
+      {
+        name: 'parenthesized equality against undefined',
+        source: 'console.log((xs[0]) === undefined);',
+        expected: 'console.log((xs[0]) === undefined);',
+      },
+      {
+        name: 'parenthesized nullish coalescing',
+        source: 'console.log((xs[0]) ?? 0);',
+        expected: 'console.log((xs[0]) ?? 0);',
+      },
+      {
+        name: 'parenthesized optional property access',
+        source: 'console.log((xs[0])?.toFixed());',
+        expected: 'console.log((xs[0])?.toFixed());',
+      },
+      {
+        name: 'parenthesized if condition',
+        source: 'if ((xs[0])) { console.log(1); }',
+        expected: 'if ((xs[0])) { console.log(1); }',
+      },
+      {
+        name: 'parenthesized typeof operand',
+        source: 'console.log(typeof (xs[0]));',
+        expected: 'console.log(typeof (xs[0]));',
+      },
+      {
+        name: 'parenthesized negation operand',
+        source: 'console.log(!((xs[0])));',
+        expected: 'console.log(!((xs[0])));',
+      },
+      {
+        name: 'parenthesized existing non-null assertion',
+        source: 'console.log((xs[0])!.toFixed());',
+        expected: 'console.log((xs[0])!.toFixed());',
+      },
+      {
+        name: 'parenthesized type assertion',
+        source: 'console.log(((xs[0]) as number).toFixed());',
+        expected: 'console.log(((xs[0]) as number).toFixed());',
+      },
+      {
+        name: 'satisfies a type without undefined, which needs the assertion',
+        source: 'console.log(xs[0] satisfies number);',
+        expected: 'console.log(xs[0]! satisfies number);',
+      },
+      {
+        name: 'parenthesized satisfies a type without undefined',
+        source: 'console.log((xs[0]) satisfies number);',
+        expected: 'console.log((xs[0]!) satisfies number);',
+      },
+      {
+        name: 'satisfies a type with undefined, where the assertion is harmless',
+        source: 'console.log(xs[0] satisfies number | undefined);',
+        expected: 'console.log(xs[0]! satisfies number | undefined);',
+      },
+      {
+        name: 'parenthesized satisfies a type with undefined',
+        source: 'console.log((xs[0]) satisfies number | undefined);',
+        expected: 'console.log((xs[0]!) satisfies number | undefined);',
+      },
+      {
+        name: 'parenthesized compound assignment target',
+        source: '(mut_ys[0]) += 1;',
+        expected: '(mut_ys[0]) += 1;',
+      },
+      {
+        name: 'parenthesized assignment target',
+        source: '(mut_ys[0]) = 1;',
+        expected: '(mut_ys[0]) = 1;',
+      },
+      {
+        name: 'parenthesized delete target',
+        source: "delete (rec['a']);",
+        expected: "delete (rec['a']);",
+      },
+      {
+        name: 'parenthesized for-of loop target',
+        source: 'for ((mut_ys[0]) of xs) { break; }',
+        expected: 'for ((mut_ys[0]) of xs) { break; }',
+      },
+    ])('$name', testFn);
+  });
+
   describe('applyLevel: "avoidWhereUndefinedIsAllowed"', () => {
     test.each([
       {
@@ -541,6 +631,27 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     );
   });
 
+  test('an access under `satisfies` or in parentheses compiles once transformed', () => {
+    const source = dedent`
+      declare const xs: readonly number[];
+
+      export const a = xs[0] satisfies number;
+
+      export const b = (xs[0]) satisfies number;
+
+      export const c = (xs[0]).toFixed();
+
+      export const d = (xs[0]) === undefined ? 0 : (xs[0]) ?? 1;
+    `;
+
+    expect(diagnosticsUnderTheOption(source).length).toBeGreaterThan(0);
+
+    assert.deepStrictEqual(
+      diagnosticsUnderTheOption(transformInProject(source)),
+      [],
+    );
+  });
+
   test('array destructuring is left alone, since `!` has nowhere to go there', () => {
     const source = dedent`
       declare const xs: readonly number[];

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

@@ -1,5 +1,5 @@
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import {
   isAtomicTypeNode,
   isReadonlyTupleOrArrayTypeNode,

package/src/functions/ast-transformers/readonly-transformer-helpers/readonly-context.mts

@@ -1,5 +1,5 @@
 import { SafeUint, match } from 'ts-data-forge';
-import { type SafeUintWithSmallInt, type StrictExtract } from 'ts-type-forge';
+import type { SafeUintWithSmallInt, StrictExtract } from 'ts-type-forge';
 
 /**
  * Controls whether to make a layer mutable during recursive transformation

package/src/functions/ast-transformers/replace-any-with-unknown.mts

@@ -4,7 +4,7 @@ import {
   isSpreadNamedTupleMemberNode,
   isSpreadParameterNode,
 } from '../functions/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-any-with-unknown';
 

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -2,7 +2,7 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-record-with-unknown-record';
 

package/src/functions/ast-transformers/transform-source-code.mts

@@ -1,6 +1,6 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const fileIgnorePrefixes = [
   'transformer-ignore',

package/src/functions/functions/is-atomic-type-node.mts

@@ -1,6 +1,6 @@
 import { ISet } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 
 // Define the set of SyntaxKinds that represent primitive type keywords
 const atomicTypeKeywordKinds = ISet.create<tsm.SyntaxKind>([

package/src/functions/functions/is-readonly-node.mts

@@ -1,6 +1,6 @@
 import { Arr, expectType } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly, type StrictOmit } from 'ts-type-forge';
+import type { DeepReadonly, StrictOmit } from 'ts-type-forge';
 import { isAtomicTypeNode } from './is-atomic-type-node.mjs';
 
 export const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>

package/src/functions/functions/unwrap-readonly.mts

@@ -1,4 +1,4 @@
-import { type ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';
+import type { ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';
 import { wrapWithParentheses } from './wrap-with-parentheses.mjs';
 
 export const unwrapReadonlyTypeArgText = (