@trebco/treb 30.1.8 → 30.2.4

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v30.1. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v30.2. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -282,6 +282,17 @@ export interface EmbeddedSpreadsheetOptions {
      * starting in 30.1.0. set to false to disable.
      */
     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;
 }
 
 /**
@@ -393,6 +404,9 @@ export declare class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
      */
     ExternalEditor(config?: Partial<ExternalEditorConfig>): void;
 
+    /** dynamically load language module */
+    LoadLanguage(language?: string): Promise<void>;
+
     /**
      * Use this function to batch multiple document changes. Essentially the
      * grid stops broadcasting events for the duration of the function call,

package/esbuild-custom-element.mjs

@@ -5,7 +5,7 @@ import * as esbuild from 'esbuild';
 import { SassPlugin, WorkerPlugin, NotifyPlugin, HTMLPlugin } from './esbuild-utils.mjs';
 import { promises as fs } from 'fs';
 
-import pkg from './package.json' assert { type: 'json' }; 
+import pkg from './package.json' with { type: 'json' }; 
 
 
 /**
@@ -58,6 +58,26 @@ for (let i = 0; i < process.argv.length; i++) {
   }
 }
 
+/**
+ * thanks to
+ * https://github.com/evanw/esbuild/issues/3337#issuecomment-2085394950
+ */
+function RewriteIgnoredImports() {
+  return {
+    name: 'RewriteIgnoredImports',
+    setup(build) {
+      build.onEnd(async (result) => {
+        if (result.outputFiles) {
+          for (const file of result.outputFiles) {
+            const { path, text } = file;
+            await fs.writeFile(path, text.replace(/esbuild-ignore-import:/, ''));
+          }
+        }
+      });
+    },
+  };
+}
+
 /** @type esbuild.BuildOptions */
 const build_options = {
   entryPoints: [
@@ -78,7 +98,9 @@ const build_options = {
     'process.env.BUILD_VERSION': `"${pkg.version}"`,
     'process.env.BUILD_NAME': `"${pkg.name}"`,
   },
+  write: false,
   plugins: [
+    RewriteIgnoredImports(),
     NotifyPlugin(),
     WorkerPlugin(options),
     HTMLPlugin(options),

package/esbuild-utils.mjs

@@ -198,6 +198,7 @@ export const WorkerPlugin = (options) => ({
   }
 });
 
+
 /** 
  * @function
  * @param {{verbose?: boolean, minify?: boolean}} [options]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "30.1.8",
+  "version": "30.2.4",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-calculator/src/expression-calculator.ts

@@ -733,6 +733,41 @@ export class ExpressionCalculator {
 
   }
 
+  /**
+   * convert expr to a cell address, possibly calculating the contents.
+   * returns single address only (ranges with len > 1 will fail)
+   */
+  protected AsReference(expr: ExpressionUnit): ICellAddress|undefined {
+
+    switch (expr.type) {
+      case 'address':
+        return expr;
+
+      case 'range':
+        if (expr.start.row === expr.end.row && expr.start.column === expr.end.column) {
+          return expr.start;
+        }
+        break;
+
+      default:
+        {
+          const union = this.CalculateExpression(expr as ExtendedExpressionUnit, true);
+          if (UnionIsExpressionUnit(union)) {
+            if (union.value.type === 'address') {
+              return union.value;
+            }
+            if (union.value.type === 'range' && union.value.start.row === union.value.end.row && union.value.start.column === union.value.end.column) {
+              return union.value.start;
+            }
+          } 
+        }
+        break;
+    }
+
+    return undefined;
+
+  }
+
   protected BinaryExpression(x: UnitBinary): (expr: UnitBinary) => UnionValue /*UnionOrArray*/ {
 
     // we are constructing and caching functions for binary expressions.
@@ -758,40 +793,13 @@ export class ExpressionCalculator {
       if (x.operator === ':') {
         return (expr: UnitBinary) => {
 
-          const left = this.CalculateExpression(expr.left as ExtendedExpressionUnit, true);
-          const right = this.CalculateExpression(expr.right as ExtendedExpressionUnit, true);
-  
-          let start: UnitAddress|undefined;
-          let end: UnitAddress|undefined;
-
-          // console.info({expr, left, right});
-
-          if (UnionIsExpressionUnit(left) && UnionIsExpressionUnit(right)) {
-
-            if (left.value.type === 'range') {
-              if (left.value.start.row === left.value.end.row && left.value.start.column === left.value.end.column) {
-                start = left.value.start;
-              }
-            }
-            else if (left.value.type === 'address') {
-              start = left.value;
-            }
-
-            if (right.value.type === 'range') {
-              if (right.value.start.row === right.value.end.row && right.value.start.column === right.value.end.column) {
-                end = right.value.start;
-              }
-            }
-            else if (right.value.type === 'address') {
-              end = right.value;
-            }
-
-            if (start && end) {
-              return this.CellFunction4(start, end);
-            }
+          const start = this.AsReference(expr.left);
+          const end = this.AsReference(expr.right);
 
+          if (start && end) {
+            return this.CellFunction4(start, end);
           }
-          
+         
           return ExpressionError();
         };
       }

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

@@ -170,7 +170,6 @@ export interface LoadDocumentOptions {
   source?: LoadSource,
 }
 
-
 /**
  * options for the GetRange method
  */
@@ -255,6 +254,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;
 
@@ -646,8 +654,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 +848,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,7 +1204,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     let list: FunctionDescriptor[] = this.calculator.SupportedFunctions();
 
-    if (this.language_model) {
+    if (this.language_model?.functions) {
 
       const map: Record<string, TranslatedFunctionDescriptor> = {};
       for (const entry of this.language_model.functions || []) {
@@ -1188,7 +1212,20 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       }
 
       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,6 +1993,47 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   // --- public API methods ----------------------------------------------------
 
+  /** dynamically load language module */
+  public async LoadLanguage(language = '') {
+
+    if (!language || language === 'locale') {
+      const locale = Localization.locale || '';
+      const parts = locale.split(/-/).map(part => part.toLowerCase());
+      language = parts[0];
+    }
+
+    this.SetLanguage(); // clear
+
+    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.
+
+      // 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);
+      }
+
+    }
+
+    if (mod) {
+      this.SetLanguage(mod.LanguageMap);
+    }
+
+  }
+
   /** 
    * this is not public _yet_ 
    * 
@@ -1973,10 +2051,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       // create a name map for grid
 
       const map: Record< string, string > = {};
-      for (const entry of model.functions || []) {
-        map[entry.base] = entry.name;
+
+      if (model.functions) {
+        for (const entry of model.functions || []) {
+          map[entry.base] = entry.name;
+        }
       }
+
       this.grid.SetLanguageMap(map);
+
     }
 
     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)) {             // .