flexdesk 0.17.4 → 0.17.6

package/src/charts/data_series_plot_window.js

@@ -107,7 +107,8 @@ class DataSeriesPlotWindow {
             this._config = { ...saved };
             this._config.yColumns = (saved.yColumns || []).filter(c => this._numericColumns.has(c.header));
         } else {
-            this._config = DataSeriesPlotWindow.createDefaultConfig(this.headers, this._numericColumns);
+            this._config = DataSeriesPlotWindow.createDefaultConfig(
+                this.headers, this._numericColumns, this.classifyHeader);
         }
 
         this.#createWindow();
@@ -694,13 +695,26 @@ class DataSeriesPlotWindow {
 
     // ── Default config factory ───────────────────────────────────────────
 
-    static createDefaultConfig(headers, numericColumns) {
+    /**
+     * The config a series with no saved one opens with: the first numeric
+     * column `classifyHeader` calls `'time'` is X (else the first numeric
+     * column), and up to MAX_AUTO_COLUMNS other numeric columns are Y.
+     *
+     * Static, so it has no window: the header classifier is a parameter. A
+     * window passes its own (`options.classifyHeader`); a caller that passes
+     * none gets the default, which knows `t`/`time`/`step`/`period`.
+     *
+     * @param {string[]} headers
+     * @param {Set<string>} [numericColumns] - absent => every column is numeric
+     * @param {(header: string) => string} [classifyHeader=defaultClassifyHeader]
+     */
+    static createDefaultConfig(headers, numericColumns, classifyHeader = defaultClassifyHeader) {
         const isNumeric = numericColumns instanceof Set ? (h) => numericColumns.has(h) : () => true;
 
         // Find best X column (time-like, must be numeric)
         let xColumn = '';
         for (const h of headers) {
-            if (isNumeric(h) && this.classifyHeader(h) === 'time') {
+            if (isNumeric(h) && classifyHeader(h) === 'time') {
                 xColumn = h;
                 break;
             }

package/src/editor/monaco_editor_factory.js

@@ -22,7 +22,13 @@ export function setDefaultLanguage(id) {
     if (typeof id === 'string' && id) _defaultLanguage = id;
 }
 
-/** Dispose a Monaco editor, swallowing the benign "Canceled" error from pending async ops. */
+/**
+ * Dispose a Monaco editor, swallowing a "Canceled" error that `dispose()` throws
+ * synchronously. It cannot catch the asynchronous kind — a pending Delayer's
+ * promise rejected by the dispose, which surfaces later as an unhandled
+ * rejection; the loader's window listener hides those (see
+ * `installCancellationGuard` in monaco_loader.js, BUG-0038).
+ */
 function safeDispose(editor) {
     try { editor.dispose(); } catch (e) { if (e?.message !== 'Canceled') throw e; }
 }

package/src/editor/monaco_loader.js

@@ -38,6 +38,38 @@ let _attempt = null;
  */
 export const monacoReady = new Promise(resolve => { _resolveMonaco = resolve; });
 
+/**
+ * Monaco's asynchronous CancellationError is benign; keep it off the page.
+ *
+ * Monaco starts timers it never awaits: its WordHighlighter calls
+ * `runDelayer.trigger()` (a 50 ms Delayer) when an editor gets focus and
+ * drops the promise. Dispose the editor inside those 50 ms and
+ * `Delayer.dispose() -> cancel()` rejects that promise with a CancellationError
+ * (name and message both 'Canceled') that nothing handles, so the browser
+ * reports an uncaught 'Canceled' (BUG-0038). VS Code hides these with its own
+ * unhandledrejection handler; standalone Monaco has none, so FlexDesk installs
+ * one here: it calls preventDefault() for exactly that error and leaves every
+ * other rejection to surface as before.
+ *
+ * Installed once per page, by the first initMonaco() that starts a load, and
+ * kept for the life of the page — like Monaco itself, which cannot be unloaded.
+ */
+let _cancellationGuardInstalled = false;
+
+function isMonacoCancellation(reason) {
+    return reason?.name === 'Canceled' && reason?.message === 'Canceled';
+}
+
+function installCancellationGuard() {
+    if (_cancellationGuardInstalled) return;
+    _cancellationGuardInstalled = true;
+    // `?.`: the loader suites' stand-in pages (tests/monaco_env.mjs and the
+    // suites that set `window = globalThis` under Node) have no event target.
+    window.addEventListener?.('unhandledrejection', (event) => {
+        if (isMonacoCancellation(event.reason)) event.preventDefault();
+    });
+}
+
 function injectLoaderScript(src) {
     return new Promise((resolve, reject) => {
         const s = document.createElement('script');
@@ -124,6 +156,10 @@ async function loadMonaco(basePath) {
  * given). An AMD-level failure is final for the page: every later call gets
  * the same rejection, and only a reload recovers (see `_attempt`).
  *
+ * The first call that starts a load also installs one window
+ * 'unhandledrejection' listener that hides Monaco's benign asynchronous
+ * CancellationError, and nothing else (see `installCancellationGuard`).
+ *
  * @param {string} [basePath] Path prefix for the vs/ directory. REQUIRED
  *     unless an attempt is already in flight or has succeeded.
  * @returns {Promise<typeof monaco>}
@@ -136,6 +172,7 @@ export function initMonaco(basePath) {
             + "initMonaco('vendor/monaco'). Monaco is a peer dependency; the library "
             + 'does not guess where you put it.'));
     }
+    installCancellationGuard();
     const attempt = loadMonaco(basePath).then(
         (m) => { _resolveMonaco(m); return m; },
         (err) => {