Clean up index.ts and parse-helper.ts

Author: gitKrystan

transforms/ember-object/index.ts

@@ -1,34 +1,34 @@
 import { getOptions } from 'codemod-cli';
 import type { Transform } from 'jscodeshift';
 import path from 'path';
-import type { Options } from '../helpers/options';
+import type { UserOptions } from '../helpers/options';
 import { DEFAULT_OPTIONS } from '../helpers/options';
-import { replaceEmberObjectExpressions } from '../helpers/parse-helper';
+import maybeTransformEmberObjects from '../helpers/transform';
 import { isRecord, verified } from '../helpers/util/types';
 
-const transformer: Transform = function (file, api) {
-  const extension = path.extname(file.path);
-
+const transformer: Transform = function (
+  { source, path: filePath },
+  { jscodeshift: j }
+) {
+  const extension = path.extname(filePath);
   if (!['.js', '.ts'].includes(extension.toLowerCase())) {
     // do nothing on non-js/ts files
     return;
   }
 
-  const j = api.jscodeshift;
-  const options = {
+  const userOptions: UserOptions = {
     ...DEFAULT_OPTIONS,
-    ...verified<Partial<Options>>(getOptions(), isRecord),
+    ...verified<Partial<UserOptions>>(getOptions(), isRecord),
   };
-  let { source } = file;
-
   const root = j(source);
+  const replaced = maybeTransformEmberObjects(j, root, filePath, userOptions);
 
-  const replaced = replaceEmberObjectExpressions(j, root, file.path, options);
   if (replaced) {
     source = root.toSource({
-      quote: options.quotes ?? options.quote,
+      quote: userOptions.quotes ?? userOptions.quote,
     });
   }
+
   return source;
 };
 

transforms/helpers/decorator-info.ts

@@ -2,25 +2,27 @@ import type { ImportSpecifier } from 'jscodeshift';
 import { assert } from './util/types';
 import { METHOD_DECORATORS } from './util/index';
 
-export interface DecoratorInfo {
+export interface DecoratorImportInfo {
   name: 'unobserves' | 'off' | 'className' | 'attribute' | string;
   importedName?: 'computed' | string;
   isImportedAs?: boolean;
   isMetaDecorator?: boolean;
   isMethodDecorator?: boolean;
   localName?: string;
 }
-
-export type ImportPropDecoratorMap = Record<string, DecoratorInfo>;
+export type DecoratorImportInfoMap = Map<
+  /** local name */ string,
+  DecoratorImportInfo
+>;
 
 /**
  * Return the decorator name for the specifier if any, using the importPropDecoratorMap from
  * `DECORATOR_PATHS` config (defined util.js)
  */
-export function getDecoratorInfo(
+export function getDecoratorImportInfo(
   specifier: ImportSpecifier,
   importPropDecoratorMap: Record<string, string> | undefined
-): DecoratorInfo {
+): DecoratorImportInfo {
   const localName = specifier.local?.name;
   const importedName = specifier.imported.name;
   const isImportedAs = importedName !== localName;

transforms/helpers/eo-prop/index.ts

@@ -1,5 +1,5 @@
 import type { Property } from 'jscodeshift';
-import type { ImportPropDecoratorMap } from '../decorator-info';
+import type { DecoratorImportInfoMap } from '../decorator-info';
 import type { RuntimeData } from '../runtime-data';
 import { assert } from '../util/types';
 import EOActionsObjectProp, {
@@ -41,13 +41,13 @@ export interface EOProps {
 export default function makeEOProp(
   eoProp: Property,
   runtimeData: RuntimeData | undefined,
-  importedDecoratedProps: ImportPropDecoratorMap
+  existingDecoratorImportInfos: DecoratorImportInfoMap
 ): EOProp {
   if (isCallExpressionProperty(eoProp)) {
     return new EOCallExpressionProp(
       eoProp,
       runtimeData,
-      importedDecoratedProps
+      existingDecoratorImportInfos
     );
   } else if (isFunctionExpressionProperty(eoProp)) {
     return new EOFunctionExpressionProp(eoProp, runtimeData);

transforms/helpers/eo-prop/private/abstract.ts

@@ -1,5 +1,5 @@
 import type { Property } from 'jscodeshift';
-import type { DecoratorInfo } from '../../decorator-info';
+import type { DecoratorImportInfo } from '../../decorator-info';
 import type { RuntimeData } from '../../runtime-data';
 import { getPropName } from '../../util/index';
 
@@ -19,7 +19,7 @@ export default abstract class AbstractEOProp<
 > {
   readonly _prop: P;
 
-  protected readonly decorators: DecoratorInfo[] = [];
+  protected readonly decorators: DecoratorImportInfo[] = [];
   readonly decoratorArgs: EODecoratorArgs = {};
 
   /** Runtime Data */

transforms/helpers/eo-prop/private/call-expression.ts

@@ -1,5 +1,5 @@
 import type { CallExpression, Identifier, Property } from 'jscodeshift';
-import type { ImportPropDecoratorMap } from '../../decorator-info';
+import type { DecoratorImportInfoMap } from '../../decorator-info';
 import type { RuntimeData } from '../../runtime-data';
 import { assert, isString, verified } from '../../util/types';
 import AbstractEOProp from './abstract';
@@ -46,7 +46,7 @@ export default class EOCallExpressionProp extends AbstractEOProp<
   constructor(
     eoProp: CallExpressionProperty,
     runtimeData: RuntimeData | undefined,
-    importedDecoratedProps: ImportPropDecoratorMap
+    existingDecoratorImportInfos: DecoratorImportInfoMap
   ) {
     super(eoProp, runtimeData);
 
@@ -64,9 +64,11 @@ export default class EOCallExpressionProp extends AbstractEOProp<
     this.modifiers = modifiers.reverse();
     this.modifiers.shift();
 
-    const decoratorInfo = importedDecoratedProps[this.calleeName];
-    if (decoratorInfo) {
-      this.decorators.push(decoratorInfo);
+    const decoratorImportInfo = existingDecoratorImportInfos.get(
+      this.calleeName
+    );
+    if (decoratorImportInfo) {
+      this.decorators.push(decoratorImportInfo);
     } else if (this.isComputed) {
       this.decorators.push({ name: this.calleeName });
     }

transforms/helpers/import-helper.ts

@@ -5,9 +5,9 @@ import type {
   ImportSpecifier,
   JSCodeshift,
 } from 'jscodeshift';
-import type { ImportPropDecoratorMap } from './decorator-info';
-import { getDecoratorInfo } from './decorator-info';
-import { DEFAULT_OPTIONS } from './options';
+import type { DecoratorImportInfoMap } from './decorator-info';
+import { getDecoratorImportInfo } from './decorator-info';
+import type { Options } from './options';
 import {
   createEmberDecoratorSpecifiers,
   createImportDeclaration,
@@ -99,8 +99,8 @@ function createNewImportDeclarations(
   root: Collection<unknown>,
   decoratorsToImport: string[],
   /** Already imported paths */
-  decoratorPathsToIgnore: string[] = [],
-  options = DEFAULT_OPTIONS
+  decoratorPathsToIgnore: string[],
+  options: Options
 ): void {
   const firstDeclaration = getFirstDeclaration(j, root);
 
@@ -263,8 +263,8 @@ function getExistingImportForPath(
 export function createDecoratorImportDeclarations(
   j: JSCodeshift,
   root: Collection<unknown>,
-  decoratorsToImport: string[] = [],
-  options = DEFAULT_OPTIONS
+  decoratorsToImport: string[],
+  options: Options
 ): void {
   // Iterate through existing imports, extract the already imported specifiers
   const decoratorPathSpecifierMap = getDecoratorPathSpecifiers(
@@ -304,13 +304,40 @@ export function createDecoratorImportDeclarations(
   );
 }
 
-/** Get decorated props from `import` statements */
-export function getImportedDecoratedProps(
+/**
+ * Get decorator import info from `import` statements
+ *
+ * e.g. For these imports:
+ * `import { observer as watcher, computed } from '@ember/object';`
+ *
+ * The returned value will be:
+ * ```
+ * {
+ *   watcher: {
+ *     name: "watcher",
+ *     importedName: "observer",
+ *     isImportedAs: true,
+ *     isMetaDecorator: false,
+ *     isMethodDecorator: true,
+ *     localName: "watcher",
+ *   },
+ *   computed: {
+ *     name: "computed",
+ *     importedName: "computed",
+ *     isImportedAs: false,
+ *     isMetaDecorator: false,
+ *     isMethodDecorator: false,
+ *     localName: "computed",
+ *   }
+ * }
+ * ```
+ */
+export function getDecoratorImportInfos(
   j: JSCodeshift,
   root: Collection<unknown>
-): ImportPropDecoratorMap {
+): DecoratorImportInfoMap {
   const existingDecoratorImports = getExistingDecoratorImports(j, root);
-  const importedDecorators: ImportPropDecoratorMap = {};
+  const decoratorImportInfo: DecoratorImportInfoMap = new Map();
 
   for (const decoratorImport of existingDecoratorImports) {
     const { importPropDecoratorMap } = defined(
@@ -325,13 +352,13 @@ export function getImportedDecoratedProps(
       if (isSpecifierDecorator(specifier, importPropDecoratorMap)) {
         const localName = specifier.local?.name;
         assert(localName, 'expected localName');
-        importedDecorators[localName] = getDecoratorInfo(
-          specifier,
-          importPropDecoratorMap
+        decoratorImportInfo.set(
+          localName,
+          getDecoratorImportInfo(specifier, importPropDecoratorMap)
         );
       }
     }
   }
 
-  return importedDecorators;
+  return decoratorImportInfo;
 }

transforms/helpers/options.ts

@@ -1,6 +1,6 @@
 import type { RuntimeData } from './runtime-data';
 
-export interface Options {
+export interface UserOptions {
   /** Enable/disable transformation using decorators */
   decorators: boolean;
   /** Enable/disable transformation using class fields */
@@ -12,11 +12,16 @@ export interface Options {
   quotes?: 'single' | 'double';
   /** Apply transformation to only passed type. */
   type?: 'services' | 'routes' | 'components' | 'controllers';
+}
+
+export interface PrivateOptions {
   /** @private */
-  runtimeData?: RuntimeData | undefined;
+  runtimeData: RuntimeData | undefined;
 }
 
-export const DEFAULT_OPTIONS: Options = {
+export type Options = UserOptions & PrivateOptions;
+
+export const DEFAULT_OPTIONS: UserOptions = {
   decorators: true,
   classFields: true,
   classicDecorator: true,