@travetto/transformer 7.0.0-rc.1 → 7.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -24,7 +24,7 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.0-rc.0",
+    "@travetto/manifest": "^7.0.0-rc.1",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3"
   },

package/src/importer.ts

@@ -9,7 +9,7 @@ import { Import } from './types/shared.ts';
 import { LiteralUtil } from './util/literal.ts';
 import { DeclarationUtil } from './util/declaration.ts';
 
-const D_OR_D_TS_EXT_RE = /[.]d([.]ts)?$/;
+const D_OR_D_TS_EXT_REGEX = /[.]d([.]ts)?$/;
 
 /**
  * Manages imports within a ts.SourceFile
@@ -19,7 +19,7 @@ export class ImportManager {
   #newImports = new Map<string, Import>();
   #imports: Map<string, Import>;
   #idx: Record<string, number> = {};
-  #ids = new Map<string, ts.Identifier>();
+  #identifiers = new Map<string, ts.Identifier>();
   #importName: string;
   #resolver: TransformResolver;
 
@@ -34,26 +34,26 @@ export class ImportManager {
     this.factory = factory;
   }
 
-  #rewriteImportClause(spec: ts.Expression | undefined, clause: ts.ImportClause | undefined): ts.ImportClause | undefined {
-    if (!(spec && clause?.namedBindings && ts.isNamedImports(clause.namedBindings))) {
+  #rewriteImportClause(expr: ts.Expression | undefined, clause: ts.ImportClause | undefined): ts.ImportClause | undefined {
+    if (!(expr && clause?.namedBindings && ts.isNamedImports(clause.namedBindings))) {
       return clause;
     }
 
-    if (spec && ts.isStringLiteral(spec) && !this.#isKnownImport(spec)) {
+    if (expr && ts.isStringLiteral(expr) && !this.#isKnownImport(expr)) {
       return clause;
     }
 
     const bindings = clause.namedBindings;
     const newBindings: ts.ImportSpecifier[] = [];
     // Remove all type only imports
-    for (const el of bindings.elements) {
-      if (!el.isTypeOnly) {
-        const type = this.#resolver.getType(el.name);
+    for (const element of bindings.elements) {
+      if (!element.isTypeOnly) {
+        const type = this.#resolver.getType(element.name);
         const objFlags = DeclarationUtil.getObjectFlags(type);
         const typeFlags = type.getFlags();
         // eslint-disable-next-line no-bitwise
         if (!(objFlags & (ts.SymbolFlags.Type | ts.SymbolFlags.Interface)) || !(typeFlags & ts.TypeFlags.Any)) {
-          newBindings.push(el);
+          newBindings.push(element);
         }
       }
     }
@@ -90,9 +90,9 @@ export class ImportManager {
   /**
    * Normalize module specifier
    */
-  normalizeModuleSpecifier<T extends ts.Expression | undefined>(spec: T): T {
-    if (spec && ts.isStringLiteral(spec) && this.#isKnownImport(spec.text)) {
-      const specText = spec.text.replace(/['"]/g, '');
+  normalizeModuleSpecifier<T extends ts.Expression | undefined>(specifier: T): T {
+    if (specifier && ts.isStringLiteral(specifier) && this.#isKnownImport(specifier.text)) {
+      const specText = specifier.text.replace(/['"]/g, '');
 
       const type = ManifestModuleUtil.getFileType(specText);
       if (type === 'js' || type === 'ts') {
@@ -103,23 +103,23 @@ export class ImportManager {
         return LiteralUtil.fromLiteral(this.factory, `${specText}${ManifestModuleUtil.OUTPUT_EXT}`) as unknown as T;
       }
     }
-    return spec;
+    return specifier;
   }
 
   /**
-   * Produces a unique ID for a given file
+   * Produces a unique identifier for a given file
    */
-  getId(file: string, name?: string): ts.Identifier {
-    if (!this.#ids.has(file)) {
+  getIdentifier(file: string, name?: string): ts.Identifier {
+    if (!this.#identifiers.has(file)) {
       if (name) {
-        this.#ids.set(file, this.factory.createIdentifier(name));
+        this.#identifiers.set(file, this.factory.createIdentifier(name));
       } else {
         const key = path.basename(file, path.extname(file)).replace(/\W+/g, '_');
         const suffix = this.#idx[key] = (this.#idx[key] ?? -1) + 1;
-        this.#ids.set(file, this.factory.createIdentifier(`Δ${key}${suffix ? suffix : ''}`));
+        this.#identifiers.set(file, this.factory.createIdentifier(`Δ${key}${suffix ? suffix : ''}`));
       }
     }
-    return this.#ids.get(file)!;
+    return this.#identifiers.get(file)!;
   }
 
   /**
@@ -134,18 +134,18 @@ export class ImportManager {
 
     // Allow for node classes to be imported directly
     if (/@types\/node\//.test(file)) {
-      file = PackageUtil.resolveImport(file.split('@types/node/')[1].replace(D_OR_D_TS_EXT_RE, ''));
+      file = PackageUtil.resolveImport(file.split('@types/node/')[1].replace(D_OR_D_TS_EXT_REGEX, ''));
     }
 
-    if (!D_OR_D_TS_EXT_RE.test(file) && !this.#newImports.has(file)) {
-      const ident = this.getId(file, name);
-      const uniqueName = ident.text;
+    if (!D_OR_D_TS_EXT_REGEX.test(file) && !this.#newImports.has(file)) {
+      const identifier = this.getIdentifier(file, name);
+      const uniqueName = identifier.text;
 
       if (this.#imports.has(uniqueName)) { // Already imported, be cool
         return this.#imports.get(uniqueName)!;
       }
 
-      const newImport = { path: file, ident };
+      const newImport = { path: file, identifier };
       this.#imports.set(uniqueName, newImport);
       this.#newImports.set(file, newImport);
     }
@@ -179,10 +179,10 @@ export class ImportManager {
     }
 
     try {
-      const importStmts = [...this.#newImports.values()].map(({ path: resolved, ident }) => {
+      const importStmts = [...this.#newImports.values()].map(({ path: resolved, identifier }) => {
         const importStmt = this.factory.createImportDeclaration(
           undefined,
-          this.factory.createImportClause(false, undefined, this.factory.createNamespaceImport(ident)),
+          this.factory.createImportClause(undefined, undefined, this.factory.createNamespaceImport(identifier)),
           this.factory.createStringLiteral(resolved)
         );
         return importStmt;
@@ -190,55 +190,55 @@ export class ImportManager {
 
       return CoreUtil.updateSource(this.factory, file, [
         ...importStmts,
-        ...file.statements.filter((x: ts.Statement & { remove?: boolean }) => !x.remove) // Exclude culled imports
+        ...file.statements.filter((node: ts.Statement & { remove?: boolean }) => !node.remove) // Exclude culled imports
       ]);
-    } catch (err) { // Missing import
-      if (!(err instanceof Error)) {
-        throw err;
+    } catch (error) { // Missing import
+      if (!(error instanceof Error)) {
+        throw error;
       }
-      const out = new Error(`${err.message} in ${file.fileName.replace(process.cwd(), '.')}`);
-      out.stack = err.stack;
+      const out = new Error(`${error.message} in ${file.fileName.replace(process.cwd(), '.')}`);
+      out.stack = error.stack;
       throw out;
     }
   }
 
-  finalizeImportExportExtension(ret: ts.SourceFile): ts.SourceFile {
+  finalizeImportExportExtension(source: ts.SourceFile): ts.SourceFile {
     const toAdd: ts.Statement[] = [];
 
-    for (const stmt of ret.statements) {
-      if (ts.isExportDeclaration(stmt)) {
-        if (!stmt.isTypeOnly) {
+    for (const statement of source.statements) {
+      if (ts.isExportDeclaration(statement)) {
+        if (!statement.isTypeOnly) {
           toAdd.push(this.factory.updateExportDeclaration(
-            stmt,
-            stmt.modifiers,
-            stmt.isTypeOnly,
-            stmt.exportClause,
-            this.normalizeModuleSpecifier(stmt.moduleSpecifier),
-            stmt.attributes
+            statement,
+            statement.modifiers,
+            statement.isTypeOnly,
+            statement.exportClause,
+            this.normalizeModuleSpecifier(statement.moduleSpecifier),
+            statement.attributes
           ));
         }
-      } else if (ts.isImportDeclaration(stmt)) {
-        if (!stmt.importClause?.isTypeOnly) {
+      } else if (ts.isImportDeclaration(statement)) {
+        if (statement.importClause?.phaseModifier !== ts.SyntaxKind.TypeKeyword) {
           toAdd.push(this.factory.updateImportDeclaration(
-            stmt,
-            stmt.modifiers,
-            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause)!,
-            this.normalizeModuleSpecifier(stmt.moduleSpecifier)!,
-            stmt.attributes
+            statement,
+            statement.modifiers,
+            this.#rewriteImportClause(statement.moduleSpecifier, statement.importClause)!,
+            this.normalizeModuleSpecifier(statement.moduleSpecifier)!,
+            statement.attributes
           ));
         }
       } else {
-        toAdd.push(stmt);
+        toAdd.push(statement);
       }
     }
-    return CoreUtil.updateSource(this.factory, ret, toAdd);
+    return CoreUtil.updateSource(this.factory, source, toAdd);
   }
 
   /**
    * Reset the imports into the source file
    */
-  finalize(src: ts.SourceFile): ts.SourceFile {
-    let node = this.finalizeNewImports(src) ?? src;
+  finalize(source: ts.SourceFile): ts.SourceFile {
+    let node = this.finalizeNewImports(source) ?? source;
     node = this.finalizeImportExportExtension(node) ?? node;
     return node;
   }
@@ -252,8 +252,8 @@ export class ImportManager {
     if (type.importName === this.#importName) {
       return factory.createIdentifier(targetName);
     } else {
-      const { ident } = this.#imports.get(type.importName) ?? this.importFile(type.importName);
-      return factory.createPropertyAccessExpression(ident, targetName);
+      const { identifier } = this.#imports.get(type.importName) ?? this.importFile(type.importName);
+      return factory.createPropertyAccessExpression(identifier, targetName);
     }
   }
 }

package/src/manager.ts

@@ -19,7 +19,7 @@ export class TransformerManager {
    * @returns
    */
   static async create(manifestIndex: ManifestIndex): Promise<TransformerManager> {
-    const transformerFiles = manifestIndex.find({ folder: f => f === '$transformer' }).map(f => f.sourceFile);
+    const transformerFiles = manifestIndex.find({ folder: folder => folder === '$transformer' }).map(file => file.sourceFile);
 
     const transformers: NodeTransformer<TransformerState>[] = [];
 
@@ -28,8 +28,13 @@ export class TransformerManager {
       transformers.push(...getAllTransformers(await import(ManifestModuleUtil.withOutputExtension(entry.import)), entry.module));
     }
 
-    for (const x of transformers) {
-      process.send?.({ type: 'log', payload: { level: 'debug', message: `Loaded Transformer: ${x.key}#${x.type}`, scope: 'transformers' } });
+    for (const transformer of transformers) {
+      process.send?.({
+        type: 'log', payload: {
+          level: 'debug',
+          message: `Loaded Transformer: ${transformer.key}#${transformer.type}`, scope: 'transformers'
+        }
+      });
     }
 
     // Prepare a new visitor factory with a given type checker
@@ -51,7 +56,7 @@ export class TransformerManager {
    */
   init(checker: ts.TypeChecker): void {
     const visitor = new VisitorFactory(
-      (ctx, src) => new TransformerState(src, ctx.factory, checker, this.#manifestIndex),
+      (ctx, source) => new TransformerState(source, ctx.factory, checker, this.#manifestIndex),
       this.#transformers
     );
 

package/src/register.ts

@@ -6,26 +6,26 @@ const HandlersSymbol = Symbol();
 
 type TransformerWithHandlers = Transformer & { [HandlersSymbol]?: NodeTransformer[] };
 
-function isTransformer(x: unknown): x is Transformer {
-  return x !== null && x !== undefined && typeof x === 'function';
+function isTransformer(value: unknown): value is Transformer {
+  return value !== null && value !== undefined && typeof value === 'function';
 }
 
 /**
  * Get all transformers
- * @param obj Object to search for transformers
+ * @param inputs Object to search for transformers
  */
-export function getAllTransformers(obj: Record<string, { [HandlersSymbol]?: NodeTransformer[] }>, module: string): NodeTransformer[] {
-  return Object.values(obj)
-    .flatMap(x => {
-      if (isTransformer(x)) {
-        x[ModuleNameSymbol] = module;
+export function getAllTransformers(inputs: Record<string, { [HandlersSymbol]?: NodeTransformer[] }>, module: string): NodeTransformer[] {
+  return Object.values(inputs)
+    .flatMap(value => {
+      if (isTransformer(value)) {
+        value[ModuleNameSymbol] = module;
       }
-      return (x[HandlersSymbol] ?? []);
+      return (value[HandlersSymbol] ?? []);
     })
     .map(handler => ({
       ...handler,
       key: `${module}:${handler.key}`,
-      target: handler.target?.map(t => `${module}:${t}`)
+      target: handler.target?.map(target => `${module}:${target}`)
     }));
 }
 
@@ -39,8 +39,8 @@ function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: Transfo
  */
 export function OnFile(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'file', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'file', target);
 }
 
 /**
@@ -48,8 +48,8 @@ export function OnFile(...target: string[]) {
  */
 export function AfterFile(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'file', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'file', target);
 }
 
 /**
@@ -57,8 +57,8 @@ export function AfterFile(...target: string[]) {
  */
 export function OnCall(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'call', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'call', target);
 }
 
 /**
@@ -66,8 +66,8 @@ export function OnCall(...target: string[]) {
  */
 export function OnFunction(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'function', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'function', target);
 }
 
 /**
@@ -75,8 +75,8 @@ export function OnFunction(...target: string[]) {
  */
 export function OnParameter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'parameter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'parameter', target);
 }
 
 /**
@@ -84,8 +84,8 @@ export function OnParameter(...target: string[]) {
  */
 export function OnProperty(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'property', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'property', target);
 }
 
 /**
@@ -93,8 +93,8 @@ export function OnProperty(...target: string[]) {
  */
 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>
-  ): void => storeHandler(inst, d.value!, 'before', 'getter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'getter', target);
 }
 
 /**
@@ -102,8 +102,8 @@ export function OnGetter(...target: string[]) {
  */
 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>
-  ): void => storeHandler(inst, d.value!, 'before', 'setter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'setter', target);
 }
 
 /**
@@ -111,8 +111,8 @@ export function OnSetter(...target: string[]) {
  */
 export function OnMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'method', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'method', target);
 }
 
 /**
@@ -120,8 +120,8 @@ export function OnMethod(...target: string[]) {
  */
 export function OnConstructor(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'constructor', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'constructor', target);
 }
 
 /**
@@ -129,8 +129,8 @@ export function OnConstructor(...target: string[]) {
  */
 export function OnStaticMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'static-method', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'static-method', target);
 }
 
 /**
@@ -138,8 +138,8 @@ export function OnStaticMethod(...target: string[]) {
  */
 export function OnClass(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'class', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'class', target);
 }
 
 /**
@@ -147,8 +147,8 @@ export function OnClass(...target: string[]) {
  */
 export function OnTypeAlias(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'type', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'type', target);
 }
 
 /**
@@ -156,8 +156,8 @@ export function OnTypeAlias(...target: string[]) {
  */
 export function OnInterface(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
-  ): void => storeHandler(inst, d.value!, 'before', 'interface', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'before', 'interface', target);
 }
 
 /**
@@ -165,8 +165,8 @@ export function OnInterface(...target: string[]) {
  */
 export function AfterCall(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'call', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'call', target);
 }
 
 /**
@@ -174,8 +174,8 @@ export function AfterCall(...target: string[]) {
  */
 export function AfterFunction(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'function', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'function', target);
 }
 
 /**
@@ -183,8 +183,8 @@ export function AfterFunction(...target: string[]) {
  */
 export function AfterParameter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'parameter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'parameter', target);
 }
 
 /**
@@ -192,8 +192,8 @@ export function AfterParameter(...target: string[]) {
  */
 export function AfterProperty(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'property', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'property', target);
 }
 
 /**
@@ -201,8 +201,8 @@ export function AfterProperty(...target: string[]) {
  */
 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>
-  ): void => storeHandler(inst, d.value!, 'after', 'getter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'getter', target);
 }
 
 /**
@@ -210,8 +210,8 @@ export function AfterGetter(...target: string[]) {
  */
 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>
-  ): void => storeHandler(inst, d.value!, 'after', 'setter', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'setter', target);
 }
 
 /**
@@ -219,8 +219,8 @@ export function AfterSetter(...target: string[]) {
  */
 export function AfterMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'method', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'method', target);
 }
 
 /**
@@ -228,8 +228,8 @@ export function AfterMethod(...target: string[]) {
  */
 export function AfterConstructor(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'constructor', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'constructor', target);
 }
 
 /**
@@ -237,8 +237,8 @@ export function AfterConstructor(...target: string[]) {
  */
 export function AfterStaticMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'static-method', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'static-method', target);
 }
 
 /**
@@ -246,8 +246,8 @@ export function AfterStaticMethod(...target: string[]) {
  */
 export function AfterClass(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'class', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'class', target);
 }
 
 
@@ -256,8 +256,8 @@ export function AfterClass(...target: string[]) {
  */
 export function AfterTypeAlias(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'type', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'type', target);
 }
 
 /**
@@ -265,6 +265,6 @@ export function AfterTypeAlias(...target: string[]) {
  */
 export function AfterInterface(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
-    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
-  ): void => storeHandler(inst, d.value!, 'after', 'interface', target);
+    inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
+  ): void => storeHandler(inst, descriptor.value!, 'after', 'interface', target);
 }