@xh/hoist 73.0.0-SNAPSHOT.1745457790188 → 73.0.0-SNAPSHOT.1745589992773

package/CHANGELOG.md

@@ -31,6 +31,8 @@ Requires `hoist-core >= 30.0` with new APIs to support the consolidated Admin Co
       the client remained on an older version.
     * Note that a misconfigured build - where the client build version is not set to the same value
       as the server - would result in a false positive for an upgrade. The two should always match.
+*  Calls to `Promise.track()` that are rejected with an exception will be tracked with new
+   severity level of `TrackSeverity.ERROR`
 
 ## v72.5.1 - 2025-04-15
 

package/build/types/core/types/Interfaces.d.ts

@@ -165,7 +165,7 @@ export interface AppOptionSpec {
 /**
  * Severity levels for tracking.  Default is 'INFO'.
  */
-export type TrackSeverity = 'DEBUG' | 'INFO' | 'WARN';
+export type TrackSeverity = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 /**
  * Options for tracking activity on the server via TrackService.
  */

package/build/types/promise/Promise.d.ts

@@ -18,7 +18,7 @@ declare global {
          *      selector will be handled by this method.
          * @param fn - catch handler
          */
-        catchWhen<TResult = undefined>(selector: ((e: any) => boolean) | Some<string>, fn?: (reason: any) => Awaitable<TResult>): Promise<T | TResult>;
+        catchWhen<TResult = undefined>(selector: ((e: unknown) => boolean) | Some<string>, fn?: (reason: unknown) => Awaitable<TResult>): Promise<T | TResult>;
         /**
          * Version of `catch()` that passes the error onto Hoist's default exception handler for
          * convention-driven logging and alerting. Typically called last in a Promise chain.
@@ -27,7 +27,7 @@ declare global {
         /**
          * Version of `catchDefault()` that will only catch certain exceptions.
          */
-        catchDefaultWhen(selector: ((e: any) => boolean) | Some<string>, options: ExceptionHandlerOptions): Promise<T | undefined>;
+        catchDefaultWhen(selector: ((e: unknown) => boolean) | Some<string>, options: ExceptionHandlerOptions): Promise<T | undefined>;
         /**
          * Wait on a potentially async function before passing on the original value.
          * Useful when we want to block and do something on the promise chain, but do not want to

package/build/types/svc/TrackService.d.ts

@@ -36,7 +36,7 @@ interface ActivityTrackingConfig {
     levels?: Array<{
         username: string | '*';
         category: string | '*';
-        severity: 'DEBUG' | 'INFO' | 'WARN';
+        severity: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
     }>;
 }
 export {};

package/core/types/Interfaces.ts

@@ -207,7 +207,7 @@ export interface AppOptionSpec {
 /**
  * Severity levels for tracking.  Default is 'INFO'.
  */
-export type TrackSeverity = 'DEBUG' | 'INFO' | 'WARN';
+export type TrackSeverity = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 
 /**
  * Options for tracking activity on the server via TrackService.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xh/hoist",
-  "version": "73.0.0-SNAPSHOT.1745457790188",
+  "version": "73.0.0-SNAPSHOT.1745589992773",
   "description": "Hoist add-on for building and deploying React Applications.",
   "repository": "github:xh/hoist-react",
   "homepage": "https://xh.io",

package/promise/Promise.ts

@@ -12,11 +12,13 @@ import {
     TrackOptions,
     XH,
     Some,
-    Awaitable
+    Awaitable,
+    TimeoutExceptionConfig
 } from '@xh/hoist/core';
 import {action} from '@xh/hoist/mobx';
 import {olderThan, SECONDS} from '@xh/hoist/utils/datetime';
 import {castArray, isFunction, isNumber, isString} from 'lodash';
+import {isOmitted} from '@xh/hoist/utils/impl';
 
 /**
  * Enhancements to the Global Promise object.
@@ -39,8 +41,8 @@ declare global {
          * @param fn - catch handler
          */
         catchWhen<TResult = undefined>(
-            selector: ((e: any) => boolean) | Some<string>,
-            fn?: (reason: any) => Awaitable<TResult>
+            selector: ((e: unknown) => boolean) | Some<string>,
+            fn?: (reason: unknown) => Awaitable<TResult>
         ): Promise<T | TResult>;
 
         /**
@@ -53,7 +55,7 @@ declare global {
          * Version of `catchDefault()` that will only catch certain exceptions.
          */
         catchDefaultWhen(
-            selector: ((e: any) => boolean) | Some<string>,
+            selector: ((e: unknown) => boolean) | Some<string>,
             options: ExceptionHandlerOptions
         ): Promise<T | undefined>;
 
@@ -169,43 +171,63 @@ export function never<T>(): Promise<T> {
 //--------------------------------
 const enhancePromise = promisePrototype => {
     Object.assign(promisePrototype, {
-        thenAction(fn) {
+        thenAction<T, TResult>(fn: (value: T) => Awaitable<TResult>): Promise<TResult> {
             return this.then(action(fn));
         },
 
-        catchWhen(selector, fn) {
-            return this.catch(e => {
+        catchWhen<T, TResult = undefined>(
+            selector: ((e: unknown) => boolean) | Some<string>,
+            fn?: (reason: unknown) => Awaitable<TResult>
+        ): Promise<T | TResult> {
+            return this.catch((e: unknown) => {
                 this.throwIfFailsSelector(e, selector);
                 return fn ? fn(e) : undefined;
             });
         },
 
-        catchDefault(options) {
-            return this.catch(e => XH.handleException(e, options));
+        catchDefault<T>(options?: ExceptionHandlerOptions): Promise<T | undefined> {
+            return this.catch((e: unknown) => XH.handleException(e, options));
         },
 
-        catchDefaultWhen(selector, options) {
-            return this.catch(e => {
+        catchDefaultWhen<T>(
+            selector: ((e: unknown) => boolean) | Some<string>,
+            options: ExceptionHandlerOptions
+        ): Promise<T | undefined> {
+            return this.catch((e: unknown) => {
                 this.throwIfFailsSelector(e, selector);
                 return XH.handleException(e, options);
             });
         },
 
-        track(options) {
-            if (!options || (isFunction(options.omit) ? options.omit() : options.omit)) return this;
-            if (isString(options)) options = {message: options};
-
-            const startTime = Date.now();
-            return this.finally(() => {
-                XH.track({
-                    timestamp: startTime,
-                    elapsed: Date.now() - startTime,
-                    ...options
-                });
-            });
+        track<T>(options: TrackOptions | string): Promise<T> {
+            if (!options) return this;
+
+            const startTime = Date.now(),
+                doTrack = (isError: boolean) => {
+                    const opts: TrackOptions = isString(options)
+                        ? {message: options}
+                        : {...options};
+
+                    opts.timestamp = startTime;
+                    opts.elapsed = Date.now() - startTime;
+                    if (isError) opts.severity = 'ERROR';
+
+                    XH.track(opts);
+                };
+
+            return this.then(
+                (v: T) => {
+                    doTrack(true);
+                    return v;
+                },
+                (t: unknown) => {
+                    doTrack(false);
+                    throw t;
+                }
+            );
         },
 
-        tap(onFulfillment) {
+        tap<T>(onFulfillment: (value: T) => any): Promise<T> {
             let ret = null;
             const resolveFn = data => {
                 ret = data;
@@ -215,13 +237,14 @@ const enhancePromise = promisePrototype => {
             return this.then(resolveFn).then(() => ret);
         },
 
-        wait(interval) {
+        wait<T>(interval: number): Promise<T> {
             return this.finally(() => wait(interval));
         },
 
-        timeout(config) {
-            if (config == null) return this;
-            if (isNumber(config)) config = {interval: config};
+        timeout<T>(spec: PromiseTimeoutSpec): Promise<T> {
+            if (spec == null) return this;
+
+            const config: TimeoutExceptionConfig = isNumber(spec) ? {interval: spec} : spec;
             const interval = config.interval;
 
             let completed = false;
@@ -236,14 +259,14 @@ const enhancePromise = promisePrototype => {
             return Promise.race([deadline, promise]);
         },
 
-        linkTo(cfg) {
+        linkTo<T>(cfg: PromiseLinkSpec): Promise<T> {
             if (!cfg) return this;
 
-            if (cfg.isTaskObserver) {
+            if (cfg instanceof TaskObserver) {
                 cfg = {observer: cfg};
             }
 
-            if (cfg.observer && !(isFunction(cfg.omit) ? cfg.omit() : cfg.omit)) {
+            if (cfg.observer && !isOmitted(cfg)) {
                 cfg.observer.linkTo(TaskObserver.forPromise({promise: this, message: cfg.message}));
             }
             return this;
@@ -252,7 +275,7 @@ const enhancePromise = promisePrototype => {
         //--------------------------------
         // Implementation
         //--------------------------------
-        throwIfFailsSelector(e, selector) {
+        throwIfFailsSelector(e: any, selector: any) {
             const fn = isFunction(selector) ? selector : e => castArray(selector).includes(e.name);
             if (!fn(e)) throw e;
         }

package/svc/TrackService.ts

@@ -168,6 +168,6 @@ interface ActivityTrackingConfig {
     levels?: Array<{
         username: string | '*';
         category: string | '*';
-        severity: 'DEBUG' | 'INFO' | 'WARN';
+        severity: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
     }>;
 }