@travetto/runtime 5.0.0-rc.10

package/support/transformer.console-log.ts

@@ -0,0 +1,112 @@
+import ts from 'typescript';
+
+import {
+  TransformerState, OnCall, LiteralUtil,
+  OnClass, AfterClass, OnMethod, AfterMethod, AfterFunction, OnFunction
+} from '@travetto/transformer';
+
+const CONSOLE_IMPORT = '@travetto/runtime/src/console';
+const MANIFEST_MOD = '@travetto/manifest';
+
+type CustomState = TransformerState & {
+  scope: { type: 'method' | 'class' | 'function', name: string }[];
+  imported?: ts.Identifier;
+};
+
+const VALID_LEVELS: Record<string, string> = {
+  log: 'info',
+  info: 'info',
+  debug: 'debug',
+  warn: 'warn',
+  error: 'error'
+};
+
+/**
+ * Logging support with code-location aware messages.
+ */
+export class ConsoleLogTransformer {
+
+  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;
+  }
+
+  @OnMethod()
+  static startMethodForLog(state: CustomState, node: ts.MethodDeclaration): typeof node {
+    this.initState(state);
+    let name = 'unknown';
+    if (ts.isIdentifier(node.name) || ts.isPrivateIdentifier(node.name)) {
+      name = node.name?.text ?? name;
+    }
+    state.scope.push({ type: 'method', name });
+    return node;
+  }
+
+  @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) || state.importName.startsWith(MANIFEST_MOD)) {
+      return node;
+    }
+
+    const chain = node.expression;
+    const name = chain.name;
+    const prop = chain.expression;
+
+    if (!ts.isIdentifier(prop) || prop.escapedText !== 'console' || !ts.isIdentifier(name)) {
+      return node;
+    }
+
+    const level = name.escapedText!;
+
+    if (VALID_LEVELS[level]) {
+      const ident = state.imported ??= state.importFile(CONSOLE_IMPORT, 'ᚕ_c').ident;
+      return state.factory.updateCallExpression(
+        node,
+        state.createAccess(ident, 'log'),
+        node.typeArguments,
+        [
+          LiteralUtil.fromLiteral(state.factory, {
+            level: state.factory.createStringLiteral(VALID_LEVELS[level]),
+            import: state.getModuleIdentifier(),
+            line: state.source.getLineAndCharacterOfPosition(node.getStart(state.source)).line + 1,
+            scope: state.scope?.map(x => x.name).join(':'),
+            args: node.arguments.slice(0)
+          }),
+        ]
+      );
+    } else {
+      return node;
+    }
+  }
+}

package/support/transformer.debug-method.ts

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+
+import { TransformerState, OnMethod, CoreUtil } from '@travetto/transformer';
+
+const DebugⲐ = Symbol.for('@travetto/runtime:debug');
+
+/**
+ * Debug transformation state
+ */
+interface DebugState {
+  [DebugⲐ]?: ts.Expression;
+}
+
+/**
+ * Add debugger-optional statement to methods that should be debuggable
+ */
+export class DebugEntryTransformer {
+
+  @OnMethod('DebugBreak')
+  static debugOnEntry(state: TransformerState & DebugState, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    if (!state[DebugⲐ]) {
+      const imp = state.importFile('@travetto/runtime/src/debug').ident;
+      state[DebugⲐ] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
+    }
+
+    return state.factory.updateMethodDeclaration(node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.questionToken,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.body ? state.factory.updateBlock(node.body, [
+        state.factory.createIfStatement(state[DebugⲐ]!,
+          state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))),
+        ...node.body.statements
+      ]) : node.body
+    );
+  }
+}

package/support/transformer.function-metadata.ts

@@ -0,0 +1,144 @@
+import ts from 'typescript';
+
+import {
+  TransformerState, OnMethod, OnClass, AfterClass,
+  CoreUtil, SystemUtil, Import, OnFunction
+} from '@travetto/transformer';
+
+import type { FunctionMetadataTag } from '../src/function';
+
+const RUNTIME_MOD = '@travetto/runtime';
+const RUNTIME_MOD_SRC = `${RUNTIME_MOD}/src`;
+const REGISTER_IMPORT = `${RUNTIME_MOD_SRC}/function`;
+
+const methods = Symbol.for(`${RUNTIME_MOD}:methods`);
+const cls = Symbol.for(`${RUNTIME_MOD}:class`);
+const fn = Symbol.for(`${RUNTIME_MOD}:function`);
+const registerImport = Symbol.for(`${RUNTIME_MOD}:registerImport`);
+const registerFn = 'registerFunction';
+
+interface MetadataInfo {
+  [registerImport]?: Import;
+  [methods]?: Record<string, FunctionMetadataTag>;
+  [cls]?: FunctionMetadataTag;
+  [fn]?: number;
+}
+
+/**
+ * Providing metadata for classes
+ */
+export class RegisterTransformer {
+
+  static #tag(state: TransformerState, node: ts.Node): FunctionMetadataTag {
+    const hash = SystemUtil.naiveHash(node.getText());
+    try {
+      const range = CoreUtil.getRangeOf(state.source, node) ?? [0, 0];
+      if (ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+        const bodyStart = CoreUtil.getRangeOf(state.source, node?.body?.statements[0])?.[0];
+        if (bodyStart) {
+          range.push(bodyStart);
+        }
+      }
+      return { hash, lines: range };
+    } catch {
+      return { hash, lines: [0, 0] };
+    }
+  }
+
+  static #valid({ importName: imp }: TransformerState): boolean {
+    return !imp.startsWith(REGISTER_IMPORT);
+  }
+
+  /**
+   * Hash each class
+   */
+  @OnClass()
+  static collectClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    if (!this.#valid(state)) {
+      return node; // Exclude self
+    }
+    state[cls] = this.#tag(state, node);
+    return node;
+  }
+
+  /**
+   * Hash each method
+   */
+  @OnMethod()
+  static collectMethodMetadata(state: TransformerState & MetadataInfo, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    if (state[cls] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
+      state[methods] ??= {};
+      state[methods]![node.name.escapedText.toString()] = this.#tag(state, node);
+    }
+    return node;
+  }
+
+  /**
+   * After visiting each class, register all the collected metadata
+   */
+  @AfterClass()
+  static registerClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    if (!state[cls]) {
+      return node;
+    }
+
+    state[registerImport] ??= state.importFile(REGISTER_IMPORT);
+
+    const name = node.name?.escapedText.toString() ?? '';
+
+    const meta = state.factory.createCallExpression(
+      state.createAccess(state[registerImport].ident, registerFn),
+      [],
+      [
+        state.createIdentifier(name),
+        state.getModuleIdentifier(),
+        state.fromLiteral(state[cls]),
+        state.extendObjectLiteral(state[methods] || {}),
+        state.fromLiteral(CoreUtil.isAbstract(node)),
+        state.fromLiteral(name.endsWith(TransformerState.SYNTHETIC_EXT))
+      ]
+    );
+
+    state[methods] = {};
+    delete state[cls];
+
+    return state.factory.updateClassDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      [
+        state.createStaticField('Ⲑinit', meta),
+        ...node.members
+      ]
+    );
+  }
+
+  /**
+   * Give proper functions a file name
+   */
+  @OnFunction()
+  static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
+    if (!this.#valid(state)) {
+      return node;
+    }
+
+    if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
+      // If we have a class like function
+      state[registerImport] ??= state.importFile(REGISTER_IMPORT);
+      const tag = this.#tag(state, node);
+      const meta = state.factory.createCallExpression(
+        state.createAccess(state[registerImport].ident, registerFn),
+        [],
+        [
+          state.createIdentifier(node.name),
+          state.getModuleIdentifier(),
+          state.fromLiteral(tag),
+        ]
+      );
+      state.addStatements([state.factory.createExpressionStatement(meta)]);
+    }
+    return node;
+  }
+}

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

@@ -0,0 +1,39 @@
+import ts from 'typescript';
+
+import { TransformerState, OnFile } from '@travetto/transformer';
+
+const PATH_REGEX = /^['"](node:)?path['"]$/;
+const PATH_TARGET = '@travetto/manifest/src/path';
+const SKIP_SRC = /^@travetto\/manifest\/(src|support)/;
+
+/**
+ * Rewriting path imports to use manifest's path
+ */
+export class PathImportTransformer {
+
+  /**
+   * Hash each class
+   */
+  @OnFile()
+  static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
+    if (SKIP_SRC.test(state.importName)) {
+      return node;
+    }
+
+    const stmt = node.statements.find((x): x is ts.ImportDeclaration =>
+      ts.isImportDeclaration(x) && PATH_REGEX.test(x.moduleSpecifier?.getText() ?? ''));
+    if (stmt) {
+      const updated = state.factory.updateImportDeclaration(
+        stmt,
+        stmt.modifiers,
+        stmt.importClause,
+        state.factory.createStringLiteral(PATH_TARGET),
+        stmt.attributes
+      );
+      return state.factory.updateSourceFile(node, node.statements.map(x =>
+        x === stmt ? updated : x
+      ));
+    }
+    return node;
+  }
+}

package/support/transformer.type-helpers.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+
+import { TransformerState, OnCall } from '@travetto/transformer';
+
+const SRC = '@travetto/runtime/src/types.ts';
+
+/**
+ * Allows for removal of type helpers at compile time
+ */
+export class TypeHelpersTransformer {
+  @OnCall()
+  static onTypeHelper(state: TransformerState, node: ts.CallExpression): ts.Node {
+    if (
+      ts.isIdentifier(node.expression) &&
+      node.arguments.length === 1 &&
+      /as(Class|Constructable|Full)|cast(To|Key)/.test(node.expression.escapedText.toString())
+    ) {
+      const type = state.resolveType(node.expression);
+      if (type.key === 'unknown' && 'importName' in type && type.importName === SRC) {
+        // return node.arguments[0];
+      }
+    }
+    return node;
+  }
+}