@travetto/runtime 7.0.3 → 7.0.5

package/README.md

@@ -214,18 +214,18 @@ export function work() {
 ```javascript
 import * as Δfunction from "@travetto/runtime/src/function.js";
 import * as Δconsole from "@travetto/runtime/src/console.js";
-var mod_1 = ["@travetto/runtime", "doc/transpile.ts"];
+var Δm_1 = ["@travetto/runtime", "doc/transpile.ts"];
 export function work() {
-    Δconsole.log({ level: "debug", import: mod_1, line: 2, scope: "work", args: ['Start Work'] });
+    Δconsole.log({ level: "debug", import: Δm_1, line: 2, scope: "work", args: ['Start Work'] });
     try {
         1 / 0;
     }
     catch (error) {
-        Δconsole.log({ level: "error", import: mod_1, line: 7, scope: "work", args: ['Divide by zero', { error }] });
+        Δconsole.log({ level: "error", import: Δm_1, line: 7, scope: "work", args: ['Divide by zero', { error }] });
     }
-    Δconsole.log({ level: "debug", import: mod_1, line: 9, scope: "work", args: ['End Work'] });
+    Δconsole.log({ level: "debug", import: Δm_1, line: 9, scope: "work", args: ['End Work'] });
 }
-Δfunction.registerFunction(work, mod_1, { hash: 159357293, lines: [1, 10, 2] });
+Δfunction.registerFunction(work, Δm_1, { hash: 159357293, lines: [1, 10, 2] });
 ```
 
 #### Filtering Debug

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.0.3",
+  "version": "7.0.5",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,12 +26,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.2",
+    "@travetto/manifest": "^7.0.4",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.3"
+    "@travetto/transformer": "^7.0.5"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/binary.ts

@@ -8,7 +8,7 @@ import { ReadableStream } from 'node:stream/web';
 import { text as toText, arrayBuffer as toArrayBuffer } from 'node:stream/consumers';
 import { isArrayBuffer } from 'node:util/types';
 
-import { BinaryInput, BlobMeta, hasFunction } from './types.ts';
+import { type BinaryInput, type BlobMeta, hasFunction } from './types.ts';
 import { Util } from './util.ts';
 
 const BlobMetaSymbol = Symbol();

package/src/debug.ts

@@ -1,5 +1,5 @@
 import { Env } from './env.ts';
-import { ClassInstance } from './types.ts';
+import type { ClassInstance } from './types.ts';
 
 /**
  * The `@DebugBreak` indicates that a function inserts an optional debugger keyword to stop on entry

package/src/file-loader.ts

@@ -1,5 +1,5 @@
 import { createReadStream } from 'node:fs';
-import { Readable } from 'node:stream';
+import type { Readable } from 'node:stream';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 

package/src/json.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 
-import type { Any } from './types';
+import type { Any } from './types.ts';
 
 /**
  * JSON Utility functions

package/src/resources.ts

@@ -8,16 +8,16 @@ import { FileLoader } from './file-loader.ts';
 class $RuntimeResources extends FileLoader {
   #computed: string[];
   #env: string;
-  #mod: string;
+  #module: string;
 
   constructor() {
     super([]);
   }
 
   override get searchPaths(): readonly string[] {
-    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.value || this.#mod !== Env.TRV_MODULE.value) {
+    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.value || this.#module !== Env.TRV_MODULE.value) {
       this.#env = Env.TRV_RESOURCES.value!;
-      this.#mod = Env.TRV_MODULE.value!;
+      this.#module = Env.TRV_MODULE.value!;
       this.#computed = Runtime.resourcePaths();
     }
     return this.#computed;

package/src/types.ts

@@ -1,5 +1,5 @@
-import { Readable } from 'node:stream';
-import { ReadableStream } from 'node:stream/web';
+import type { Readable } from 'node:stream';
+import type { ReadableStream } from 'node:stream/web';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Any = any;

package/src/watch.ts

@@ -1,12 +1,12 @@
-import { ChildProcess } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
 
-import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler/support/types.ts';
+import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler';
 
-import { AppError } from './error';
-import { Util } from './util';
-import { RuntimeIndex } from './manifest-index';
-import { ShutdownManager } from './shutdown';
-import { castTo } from './types';
+import { AppError } from './error.ts';
+import { Util } from './util.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import { ShutdownManager } from './shutdown.ts';
+import { castTo } from './types.ts';
 
 type RetryRunState = {
   iteration: number;
@@ -115,7 +115,7 @@ export class WatchUtil {
     filter?: (input: T) => boolean,
     options?: Partial<RetryRunConfig>,
   ): Promise<void> {
-    const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
+    const { CompilerClient } = await import('@travetto/compiler/src/server/client.ts');
     const client = new CompilerClient(RuntimeIndex.manifest, console);
 
     return this.runWithRetry(async ({ signal }) => {

package/support/transformer/metadata.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 
-import { FunctionMetadataTag } from '@travetto/runtime';
-import { CoreUtil, Import, SystemUtil, TransformerState } from '@travetto/transformer';
+import { CoreUtil, type Import, SystemUtil, type TransformerState } from '@travetto/transformer';
+import { type FunctionMetadataTag } from '../../src/function.ts';
 
 const RegisterImportSymbol = Symbol();
 

package/support/transformer.concrete-type.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { TransformerState, OnInterface, OnCall, OnTypeAlias } from '@travetto/transformer';
+import { type TransformerState, TransformerHandler } from '@travetto/transformer';
 
 import { MetadataRegistrationUtil } from './transformer/metadata.ts';
 
@@ -11,6 +11,12 @@ const SRC = '@travetto/runtime/src/types.ts';
  */
 export class ConcreteTransformer {
 
+  static {
+    TransformerHandler(this, this.onInterface, 'before', 'interface');
+    TransformerHandler(this, this.onTypeAlias, 'before', 'type');
+    TransformerHandler(this, this.onToConcreteCall, 'before', 'call');
+  }
+
   static #isConcreteSimple(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration): boolean {
     return /^\s*[*]\s+@concrete\s*$/gm.test(node.getFullText());
   }
@@ -46,7 +52,6 @@ export class ConcreteTransformer {
   /**
    * Handle concrete interface
    */
-  @OnInterface()
   static onInterface(state: TransformerState, node: ts.InterfaceDeclaration): typeof node {
     if (this.#isConcreteSimple(node)) {
       const func = this.#createConcreteFunction(state, node.name);
@@ -58,7 +63,6 @@ export class ConcreteTransformer {
   /**
    * Handle type alias
    */
-  @OnTypeAlias()
   static onTypeAlias(state: TransformerState, node: ts.TypeAliasDeclaration): typeof node {
     if (this.#isConcreteSimple(node)) {
       const func = this.#createConcreteFunction(state, node.name);
@@ -67,7 +71,6 @@ export class ConcreteTransformer {
     return node;
   }
 
-  @OnCall()
   static onToConcreteCall(state: TransformerState, node: ts.CallExpression): typeof node {
     if (ts.isIdentifier(node.expression) && node.expression.text === 'toConcrete' && node.typeArguments?.length && node.arguments.length === 0) {
       const type = state.resolveType(node.expression);

package/support/transformer.console-log.ts

@@ -1,9 +1,6 @@
 import ts from 'typescript';
 
-import {
-  TransformerState, OnCall, LiteralUtil, OnClass, AfterClass, OnMethod, AfterMethod,
-  AfterFunction, OnFunction, OnStaticMethod, AfterStaticMethod
-} from '@travetto/transformer';
+import { type TransformerState, LiteralUtil, TransformerHandler } from '@travetto/transformer';
 
 const CONSOLE_IMPORT = '@travetto/runtime/src/console.ts';
 
@@ -25,25 +22,33 @@ const VALID_LEVELS: Record<string, string> = {
  */
 export class ConsoleLogTransformer {
 
+  static {
+    TransformerHandler(this, this.startClassForLog, 'before', 'class');
+    TransformerHandler(this, this.leaveClassForLog, 'after', 'class');
+    TransformerHandler(this, this.startMethodForLog, 'before', 'method');
+    TransformerHandler(this, this.startMethodForLog, 'before', 'static-method');
+    TransformerHandler(this, this.leaveMethodForLog, 'after', 'method');
+    TransformerHandler(this, this.leaveMethodForLog, 'after', 'static-method');
+    TransformerHandler(this, this.startFunctionForLog, 'before', 'function');
+    TransformerHandler(this, this.leaveFunctionForLog, 'after', 'function');
+    TransformerHandler(this, this.onLogCall, 'before', 'call');
+  }
+
   static initState(state: CustomState): void {
     state.scope = state.scope ?? [];
   }
 
-  @OnClass()
   static startClassForLog(state: CustomState, node: ts.ClassDeclaration): typeof node {
     this.initState(state);
     state.scope.push({ type: 'class', name: node.name?.text ?? 'unknown' });
     return node;
   }
 
-  @AfterClass()
   static leaveClassForLog(state: CustomState, node: ts.ClassDeclaration): typeof node {
     state.scope.pop();
     return node;
   }
 
-  @OnStaticMethod()
-  @OnMethod()
   static startMethodForLog(state: CustomState, node: ts.MethodDeclaration): typeof node {
     this.initState(state);
     let name = 'unknown';
@@ -54,27 +59,22 @@ export class ConsoleLogTransformer {
     return node;
   }
 
-  @AfterStaticMethod()
-  @AfterMethod()
   static leaveMethodForLog(state: CustomState, node: ts.MethodDeclaration): typeof node {
     state.scope.pop();
     return node;
   }
 
-  @OnFunction()
   static startFunctionForLog(state: CustomState, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
     this.initState(state);
     state.scope.push({ type: 'function', name: node.name?.text ?? 'unknown' });
     return node;
   }
 
-  @AfterFunction()
   static leaveFunctionForLog(state: CustomState, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
     state.scope.pop();
     return node;
   }
 
-  @OnCall()
   static onLogCall(state: CustomState, node: ts.CallExpression): typeof node | ts.Identifier {
     if (!ts.isPropertyAccessExpression(node.expression)) {
       return node;

package/support/transformer.debug-method.ts

@@ -1,6 +1,6 @@
-import ts from 'typescript';
+import type ts from 'typescript';
 
-import { TransformerState, OnMethod, CoreUtil } from '@travetto/transformer';
+import { type TransformerState, CoreUtil, TransformerHandler } from '@travetto/transformer';
 
 const DebugSymbol = Symbol();
 
@@ -16,7 +16,10 @@ interface DebugState {
  */
 export class DebugEntryTransformer {
 
-  @OnMethod('DebugBreak')
+  static {
+    TransformerHandler(this, this.debugOnEntry, 'before', 'method', ['DebugBreak']);
+  }
+
   static debugOnEntry(state: TransformerState & DebugState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (!state[DebugSymbol]) {
       const imp = state.importFile('@travetto/runtime/src/debug.ts').identifier;

package/support/transformer.dynamic-import.ts

@@ -1,13 +1,16 @@
 import ts from 'typescript';
 
-import { OnCall, TransformerState } from '@travetto/transformer';
+import { TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 /**
  * Dynamic Import Transformer
  */
 export class DynamicImportTransformer {
 
-  @OnCall()
+  static {
+    TransformerHandler(this, this.onCall, 'before', 'call');
+  }
+
   static onCall(state: TransformerState, node: ts.CallExpression): typeof node | ts.Identifier {
     if (
       ts.isCallExpression(node) &&

package/support/transformer.function-metadata.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { TransformerState, OnMethod, OnClass, AfterClass, CoreUtil, OnFunction } from '@travetto/transformer';
+import { type TransformerState, CoreUtil, TransformerHandler } from '@travetto/transformer';
 
 import type { FunctionMetadataTag } from '../src/function.ts';
 import { MetadataRegistrationUtil } from './transformer/metadata.ts';
@@ -18,10 +18,16 @@ interface MetadataInfo {
  */
 export class RegisterTransformer {
 
+  static {
+    TransformerHandler(this, this.collectClassMetadata, 'before', 'class');
+    TransformerHandler(this, this.collectMethodMetadata, 'before', 'method');
+    TransformerHandler(this, this.registerClassMetadata, 'after', 'class');
+    TransformerHandler(this, this.registerFunctionMetadata, 'before', 'function');
+  }
+
   /**
    * Hash each class
    */
-  @OnClass()
   static collectClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
     if (!MetadataRegistrationUtil.isValid(state)) {
       return node; // Exclude self
@@ -35,7 +41,6 @@ export class RegisterTransformer {
   /**
    * Hash each method
    */
-  @OnMethod()
   static collectMethodMetadata(state: TransformerState & MetadataInfo, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (state[ClassSymbol] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
       state[MethodsSymbol]![node.name.escapedText.toString()] = MetadataRegistrationUtil.tag(state, node);
@@ -46,7 +51,6 @@ export class RegisterTransformer {
   /**
    * After visiting each class, register all the collected metadata
    */
-  @AfterClass()
   static registerClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
     if (!state[ClassSymbol]) {
       return node;
@@ -60,7 +64,6 @@ export class RegisterTransformer {
   /**
    * Register proper functions
    */
-  @OnFunction()
   static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
     if (!MetadataRegistrationUtil.isValid(state) || !ts.isFunctionDeclaration(node)) {
       return node;

package/support/transformer.rewrite-path-import.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { TransformerState, OnFile } from '@travetto/transformer';
+import { type TransformerState, TransformerHandler } from '@travetto/transformer';
 
 const PATH_IMPORT = '@travetto/manifest/src/path.ts';
 
@@ -17,7 +17,10 @@ const isImport = (node: ts.Node): node is ts.ImportDeclaration =>
  */
 export class PathImportTransformer {
 
-  @OnFile()
+  static {
+    TransformerHandler(this, this.rewritePathImport, 'before', 'file');
+  }
+
   static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
     const statement = node.statements.find(isImport);
     if (statement) {