@trebco/treb 31.9.1 → 32.3.1

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

@@ -111,13 +111,17 @@ export class DataModel {
   }
 
   /**
-   * 
+   * @param force_locale - always parse assuming a locale like en-us (comma
+   * argument separators). the current thinking is that this is required for
+   * XLSX import, although that might be incorrect.
    */
-  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet) {
+  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet, force_locale = false) {
 
     this.parser.Save();
-    this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
-    
+    if (force_locale) {
+      this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
+    }
+
     //const sorted = names.map(named => {
     for (const named of names) {
 
@@ -197,6 +201,7 @@ export class DataModel {
       const named: SerializedNamed = {
         name: entry.name,
         expression: '',
+        type: entry.type,
       };
 
       if (entry.scope) {
@@ -239,6 +244,11 @@ export class DataModel {
           return true;
         });
 
+        // this is using the current locale settings, but unserialize
+        // assumes we are unserializing in US-style locale. I think we
+        // do that because excel always uses that? not sure, but we need
+        // to be consistent.
+
         named.expression = this.parser.Render(entry.expression, { missing: '' });
 
       }
@@ -601,9 +611,9 @@ export class DataModel {
    * 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 {
+  public TranslateFunction(value: string, options?: { r1c1?: boolean }): string {
     if (this.language_map) {
-      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false);
+      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false, options);
     }
     return value;
   }
@@ -612,14 +622,14 @@ export class DataModel {
    * translate from local language -> common (english).
    * @see TranslateFunction
    */
-  public UntranslateFunction(value: string): string {
+  public UntranslateFunction(value: string, options?: { r1c1?: boolean }): string {
     if (this.reverse_language_map) {
-      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE');
+      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE', options);
     }
     return value;
   }
 
-  public UntranslateData(value: CellValue|CellValue[]|CellValue[][]): CellValue|CellValue[]|CellValue[][] {
+  public UntranslateData(value: CellValue|CellValue[]|CellValue[][], options?: { r1c1?: boolean }): CellValue|CellValue[]|CellValue[][] {
 
     if (Array.isArray(value)) {
 
@@ -628,7 +638,7 @@ export class DataModel {
       if (Is2DArray(value)) {
         return value.map(row => row.map(entry => {
           if (entry && typeof entry === 'string' && entry[0] === '=') {
-            return this.UntranslateFunction(entry);
+            return this.UntranslateFunction(entry, options);
           }
           return entry;
         }));
@@ -636,7 +646,7 @@ export class DataModel {
       else {
         return value.map(entry => {
           if (entry && typeof entry === 'string' && entry[0] === '=') {
-            return this.UntranslateFunction(entry);
+            return this.UntranslateFunction(entry, options);
           }
           return entry;
         });
@@ -646,7 +656,7 @@ export class DataModel {
     else if (value && typeof value === 'string' && value[0] === '=') {
 
       // single value
-      value = this.UntranslateFunction(value);
+      value = this.UntranslateFunction(value, options);
 
     }
 
@@ -663,7 +673,10 @@ export class DataModel {
    * 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 {
+  private TranslateInternal(value: string, map: Record<string, string>, boolean_true?: string, boolean_false?: string, options?: { r1c1?: boolean }): string {
+
+    this.parser.Save();
+    this.parser.flags.r1c1 = options?.r1c1;
 
     const parse_result = this.parser.Parse(value);
 
@@ -694,10 +707,12 @@ export class DataModel {
       if (modified) {
         return '=' + this.parser.Render(parse_result.expression, { 
           missing: '', boolean_true, boolean_false,
+          r1c1: options?.r1c1,
         });
       }
     }
 
+    this.parser.Restore();
     return value;
 
   }

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

@@ -33,6 +33,7 @@ interface NamedRange {
   area: Area;
 }
 
+/** @internal */
 export type Named = (NamedExpression | NamedRange) & {
   name: string;     // canonical name
   scope?: number;   // scope to sheet by ID
@@ -57,6 +58,12 @@ export interface SerializedNamed {
   /** scope is a sheet name (not ID) */
   scope?: string;
 
+  /** 
+   * adding type. this is optional, it's not used by tooling. it's 
+   * just for informational purpopses for clients.
+   */
+  type?: 'range'|'expression';
+
 }
 
 /**

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

@@ -1631,6 +1631,23 @@ export class Sheet {
       cell.rendered_type = ValueType.dimensioned_quantity; // who cares about rendered_type? (...)
 
     }
+    else if (type === ValueType.function) {
+
+      /*
+      // FIXME: lock down this type (function)
+
+      if ((cell.calculated as any)?.alt) {
+        cell.formatted = (cell.calculated as any).alt.toString();
+        cell.rendered_type = ValueType.string;
+      }
+      else 
+      */
+     
+      {
+        cell.formatted = '𝑓()'; // FIXME
+        cell.rendered_type = ValueType.string;
+      }
+    }
     else {
 
       // why is this being treated as a number? (...)
@@ -2539,7 +2556,7 @@ export class Sheet {
         cell_reference_map[c] = [];
         for (let r = 0; r < column.length; r++) {
           if (column[r]) {
-            const style_as_json = JSON.stringify(column[r]);
+            const style_as_json = Style.Serialize(column[r]); // JSON.stringify(column[r]);
             if (style_as_json !== empty_json) {
               let reference_index = cell_style_map[style_as_json];
               if (typeof reference_index !== 'number') {
@@ -2562,7 +2579,7 @@ export class Sheet {
      */
     const StyleToRef = (style: CellStyle) => {
 
-      const style_as_json = JSON.stringify(style);
+      const style_as_json = Style.Serialize(style); // JSON.stringify(style);
       if (style_as_json === empty_json) {
         return 0;
       }

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

@@ -49,9 +49,9 @@ import type {
     CondifionalFormatExpressionOptions,
     ConditionalFormatCellMatchOptions,
     ConditionalFormatCellMatch,
-
     LanguageModel, 
     TranslatedFunctionDescriptor,
+    SerializedNamed,
 
    } from 'treb-data-model';
 
@@ -2242,8 +2242,11 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     // console.info({events});
 
+    // FIXME: composite? (...)
+
     for (const event of events) {
       switch (event.type) {
+        case 'composite':
         case 'data':
           recalc = true;
           break;
@@ -4000,8 +4003,13 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // API v1 OK
 
     let area: Area | undefined;
-    if (event && event.type === 'data' && event.area) {
-      area = event.area;
+    switch (event?.type) {
+      case 'data':
+        area = event.area;
+        break;
+      case 'composite':
+        area = event.data_area;
+        break;
     }
 
     this.calculator.Calculate(area);
@@ -4172,7 +4180,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @public
    */
-  public Resolve(reference: string): ICellAddress | IArea | undefined {
+  public Resolve(reference: string, options?: { r1c1?: boolean }): ICellAddress | IArea | undefined {
 
     // API v1 OK
 
@@ -4183,7 +4191,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // FIXME: we're using the sheet EnsureAddress method, but that should
     // move either in here or into some sort of helper class
 
-    const result = this.model.ResolveAddress(reference, this.grid.active_sheet);
+    const result = this.model.ResolveAddress(reference, this.grid.active_sheet, options);
 
     if (IsCellAddress(result)) {
       return result.sheet_id ? result : undefined;
@@ -4418,6 +4426,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   }
 
+  public ListNames(): SerializedNamed[] {
+    return this.model.SerializeNames();    
+  }
+
   /**
    * Create a named range or named expression. A named range refers to an
    * address or range. A named expression can be any value or formula. To set 
@@ -6445,7 +6457,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     model.named.Reset(); 
 
     if (data.named) {
+
+      // use locale setting for parsing
       this.model.UnserializeNames(data.named, this.grid.active_sheet);
+
     }
     else {
 
@@ -6482,6 +6497,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       if (data.named_expressions) {
         for (const pair of data.named_expressions) {
 
+        // use locale setting for parsing
+
           this.model.UnserializeNames([{
             name: pair.name,
             expression: pair.expression,

package/treb-embed/style/theme-defaults.scss

@@ -33,24 +33,6 @@
 $primary-selection-color: #4caaf1;
 $primary-selection-color-unfocused: #acc0cf;
 
-/*
-$alternate-selection-color-1: rgb(251, 177, 60);
-$alternate-selection-color-2: rgb(64, 192, 64);
-$alternate-selection-color-3: rgb(182, 109, 13);
-$alternate-selection-color-4: rgb(33, 118, 174);
-$alternate-selection-color-5: rgb(254, 104, 71);
-
-/ * *
- * slightly darkening colors for text highlighting
- * algo: convert to HSL; if L > .5, regenerate with L = .5; back to RGB (why?)
- * /
-$text-reference-color-1: rgb(250, 155, 5);
-$text-reference-color-2: rgb(58, 173, 58);
-$text-reference-color-3: rgb(182, 109, 13);
-$text-reference-color-4: rgb(33, 118, 174);
-$text-reference-color-5: rgb(254, 47, 1);
-*/
-
 .treb-main.treb-main {
 
   --alternate-selection-color-1: rgb(251, 177, 60);
@@ -324,25 +306,21 @@ $text-reference-color-5: rgb(254, 47, 1);
 
     /* span:nth-of-type(2n) { */
     span.highlight-2 {
-      // color: $text-reference-color-2;
       color: var(--text-reference-color-2);
     }
 
     /* span:nth-of-type(3n) { */
     span.highlight-3 {
-      // color: $text-reference-color-3;
       color: var(--text-reference-color-3);
     }
 
     /* span:nth-of-type(4n) { */
     span.highlight-4 {
-      // color: $text-reference-color-4;
       color: var(--text-reference-color-4);
     }
 
     /* span:nth-of-type(5n) { */
     span.highlight-5 {
-      // color: $text-reference-color-5;
       color: var(--text-reference-color-5);
     }
 

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

@@ -1036,11 +1036,25 @@ export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorE
     if (matcher) {
       Promise.resolve().then(() => {
         const exec_result = matcher.Exec({ text, cursor: substring_end.length });
+
+        // fix behavior around "f16round", which is a function we accidentally
+        // inherit from Math in Safari and Firefox. it breaks arrow-selection
+        // because it pops up an AC window. we don't want to break AC behavior
+        // on tooltips, though, so we still want to call AC methods. just block
+        // the completion list.
+
+        if (this.selecting && exec_result.completions?.length) {
+          // console.info("Blocking completion list", JSON.stringify(exec_result.completions));
+          exec_result.completions = undefined;
+        }
+        
         const node = 
           this.NodeAtIndex(exec_result.completions?.length ? 
                 (exec_result.position || 0) :
                 (exec_result.function_position || 0));
+
         this.Autocomplete(exec_result, node);
+        
       });
     }
 

package/treb-grid/src/types/grid.ts

@@ -1284,7 +1284,7 @@ export class Grid extends GridBase {
     this.model.named.Reset();
 
     if (import_data.named) {
-      this.model.UnserializeNames(import_data.named, this.active_sheet);
+      this.model.UnserializeNames(import_data.named, this.active_sheet, true);
     }
 
     // FIXME: do we need to rebuild autocomplete here (A: yes)
@@ -2041,6 +2041,7 @@ export class Grid extends GridBase {
         command.expression = parse_result.expression;
       }
       else {
+        console.info({expression, parse_result});
         throw new Error('invalid expression');
       }
     }
@@ -2350,11 +2351,12 @@ export class Grid extends GridBase {
       
 
     // this is public so we need to (un)translate.
-    data = this.model.UntranslateData(data);
+    // console.info("PRE", {r1c1}, data);
+    data = this.model.UntranslateData(data, { r1c1 });
+    // console.info("POST", data, "\n");
     
      // single value, easiest
     if (!Array.isArray(data)) {
-
       if (recycle || array) {
         this.ExecCommand({ key: CommandKey.SetRange, area: range, value: data, array, r1c1 });
       }
@@ -4553,20 +4555,8 @@ export class Grid extends GridBase {
         if (selecting_argument) {
           this.UpdateSelectedArgument(selection);
         }
-        else if (!selection.empty && !selection.area.entire_sheet) {
-          if (selection.area.entire_column) {
-            this.UpdateAddressLabel(undefined, selection.area.columns + 'C');
-          }
-          else if (selection.area.entire_row) {
-            this.UpdateAddressLabel(undefined, selection.area.rows + 'R');
-          }
-          else if (selection.area.count > 1) {
-            this.UpdateAddressLabel(undefined, selection.area.rows + 'R x ' +
-              selection.area.columns + 'C');
-          }
-          else {
-            this.UpdateAddressLabel(selection);
-          }
+        else {
+          this.UpdateAddressLabelArea(selection); // 3R x 2C
         }
       }
     }, () => {
@@ -5113,6 +5103,9 @@ export class Grid extends GridBase {
 
         if (!selection.empty && (delta.columns || delta.rows)) {
           if (this.BlockSelection(selection, !!event.shiftKey, delta.columns, delta.rows)) {
+            if (event.shiftKey && !selecting_argument) {
+              this.UpdateAddressLabelArea(selection);
+            }
             return;
           }
         }
@@ -5279,6 +5272,9 @@ export class Grid extends GridBase {
 
     if (delta.rows || delta.columns) {
       this.AdvanceSelection(delta, selection, within_selection, expand_selection, !editor_open);
+      if (event.shiftKey && !selecting_argument) {
+        this.UpdateAddressLabelArea(selection);
+      }
     }
 
   }
@@ -5659,7 +5655,13 @@ export class Grid extends GridBase {
               }
             }
           }
-          if (formula_parse_result.dependencies) {
+          if (formula_parse_result.expression) {
+
+            // we were previously looking at address arguments, and ignoring
+            // ranges. this leads to inconsistent behavior. we'll now look at 
+            // ranges when inferring number format.
+
+            // there was also an issue with using the correct sheet, also fixed.
 
             // this was set up to just use the first format we found. 
             // updating to change priority -- if the first one is a 
@@ -5668,14 +5670,10 @@ export class Grid extends GridBase {
 
             let found_number_format: string|undefined = undefined;
 
-            const list = formula_parse_result.dependencies;
-            for (const key of Object.keys(list.addresses)) {
-              const address = list.addresses[key];
-              if (this.active_sheet.HasCellStyle({ ...address })) {
-
-                // FIXME: this should not be active_sheet
-
-                const test = this.active_sheet.CellData({ ...address });
+            /** returns true if we've found a non-% number format */
+            const Check = (address: ICellAddress, sheet = this.active_sheet) => {
+              if (sheet.HasCellStyle({...address})) {
+                const test = sheet.CellData({ ...address });
                 if (test.style && test.style.number_format) {
                   if (!found_number_format || /%/.test(found_number_format)) {
 
@@ -5685,13 +5683,43 @@ export class Grid extends GridBase {
 
                     found_number_format = NumberFormatCache.Translate(test.style.number_format);
                     if (!/%/.test(found_number_format)) {
-                      break;
+                      return true;
                     }
 
                   }
                 }
               }
-            }
+              return false;
+            };
+
+            let finished = false;
+            let sheet: Sheet|undefined = this.active_sheet;
+
+            this.parser.Walk(formula_parse_result.expression, unit => {
+              
+              if (finished) { 
+                return false; 
+              }
+
+              switch (unit.type) {
+                case 'address':
+                  this.model.ResolveSheetID(unit);
+                  sheet = this.model.sheets.Find(unit.sheet_id || 0);
+                  finished = finished || Check(unit, sheet);
+                  break;
+
+                case 'range':
+                  this.model.ResolveSheetID(unit);
+                  sheet = this.model.sheets.Find(unit.start.sheet_id || 0);
+                  for (const address of new Area(unit.start, unit.end)) {
+                    finished = finished || Check(address, sheet);
+                    if (finished) { break; }
+                  }
+                  break;
+              }
+              return !finished;
+
+            });
 
             if (found_number_format) {
 
@@ -7024,6 +7052,24 @@ export class Grid extends GridBase {
     }
   }
 
+  private UpdateAddressLabelArea(selection: GridSelection) {
+    if (!selection.empty && !selection.area.entire_sheet) {
+      if (selection.area.entire_column) {
+        this.UpdateAddressLabel(undefined, selection.area.columns + 'C');
+      }
+      else if (selection.area.entire_row) {
+        this.UpdateAddressLabel(undefined, selection.area.rows + 'R');
+      }
+      else if (selection.area.count > 1) {
+        this.UpdateAddressLabel(undefined, selection.area.rows + 'R x ' +
+          selection.area.columns + 'C');
+      }
+      else {
+        this.UpdateAddressLabel(selection);
+      }
+    }
+  }
+
   private UpdateAddressLabel(selection = this.primary_selection, text?: string) {
 
     if (!this.formula_bar) { return; }

package/treb-parser/src/parser-types.ts

@@ -167,6 +167,17 @@ export interface UnitCall extends BaseUnit {
 
 }
 
+/**
+ * new call type: implicit. we might merge these.
+ */
+export interface UnitImplicitCall extends BaseUnit {
+  type: 'implicit-call';
+  position: number;
+  args: ExpressionUnit[];
+  call: ExpressionUnit;
+
+}
+
 /**
  * this isn't an output type (unless parsing fails), but it's useful
  * to be able to pass these around with the same semantics.
@@ -177,6 +188,14 @@ export interface UnitOperator extends BaseUnit {
   operator: string;
 }
 
+/**
+ * also not an output type
+ */
+export interface UnitGroupSeparator extends BaseUnit {
+  type: 'group-separator';
+  position: number;
+}
+
 /**
  * expression unit representing a binary operation. operations may be
  * re-ordered based on precendence.
@@ -259,9 +278,11 @@ export type BaseExpressionUnit =
 | UnitArray
 | UnitIdentifier
 | UnitCall
+| UnitImplicitCall
 | UnitMissing
 | UnitGroup
 | UnitOperator
+| UnitGroupSeparator
 | UnitBinary
 | UnitUnary
 | UnitAddress
@@ -424,6 +445,9 @@ export interface RenderOptions {
   /** base for offsetting relative R1C1 addresses */
   r1c1_base?: UnitAddress;
 
+  /** force addresses to be relative */
+  r1c1_force_relative?: boolean;
+
   /** if we're just translating, don't have to render addresses */
   pass_through_addresses?: boolean;