@trebco/treb 32.14.0 → 36.1.2

package/treb-embed/src/embedded-spreadsheet.ts

@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU General Public License along 
  * with TREB. If not, see <https://www.gnu.org/licenses/>. 
  *
- * Copyright 2022-2025 trebco, llc. 
+ * Copyright 2022-2026 trebco, llc. 
  * info@treb.app
  * 
  */
@@ -26,6 +26,7 @@ import type {
   SheetChangeEvent, GridOptions, 
   CellEvent, FunctionDescriptor, 
   ExternalEditorConfig,
+  GridSelectionEvent,
 } from 'treb-grid';
 
 import { DataModel, Sheet, StandardGradientsList } from 'treb-data-model';
@@ -74,6 +75,7 @@ import type {
   IArea, CellValue, Point,
   Complex, ExtendedUnion, IRectangle,
   AddressReference, RangeReference, TableSortOptions, Table, TableTheme,
+  Theme,
 } from 'treb-base-types';
 
 import {
@@ -92,7 +94,7 @@ import { NumberFormatCache, ValueParser, NumberFormat, LotusDate, UnlotusDate }
 import { Dialog, DialogType } from './progress-dialog';
 import { Spinner } from './spinner';
 import { type EmbeddedSpreadsheetOptions, DefaultOptions, type ExportOptions } from './options';
-import { type TREBDocument, SaveFileType, LoadSource, type EmbeddedSheetEvent, type InsertTableOptions } from './types';
+import { type TREBDocument, SaveFileType, LoadSource, type EmbeddedSheetEvent, type InsertTableOptions, type SelectionEvent } from './types';
 
 import type { SelectionState } from './selection-state';
 import type { BorderToolbarMessage, ToolbarMessage } from './toolbar-message';
@@ -102,6 +104,7 @@ import type { SetRangeOptions, ClipboardData, PasteOptions } from 'treb-grid';
 
 import type { StateLeafVertex } from 'treb-calculator';
 
+import * as ImportExportMessages from 'treb-export/src/import-export-messages';
 
 // --- worker ------------------------------------------------------------------
 
@@ -109,9 +112,20 @@ import type { StateLeafVertex } from 'treb-calculator';
  * import type for our worker, plus markup files
  */
 import './content-types.d.ts';
+import { CreateWorker, type WorkerProxy } from 'treb-base-types';
 
 // --- types -------------------------------------------------------------------
 
+/** new, intended for tui support but keeping it as generic as possible */
+export type CustomGridFactory = (
+        options: GridOptions, 
+        model: DataModel,
+        theme: Theme|undefined,
+        initialze_dom: boolean,
+        DOM: DOMContext,
+      ) => Grid;
+
+
 /**
  * options for saving files. we add the option for JSON formatting.
  */
@@ -243,6 +257,18 @@ export type TableFilterFunction = (value: CellValue, calculated_value: CellValue
  */
 export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> { 
 
+  /**
+   * this is temporary. we need a better way to handle this, perhaps
+   * making the factory method (createSpreadsheet) async.
+   * 
+   * for now, you can test on this set of promises to see when the 
+   * app is ready
+   */
+  protected _ready_state: Promise<void>[] = [];
+  public get ready () {
+    return Promise.all(this._ready_state);
+  }
+
   /** @internal */
   public static treb_base_path = '';
 
@@ -463,8 +489,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   /**
    * export worker (no longer using worker-loader).
    * export worker is loaded on demand, not by default.
+   * 
+   * FIXME: type
    */
-  protected export_worker?: Worker;
+  protected export_worker?: WorkerProxy<ImportExportMessages.RXMessages, ImportExportMessages.TXMessages>;
 
   /**
    * undo pointer points to the next insert spot. that means that when
@@ -651,7 +679,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @internal
    */
-  constructor(options: EmbeddedSpreadsheetOptions & { model?: EmbeddedSpreadsheet }) { 
+  constructor(options: EmbeddedSpreadsheetOptions & { model?: EmbeddedSpreadsheet, custom_grid?: CustomGridFactory }) { 
 
     // we renamed this option, default to the new name
 
@@ -832,8 +860,12 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     }
 
-    //this.extra_calculator = //new Calculator(this.model);
-    //  this.CreateCalculator(this.model);
+    // FIXME: we should start figuring out what can happen before
+    // this async init, and what has to wait. then we can split the 
+    // ctor into two parts, and move stuff that has to wait to part 2
+
+    const calculator_init = this.calculator.InitResources();
+    this._ready_state.push(calculator_init);
 
     if (container) {
       this.DOM = DOMContext.GetInstance(container.ownerDocument);
@@ -847,12 +879,30 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // it when we don't have a container? or was it built for something
     // else? (A: it was)
 
-    this.grid = new Grid(
-        grid_options, 
-        this.model, 
-        undefined, 
-        !!container, 
-        this.DOM);
+    if (options.custom_grid) {
+      this.grid = options.custom_grid(
+          grid_options, 
+          this.model, 
+          undefined, 
+          !!container, 
+          this.DOM);
+
+      // we're going to need to create some sort of capabilities map
+      // for custom grids. for the time being, let's subscribe to events
+      // and see what happens.
+
+      // UPDATE: do that a little later...
+
+
+    }
+    else {
+      this.grid = new Grid(
+          grid_options, 
+          this.model, 
+          undefined, 
+          !!container, 
+          this.DOM);
+      }
 
     if (this.options.headless) {
       this.grid.headless = true; // FIXME: move into grid options
@@ -970,7 +1020,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
           case 'selection':
             // console.info('selection event');
-            this.UpdateSelection(event.selection);
+            this.UpdateSelection(event.selection, event.reason);
             this.UpdateSelectionStyle(event.selection);
             break;
 
@@ -1133,11 +1183,204 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     }
     else {
+
+      if (options.custom_grid) {
+        console.info("creating subscription for custom grid (TODO: capabilities)")
+
+        ////
+
+
+        this.grid.grid_events.Subscribe((event) => {
+
+          // console.info({event});
+
+          switch (event.type) {
+
+            // these messages can stack, they don't have undo effect
+
+            case 'error':
+              /*
+              this.dialog?.ShowDialog({
+                type: DialogType.error,
+                ...this.TranslateGridError(event.code),
+                timeout: 3000,
+                close_box: true,
+              });
+              */
+
+              // ??
+
+              break;
+
+            case 'selection':
+              // console.info('selection event');
+              this.UpdateSelection(event.selection, event.reason);
+              this.UpdateSelectionStyle(event.selection);
+              break;
+
+            case 'sheet-change':
+              this.OnSheetChange(event);
+              this.UpdateSelectionStyle();
+              break;
+
+            case 'scale':
+              this.RebuildAllAnnotations();
+              this.Publish({ type: 'view-change' });
+              break;
+    
+            case 'cell-event':
+              this.HandleCellEvent(event);
+              break;
+
+            // messages that trigger undo need some special handling, 
+            // because we don't want to stack a sequence of messages
+            // and push multiple undo events. that applies to data, 
+            // style, structure, and (maybe?) annotations
+
+            // OK, temp we have a composite event for data+style
+
+            case 'composite':
+              {
+                const cached_selection = this.last_selection;
+                if (this.calculation === CalculationOptions.automatic) {
+                  this.Recalculate(event);
+                }
+                this.DocumentChange(cached_selection);
+                this.UpdateDocumentStyles();
+                this.UpdateSelectionStyle();
+              }
+              break;
+
+            case 'data':
+              {
+                // because this is async (more than once), we can't expect the 
+                // selection event to happen after the PushUndo call. we need
+                // to preserve the current selection and pass it through.
+
+                const cached_selection = this.last_selection;
+
+                // recalc is no longer async
+
+                if (this.calculation === CalculationOptions.automatic) {
+                  this.Recalculate(event);
+                }
+
+                this.DocumentChange(cached_selection);
+
+              }
+              break;
+
+            case 'style':
+              this.DocumentChange();
+              this.UpdateDocumentStyles();
+              this.UpdateSelectionStyle();
+              break;
+
+            case 'annotation':
+
+              /*
+              // FIXME: maybe need to update vertices (on create, update, delete,
+              // not on move or resize)
+
+              if (event.annotation) {
+                const view: AnnotationViewData = event.annotation.view[this.grid.view_index] || {};
+
+                let update_toolbar = false;
+
+                if (event.event === 'select') {
+                  update_toolbar = true;
+                }
+                else {
+                  this.DocumentChange();
+                  switch (event.event) {
+                    case 'create':
+                      this.InflateAnnotation(event.annotation);
+                      this.calculator.UpdateAnnotations(event.annotation, this.grid.active_sheet);
+                      this.grid.AnnotationUpdated(event.annotation);
+                      update_toolbar = (event.annotation === this.grid.selected_annotation);
+                      break;
+                    case 'delete':
+                      this.calculator.RemoveAnnotation(event.annotation); // clean up vertex
+                      break;
+                    case 'update':
+                      if (view.update_callback) {
+                        view.update_callback();
+                        this.grid.AnnotationUpdated(event.annotation);
+                      }
+                      else {
+                        console.info('annotation update event without update callback');
+                      }
+                      this.calculator.UpdateAnnotations(event.annotation, this.grid.active_sheet);
+                      update_toolbar = (event.annotation === this.grid.selected_annotation);
+                      break;
+                    case 'resize':
+                      if (view.resize_callback) {
+                        view.resize_callback();
+                        this.grid.AnnotationUpdated(event.annotation);
+                      }
+                      break;
+                  }
+
+                }
+
+                if (update_toolbar) {
+                  this.UpdateSelectionStyleAnnotation(event.annotation);
+                  this.Publish({ type: 'annotation-selection' });
+                  break;
+                }
+
+              }
+              else {
+                console.info('annotation event without annotation');
+              }
+              */
+              break;
+
+            case 'structure':
+              {
+                // console.info("S event", event);
+
+                const cached_selection = this.last_selection;
+                if (event.conditional_format) {
+                  this.calculator.UpdateConditionals();
+                  this.ApplyConditionalFormats(this.grid.active_sheet, false);
+                }
+
+                if (event.rebuild_required) {
+                  this.calculator.Reset();
+
+                  // recalculate is no longer async
+
+                  if (this.calculation === CalculationOptions.automatic) {
+                    this.Recalculate(event);
+                  }
+                  this.DocumentChange(cached_selection);
+
+                }
+                else {
+                  this.DocumentChange(cached_selection);
+                }
+              }
+              this.UpdateSelectionStyle();
+              break;
+
+          }
+        });
+
+        ////
+
+        
+      }
+
       if (!EmbeddedSpreadsheet.one_time_warnings.headless) {
-        EmbeddedSpreadsheet.one_time_warnings.headless = true;
-        console.info('not initializing layout; don\'t call UI functions');
+
+        // suppress this warning if you explicitly set headless mode
+
+        if (!options.headless) {
+          EmbeddedSpreadsheet.one_time_warnings.headless = true;
+          console.info('not initializing layout; don\'t call UI functions');
+        }
       }
-      // this.grid.headless = true; // ensure
     }
 
     if (options.preload) {
@@ -1151,7 +1394,9 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
         data = JSON.parse(data);
       }
       if (data) {
-        this.LoadDocument(data as TREBDocument, { recalculate: !!this.options.recalculate, source});
+        calculator_init.then(() => {
+          this.LoadDocument(data as TREBDocument, { recalculate: !!this.options.recalculate, source});
+        });
       }
       else {
         this.UpdateDocumentStyles();
@@ -1206,13 +1451,16 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       this.spinner = new Spinner(container);
     }
 
+
     // don't load if we are a split view
     // UPDATE: don't load if we have a local_storage document. this is taking
     // over the old alternate_document flow, because it doesn't make any sense
     // otherwise. what would local_storage with document_name mean otherwise?
 
     if (network_document && !options.model && !data) {
-      this.LoadNetworkDocument(network_document, this.options);
+      calculator_init.then(() => {
+        this.LoadNetworkDocument(network_document, this.options);
+      });
     }
 
     // create mask dialog
@@ -1286,6 +1534,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     return new Calculator(model, {
       complex_numbers: options.complex,
       spill: options.spill,
+      headless: options.headless,
     });
   }
 
@@ -1881,6 +2130,17 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
         case 'insert-scatter-plot': insert_annotation('Scatter.Plot'); break;
         case 'insert-box-plot': insert_annotation('Box.Plot'); break;
 
+        case 'toggle-grouping':
+          if (this.selection_state?.style) {
+            const format = NumberFormatCache.Get(this.selection_state.style.number_format || 'General');
+            if (format.date_format) { break; }
+            const clone = new NumberFormat(format.pattern);
+            clone.ToggleGrouping();
+            const rendered = clone.toString();
+            updated_style.number_format = NumberFormatCache.SymbolicName(rendered) || rendered;
+          }
+          break;
+
         case 'increase-precision':
         case 'decrease-precision':
           if (this.selection_state?.style) {
@@ -1890,78 +2150,18 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
             const clone = new NumberFormat(format.pattern);
 
-            // special case: from general, we want to go to a relative number...
-            // for that to work, we need a (the first) value... then go from there.
-
-            // NOTE: this isn't really the way to identify this, we only want
-            // to do this if the style === 'General'. 
-
-            if (format.magic_decimal) {
-
-              // but what we're doing here, if there's a magic decimal, is
-              // measuring the decimal part of the first number we find. then
-              // we increase/decrease from that.
-
-              let len = 0;
-              let rng = this.GetRange();
-              
-              // find the first number...
-
-              if (!Array.isArray(rng)) {
-                rng = [[rng]];
-              }
-
-              find_number:
-              for (let i = 0; i < rng.length; i++) {
-                for (let j = 0; j < rng[i].length; j++) {
-                  const value = rng[i][j];
-
-                  if (typeof value !== 'undefined' && IsComplex(value)) {
-
-                    // find the longer of the two, use that as base
-
-                    //const f2 = NumberFormatCache.Get(this.active_selection_style.number_format || 'General', true);
-                    const f2 = NumberFormatCache.Get(this.selection_state.style.number_format || 'General', true);
-                    const real_parts = f2.BaseFormat(value.real);
-                    const imaginary_parts = f2.BaseFormat(value.imaginary);
-
-                    if (real_parts.parts && typeof real_parts.parts[1] === 'string') {
-                      len = real_parts.parts[1].length;
-                    }
-                    if (imaginary_parts.parts && typeof imaginary_parts.parts[1] === 'string') {
-                      len = Math.max(len, imaginary_parts.parts[1].length);
-                    }
-                    
-                    break find_number;
-
-                  }
-                  else if (typeof value === 'number') {
-                    const parts = format.BaseFormat(value);
-                    if (parts.parts && typeof parts.parts[1] === 'string') {
-                      len = parts.parts[1].length;
-                    }
-                    break find_number;
-                  }
-                }
-              }
-
-              if (event.command === 'increase-precision') {
-                clone.SetDecimal(len + 1);
-              }
-              else {
-                clone.SetDecimal(Math.max(0, len - 1));
-              }
-              
+            if (event.command === 'increase-precision' ) {
+              clone.IncreaseDecimal();
             }
             else {
-              if (event.command === 'increase-precision' ) {
-                clone.IncreaseDecimal();
-              }
-              else {
-                clone.DecreaseDecimal();
-              }
+              clone.DecreaseDecimal();
             }
-            updated_style.number_format = clone.toString();
+
+            // try to resolve this to a standard format, if possible
+
+            const rendered = clone.toString();
+            updated_style.number_format = NumberFormatCache.SymbolicName(rendered) || rendered;
+
           }
           break;
 
@@ -2203,7 +2403,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       // comments
 
       try {
-        mod = await import(`esbuild-ignore-import:./languages/treb-i18n-${language}.mjs`);
+        const path = `./languages/treb-i18n-${language}.mjs`;
+        mod = await import(path);
       }
       catch (err) {
         console.error(err);
@@ -2222,6 +2423,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     this.grid.Update(true);
     this.UpdateAC();
 
+    this.Publish({
+      type: 'language-change',
+    });
+
   }
 
   /**
@@ -2870,6 +3075,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @param column - column, or columns (array), or undefined means all columns
    * @param width - desired width (can be 0) or undefined means 'auto-size'
+   * @param allow_shrinking - for auto-size, allow shrinking. defaults to true.
    * 
    * @privateRemarks
    * 
@@ -2878,9 +3084,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @public
    */
-  public SetColumnWidth(column?: number | number[], width?: number): void {
-   
-    this.grid.SetColumnWidth(column, width);
+  public SetColumnWidth(column?: number | number[], width?: number, allow_shrinking?: boolean): void {
+    this.grid.SetColumnWidth(column, width, allow_shrinking);
   }
 
   /**
@@ -3084,14 +3289,16 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     return new Promise<Blob>((resolve, reject) => {
 
       if (this.export_worker) {
-        this.export_worker.onmessage = (event) => {
-          resolve(event.data ? event.data.blob : undefined);
-        };
-        this.export_worker.onerror = (event) => {
+        this.export_worker.OnMessage((event) => {
+          if (event.data.type === 'export-complete') {
+            resolve(event.data.blob);
+          }
+        });
+        this.export_worker.OnError((event) => {
           console.error('export worker error');
           console.info(event);
           reject(event);
-        };
+        });
 
         if (!serialized) {        
           serialized = this.Serialize({
@@ -3109,8 +3316,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
         // why do _we_ put this in, instead of the grid method? 
         serialized.decimal_mark = Localization.decimal_separator;
 
-        this.export_worker.postMessage({
-          command: 'export', 
+        this.export_worker.PostMessage({
+          type: 'export', 
           sheet: serialized, 
           decorated: this.calculator.DecoratedFunctionList(),
         });
@@ -4041,7 +4248,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     this.calculator.Calculate(area);
 
-    if (this.calculator.grid_expanded) {
+    if (this.calculator.grid_expanded && !this.grid.headless) {
       // console.info("GRID EXPANDED");
       this.grid.UpdateLayout();
     }
@@ -5061,7 +5268,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    *
    */
    protected async ImportXLSX( // data: string, source: LoadSource): Promise<Blob | void> {
-    data: ArrayBuffer, source: LoadSource): Promise<Blob | void> {
+    data: ArrayBuffer, source: LoadSource, path?: string): Promise<Blob | void> {
 
     // this is inlined to ensure the code will be tree-shaken properly
     if (!process.env.XLSX_SUPPORT) {
@@ -5089,12 +5296,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
           message: 'Importing XLSX...'
         });
 
-        this.export_worker.onmessage = (event) => {
+        this.export_worker.OnMessage((event) => {
           if (event.data) {
 
-            if (event.data.status === 'error') {
+            if (event.data.type === 'import-error') {
               return reject(event.data.error || 'unknown error');
             }
+            if (event.data.type !== 'import-complete') {
+              return reject('unknown error (invalid message)');
+            }
 
             if (this.parser.decimal_mark !== DecimalMarkType.Period) {
               
@@ -5118,15 +5328,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
                   });
               };
 
-              for (const named of event.data.results) {
-                named.expression = translate(named.expression);                
+              for (const named of event.data.results.named || []) {
+                named.expression = translate(named.expression) || '';                
               }
 
               for (const sheet of event.data.results.sheets || []) {
 
                 for (const cell of sheet.cells || []) {
                   if (cell.type === 'formula' && cell.value) {
-                    cell.value = translate(cell.value);
+                    cell.value = translate(cell.value as string);
                   }
                 }
 
@@ -5152,7 +5362,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
             // this one _is_ the grid cells
 
             // this.calculator.AttachModel();
-            this.Publish({ type: 'load', source, });
+            this.Publish({ type: 'load', source, path });
             this.UpdateDocumentStyles();
 
             // add to support import charts
@@ -5171,15 +5381,18 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
           this.dialog?.HideDialog();
           resolve();
-        };
-        this.export_worker.onerror = (event) => {
+        });
+
+        this.export_worker.OnError((event) => {
           console.error('import worker error');
           console.info(event);
           reject(event);
-        };
-        this.export_worker.postMessage({
-          command: 'import', data,
         });
+
+        this.export_worker.PostMessage({
+          type: 'import', data,
+        });
+
       }
       else {
         reject('worker failed');
@@ -5630,21 +5843,6 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     }
   }
 
-  /*
-  public SetHeadless(headless = true): void {
-    if (this.grid.headless === headless) {
-      return;
-    }
-
-    this.grid.headless = headless;
-    if (!headless) {
-      this.grid.Update(true);
-      this.RebuildAllAnnotations();
-      // this.InflateAnnotations();
-    }
-  }
-  */
-
   /**
    * this method should be called after changing the headless flag
    */
@@ -6119,14 +6317,19 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * we can also use this to better manage selection in the undo system...
    * 
    */
-  protected UpdateSelection(selection: GridSelection): void {
+  protected UpdateSelection(selection: GridSelection, reason?: GridSelectionEvent['reason']): void {
 
     // console.info("US", JSON.stringify(selection));
 
     // cache for undo
     this.last_selection = JSON.stringify(selection);
 
-    this.Publish({ type: 'selection' });
+    const event: SelectionEvent = { type: 'selection' };
+    if (reason === 'sheet-change') {
+      event.reason = reason;
+    }
+
+    this.Publish(event);
   }
 
   /** update selection style for the toolbar, when an annotation is selected. */
@@ -6240,12 +6443,6 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   }
 
-  /* * overloadable for subclasses * /
-  protected InitCalculator(): CalcType {
-    return new Calculator();
-  }
-  */
-
   /**
    * this function is called when the file locale (as indicated by the
    * decimal separator) is different than the current active locale.
@@ -6577,21 +6774,17 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   }
 
   /**
-   * worker now uses a dynamic import with a module built separately.
-   * see `export-worker.ts` (in this directory) for more detail.
-   */
-  protected async LoadWorker(): Promise<Worker> {
-    try {
-      const worker = `export`;
-      const mod = await import(`esbuild-ignore-import:./treb-${worker}-worker.mjs`) as {
-        CreateWorker: () => Promise<Worker>;
-      };
-      return await mod.CreateWorker();
-    }
-    catch (err) {
-      console.error(err);
-      throw(err);
-    }
+   * switching to worker proxy so we can support node
+   * FIXME: type
+   */
+  protected async LoadWorker(): Promise<WorkerProxy<ImportExportMessages.RXMessages, ImportExportMessages.TXMessages>> {
+    const worker = CreateWorker<ImportExportMessages.RXMessages, ImportExportMessages.TXMessages>(!!this.options.in_process_workers);
+    await worker.Init('./treb-export-worker.mjs', () => {
+      return new Worker(new URL('./treb-export-worker.mjs', import.meta.url), { 
+          type: 'module' 
+      }) as Worker;
+    });
+    return worker;
   }
 
   /**