@xh/hoist 59.3.1 → 59.3.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 59.3.2 - 2023-11-21
+
+### 🐞 Bug Fixes
+
+* `ZoneGrid` will more gracefully handle state that has become out of sync with its mapper requirements.
+
 ## 59.3.1 - 2023-11-10
 
 ### 🐞 Bug Fixes

package/cmp/zoneGrid/ZoneGridModel.ts

@@ -49,7 +49,7 @@ import {
 } from '@ag-grid-community/core';
 import {Icon} from '@xh/hoist/icon';
 import {throwIf, withDefault} from '@xh/hoist/utils/js';
-import {castArray, forOwn, isEmpty, isFinite, isPlainObject, isString} from 'lodash';
+import {castArray, forOwn, isEmpty, isFinite, isPlainObject, isString, find} from 'lodash';
 import {ReactNode} from 'react';
 import {ZoneMapperConfig, ZoneMapperModel} from './impl/ZoneMapperModel';
 import {ZoneGridPersistenceModel} from './impl/ZoneGridPersistenceModel';
@@ -326,7 +326,7 @@ export class ZoneGridModel extends HoistModel {
 
         this.availableColumns = columns.map(it => ({...it, hidden: true}));
         this.limits = limits;
-        this.mappings = this.parseMappings(mappings);
+        this.mappings = this.parseMappings(mappings, true);
 
         this.leftColumnSpec = leftColumnSpec;
         this.rightColumnSpec = rightColumnSpec;
@@ -397,7 +397,7 @@ export class ZoneGridModel extends HoistModel {
 
     @action
     setMappings(mappings: Record<Zone, Some<string | ZoneMapping>>) {
-        this.mappings = this.parseMappings(mappings);
+        this.mappings = this.parseMappings(mappings, false);
         this.gridModel.setColumns(this.getColumns());
     }
 
@@ -611,46 +611,62 @@ export class ZoneGridModel extends HoistModel {
     }
 
     private parseMappings(
-        mappings: Record<Zone, Some<string | ZoneMapping>>
+        mappings: Record<Zone, Some<string | ZoneMapping>>,
+        strict: boolean
     ): Record<Zone, ZoneMapping[]> {
         const ret = {} as Record<Zone, ZoneMapping[]>;
-        forOwn(mappings, (rawMapping, zone) => {
-            // 1) Standardize mapping into an array of ZoneMappings
-            const mapping = [];
-            castArray(rawMapping).forEach(it => {
-                if (!it) return;
+        forOwn(mappings, (rawMapping, zone: Zone) => {
+            try {
+                ret[zone] = this.parseZoneMapping(zone, rawMapping);
+            } catch (e) {
+                if (strict) throw e;
+                console.warn(e.message);
+                ret[zone] = this._defaultState.mappings[zone];
+            }
+        });
+        return ret;
+    }
 
-                const ret = isString(it) ? {field: it} : it,
-                    col = this.findColumnSpec(ret);
+    private parseZoneMapping(zone: Zone, rawMapping: Some<string | ZoneMapping>): ZoneMapping[] {
+        const ret: ZoneMapping[] = [];
 
-                throwIf(!col, `Column not found for field ${ret.field}`);
-                return mapping.push(ret);
-            });
+        // 1) Standardize raw mapping into an array of ZoneMappings
+        castArray(rawMapping).forEach(it => {
+            if (!it) return;
 
-            // 2) Ensure mapping respects configured limits
-            const limit = this.limits?.[zone];
-            if (limit) {
-                throwIf(
-                    isFinite(limit.min) && mapping.length < limit.min,
-                    `Requires minimum ${limit.min} mappings in zone "${zone}"`
-                );
-                throwIf(
-                    isFinite(limit.max) && mapping.length > limit.max,
-                    `Exceeds maximum ${limit.max} mappings in zone "${zone}"`
-                );
-
-                if (!isEmpty(limit.only)) {
-                    mapping.forEach(it => {
-                        throwIf(
-                            !limit.only.includes(it.field),
-                            `Field "${it.field}" not allowed in zone "${zone}"`
-                        );
-                    });
-                }
-            }
+            const fieldSpec = isString(it) ? {field: it} : it,
+                col = this.findColumnSpec(fieldSpec);
+
+            throwIf(!col, `Column not found for field '${fieldSpec.field}'`);
 
-            ret[zone] = mapping;
+            ret.push(fieldSpec);
         });
+
+        // 2) Ensure we respect configured limits
+        const limit = this.limits?.[zone];
+        if (limit) {
+            throwIf(
+                isFinite(limit.min) && ret.length < limit.min,
+                `Requires minimum ${limit.min} mappings in zone "${zone}."`
+            );
+
+            throwIf(
+                isFinite(limit.max) && ret.length > limit.max,
+                `Exceeds maximum ${limit.max} mappings in zone "${zone}".`
+            );
+
+            if (!isEmpty(limit.only)) {
+                const offender = find(ret, it => !limit.only.includes(it.field));
+                throwIf(offender, `Field "${offender?.field}" not allowed in zone "${zone}".`);
+            }
+        }
+
+        // 3) Ensure top zones have at least the minimum required single field
+        throwIf(
+            (zone == 'tl' || zone == 'tr') && isEmpty(ret),
+            `Top mapping '${zone}' requires at least one field.`
+        );
+
         return ret;
     }
 

package/core/XH.ts

@@ -674,9 +674,9 @@ export class XHApi {
 
     /** Get the first active model that matches the given selector, or null if none found. */
     getModel<T extends HoistModel>(selector: ModelSelector = '*'): T {
-        instanceManager.models.forEach(m => {
-            if (m.matchesSelector(selector, true)) return m;
-        });
+        for (let m of instanceManager.models) {
+            if (m.matchesSelector(selector, true)) return m as T;
+        }
         return null;
     }
 

package/package.json

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

package/svc/EnvironmentService.ts

@@ -125,7 +125,7 @@ export class EnvironmentService extends HoistService {
             } else if (mode === 'forceReload') {
                 XH.suspendApp({
                     reason: 'APP_UPDATE',
-                    message: `A new version of ${XH.clientAppName} is available!`
+                    message: `A new version of ${XH.clientAppName} is now available (${appVersion}) and requires an immediate update.`
                 });
             }
         }

package/utils/async/Timer.ts

@@ -15,19 +15,20 @@ import {isBoolean, isFinite, isFunction, isNil, isString, pull} from 'lodash';
  * Promise-aware recurring task timer for use by framework and applications.
  *
  * This object is designed to be robust across failing tasks, and never to re-run the task
- * simultaneously, unless in the case of a timeout.  Callers can optionally specify
- * the duration of asynchronous tasks by returning a Promise from runFn.
+ * simultaneously, unless in the case of a timeout. Callers can optionally specify the duration
+ * of asynchronous tasks by returning a Promise from runFn.
  *
- * This object seeks to mirror the API and semantics of the server-side equivalent 'Timer'
- * as closely as possible. However, there are important differences due to the synchronous
- * nature of javascript. In particular, there is no support for 'runImmediatelyAndBlock', and the
- * 'timeout' argument will not be able to interrupt synchronous activity of the runFn.
+ * This object seeks to mirror the API and semantics of `Timer.groovy` from Hoist Core as closely
+ * as possible. However, there are important differences due to the synchronous nature of
+ * javascript. In particular, there is no support for `runImmediatelyAndBlock`, and the `timeout`
+ * argument will not be able to interrupt synchronous activity of the runFn.
  *
- * All public properties should be considered read-only. See `setInterval()` to change the interval
- * of this timer dynamically.
+ * All public properties should be considered read-only.
+ * See `setInterval()` to change the interval of this Timer dynamically.
  */
 export class Timer {
     static _timers: Timer[] = [];
+    static MIN_INTERVAL_MS = 500;
 
     runFn: () => any = null;
     interval: number | (() => number) = null;
@@ -41,6 +42,8 @@ export class Timer {
     isRunning: boolean = false;
     lastRun: Date = null;
 
+    private warnedIntervals = new Set();
+
     /** Create a new Timer. */
     static create({
         runFn,
@@ -67,9 +70,7 @@ export class Timer {
         this._timers = [];
     }
 
-    /**
-     * Permanently cancel this timer.
-     */
+    /** Permanently cancel this timer. */
     cancel() {
         this.cancelInternal();
         pull(Timer._timers, this);
@@ -77,7 +78,6 @@ export class Timer {
 
     /**
      * Change the interval of this timer.
-     *
      * @param interval - ms to wait between runs or any value `<=0` to pause the timer.
      */
     setInterval(interval: number) {
@@ -94,7 +94,10 @@ export class Timer {
         this.intervalUnits = args.intervalUnits;
         this.timeoutUnits = args.timeoutUnits;
         this.delay = this.parseDelay(args.delay);
-        throwIf(this.interval == null || this.runFn == null, 'Missing req arguments for Timer');
+        throwIf(
+            this.interval == null || this.runFn == null,
+            'Missing required arguments for Timer - both interval and runFn must be specified.'
+        );
 
         wait(this.delay).then(() => this.heartbeatAsync());
     }
@@ -133,18 +136,27 @@ export class Timer {
         return isString(val) ? () => XH.configService.get(val) : val;
     }
 
-    private parseDelay(val): number {
+    private parseDelay(val: number | boolean): number {
         if (isBoolean(val)) return val ? this.intervalMs : 0;
         return isFinite(val) ? val : 0;
     }
 
     private get intervalMs() {
-        const {interval, intervalUnits} = this;
+        const {interval, intervalUnits, warnedIntervals} = this,
+            min = Timer.MIN_INTERVAL_MS;
+
         if (isNil(interval)) return null;
+
         let ret = (isFunction(interval) ? interval() : interval) * intervalUnits;
-        if (ret > 0 && ret < 500) {
-            console.warn('Timer cannot be set for values less than 500ms.');
-            ret = 500;
+
+        if (ret > 0 && ret < min) {
+            if (!warnedIntervals.has(ret)) {
+                warnedIntervals.add(ret);
+                console.warn(
+                    `Timer interval of ${ret}ms requested - forcing to min interval of ${min}ms.`
+                );
+            }
+            ret = min;
         }
         return ret;
     }