@trebco/treb 30.1.8 → 30.2.10

package/treb-data-model/src/data_model.ts

@@ -22,12 +22,13 @@
 import type { Sheet } from './sheet';
 import { SheetCollection } from './sheet_collection';
 import { type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
-import type { IArea, ICellAddress, Table, CellStyle } from 'treb-base-types';
+import type { IArea, ICellAddress, Table, CellStyle, CellValue } from 'treb-base-types';
+import { Is2DArray } from 'treb-base-types';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
 import type { SerializedNamed } from './named';
 import { NamedRangeManager } from './named';
 import type { ConnectedElementType, MacroFunction } from './types';
-
+import type { LanguageModel } from './language-model';
 
 /**
  * 
@@ -36,6 +37,9 @@ export class DataModel {
 
   public readonly parser: Parser = new Parser();
 
+  /** moved from embedded spreadsheet */
+  public language_model?: LanguageModel;
+
   /** document metadata */
   public document_name?: string;
 
@@ -523,5 +527,226 @@ export class DataModel {
    */
   public connected_elements: Map<number, ConnectedElementType> = new Map();
 
+
+
+  // --- moving translation here ----------------------------------------------
+
+  
+  /** 
+   * maps common language (english) -> local language. this should 
+   * be passed in (actually set via a function).
+   */
+  private language_map?: Record<string, string>;
+
+  /**
+   * maps local language -> common (english). this should be constructed
+   * when the forward function is passed in, so there's a 1-1 correspondence.
+   */
+ private reverse_language_map?: Record<string, string>;
+
+
+  /**
+   * set the language translation map. this is a set of function names 
+   * (in english) -> the local equivalent. both should be in canonical form,
+   * as that will be used when we translate one way or the other.
+   */
+  public SetLanguageMap(language_map?: Record<string, string>) {
+
+    if (!language_map) {
+      this.language_map = this.reverse_language_map = undefined;
+    }
+    else {
+
+      const keys = Object.keys(language_map);
+
+      // normalize forward
+      this.language_map = {};
+      for (const key of keys) {
+        this.language_map[key.toUpperCase()] = language_map[key];
+      }
+
+      // normalize backward
+      this.reverse_language_map = {};
+      for (const key of keys) {
+        const value = language_map[key];
+        this.reverse_language_map[value.toUpperCase()] = key;
+      }
+
+    }
+
+    /*
+    // we might need to update the current displayed selection. depends
+    // on when we expect languages to be set.
+
+    if (!this.primary_selection.empty) {
+      this.Select(this.primary_selection, this.primary_selection.area, this.primary_selection.target);
+    }
+    */
+
+  }
+
+  /**
+   * translate function from common (english) -> local language. this could
+   * be inlined (assuming it's only called in one place), but we are breaking
+   * it out so we can develop/test/manage it.
+   */
+  public TranslateFunction(value: string): string {
+    if (this.language_map) {
+      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false);
+    }
+    return value;
+  }
+
+  /**
+   * translate from local language -> common (english).
+   * @see TranslateFunction
+   */
+  public UntranslateFunction(value: string): string {
+    if (this.reverse_language_map) {
+      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE');
+    }
+    return value;
+  }
+
+  public UntranslateData(value: CellValue|CellValue[]|CellValue[][]): CellValue|CellValue[]|CellValue[][] {
+
+    if (Array.isArray(value)) {
+
+      // could be 1d or 2d. typescript is complaining, not sure why...
+
+      if (Is2DArray(value)) {
+        return value.map(row => row.map(entry => {
+          if (entry && typeof entry === 'string' && entry[0] === '=') {
+            return this.UntranslateFunction(entry);
+          }
+          return entry;
+        }));
+      }
+      else {
+        return value.map(entry => {
+          if (entry && typeof entry === 'string' && entry[0] === '=') {
+            return this.UntranslateFunction(entry);
+          }
+          return entry;
+        });
+      }
+
+    }
+    else if (value && typeof value === 'string' && value[0] === '=') {
+
+      // single value
+      value = this.UntranslateFunction(value);
+
+    }
+
+    return value;
+
+  }
+
+
+  /**
+   * translation back and forth is the same operation, with a different 
+   * (inverted) map. although it still might be worth inlining depending
+   * on cost.
+   * 
+   * FIXME: it's about time we started using proper maps, we dropped 
+   * support for IE11 some time ago.
+   */
+  private TranslateInternal(value: string, map: Record<string, string>, boolean_true?: string, boolean_false?: string): string {
+
+    const parse_result = this.parser.Parse(value);
+
+    if (parse_result.expression) {
+      
+      let modified = false;
+      this.parser.Walk(parse_result.expression, unit => {
+        if (unit.type === 'call') {
+          const replacement = map[unit.name.toUpperCase()];
+          if (replacement) {
+            modified = true;
+            unit.name = replacement;
+          }
+        }
+        else if (unit.type === 'literal' && typeof unit.value === 'boolean') {
+
+          // to/from english/locale depends on the direction, but we're not 
+          // passing that in? FIXME, pass it as a parameter. it doesn't matter
+          // here, but later when we render.
+
+          modified = true;
+
+        } 
+
+        return true;
+      });
+
+      if (modified) {
+        return '=' + this.parser.Render(parse_result.expression, { 
+          missing: '', boolean_true, boolean_false,
+        });
+      }
+    }
+
+    return value;
+
+  }
+  
+
+  /** 
+   * this is not public _yet_ 
+   * 
+   * @internal
+   */
+  public SetLanguage(model?: LanguageModel): void {
+
+    this.language_model = model;
+
+    if (!model) {
+      this.SetLanguageMap(); // clear
+
+      // set defaults for parsing. 
+
+      this.parser.flags.boolean_true = 'TRUE';
+      this.parser.flags.boolean_false = 'FALSE';
+
+    }
+    else {
+
+      // create a name map for grid
+
+      const map: Record< string, string > = {};
+
+      if (model.functions) {
+        for (const entry of model.functions || []) {
+          map[entry.base.toUpperCase()] = entry.name; // toUpperCase because of a data error -- fix at the source
+        }
+      }
+
+      this.SetLanguageMap(map);
+
+      // console.info({map});
+
+      if (!model.boolean_false) {
+        model.boolean_false = map['FALSE'];
+      }
+      if (!model.boolean_true) {
+        model.boolean_true = map['TRUE'];
+      }
+
+      // set defaults for parsing. 
+
+      this.parser.flags.boolean_true = model.boolean_true || 'TRUE';
+      this.parser.flags.boolean_false = model.boolean_false || 'FALSE';
+
+      // console.info("booleans:", this.model.parser.flags.boolean_true, ",", this.model.parser.flags.boolean_false)
+
+    }
+
+    for (const sheet of this.sheets.list) {
+      sheet.FlushCellStyles();
+    }
+
+  }
+
 }
 

package/treb-data-model/src/index.ts

@@ -34,4 +34,5 @@ export type { AnnotationData, AnnotationType } from './annotation';
 
 export * from './data-validation';
 export * from './types';
+export * from './language-model';
 

package/{treb-embed → treb-data-model}/src/language-model.ts

@@ -37,5 +37,8 @@ export interface LanguageModel {
   version?: string;
   locale?: string;
   functions?: TranslatedFunctionDescriptor[];
+  
+  boolean_true?: string;
+  boolean_false?: string;
 }
 

package/treb-data-model/src/sheet.ts

@@ -807,19 +807,6 @@ export class Sheet {
     }
   }
 
-  /* *
-   * factory method creates a sheet from a 2D array.
-   *
-   * /
-  public static FromArray(data: any[] = [], transpose = false): Sheet {
-    const sheet = new Sheet();
-    sheet.cells.FromArray(data, transpose);
-
-    return sheet;
-  }
-  */
-
-
   // --- public methods -------------------------------------------------------
 
   public MergeCells(area: Area): void {

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

@@ -49,7 +49,10 @@ import type {
     CondifionalFormatExpressionOptions,
     ConditionalFormatCellMatchOptions,
     ConditionalFormatCellMatch,
-  
+
+    LanguageModel, 
+    TranslatedFunctionDescriptor,
+
    } from 'treb-data-model';
 
 
@@ -88,7 +91,6 @@ 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 { LanguageModel, TranslatedFunctionDescriptor } from './language-model';
 import type { SelectionState } from './selection-state';
 import type { BorderToolbarMessage, ToolbarMessage } from './toolbar-message';
 
@@ -170,7 +172,6 @@ export interface LoadDocumentOptions {
   source?: LoadSource,
 }
 
-
 /**
  * options for the GetRange method
  */
@@ -255,6 +256,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   /** @internal */
   public static treb_embedded_script_path = '';
 
+  /** 
+   * @internal 
+   * 
+   * keep track of modules we've tried to load dynamically, so we don't
+   * do it again. not sure if this is strictly necessary but especially if
+   * we're logging I don't want to see it again 
+   */
+  protected static failed_dynamic_modules: string[] = [];
+
   /* * @internal */
   // public static enable_engine = false;
 
@@ -333,8 +343,9 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     return Localization;
   }
 
-  /** loaded language model, if any */
+  /* * loaded language model, if any (moved to data model) * /
   protected language_model?: LanguageModel;
+  */
 
   /** FIXME: fix type (needs to be extensible) */
   protected events = new EventSource<{ type: string }>();
@@ -646,8 +657,6 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    */
   constructor(options: EmbeddedSpreadsheetOptions & { model?: EmbeddedSpreadsheet }) { 
 
-    // super();
-
     // we renamed this option, default to the new name
 
     if (options.storage_key && !options.local_storage) {
@@ -842,6 +851,24 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       this.grid.headless = true; // FIXME: move into grid options
     }
 
+    // --- testing dynamic loading ---------------------------------------------
+
+    this.LoadLanguage(options.language);
+
+    // --- testing plugins -----------------------------------------------------
+
+    /*
+    // FIXME: when to do this? could it wait? should it be async? (...)
+
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        plugin.Attach(this);
+      }
+    }
+    */
+
+    // -------------------------------------------------------------------------
+
     // we're now gating this on container to support fully headless operation
 
     if (container) {
@@ -1180,15 +1207,28 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     let list: FunctionDescriptor[] = this.calculator.SupportedFunctions();
 
-    if (this.language_model) {
+    if (this.model.language_model?.functions) {
 
       const map: Record<string, TranslatedFunctionDescriptor> = {};
-      for (const entry of this.language_model.functions || []) {
+      for (const entry of this.model.language_model.functions || []) {
         map[entry.base.toUpperCase()] = entry;
       }
 
       list = list.map(descriptor => {
-        return map[descriptor.name.toUpperCase()] || descriptor;
+        const partial = map[descriptor.name.toUpperCase()];
+
+        // FIXME: this is not deep enough if we are going to modify
+        // argument names. we will need to keep other elements of the 
+        // argument entries. this is sufficient for now if we're just
+        // setting function names / descriptions.
+
+        if (partial) {
+          return {
+            ...descriptor,
+            ...partial, 
+          };
+        }
+        return descriptor;
       });
 
     }
@@ -1956,29 +1996,48 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   // --- public API methods ----------------------------------------------------
 
-  /** 
-   * this is not public _yet_ 
-   * 
-   * @internal
-   */
-  public SetLanguage(model?: LanguageModel): void {
+  /** dynamically load language module */
+  public async LoadLanguage(language = '') {
 
-    this.language_model = model;
-
-    if (!model) {
-      this.grid.SetLanguageMap(); // clear
+    if (!language || language === 'locale') {
+      const locale = Localization.locale || '';
+      const parts = locale.split(/-/).map(part => part.toLowerCase());
+      language = parts[0];
     }
-    else {
 
-      // create a name map for grid
+    language = language.toLowerCase();
+
+    let mod: { LanguageMap: LanguageModel } | undefined;
+
+    if (language && language !== 'en') {
+
+      // FIXME: even though we now have a dynamic import
+      // working, we still probably want to use a filter
+      // list to avoid unnecessary 404s.
 
-      const map: Record< string, string > = {};
-      for (const entry of model.functions || []) {
-        map[entry.base] = entry.name;
+      // regarding the import, this is specially crafted to 
+      // work in both esbuild and vite. probably will break
+      // some other bundlers though -- might need some magic
+      // comments
+
+      try {
+        mod = await import(`esbuild-ignore-import:./languages/treb-i18n-${language}.mjs`);
+      }
+      catch (err) {
+        console.error(err);
       }
-      this.grid.SetLanguageMap(map);
+
     }
 
+    if (mod) {
+      this.model.SetLanguage(mod.LanguageMap);
+    }
+    else {
+      this.model.SetLanguage();
+    }
+
+    this.grid.Reselect();
+    this.grid.Update(true);
     this.UpdateAC();
 
   }

package/treb-embed/src/options.ts

@@ -22,6 +22,7 @@
 import type { ICellAddress } from 'treb-base-types';
 import type { TREBDocument } from './types';
 import type { ChartRenderer } from 'treb-charts';
+// import type { TREBPlugin } from './plugin';
 
 /**
  * factory type for chart renderer, if you want instances (pass a constructor)
@@ -327,6 +328,23 @@ export interface EmbeddedSpreadsheetOptions {
    */
   spill?: boolean;
 
+  /**
+   * language. at the moment this controls spreadsheet function names
+   * only; the plan is to expand to the rest of the interface over time.
+   * should be an ISO 639-1 language code, like "en", "fr" or "sv" (case
+   * insensitive). we only support a limited subset of languages at the 
+   * moment.
+   * 
+   * leave blank or set to "locale" to use the current locale.
+   */
+  language?: string;
+
+  /* * 
+   * @internal 
+   * testing plugins
+   */
+  // plugins?: TREBPlugin[];
+
 }
 
 /**

package/treb-embed/src/plugin.ts

@@ -0,0 +1,31 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * 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-2024 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import type { EmbeddedSpreadsheet } from './embedded-spreadsheet';
+
+/** 
+ * @internal
+ * 
+ * testing plugins
+ */
+export interface TREBPlugin {
+  Attach: (instance: EmbeddedSpreadsheet) => void;
+}

package/treb-grid/src/editors/autocomplete_matcher.ts

@@ -151,6 +151,8 @@ export class AutocompleteMatcher {
       return {};
     }
 
+    // console.info(data);
+
     let match;
     let result: AutocompleteExecResult = {};
 
@@ -162,7 +164,8 @@ export class AutocompleteMatcher {
       // if it's a token, and ends with a legal character
       // UPDATE: adding the negative leading \d to fix entering complex numbers
 
-      match = data.text.match(/(?:^|[^A-Za-z_\d])([A-Za-z_][\w\d_.]*)\s*$/);
+      // match = data.text.match(/(?:^|[^A-Za-z_\d])([A-Za-z_][\w\d_.]*)\s*$/);
+      match = data.text.match(/(?:^|[^a-zA-Z\u00C0-\u024F_\d])([a-zA-Z\u00C0-\u024F_][\w\d\u00C0-\u024F_.]*)\s*$/);
 
       if (match) {
         const token = match[1];
@@ -178,6 +181,9 @@ export class AutocompleteMatcher {
         };
 
       }
+      else {
+        // console.info("NOP");
+      }
 
     }
 
@@ -261,6 +267,7 @@ export class AutocompleteMatcher {
             if ( (char >= 0x61 && char <= 0x7a) // a-z
               || (char >= 0x41 && char <= 0x5a) // A-Z
               || (char >= 0x30 && char <= 0x39) // 0-9
+              || (char >= 0x00C0 && char <= 0x024F) // accented characters
               || (char === 0x5f)                // _
               || (char === 0x2e)) {             // .
     

package/treb-grid/src/render/tile_renderer.ts

@@ -727,6 +727,20 @@ export class TileRenderer {
     let pad_entry: RenderTextPart | undefined;
     let composite_width = 0;
 
+    // -------------------------------------------------------------------------
+
+    // moved translated boolean formatting here. I don't like this. it 
+    // should be in sheet (at least that's where the rest of formatting
+    // is), but sheet doesn't have a reference to data model (and because
+    // sheets are owned by data model, I don't want to add a circular ref).
+
+    if (cell.rendered_type === ValueType.boolean) {
+      const value = cell.calculated_type ? cell.calculated : cell.value;
+      cell.formatted = value ? (this.model.language_model?.boolean_true || 'TRUE') : (this.model.language_model?.boolean_false || 'FALSE');
+    }
+
+    // -------------------------------------------------------------------------
+
     let override_formatting: string | undefined;
     let formatted = cell.editing ? '' : cell.formatted; // <-- empty on editing, to remove overflows