@travetto/runtime 8.0.0-alpha.9 → 8.0.0

package/support/transformer.concrete-type.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { type TransformerState, TransformerHandler } from '@travetto/transformer';
+import { TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 import { MetadataRegistrationUtil } from './transformer/metadata.ts';
 
@@ -10,7 +10,6 @@ const SRC = '@travetto/runtime/src/types.ts';
  * Providing support for concrete types
  */
 export class ConcreteTransformer {
-
   static {
     TransformerHandler(this, this.onInterface, 'before', 'interface');
     TransformerHandler(this, this.onTypeAlias, 'before', 'type');
@@ -25,24 +24,23 @@ export class ConcreteTransformer {
     const final = typeof name === 'string' ? name : name.getText();
 
     const declaration = state.factory.createFunctionDeclaration(
-      // eslint-disable-next-line no-bitwise
       state.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export | ts.ModifierFlags.Const),
-      undefined, `${final}$Concrete`, [], [], undefined,
+      undefined,
+      `${final}$Concrete`,
+      [],
+      [],
+      undefined,
       state.factory.createBlock([])
     );
 
     state.addStatements([
       declaration,
       state.factory.createExpressionStatement(
-        state.factory.createCallExpression(
-          state.createAccess('Object', 'defineProperty'),
-          undefined,
-          [
-            declaration.name!,
-            state.fromLiteral('name'),
-            state.fromLiteral({ value: final })
-          ]
-        )
+        state.factory.createCallExpression(state.createAccess('Object', 'defineProperty'), undefined, [
+          declaration.name!,
+          state.fromLiteral('name'),
+          state.fromLiteral({ value: final })
+        ])
       )
     ]);
 
@@ -72,19 +70,19 @@ export class ConcreteTransformer {
   }
 
   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) {
+    if (
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === 'toConcrete' &&
+      node.typeArguments?.length &&
+      node.arguments.length === 0
+    ) {
       const type = state.resolveType(node.expression);
       if ('importName' in type && type.importName === SRC) {
         const [target] = node.typeArguments;
-        return state.factory.updateCallExpression(
-          node,
-          node.expression,
-          node.typeArguments,
-          [state.getConcreteType(target)]
-        );
+        return state.factory.updateCallExpression(node, node.expression, node.typeArguments, [state.getConcreteType(target)]);
       }
     }
 
     return node;
   }
-}
+}

package/support/transformer.console-log.ts

@@ -1,11 +1,11 @@
 import ts from 'typescript';
 
-import { type TransformerState, LiteralUtil, TransformerHandler } from '@travetto/transformer';
+import { LiteralUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 const CONSOLE_IMPORT = '@travetto/runtime/src/console.ts';
 
 type CustomState = TransformerState & {
-  scope: { type: 'method' | 'class' | 'function', name: string }[];
+  scope: { type: 'method' | 'class' | 'function'; name: string }[];
   imported?: ts.Identifier;
 };
 
@@ -21,7 +21,6 @@ const VALID_LEVELS: Record<string, string> = {
  * Logging support with code-location aware messages.
  */
 export class ConsoleLogTransformer {
-
   static {
     TransformerHandler(this, this.startClassForLog, 'before', 'class');
     TransformerHandler(this, this.leaveClassForLog, 'after', 'class');
@@ -91,23 +90,18 @@ export class ConsoleLogTransformer {
     const level = name.escapedText!;
 
     if (VALID_LEVELS[level]) {
-      const identifier = state.imported ??= state.importFile(CONSOLE_IMPORT).identifier;
-      return state.factory.updateCallExpression(
-        node,
-        state.createAccess(identifier, '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(part => part.name).join(':'),
-            args: node.arguments.slice(0)
-          }),
-        ]
-      );
+      const identifier = (state.imported ??= state.importFile(CONSOLE_IMPORT).identifier);
+      return state.factory.updateCallExpression(node, state.createAccess(identifier, '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(part => part.name).join(':'),
+          args: node.arguments.slice(0)
+        })
+      ]);
     } else {
       return node;
     }
   }
-}
+}

package/support/transformer.debug-method.ts

@@ -1,6 +1,6 @@
 import type ts from 'typescript';
 
-import { type TransformerState, CoreUtil, TransformerHandler } from '@travetto/transformer';
+import { CoreUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 const DebugSymbol = Symbol();
 
@@ -15,7 +15,6 @@ interface DebugState {
  * Add debugger-optional statement to methods that should be debuggable
  */
 export class DebugEntryTransformer {
-
   static {
     TransformerHandler(this, this.debugOnEntry, 'before', 'method', ['DebugBreak']);
   }
@@ -26,7 +25,8 @@ export class DebugEntryTransformer {
       state[DebugSymbol] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
     }
 
-    return state.factory.updateMethodDeclaration(node,
+    return state.factory.updateMethodDeclaration(
+      node,
       node.modifiers,
       node.asteriskToken,
       node.name,
@@ -34,11 +34,15 @@ export class DebugEntryTransformer {
       node.typeParameters,
       node.parameters,
       node.type,
-      node.body ? state.factory.updateBlock(node.body, [
-        state.factory.createIfStatement(state[DebugSymbol]!,
-          state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))),
-        ...node.body.statements
-      ]) : node.body
+      node.body
+        ? state.factory.updateBlock(node.body, [
+            state.factory.createIfStatement(
+              state[DebugSymbol]!,
+              state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))
+            ),
+            ...node.body.statements
+          ])
+        : node.body
     );
   }
-}
+}

package/support/transformer.dynamic-import.ts

@@ -6,7 +6,6 @@ import { TransformerHandler, type TransformerState } from '@travetto/transformer
  * Dynamic Import Transformer
  */
 export class DynamicImportTransformer {
-
   static {
     TransformerHandler(this, this.onCall, 'before', 'call');
   }
@@ -25,4 +24,4 @@ export class DynamicImportTransformer {
     }
     return node;
   }
-}
+}

package/support/transformer.function-metadata.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { type TransformerState, CoreUtil, TransformerHandler } from '@travetto/transformer';
+import { CoreUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 import type { FunctionMetadataTag } from '../src/function.ts';
 import { MetadataRegistrationUtil } from './transformer/metadata.ts';
@@ -17,7 +17,6 @@ interface MetadataInfo {
  * Providing metadata for classes
  */
 export class RegisterTransformer {
-
   static {
     TransformerHandler(this, this.collectClassMetadata, 'before', 'class');
     TransformerHandler(this, this.collectMethodMetadata, 'before', 'method');
@@ -64,7 +63,10 @@ export class RegisterTransformer {
   /**
    * Register proper functions
    */
-  static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
+  static registerFunctionMetadata(
+    state: TransformerState & MetadataInfo,
+    node: ts.FunctionDeclaration | ts.FunctionExpression
+  ): typeof node {
     if (!MetadataRegistrationUtil.isValid(state) || !ts.isFunctionDeclaration(node)) {
       return node;
     }
@@ -74,4 +76,4 @@ export class RegisterTransformer {
     }
     return node;
   }
-}
+}

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

@@ -1,22 +1,18 @@
 import ts from 'typescript';
 
-import { type TransformerState, TransformerHandler } from '@travetto/transformer';
+import { TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 const PATH_IMPORT = '@travetto/manifest/src/path.ts';
 
 const isImport = (node: ts.Node): node is ts.ImportDeclaration =>
-  ts.isImportDeclaration(node)
-  && ts.isStringLiteral(node.moduleSpecifier)
-  && (
-    node.moduleSpecifier.text === 'node:path'
-    || node.moduleSpecifier.text === 'path'
-  );
+  ts.isImportDeclaration(node) &&
+  ts.isStringLiteral(node.moduleSpecifier) &&
+  (node.moduleSpecifier.text === 'node:path' || node.moduleSpecifier.text === 'path');
 
 /**
  * Rewriting path imports to use manifest's path
  */
 export class PathImportTransformer {
-
   static {
     TransformerHandler(this, this.rewritePathImport, 'before', 'file');
   }
@@ -31,10 +27,11 @@ export class PathImportTransformer {
         state.factory.createStringLiteral(PATH_IMPORT),
         statement.attributes
       );
-      return state.factory.updateSourceFile(node, node.statements.map(item =>
-        item === statement ? updated : item
-      ));
+      return state.factory.updateSourceFile(
+        node,
+        node.statements.map(item => (item === statement ? updated : item))
+      );
     }
     return node;
   }
-}
+}