@travetto/runtime 7.0.0-rc.1 → 7.0.0-rc.3

package/src/watch.ts

@@ -1,11 +1,24 @@
+import { ManifestModuleUtil, type ChangeEventType, type ManifestModuleFileType } from '@travetto/manifest';
+
 import { RuntimeIndex } from './manifest-index.ts';
-import { ExecUtil } from './exec.ts';
 import { ShutdownManager } from './shutdown.ts';
 import { Util } from './util.ts';
+import { AppError } from './error.ts';
+
+type WatchEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
 
-export type WatchEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
+type WatchCompilerOptions = {
+  /**
+   * Restart the watch loop on compiler exit
+   */
+  restartOnCompilerExit?: boolean;
+  /**
+   * Run on restart
+   */
+  onRestart?: () => void;
+};
 
-export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: AbortSignal }): AsyncIterable<WatchEvent> {
+export async function* watchCompiler(config?: WatchCompilerOptions): AsyncIterable<WatchEvent> {
   // Load at runtime
   const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
 
@@ -16,24 +29,59 @@ export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: A
     info(message, ...args): void { console.error('info', message, ...args); },
   });
 
-  const ctrl = new AbortController();
-  const remove = ShutdownManager.onGracefulShutdown(async () => ctrl.abort());
+  const controller = new AbortController();
+  const remove = ShutdownManager.onGracefulShutdown(async () => controller.abort());
+
+  const maxIterations = 10;
+  const maxWindow = 10 * 1000;
+  const iterations: number[] = [];
+  let iterationsExhausted = false;
 
-  await client.waitForState(['compile-end', 'watch-start'], undefined, ctrl.signal);
+  while (
+    !controller.signal.aborted &&
+    !iterationsExhausted &&
+    (config?.restartOnCompilerExit || iterations.length === 0)
+  ) {
+    if (iterations.length) { // Wait on next iteration
+      await Util.nonBlockingTimeout(10);
+    }
+
+    await client.waitForState(['compile-end', 'watch-start'], undefined, controller.signal);
 
-  if (!await client.isWatching()) { // If we get here, without a watch
-    while (!await client.isWatching()) { // Wait until watch starts
-      await Util.nonBlockingTimeout(1000 * 60);
+    if (!await client.isWatching()) { // If we get here, without a watch
+      throw new AppError('Compiler is not running');
+    } else {
+      if (iterations.length) {
+        config?.onRestart?.();
+      }
+      yield* client.fetchEvents('change', { signal: controller.signal, enforceIteration: true });
+    }
+
+    iterations.push(Date.now());
+    if (iterations.length >= maxIterations) {
+      iterationsExhausted = (Date.now() - iterations[0]) > maxWindow;
+      iterations.shift();
     }
-  } else {
-    yield* client.fetchEvents('change', { signal: ctrl.signal, enforceIteration: true });
   }
 
   remove();
+}
+
+export function listenForSourceChanges(onChange: () => void, debounceDelay = 10): void {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+
+  const validFileTypes = new Set<ManifestModuleFileType>(['ts', 'js', 'package-json', 'typings']);
 
-  if (cfg?.restartOnExit) {
-    // We are done, request restart
-    await ShutdownManager.gracefulShutdown('@travetto/runtime:watchCompiler');
-    process.exit(ExecUtil.RESTART_EXIT_CODE);
+  function send(): void {
+    clearTimeout(timeout);
+    timeout = setTimeout(onChange, debounceDelay);
   }
+
+  (async function (): Promise<void> {
+    for await (const item of watchCompiler({ restartOnCompilerExit: true, onRestart: send })) {
+      if (validFileTypes.has(ManifestModuleUtil.getFileType(item.file)) && RuntimeIndex.findModuleForArbitraryFile(item.file)) {
+        send();
+      }
+    }
+  })();
 }

package/support/transformer/metadata.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import { FunctionMetadataTag } from '@travetto/runtime';
 import { CoreUtil, Import, SystemUtil, TransformerState } from '@travetto/transformer';
@@ -43,14 +43,14 @@ export class MetadataRegistrationUtil {
    */
   static registerFunction(state: TransformerState & MetadataInfo,
     node: ts.FunctionDeclaration | ts.FunctionExpression,
-    src?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
+    source?: ts.FunctionDeclaration | ts.FunctionExpression | ts.InterfaceDeclaration | ts.TypeAliasDeclaration
   ): void {
     // If we have a class like function
     state[RegisterImportSymbol] ??= state.importFile(this.REGISTER_IMPORT);
 
-    const tag = this.tag(state, src ?? node);
+    const tag = this.tag(state, source ?? node);
     const meta = state.factory.createCallExpression(
-      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      state.createAccess(state[RegisterImportSymbol].identifier, this.REGISTER_FN),
       [],
       [
         state.createIdentifier(node.name!.text),
@@ -74,7 +74,7 @@ export class MetadataRegistrationUtil {
     const name = node.name?.escapedText.toString() ?? '';
 
     const meta = state.factory.createCallExpression(
-      state.createAccess(state[RegisterImportSymbol].ident, this.REGISTER_FN),
+      state.createAccess(state[RegisterImportSymbol].identifier, this.REGISTER_FN),
       [],
       [
         state.createIdentifier(name),

package/support/transformer.concrete-type.ts

@@ -18,7 +18,7 @@ export class ConcreteTransformer {
   static #createConcreteFunction(state: TransformerState, name: string | ts.Identifier): ts.FunctionDeclaration {
     const final = typeof name === 'string' ? name : name.getText();
 
-    const dec = state.factory.createFunctionDeclaration(
+    const declaration = state.factory.createFunctionDeclaration(
       // eslint-disable-next-line no-bitwise
       state.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export | ts.ModifierFlags.Const),
       undefined, `${final}$Concrete`, [], [], undefined,
@@ -26,13 +26,13 @@ export class ConcreteTransformer {
     );
 
     state.addStatements([
-      dec,
+      declaration,
       state.factory.createExpressionStatement(
         state.factory.createCallExpression(
           state.createAccess('Object', 'defineProperty'),
           undefined,
           [
-            dec.name!,
+            declaration.name!,
             state.fromLiteral('name'),
             state.fromLiteral({ value: final })
           ]
@@ -40,7 +40,7 @@ export class ConcreteTransformer {
       )
     ]);
 
-    return dec;
+    return declaration;
   }
 
   /**

package/support/transformer.console-log.ts

@@ -83,26 +83,26 @@ export class ConsoleLogTransformer {
 
     const chain = node.expression;
     const name = chain.name;
-    const prop = chain.expression;
+    const expr = chain.expression;
 
-    if (!ts.isIdentifier(prop) || prop.escapedText !== 'console' || !ts.isIdentifier(name)) {
+    if (!ts.isIdentifier(expr) || expr.escapedText !== 'console' || !ts.isIdentifier(name)) {
       return node;
     }
 
     const level = name.escapedText!;
 
     if (VALID_LEVELS[level]) {
-      const ident = state.imported ??= state.importFile(CONSOLE_IMPORT).ident;
+      const identifier = state.imported ??= state.importFile(CONSOLE_IMPORT).identifier;
       return state.factory.updateCallExpression(
         node,
-        state.createAccess(ident, 'log'),
+        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(x => x.name).join(':'),
+            scope: state.scope?.map(part => part.name).join(':'),
             args: node.arguments.slice(0)
           }),
         ]

package/support/transformer.debug-method.ts

@@ -19,7 +19,7 @@ export class DebugEntryTransformer {
   @OnMethod('DebugBreak')
   static debugOnEntry(state: TransformerState & DebugState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (!state[DebugSymbol]) {
-      const imp = state.importFile('@travetto/runtime/src/debug.ts').ident;
+      const imp = state.importFile('@travetto/runtime/src/debug.ts').identifier;
       state[DebugSymbol] = CoreUtil.createAccess(state.factory, imp, 'tryDebugger');
     }
 

package/support/transformer.function-metadata.ts

@@ -52,9 +52,9 @@ export class RegisterTransformer {
       return node;
     }
 
-    const { [MethodsSymbol]: m, [ClassSymbol]: c } = state;
+    const { [MethodsSymbol]: method, [ClassSymbol]: cls } = state;
     delete state[ClassSymbol];
-    return MetadataRegistrationUtil.registerClass(state, node, c!, m);
+    return MetadataRegistrationUtil.registerClass(state, node, cls!, method);
   }
 
   /**

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

@@ -5,6 +5,9 @@ import { TransformerState, OnFile } from '@travetto/transformer';
 const PATH_REGEX = /^['"](node:)?path['"]$/;
 const PATH_IMPORT = '@travetto/manifest/src/path.ts';
 
+const isImport = (node: ts.Node): node is ts.ImportDeclaration =>
+  ts.isImportDeclaration(node) && PATH_REGEX.test(node.moduleSpecifier?.getText() ?? '');
+
 /**
  * Rewriting path imports to use manifest's path
  */
@@ -15,18 +18,17 @@ export class PathImportTransformer {
    */
   @OnFile()
   static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
-    const stmt = node.statements.find((x): x is ts.ImportDeclaration =>
-      ts.isImportDeclaration(x) && PATH_REGEX.test(x.moduleSpecifier?.getText() ?? ''));
-    if (stmt) {
+    const statement = node.statements.find(isImport);
+    if (statement) {
       const updated = state.factory.updateImportDeclaration(
-        stmt,
-        stmt.modifiers,
-        stmt.importClause,
+        statement,
+        statement.modifiers,
+        statement.importClause,
         state.factory.createStringLiteral(PATH_IMPORT),
-        stmt.attributes
+        statement.attributes
       );
-      return state.factory.updateSourceFile(node, node.statements.map(x =>
-        x === stmt ? updated : x
+      return state.factory.updateSourceFile(node, node.statements.map(item =>
+        item === statement ? updated : item
       ));
     }
     return node;