@travetto/runtime 8.0.0-alpha.14 → 8.0.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "8.0.0-alpha.14",
+  "version": "8.0.0-alpha.17",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,17 +26,20 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^8.0.0-alpha.7",
+    "@travetto/manifest": "^8.0.0-alpha.8",
     "@types/debug": "^4.1.13",
-    "debug": "^4.4.3",
-    "temporal-polyfill-lite": "^0.3.4"
+    "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.10"
+    "@travetto/transformer": "^8.0.0-alpha.11",
+    "temporal-polyfill-lite": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {
       "optional": true
+    },
+    "temporal-polyfill-lite": {
+      "optional": true
     }
   },
   "travetto": {

package/src/codec.ts

@@ -85,7 +85,10 @@ export class CodecUtil {
   /** Consume lines  */
   static async readLines(stream: BinaryType, handler: (input: string) => unknown | Promise<unknown>): Promise<void> {
     for await (const item of createInterface(BinaryUtil.toReadable(stream))) {
-      await handler(item);
+      const result = await handler(item);
+      if (result === false) {
+        break;
+      }
     }
   }
 
@@ -102,4 +105,19 @@ export class CodecUtil {
     return BinaryUtil.isBinaryArray(chunk) ? chunk :
       Buffer.from(typeof chunk === 'string' ? chunk : `${chunk}`, castTo(encoding ?? 'utf8'));
   }
+
+  static readFirstLine(data: string): string;
+  static readFirstLine(data: string | undefined, defaultValue: string): string;
+  static readFirstLine(data: string | undefined, defaultValue: string = ''): string {
+    if (typeof data === 'undefined') {
+      return defaultValue;
+    } else {
+      const end = data.indexOf('\n');
+      if (end === -1) {
+        return data.trim();
+      } else {
+        return data.substring(0, end).trim();
+      }
+    }
+  }
 }

package/src/exec.ts

@@ -40,6 +40,18 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  */
 export class ExecUtil {
 
+  /** Read stream as string from a result */
+  static toString(result: ExecutionResult<BinaryArray | string>, stream: 'stdout' | 'stderr' | 'any'): string {
+    if (stream === 'any') {
+      return this.toString(result, 'stderr') || this.toString(result, 'stdout');
+    }
+    const value = result[stream];
+    if (typeof value === 'string') {
+      return value.trim();
+    }
+    return CodecUtil.toUTF8String(value).trim();
+  }
+
   /**
    * Take a child process, and some additional options, and produce a promise that
    * represents the entire execution.  On successful completion the promise will resolve, and

package/src/global.d.ts

@@ -2,10 +2,6 @@ import './types';
 
 declare const write: unique symbol;
 
-declare global {
-  var devProcessWarningExclusions: ((message: string, category: string) => boolean)[] | undefined;
-}
-
 declare global {
   // https://github.com/microsoft/TypeScript/issues/59012
   interface WritableStreamDefaultWriter<W = any> {

package/src/types.ts

@@ -12,7 +12,6 @@ export type TypedFunction<R = Any, V = unknown> = (this: V, ...args: Any[]) => R
 export type MethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<R, V>>;
 export type AsyncMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<Promise<R>, V>>;
 export type AsyncIterableMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
-export type ClassTDecorator<T extends Class = Class> = (target: T) => T | void;
 
 export type NumericPrimitive = number | bigint;
 export type Primitive = NumericPrimitive | boolean | string;
@@ -34,10 +33,17 @@ export type ValidFields<T, I> = {
 
 export type RetainIntrinsicFields<T> = Pick<T, ValidFields<T, IntrinsicType>>;
 
-export type ValidTypedFields<T, F> = {
-  [K in Extract<keyof T, string>]:
-  (T[K] extends F ? K : never)
-}[Extract<keyof T, string>];
+export type KeyPaths<T, PrimitiveType = IntrinsicType | IntrinsicType[], PREFIX extends string = '', SEP extends string = '.'> =
+  { [K in keyof T]:
+    (K extends string ? (
+      (T[K] extends (IntrinsicType[] | IntrinsicType | undefined) ?
+        (T[K] extends PrimitiveType ? `${PREFIX}${K}` : never) : (
+          (T[K] extends Any[] ?
+            KeyPaths<T[K][number], PrimitiveType, `${K}${SEP}`, SEP> :
+            (T[K] extends object ? KeyPaths<T[K], PrimitiveType, `${K}${SEP}`, SEP> : never))
+        )
+      )) : never)
+  }[keyof T];
 
 export const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T & string>(value: T): K[];

package/support/patch.js

@@ -1,28 +1,15 @@
-import 'temporal-polyfill-lite/global';
 import fs from 'node:fs/promises';
 
 if (process.env.NODE_ENV !== 'production') {
   process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
   process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
   Error.stackTraceLimit = 50;
-
-  const ogEmitWarning = process.emitWarning;
-  const exclusions = global.devProcessWarningExclusions = [];
-  process.emitWarning = (message, category, ...other) => {
-    if (exclusions.length === 0 || !exclusions.some(filter => filter(message, category))) {
-      return ogEmitWarning(message, category, ...other);
-    }
-  };
 }
 
-const isError = Error.isError.bind(Error);
-Object.defineProperty(Error, 'isError', {
-  value: (input) => isError(input) || (input instanceof Error)
-});
-
 // polyfills
-
-const [majorVersion, minorVersion] = process.version.replace(/^v/, '').split('.').map(text => parseInt(text, 10));
+if (!globalThis.Temporal) { // For anyone that doesn't have it
+  void import('temporal-polyfill-lite/global');
+}
 
 Map.prototype.getOrInsert ??= function (key, value) {
   return (this.has(key) || this.set(key, value), this.get(key));
@@ -33,6 +20,7 @@ Map.prototype.getOrInsertComputed ??= function (key, compute) {
 };
 
 // Allow for the throwIfNoEntry if on a version of node that is less than 25.7
+const [majorVersion, minorVersion] = process.version.match(/\d+/g).map(text => parseInt(text, 10));
 if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
   const og = fs.stat;
   Object.defineProperty(fs, 'stat', {
@@ -44,4 +32,4 @@ if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
       return out;
     }
   });
-}
+}