@travetto/runtime 8.0.0-alpha.3 → 8.0.0-alpha.5

package/README.md

@@ -284,7 +284,7 @@ tpl`{{age:20}} {{name: 'bob'}}</>;
 The [BinaryUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/binary.ts#L59) class provides a unified interface for working with binary data across different formats, especially bridging the gap between Node.js specific types (`Buffer`, `Stream`) and Web Standard types (`Blob`, `ArrayBuffer`). The framework leverages this to allow for seamless handling of binary data, regardless of the source.
 
 ## JSON Utilities
-The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/json.ts#L31) class provides a comprehensive set of utilities for working with JSON data, including serialization, deserialization, encoding, and deep cloning capabilities. The utility handles special types like `Date`, `BigInt`, and `Error` objects seamlessly. Key features include:
+The [JSONUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/json.ts#L33) class provides a comprehensive set of utilities for working with JSON data, including serialization, deserialization, encoding, and deep cloning capabilities. The utility handles special types like `Date`, `BigInt`, and `Error` objects seamlessly. Key features include:
    *  `fromUTF8(input, config?)` - Parse JSON from a UTF-8 string
    *  `toUTF8(value, config?)` - Serialize a value to JSON string
    *  `toUTF8Pretty(value)` - Serialize with pretty formatting (2-space indent)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "8.0.0-alpha.3",
+  "version": "8.0.0-alpha.5",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,13 +26,13 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^8.0.0-alpha.3",
+    "@travetto/manifest": "^8.0.0-alpha.4",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3",
-    "temporal-polyfill-lite": "^0.3.1"
+    "temporal-polyfill-lite": "^0.3.2"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.3"
+    "@travetto/transformer": "^8.0.0-alpha.4"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/global.d.ts

@@ -1,6 +1,11 @@
 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/json.ts

@@ -1,16 +1,18 @@
+import { AssertionError } from 'node:assert';
+
 import type { BinaryArray } from './binary.ts';
 import { CodecUtil } from './codec.ts';
 import { RuntimeError, type RuntimeErrorOptions } from './error.ts';
-import { castTo } from './types.ts';
+import { castTo, type Any } from './types.ts';
+
+const VALID_JSON_ERROR_TYPES = ['runtime', 'plain', 'assert'] as const;
+const VALID_JSON_ERROR_TYPE_SET = new Set<unknown>(VALID_JSON_ERROR_TYPES);
 
 type JSONTransformer = (this: unknown, key: string, value: unknown) => unknown;
 type JSONOutputConfig = { indent?: number, replacer?: JSONTransformer };
 type JSONInputConfig = { reviver?: JSONTransformer };
 type JSONCloneConfig = JSONOutputConfig & JSONInputConfig;
-type ErrorShape<T extends string, V> = { $trv: T, message: string, stack?: string } & V;
-type JSONError =
-  ErrorShape<'runtime', RuntimeErrorOptions<Record<string, unknown>>> |
-  ErrorShape<'plain', { name: string }>;
+type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number], name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
 
 Object.defineProperty(BigInt.prototype, 'toJSON', {
   value() { return `${this}n`; },
@@ -47,53 +49,46 @@ export class JSONUtil {
 
 
   static isJSONError(value: unknown): value is JSONError {
-    return typeof value === 'object' && value !== null && '$trv' in value && (
-      value.$trv === 'runtime' || value.$trv === 'plain'
-    );
+    return typeof value === 'object' && value !== null && '$trv' in value && VALID_JSON_ERROR_TYPE_SET.has(value.$trv);
   }
 
   /** Convert from JSON object */
-  static jsonErrorToError(error: JSONError): Error | RuntimeError {
-    switch (error.$trv) {
-      case 'runtime': {
-        const { $trv: _, ...rest } = error;
-        const result = new RuntimeError(error.message, castTo<RuntimeErrorOptions<Record<string, unknown>>>(rest));
-        result.stack = error.stack;
-        return result;
-      }
-      case 'plain': {
-        const result = new Error(error.message);
-        result.name = error.name;
-        result.stack = error.stack ?? result.stack;
-        return result;
-      }
+  static jsonErrorToError(error: JSONError): Error {
+    const { $trv, message, stack, name, ...rest } = error;
+    let response: Error;
+    switch ($trv) {
+      case 'runtime': response = new RuntimeError(message!, castTo<Any>(rest)); break;
+      case 'assert': response = new AssertionError({ message, ...rest }); break;
+      case 'plain': response = new Error(message!); break;
     }
+    response.stack = stack;
+    if (name) { response.name = name; }
+    return response;
   }
 
   /**
    * Serializes an error to a basic object
    */
-  static errorToJSONError(error: RuntimeError | Error, includeStack?: boolean): JSONError | undefined {
+  static errorToJSONError(error: Error, includeStack?: boolean): JSONError | undefined {
     includeStack ??= JSONUtil.includeStackTraces;
-    if (error instanceof RuntimeError) {
-      return {
-        $trv: 'runtime',
-        message: error.message,
+    let $trv: JSONError['$trv'];
+    switch (true) {
+      case error instanceof RuntimeError: $trv = 'runtime'; break;
+      case error instanceof AssertionError: $trv = 'assert'; break;
+      default: $trv = 'plain'; break;
+    }
+    return {
+      $trv,
+      message: error.message,
+      ...(error.cause ? { cause: `${error.cause}` } : undefined),
+      ...(includeStack ? { stack: error.stack } : undefined),
+      ...(error instanceof RuntimeError ? {
         category: error.category,
-        ...(error.cause ? { cause: `${error.cause}` } : undefined),
         type: error.type,
         at: error.at,
         ...(error.details ? { details: error.details } : undefined!),
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
-    } else {
-      return {
-        $trv: 'plain',
-        message: error.message,
-        name: error.name,
-        ...(includeStack ? { stack: error.stack } : undefined)
-      };
-    }
+      } : {})
+    };
   }
 
   /** UTF8 string to JSON */

package/src/watch.ts

@@ -91,7 +91,12 @@ export class WatchUtil {
       error: (...args: unknown[]): void => console.error(...args),
     });
 
-    return this.runWithRetry(async ({ signal }) => {
+    // pre-check
+    if (!await client.isWatching()) { // If we get here, without a watch
+      throw new RuntimeError('Compile Server is not running');
+    }
+
+    void this.runWithRetry(async ({ signal }) => {
       await client.waitForState(['compile-end', 'watch-start'], undefined, signal);
 
       if (!await client.isWatching()) { // If we get here, without a watch

package/support/patch.js

@@ -0,0 +1,47 @@
+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));
+
+Map.prototype.getOrInsert ??= function (key, value) {
+  return (this.has(key) || this.set(key, value), this.get(key));
+};
+
+Map.prototype.getOrInsertComputed ??= function (key, compute) {
+  return (this.has(key) || this.set(key, compute()), this.get(key));
+};
+
+// Allow for the throwIfNoEntry if on a version of node that is less than 25.7
+if (majorVersion < 25 || (majorVersion === 25 && minorVersion < 7)) {
+  const og = fs.stat;
+  Object.defineProperty(fs, 'stat', {
+    value: (...args) => {
+      const out = og.call(fs, ...args);
+      if (typeof args[1] === 'object' && args[1].throwIfNoEntry === false) {
+        return out.catch(() => { });
+      }
+      return out;
+    }
+  });
+}

package/support/polyfill.js

@@ -1,9 +0,0 @@
-import 'temporal-polyfill-lite/global';
-
-Map.prototype.getOrInsert ??= function(key, value) {
-  return (this.has(key) || this.set(key, value), this.get(key));
-};
-
-Map.prototype.getOrInsertComputed ??= function(key, compute) {
-  return (this.has(key) || this.set(key, compute()), this.get(key));
-};