@travetto/transformer 2.0.1 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/transformer",
   "displayName": "Transformation",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -25,7 +25,7 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/base": "^2.0.1"
+    "@travetto/base": "^2.1.0"
   },
   "publishConfig": {
     "access": "public"

package/src/register.ts

@@ -59,6 +59,24 @@ export function OnProperty(...target: string[]) {
   ) => storeHandler(inst, d.value!, 'before', 'property', target);
 }
 
+/**
+ * Listens for a `ts.GetAccessorDeclaration`, on descent
+ */
+export function OnGetter(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ) => storeHandler(inst, d.value!, 'before', 'getter', target);
+}
+
+/**
+ * Listens for a `ts.SetAccessorDeclaration`, on descent
+ */
+export function OnSetter(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ) => storeHandler(inst, d.value!, 'before', 'setter', target);
+}
+
 /**
  * Listens for a `ts.MethodDeclaration`, on descent
  */
@@ -122,6 +140,24 @@ export function AfterProperty(...target: string[]) {
   ) => storeHandler(inst, d.value!, 'after', 'property', target);
 }
 
+/**
+ * Listens for a `ts.GetAccessorDeclaration`, on ascent
+ */
+export function AfterGetter(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ) => storeHandler(inst, d.value!, 'after', 'getter', target);
+}
+
+/**
+ * Listens for a `ts.SetAccessorDeclaration`, on ascent
+ */
+export function AfterSetter(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ) => storeHandler(inst, d.value!, 'after', 'setter', target);
+}
+
 /**
  * Listens for a `ts.MethodDeclaration`, on ascent
  */

package/src/resolver/builder.ts

@@ -64,6 +64,8 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type): { catego
     const source = DeclarationUtil.getPrimaryDeclarationNode(resolvedType).getSourceFile();
     if (source?.fileName.includes('@types/node/globals') || source?.fileName.includes('typescript/lib')) {
       return { category: 'literal', type };
+    } else if (!source?.fileName.includes('@travetto') && source?.fileName.endsWith('.d.ts')) {
+      return { category: 'unknown', type };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
     } else {
@@ -178,13 +180,13 @@ export const TypeBuilder: {
       const name = CoreUtil.getSymbol(alias ?? type);
       const source = DeclarationUtil.getPrimaryDeclarationNode(type)?.getSourceFile();
       for (const member of checker.getPropertiesOfType(type)) {
-        const memberType = checker.getType(
-          DeclarationUtil.getPrimaryDeclarationNode(member)
-        );
-        if (memberType.getCallSignatures().length) {
-          continue;
+        const dec = DeclarationUtil.getPrimaryDeclarationNode(member);
+        if (DeclarationUtil.isPublic(dec)) { // If public
+          const memberType = checker.getType(dec);
+          if (!memberType.getCallSignatures().length) { // if not a function
+            fieldNodes[member.getName()] = memberType;
+          }
         }
-        fieldNodes[member.getName()] = memberType;
       }
       return {
         key: 'shape', name: name?.getName(),

package/src/types/visitor.ts

@@ -22,7 +22,7 @@ export type State = {
 
 export type TransformPhase = 'before' | 'after';
 
-export type TransformerType = 'class' | 'method' | 'property' | 'parameter' | 'static-method' | 'call' | 'function';
+export type TransformerType = 'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' | 'static-method' | 'call' | 'function';
 
 export const TransformerId = Symbol.for('@trv:transformer/id');
 

package/src/util/declaration.ts

@@ -60,4 +60,29 @@ export class DeclarationUtil {
     // @ts-ignore
     return ts.getObjectFlags(type);
   }
+
+  /**
+   * Get accessor pair based off of passing in one in
+   *
+   * @param node
+   * @returns
+   */
+  static getAccessorPair(node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration) {
+    const acc = { getter: ts.isGetAccessorDeclaration(node) ? node : undefined, setter: ts.isSetAccessorDeclaration(node) ? node : undefined };
+    if (ts.isClassDeclaration(node.parent)) {
+      for (const el of node.parent.members) {
+        if (el.name && el.name.getText() === node.name.getText()) {
+          if (ts.isGetAccessor(el)) {
+            acc.getter = el;
+          } else if (ts.isSetAccessor(el)) {
+            acc.setter = el;
+          }
+          if (acc.getter && acc.setter) {
+            return acc;
+          }
+        }
+      }
+    }
+    return acc;
+  }
 }

package/src/visitor.ts

@@ -30,6 +30,10 @@ export class VisitorFactory<S extends State = State> {
       return 'parameter';
     } else if (ts.isFunctionDeclaration(node) || (ts.isFunctionExpression(node) && !ts.isArrowFunction(node))) {
       return 'function';
+    } else if (ts.isGetAccessor(node)) {
+      return 'getter';
+    } else if (ts.isSetAccessor(node)) {
+      return 'setter';
     }
   }