Re-org EOProp classes

Author: gitKrystan

transforms/helpers/ast.ts

@@ -31,7 +31,6 @@ import { LAYOUT_DECORATOR_NAME } from './util/index';
 import { isRecord } from './util/types';
 
 export type { ClassBodyBuilder } from 'ast-types/gen/builders';
-export type { CommentKind } from 'ast-types/gen/kinds';
 export type {
   ASTNode,
   CallExpression,

transforms/helpers/eo-extend-expression.ts

@@ -69,7 +69,7 @@ export default class EOExtendExpression {
         existingDecoratorImportInfos,
         options
       );
-      if ('isClassDecorator' in eoProp) {
+      if (eoProp.isClassDecorator) {
         decorators.push(eoProp);
       } else {
         properties.push(eoProp);

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

@@ -1,5 +1,4 @@
 import type {
-  CommentKind,
   Decorator,
   EOExpressionProp,
   EOMethod,
@@ -23,23 +22,33 @@ type EOPropValue = EOProperty['value'] | EOMethod;
  * A wrapper object for ember object properties
  */
 export default abstract class AbstractEOProp<P extends EOExpressionProp, B> {
-  readonly _prop: P & {
-    // ast-types missing these properties that exist on @babel/types
-    decorators?: Decorator[] | null;
-  };
+  abstract readonly isClassDecorator: boolean;
 
-  protected decorators: DecoratorImportInfo[] = [];
+  protected abstract readonly value: EOPropValue;
+
+  protected readonly key = this.rawProp.key;
+
+  protected readonly comments = this.rawProp.comments ?? null;
 
-  /** Runtime Data */
-  readonly runtimeData: RuntimeData;
-  private readonly runtimeType: string | undefined;
+  protected readonly existingDecorators = this.rawProp.decorators ?? null;
 
-  constructor(eoProp: P, protected readonly options: Options) {
-    this._prop = eoProp;
+  protected decorators: DecoratorImportInfo[] = [];
+
+  protected readonly runtimeData: RuntimeData;
 
+  /** Override to `true` if the property type supports object literal decorators. */
+  protected readonly supportsObjectLiteralDecorators: boolean = false;
+
+  constructor(
+    protected readonly rawProp: P & {
+      // ast-types missing these properties that exist on @babel/types
+      decorators?: Decorator[] | null;
+    },
+    protected readonly options: Options
+  ) {
     this.runtimeData = options.runtimeData;
     if (this.runtimeData.type) {
-      const { type, offProperties, unobservedProperties } = this.runtimeData;
+      const { offProperties, unobservedProperties } = this.runtimeData;
 
       const unobservedArgs = unobservedProperties[this.name];
       if (unobservedArgs) {
@@ -53,15 +62,12 @@ export default abstract class AbstractEOProp<P extends EOExpressionProp, B> {
       if (offArgs) {
         this.decorators.push({ name: 'off', args: offArgs });
       }
-      this.runtimeType = type;
     }
   }
 
-  // FIXME: Verify that everything on these classes is still needed
-  // FIXME: Verify access modifiers
-  abstract value: EOPropValue;
-
-  abstract build(): B;
+  get name(): string {
+    return this.key.name;
+  }
 
   /**
    * Get the map of decorators to import other than the computed props, services etc
@@ -81,75 +87,6 @@ export default abstract class AbstractEOProp<P extends EOExpressionProp, B> {
     };
   }
 
-  get type(): EOPropValue['type'] {
-    return this.value.type;
-  }
-
-  get key(): P['key'] {
-    return this._prop.key;
-  }
-
-  get name(): string {
-    return this._prop.key.name;
-  }
-
-  get comments(): CommentKind[] | null {
-    return this._prop.comments ?? null;
-  }
-
-  get computed(): boolean {
-    return this._prop.computed ?? false;
-  }
-
-  get isComputed(): boolean {
-    return this.runtimeData.computedProperties.includes(this.name);
-  }
-
-  get isOverridden(): boolean {
-    return this.runtimeData.overriddenProperties.includes(this.name);
-  }
-
-  get hasRuntimeData(): boolean {
-    return !!this.runtimeType;
-  }
-
-  get replaceSuperWithUndefined(): boolean {
-    return this.hasRuntimeData && !this.isOverridden;
-  }
-
-  get existingDecorators(): Decorator[] | null {
-    return this._prop.decorators ?? null;
-  }
-
-  get hasDecorators(): boolean {
-    return this.decorators.length > 0;
-  }
-
-  get hasUnobservesDecorator(): boolean {
-    return this.decorators.some((d) => d.name === 'unobserves');
-  }
-
-  get hasOffDecorator(): boolean {
-    return this.decorators.some((d) => d.name === 'off');
-  }
-
-  get hasMetaDecorator(): boolean {
-    return this.decorators.some((d) => d.isMetaDecorator);
-  }
-
-  /** Override to `true` if the property type supports object literal decorators. */
-  protected supportsObjectLiteralDecorators = false;
-
-  protected get needsDecorators(): boolean {
-    return this.hasExistingDecorators || this.hasDecorators;
-  }
-
-  private get hasExistingDecorators(): boolean {
-    return (
-      this.existingDecorators !== null && this.existingDecorators.length > 0
-    );
-  }
-
   get errors(): string[] {
     let errors: string[] = [];
 
@@ -164,7 +101,6 @@ export default abstract class AbstractEOProp<P extends EOExpressionProp, B> {
         );
       }
 
-      // FIXME: only include if existing decorators are supported?
       for (const decorator of this.existingDecorators) {
         const decoratorName = isNode(decorator.expression, 'Identifier')
           ? decorator.expression.name
@@ -205,17 +141,58 @@ export default abstract class AbstractEOProp<P extends EOExpressionProp, B> {
       );
     }
 
-    errors = [...errors, ...this._errors];
+    errors = [...errors, ...this.typeErrors];
 
     return errors;
   }
 
+  /** Returns the appropriate ClassBody member for the property type. */
+  abstract build(): B;
+
+  protected makeError(message: string): string {
+    return `[${this.name}]: Transform not supported - ${message}`;
+  }
+
   /** Override to add errors specific to the property type. */
-  protected get _errors(): string[] {
+  protected get typeErrors(): string[] {
     return [];
   }
 
-  protected makeError(message: string): string {
-    return `[${this.name}]: Transform not supported - ${message}`;
+  protected get type(): EOPropValue['type'] {
+    return this.value.type;
+  }
+
+  protected get isOverridden(): boolean {
+    return this.runtimeData.overriddenProperties.includes(this.name);
+  }
+
+  protected get replaceSuperWithUndefined(): boolean {
+    return this.hasRuntimeData && !this.isOverridden;
+  }
+
+  private get hasRuntimeData(): boolean {
+    return !!this.runtimeData.type;
+  }
+
+  protected get hasDecorators(): boolean {
+    return this.decorators.length > 0;
+  }
+
+  protected get needsDecorators(): boolean {
+    return this.hasExistingDecorators || this.hasDecorators;
+  }
+
+  private get hasUnobservesDecorator(): boolean {
+    return this.decorators.some((d) => d.name === 'unobserves');
+  }
+
+  private get hasOffDecorator(): boolean {
+    return this.decorators.some((d) => d.name === 'off');
+  }
+
+  private get hasExistingDecorators(): boolean {
+    return (
+      this.existingDecorators !== null && this.existingDecorators.length > 0
+    );
   }
 }

transforms/helpers/eo-prop/private/actions/index.ts

@@ -14,6 +14,17 @@ export default class EOActionsProp extends AbstractEOProp<
   EOPropertyWithActionsObject,
   ClassMethod[]
 > {
+  readonly isClassDecorator = false as const;
+
+  protected readonly value = this.rawProp.value;
+
+  override get decoratorImportSpecs(): DecoratorImportSpecs {
+    return {
+      ...super.decoratorImportSpecs,
+      action: true,
+    };
+  }
+
   /**
    * FIXME: Verify docs
    *
@@ -34,21 +45,14 @@ export default class EOActionsProp extends AbstractEOProp<
    * }
    * ```
    */
-  override build(): ClassMethod[] {
+  build(): ClassMethod[] {
     return this.actions.map((action) => {
       return action.build();
     });
   }
 
-  override get decoratorImportSpecs(): DecoratorImportSpecs {
-    return {
-      ...super.decoratorImportSpecs,
-      action: true,
-    };
-  }
-
-  get value(): EOPropertyWithActionsObject['value'] {
-    return this._prop.value;
+  protected override get typeErrors(): string[] {
+    return [...this.lifecycleHookErrors, ...this.infiniteLoopErrors];
   }
 
   private get actions(): Array<ActionProp | ActionMethod> {
@@ -59,10 +63,6 @@ export default class EOActionsProp extends AbstractEOProp<
     );
   }
 
-  protected override get _errors(): string[] {
-    return [...this.lifecycleHookErrors, ...this.infiniteLoopErrors];
-  }
-
   /**
    * Iterate over actions and verify that the action name does not match the lifecycle hooks
    * The transformation is not supported if an action has the same name as lifecycle hook

transforms/helpers/eo-prop/private/actions/method.ts

@@ -11,24 +11,6 @@ import EOMethodProp from '../method';
 import type { Action } from './index';
 
 export default class ActionMethod extends EOMethodProp implements Action {
-  override build(): ClassMethod {
-    return replaceActionSuperExpressions(
-      j.classMethod.from({
-        kind: this.kind,
-        key: this.key,
-        params: this.params,
-        body: this.body,
-        comments: this.comments,
-        decorators: buildActionDecorator(),
-      }),
-      this.replaceSuperWithUndefined
-    );
-  }
-
-  override get isOverridden(): boolean {
-    return this.runtimeData.overriddenActions.includes(this.name);
-  }
-
   get hasInfiniteLoop(): boolean {
     const { name, value } = this;
     const collection = j(value.body) as Collection;
@@ -52,4 +34,22 @@ export default class ActionMethod extends EOMethodProp implements Action {
 
     return actionLiterals.length > 0 || actionCalls.length > 0;
   }
+
+  override build(): ClassMethod {
+    return replaceActionSuperExpressions(
+      j.classMethod.from({
+        kind: this.kind,
+        key: this.key,
+        params: this.params,
+        body: this.body,
+        comments: this.comments,
+        decorators: buildActionDecorator(),
+      }),
+      this.replaceSuperWithUndefined
+    );
+  }
+
+  protected override get isOverridden(): boolean {
+    return this.runtimeData.overriddenActions.includes(this.name);
+  }
 }

transforms/helpers/eo-prop/private/actions/property.ts

@@ -8,11 +8,11 @@ export default class ActionProp
   extends AbstractEOProp<EOActionProperty, ClassMethod>
   implements Action
 {
-  hasInfiniteLoop = false;
+  readonly isClassDecorator = false as const;
 
-  get value(): EOActionProperty['value'] {
-    return this._prop.value;
-  }
+  readonly hasInfiniteLoop = false;
+
+  protected readonly value = this.rawProp.value;
 
   /**
    * Actions with identifier converted to method definition
@@ -41,7 +41,7 @@ export default class ActionProp
    * });
    * ```
    */
-  override build(): ClassMethod {
+  build(): ClassMethod {
     const body = j.blockStatement([
       j.returnStatement(
         j.callExpression(j.memberExpression(this.value, j.identifier('call')), [