@travetto/runtime 8.0.0-alpha.19 → 8.0.0-alpha.20

package/src/env.ts

@@ -3,11 +3,13 @@ import { castKey, castTo } from './types.ts';
 const IS_TRUE = /^(true|yes|on|1)$/i;
 const IS_FALSE = /^(false|no|off|0)$/i;
 
-export interface EnvData { }
+export interface EnvData {}
 
 export class EnvProp<T> {
   readonly key: string;
-  constructor(key: string) { this.key = key; }
+  constructor(key: string) {
+    this.key = key;
+  }
 
   /** Set value according to type */
   set(value: T | undefined | null): void {
@@ -26,14 +28,18 @@ export class EnvProp<T> {
   /** Export value */
   export(value?: T | undefined | null): Record<string, string> {
     let out: string;
-    if (arguments.length === 0) { // If nothing passed in
+    // biome-ignore lint/complexity/noArguments: We want to use arguments here to detect if nothing was truly passed
+    if (arguments.length === 0) {
+      // If nothing passed in
       out = `${this.value}`;
     } else if (value === undefined || value === null) {
       out = '';
     } else if (Array.isArray(value)) {
       out = value.join(',');
     } else if (typeof value === 'object') {
-      out = Object.entries(value).map(([key, keyValue]) => `${key}=${keyValue}`).join(',');
+      out = Object.entries(value)
+        .map(([key, keyValue]) => `${key}=${keyValue}`)
+        .join(',');
     } else {
       out = `${value}`;
     }
@@ -41,13 +47,19 @@ export class EnvProp<T> {
   }
 
   /** Read value as string */
-  get value(): string | undefined { return process.env[this.key] || undefined; }
+  get value(): string | undefined {
+    return process.env[this.key] || undefined;
+  }
 
   /** Read value as list */
   get list(): string[] | undefined {
     const value = this.value;
-    return (value === undefined || value === '') ?
-      undefined : value.split(/[, ]+/g).map(item => item.trim()).filter(item => !!item);
+    return value === undefined || value === ''
+      ? undefined
+      : value
+          .split(/[, ]+/g)
+          .map(item => item.trim())
+          .filter(item => !!item);
   }
 
   /** Read value as object */
@@ -58,7 +70,7 @@ export class EnvProp<T> {
 
   /** Add values to list */
   add(...items: string[]): void {
-    process.env[this.key] = [... new Set([...this.list ?? [], ...items])].join(',');
+    process.env[this.key] = [...new Set([...(this.list ?? []), ...items])].join(',');
   }
 
   /** Read value as int  */
@@ -70,7 +82,7 @@ export class EnvProp<T> {
   /** Read value as boolean */
   get bool(): boolean | undefined {
     const value = this.value;
-    return (value === undefined || value === '') ? undefined : IS_TRUE.test(value);
+    return value === undefined || value === '' ? undefined : IS_TRUE.test(value);
   }
 
   /** Determine if the underlying value is truthy */
@@ -91,24 +103,32 @@ export class EnvProp<T> {
 }
 
 type EnvDataCombinedType = {
-  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'value' | 'set' | 'clear' | 'isSet' |
-    (EnvData[K] extends unknown[] ? 'list' | 'add' : never) |
-    (Extract<EnvData[K], object> extends never ? never : 'object') |
-    (Extract<EnvData[K], number> extends never ? never : 'int') |
-    (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
-  >
+  [K in keyof EnvData]: Pick<
+    EnvProp<EnvData[K]>,
+    | 'key'
+    | 'export'
+    | 'value'
+    | 'set'
+    | 'clear'
+    | 'isSet'
+    | (EnvData[K] extends unknown[] ? 'list' | 'add' : never)
+    | (Extract<EnvData[K], object> extends never ? never : 'object')
+    | (Extract<EnvData[K], number> extends never ? never : 'int')
+    | (Extract<EnvData[K], boolean> extends never ? never : 'bool' | 'isTrue' | 'isFalse')
+  >;
 };
 
 function delegate<T extends object>(base: T): EnvDataCombinedType & T {
   return new Proxy(castTo(base), {
     get(target, property): unknown {
-      return typeof property !== 'string' ? undefined :
-        (property in base ? base[castKey(property)] :
-          target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property))
-        );
+      return typeof property !== 'string'
+        ? undefined
+        : property in base
+          ? base[castKey(property)]
+          : (target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property)));
     }
   });
 }
 
 /** Basic utils for reading known environment variables */
-export const Env = delegate({});
+export const Env = delegate({});

package/src/error.ts

@@ -1,13 +1,6 @@
 import { castTo } from './types.ts';
 
-export type ErrorCategory =
-  'general' |
-  'notfound' |
-  'data' |
-  'permissions' |
-  'authentication' |
-  'timeout' |
-  'unavailable';
+export type ErrorCategory = 'general' | 'notfound' | 'data' | 'permissions' | 'authentication' | 'timeout' | 'unavailable';
 
 export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T extends undefined ? { details?: T } : { details: T });
 
@@ -15,7 +8,6 @@ export type RuntimeErrorOptions<T> = Omit<Partial<RuntimeError>, 'details'> & (T
  * Framework error class, with the aim of being extensible
  */
 export class RuntimeError<T = Record<string, unknown> | undefined> extends Error {
-
   static defaultCategory: ErrorCategory = 'general';
 
   type: string;
@@ -28,14 +20,11 @@ export class RuntimeError<T = Record<string, unknown> | undefined> extends Error
    *
    * @param message The error message
    */
-  constructor(
-    ...[message, options]:
-      T extends undefined ? ([string] | [string, RuntimeErrorOptions<T>]) : [string, RuntimeErrorOptions<T>]
-  ) {
+  constructor(...[message, options]: T extends undefined ? [string] | [string, RuntimeErrorOptions<T>] : [string, RuntimeErrorOptions<T>]) {
     super(message, options?.cause ? { cause: options.cause } : undefined);
     this.type = options?.type ?? this.constructor.name;
-    this.details = options?.details!;
+    this.details = options?.details ?? undefined!;
     this.category = options?.category ?? castTo<typeof RuntimeError>(this.constructor).defaultCategory ?? 'general';
     this.at = new Date(options?.at ?? Date.now());
   }
-}
+}

package/src/exec.ts

@@ -1,9 +1,9 @@
-import { type ChildProcess, spawn, type SpawnOptions } from 'node:child_process';
+import { type ChildProcess, type SpawnOptions, spawn } from 'node:child_process';
 
-import { castTo } from './types.ts';
-import { RuntimeIndex } from './manifest-index.ts';
-import { BinaryUtil, type BinaryArray } from './binary.ts';
+import { type BinaryArray, BinaryUtil } from './binary.ts';
 import { CodecUtil } from './codec.ts';
+import { RuntimeIndex } from './manifest-index.ts';
+import { castTo } from './types.ts';
 
 const ResultSymbol = Symbol();
 
@@ -39,7 +39,6 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  * Standard utilities for managing executions
  */
 export class ExecUtil {
-
   /** Read stream as string from a result */
   static toString(result: ExecutionResult<BinaryArray | string>, stream: 'stdout' | 'stderr' | 'any'): string {
     if (stream === 'any') {
@@ -61,11 +60,14 @@ export class ExecUtil {
    * @param options The options to use to enhance the process
    */
   static getResult(subProcess: ChildProcess): Promise<ExecutionResult<string>>;
-  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
-  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<BinaryArray>>;
-  static getResult<T extends string | BinaryArray>(subProcess: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary?: false }): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean; binary: true }): Promise<ExecutionResult<BinaryArray>>;
+  static getResult<T extends string | BinaryArray>(
+    subProcess: ChildProcess,
+    options: { catch?: boolean; binary?: boolean } = {}
+  ): Promise<ExecutionResult<T>> {
     const typed: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = subProcess;
-    const result = typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
+    const result = (typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: BinaryArray[] = [];
       const stderr: BinaryArray[] = [];
       let done = false;
@@ -77,7 +79,7 @@ export class ExecUtil {
 
         const buffers = {
           stdout: BinaryUtil.combineBinaryArrays(stdout),
-          stderr: BinaryUtil.combineBinaryArrays(stderr),
+          stderr: BinaryUtil.combineBinaryArrays(stderr)
         };
 
         const final = {
@@ -86,37 +88,37 @@ export class ExecUtil {
           ...finalResult
         };
 
-        resolve(!final.valid ?
-          { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } :
-          final
-        );
+        resolve(!final.valid ? { ...final, message: `${final.message || final.stderr || final.stdout || 'failed'}` } : final);
       };
 
       subProcess.stdout?.on('data', data => stdout.push(CodecUtil.readChunk(data, subProcess.stdout?.readableEncoding)));
       subProcess.stderr?.on('data', data => stderr.push(CodecUtil.readChunk(data, subProcess.stderr?.readableEncoding)));
 
-      subProcess.on('error', (error: Error) =>
-        finish({ code: 1, message: error.message, valid: false }));
+      subProcess.on('error', (error: Error) => finish({ code: 1, message: error.message, valid: false }));
 
-      subProcess.on('close', (code: number) =>
-        finish({ code, valid: code === null || code === 0 }));
+      subProcess.on('close', (code: number) => finish({ code, valid: code === null || code === 0 }));
 
-      if (subProcess.exitCode !== null) { // We are already done
+      if (subProcess.exitCode !== null) {
+        // We are already done
         finish({ code: subProcess.exitCode, valid: subProcess.exitCode === 0 });
       }
-    });
-
-    return castTo(options.catch ? result : result.then(executionResult => {
-      if (executionResult.valid) {
-        return executionResult;
-      } else {
-        throw new Error(executionResult.message);
-      }
     }));
+
+    return castTo(
+      options.catch
+        ? result
+        : result.then(executionResult => {
+            if (executionResult.valid) {
+              return executionResult;
+            } else {
+              throw new Error(executionResult.message);
+            }
+          })
+    );
   }
 
   /** Spawn a package command */
   static spawnPackageCommand(cmd: string, args: string[], config: SpawnOptions = {}): ChildProcess {
     return spawn(process.argv0, [RuntimeIndex.resolvePackageCommand(cmd), ...args], config);
   }
-}
+}

package/src/file-loader.ts

@@ -2,14 +2,13 @@ import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import { type BinaryArray, type BinaryStream, BinaryUtil } from './binary.ts';
 import { RuntimeError } from './error.ts';
-import { BinaryUtil, type BinaryArray, type BinaryStream } from './binary.ts';
 
 /**
  * File loader that will search for files across the provided search paths
  */
 export class FileLoader {
-
   #searchPaths: readonly string[];
 
   constructor(paths: string[]) {
@@ -72,4 +71,4 @@ export class FileLoader {
     const buffer = BinaryUtil.binaryArrayToBuffer(await this.readBinaryArray(relativePath));
     return new File([buffer], path.basename(relativePath));
   }
-}
+}

package/src/function.ts

@@ -1,6 +1,6 @@
 import { ManifestModuleUtil } from '@travetto/manifest';
 
-export type FunctionMetadataTag = { hash: number, lines: [start: number, end: number, bodyStart?: number] };
+export type FunctionMetadataTag = { hash: number; lines: [start: number, end: number, bodyStart?: number] };
 export type FunctionMetadata = FunctionMetadataTag & {
   id: string;
   import: string;
@@ -26,13 +26,16 @@ const pending = new Set<Function>([]);
  * @private
  */
 export function registerFunction(
-  input: Function, [module, relativePath]: [string, string], tag: FunctionMetadataTag,
-  methods?: Record<string, FunctionMetadataTag>, abstract?: boolean,
+  input: Function,
+  [module, relativePath]: [string, string],
+  tag: FunctionMetadataTag,
+  methods?: Record<string, FunctionMetadataTag>,
+  abstract?: boolean
 ): void {
   const modulePath = ManifestModuleUtil.withoutSourceExtension(relativePath);
 
   const metadata: FunctionMetadata = {
-    id: (input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`),
+    id: input.name ? `${module}:${modulePath}#${input.name}` : `${module}:${modulePath}`,
     import: `${module}/${relativePath}`,
     module,
     modulePath,
@@ -65,5 +68,10 @@ export function describeFunction(input?: Function): FunctionMetadata | undefined
 
 const foreignTypeRegistry = new Map<string, Function>();
 export function foreignType(id: string): Function {
-  return foreignTypeRegistry.getOrInsert(id, class { static Ⲑid = id; });
-}
+  return foreignTypeRegistry.getOrInsert(
+    id,
+    class {
+      static Ⲑid = id;
+    }
+  );
+}

package/src/json.ts

@@ -3,27 +3,33 @@ 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, type Any } from './types.ts';
+import { type Any, castTo } 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 JSONOutputConfig = { indent?: number; replacer?: JSONTransformer };
 type JSONInputConfig = { reviver?: JSONTransformer };
 type JSONCloneConfig = JSONOutputConfig & JSONInputConfig;
-type JSONError = { $trv: (typeof VALID_JSON_ERROR_TYPES)[number], name?: string } & Partial<RuntimeErrorOptions<Record<string, unknown>>>;
+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`; },
+  value() {
+    return `${this}n`;
+  }
 });
 
 Object.defineProperty(Error.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 Object.defineProperty(RuntimeError.prototype, 'toJSON', {
-  value() { return JSONUtil.errorToJSONError(this); },
+  value() {
+    return JSONUtil.errorToJSONError(this);
+  }
 });
 
 const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
@@ -31,7 +37,6 @@ const BIGINT_REGEX = /^-?\d+n$/;
 
 /** Utilities for JSON  */
 export class JSONUtil {
-
   static includeStackTraces = false;
 
   static TRANSMIT_REVIVER: JSONTransformer = function (this: unknown, key: string, value: unknown): unknown {
@@ -47,7 +52,6 @@ export class JSONUtil {
     return value;
   };
 
-
   static isJSONError(value: unknown): value is JSONError {
     return typeof value === 'object' && value !== null && '$trv' in value && VALID_JSON_ERROR_TYPE_SET.has(value.$trv);
   }
@@ -57,12 +61,20 @@ export class JSONUtil {
     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;
+      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; }
+    if (name) {
+      response.name = name;
+    }
     return response;
   }
 
@@ -73,21 +85,29 @@ export class JSONUtil {
     includeStack ??= JSONUtil.includeStackTraces;
     let $trv: JSONError['$trv'];
     switch (true) {
-      case error instanceof RuntimeError: $trv = 'runtime'; break;
-      case error instanceof AssertionError: $trv = 'assert'; break;
-      default: $trv = 'plain'; break;
+      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,
-        type: error.type,
-        at: error.at,
-        ...(error.details ? { details: error.details } : undefined!),
-      } : {})
+      ...(error instanceof RuntimeError
+        ? {
+            category: error.category,
+            type: error.type,
+            at: error.at,
+            ...(error.details ? { details: error.details } : undefined!)
+          }
+        : {})
     };
   }
 
@@ -147,4 +167,4 @@ export class JSONUtil {
   static cloneFromTransmit<T, R = T>(input: T): R {
     return JSONUtil.clone<T, R>(input, { reviver: JSONUtil.TRANSMIT_REVIVER });
   }
-}
+}

package/src/manifest-index.ts

@@ -1,4 +1,4 @@
 import { ManifestIndex } from '@travetto/manifest';
 
 /** Runtime manifest index */
-export const RuntimeIndex = new ManifestIndex();
+export const RuntimeIndex = new ManifestIndex();

package/src/queue.ts

@@ -2,7 +2,6 @@
  * An asynchronous queue
  */
 export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
-
   #buffer: X[] = [];
   #done = false;
   #ready = Promise.withResolvers<void>();
@@ -59,4 +58,4 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     this.#ready.reject(error);
     return { value: undefined, done: this.#done };
   }
-}
+}

package/src/resources.ts

@@ -25,4 +25,4 @@ class $RuntimeResources extends FileLoader {
 }
 
 /** Runtime resources */
-export const RuntimeResources = new $RuntimeResources();
+export const RuntimeResources = new $RuntimeResources();

package/src/shutdown.ts

@@ -1,17 +1,21 @@
 import type { ChildProcess } from 'node:child_process';
 
 import { Env } from './env.ts';
-import { Util } from './util.ts';
 import { TimeUtil } from './time.ts';
+import { Util } from './util.ts';
 
-const MAPPING = [['restart', 200], ['error', 1], ['quit', 0]] as const;
-export type ShutdownReason = typeof MAPPING[number][0];
+const MAPPING = [
+  ['restart', 200],
+  ['error', 1],
+  ['quit', 0]
+] as const;
+export type ShutdownReason = (typeof MAPPING)[number][0];
 
 const REASON_TO_CODE = new Map<ShutdownReason, number>(MAPPING);
 const CODE_TO_REASON = new Map<number, ShutdownReason>(MAPPING.map(([k, v]) => [v, k]));
 
 type Handler = (event: Event) => unknown;
-type ShutdownEvent = { reason?: ShutdownReason, mode?: 'exit' | 'interrupt' };
+type ShutdownEvent = { reason?: ShutdownReason; mode?: 'exit' | 'interrupt' };
 
 const isShutdownEvent = (event: unknown): event is ShutdownEvent =>
   typeof event === 'object' && event !== null && 'type' in event && event.type === 'shutdown';
@@ -33,14 +37,20 @@ export class ShutdownManager {
   static #controller = new AbortController();
 
   static {
-    this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => { this.#registered.add(listener); };
-    this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => { this.#registered.delete(listener); };
+    this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => {
+      this.#registered.add(listener);
+    };
+    this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => {
+      this.#registered.delete(listener);
+    };
     try {
       process
-        .on('message', event => { isShutdownEvent(event) && this.shutdown(event); })
+        .on('message', event => {
+          isShutdownEvent(event) && this.shutdown(event);
+        })
         .on('SIGINT', () => this.shutdown({ mode: 'interrupt' }))
         .on('SIGTERM', () => this.shutdown());
-    } catch { }
+    } catch {}
   }
 
   static get signal(): AbortSignal {
@@ -60,7 +70,7 @@ export class ShutdownManager {
 
   /** Trigger a watch signal signal to a subprocess */
   static async shutdownChild(subprocess: ChildProcess, config?: ShutdownEvent): Promise<void> {
-    subprocess?.send!({ type: 'shutdown', ...config });
+    subprocess?.send?.({ type: 'shutdown', ...config });
   }
 
   /**
@@ -87,10 +97,7 @@ export class ShutdownManager {
     this.#controller.abort('Shutdown started');
     console.debug('Shutdown started', context);
 
-    const winner = await Promise.race([
-      Util.nonBlockingTimeout(timeout).then(() => this),
-      Promise.all([...this.#registered].map(wrapped))
-    ]);
+    const winner = await Promise.race([Util.nonBlockingTimeout(timeout).then(() => this), Promise.all([...this.#registered].map(wrapped))]);
 
     if (winner !== this) {
       console.debug('Shutdown completed', context);
@@ -102,4 +109,4 @@ export class ShutdownManager {
       process.exit();
     }
   }
-}
+}

package/src/time.ts

@@ -2,16 +2,32 @@ import { RuntimeError } from './error.ts';
 import { castTo } from './types.ts';
 
 const TIME_UNIT_TO_TEMPORAL_UNIT = {
-  y: 'years', year: 'years', years: 'years',
-  M: 'months', month: 'months', months: 'months',
-  w: 'weeks', week: 'weeks', weeks: 'weeks',
-  d: 'days', day: 'days', days: 'days',
-  h: 'hours', hour: 'hours', hours: 'hours',
-  m: 'minutes', minute: 'minutes', minutes: 'minutes',
-  s: 'seconds', second: 'seconds', seconds: 'seconds',
-  ms: 'milliseconds', millisecond: 'milliseconds', milliseconds: 'milliseconds'
+  y: 'years',
+  year: 'years',
+  years: 'years',
+  M: 'months',
+  month: 'months',
+  months: 'months',
+  w: 'weeks',
+  week: 'weeks',
+  weeks: 'weeks',
+  d: 'days',
+  day: 'days',
+  days: 'days',
+  h: 'hours',
+  hour: 'hours',
+  hours: 'hours',
+  m: 'minutes',
+  minute: 'minutes',
+  minutes: 'minutes',
+  s: 'seconds',
+  second: 'seconds',
+  seconds: 'seconds',
+  ms: 'milliseconds',
+  millisecond: 'milliseconds',
+  milliseconds: 'milliseconds'
 } as const;
-type TemporalUnit = typeof TIME_UNIT_TO_TEMPORAL_UNIT[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
+type TemporalUnit = (typeof TIME_UNIT_TO_TEMPORAL_UNIT)[keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT];
 
 export type TimeSpan = `${number}${keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT}`;
 export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
@@ -19,7 +35,6 @@ export type TimeUnit = keyof typeof TIME_UNIT_TO_TEMPORAL_UNIT;
 const TIME_PATTERN = /^(?<amount>-?[0-9]+)(?<unit>(?:year|month|week|day|hour|minute|second|millisecond)s?|y|M|w|d|h|m|s|ms)$/;
 
 export class TimeUtil {
-
   /**
    * Test to see if a string is valid for relative time
    */
@@ -50,20 +65,40 @@ export class TimeUtil {
     }
 
     switch (unit) {
-      case 'years': { unit = 'hours'; value = value * 365 * 24; break; }
-      case 'months': { value = value * 30 * 24; unit = 'hours'; break; }
-      case 'weeks': { value = value * 7 * 24; unit = 'hours'; break; }
-      case 'days': { value = value * 24; unit = 'hours'; break; }
+      case 'years': {
+        unit = 'hours';
+        value = value * 365 * 24;
+        break;
+      }
+      case 'months': {
+        value = value * 30 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'weeks': {
+        value = value * 7 * 24;
+        unit = 'hours';
+        break;
+      }
+      case 'days': {
+        value = value * 24;
+        unit = 'hours';
+        break;
+      }
     }
 
     const duration = Temporal.Duration.from({ [unit]: value });
     if (outputUnit) {
       const resolved = TIME_UNIT_TO_TEMPORAL_UNIT[outputUnit];
       switch (resolved) {
-        case 'years': return Math.trunc(duration.total('hours') / (365 * 24));
-        case 'months': return Math.trunc(duration.total('hours') / (30 * 24));
-        case 'weeks': return Math.trunc(duration.total('hours') / (7 * 24));
-        default: return Math.trunc(duration.total(resolved));
+        case 'years':
+          return Math.trunc(duration.total('hours') / (365 * 24));
+        case 'months':
+          return Math.trunc(duration.total('hours') / (30 * 24));
+        case 'weeks':
+          return Math.trunc(duration.total('hours') / (7 * 24));
+        default:
+          return Math.trunc(duration.total(resolved));
       }
     } else {
       return duration;
@@ -94,4 +129,4 @@ export class TimeUtil {
       return `${toFixed(seconds)}s`;
     }
   }
-}
+}