@trebco/treb 31.8.2 → 32.1.1

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

@@ -78,7 +78,7 @@ export class SVGSelectionBlock {
       // and use currentColor, but we can't set opacity separately so we
       // need another node. which is a waste, but ergonomics ftw!
 
-      this.fill = DOM.SVG('rect', 'fill');
+      this.fill = DOM.SVG('rect', 'treb-selection-fill');
 
       // this.SetThemeColor(0);
       // if (theme.additional_selection_line_dash_array) {
@@ -95,42 +95,6 @@ export class SVGSelectionBlock {
     this.g.setAttribute('transform', `translate(${offset.x}, ${offset.y})`);
   }
 
-  /*
-  public SetThemeColor(index = 0) {
-
-    if (Array.isArray(this.theme.additional_selection_color)) {
-      if (index >= this.theme.additional_selection_color.length) {
-        index = index % this.theme.additional_selection_color.length;
-      }
-    }
-
-    if (this.theme.additional_selection_overlay_color) {
-      if (typeof this.theme.additional_selection_overlay_color === 'string') {
-        this.outline.setAttribute('fill', this.theme.additional_selection_overlay_color);
-      }
-      else {
-        this.outline.setAttribute('fill', this.theme.additional_selection_overlay_color[index] || '');
-      }
-    }
-    else {
-      this.outline.setAttribute('fill', '');
-    }
-
-    if (this.theme.additional_selection_color) {
-      if (typeof this.theme.additional_selection_color === 'string') {
-        this.outline.setAttribute('stroke', this.theme.additional_selection_color);
-      }
-      else {
-        this.outline.setAttribute('stroke', this.theme.additional_selection_color[index] || '');
-      }
-    }
-    else {
-      this.outline.setAttribute('stroke', '');
-    }
-
-  }
-  */
-
   public Show(show = true) {
     this.g.style.display = show ? 'block' : 'none';
   }

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)
@@ -2350,11 +2350,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 });
       }

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

package/treb-parser/src/parser.ts

@@ -411,6 +411,13 @@ export class Parser {
         }
         break;
 
+      case 'implicit-call':
+        if (func(unit)) {
+          unit.call = this.Walk2(unit.call, func);
+          unit.args = unit.args.map(source => this.Walk2(source, func));
+        }
+        break;
+
       case 'call':
         if (func(unit)) {
           unit.args = unit.args.map(source => this.Walk2(source, func));
@@ -477,6 +484,15 @@ export class Parser {
         }
         return;
 
+      case 'implicit-call':
+        if (func(unit)) {
+          this.Walk(unit.call, func);          
+          for (const arg of unit.args) {
+            this.Walk(arg, func);
+          }
+        }
+        return;
+
       case 'call':
         if (func(unit)) {
           for (const arg of unit.args) {
@@ -755,6 +771,10 @@ export class Parser {
             .map((x) => this.Render(x, options)).join(separator);
         }
 
+      case 'implicit-call':
+        return this.Render(unit.call, options) + 
+          '(' + unit.args.map(element => this.Render(element, options)).join(separator) + ')';
+
       case 'call':
         return (
           unit.name +
@@ -948,8 +968,13 @@ export class Parser {
         '\'' + address.sheet + '\'' : address.sheet) + '!';
     }
 
+    const row = address.offset_row ? `[${address.row}]` : address.row + 1;
+    const column = address.offset_column ? `[${address.column}]` : address.column + 1;
+
+    /*    
     const row = (address.absolute_row || !base) ? (address.row + 1).toString() : `[${address.row - base.row}]`;
     const column = (address.absolute_column || !base) ? (address.column + 1).toString() : `[${address.column - base.column}]`;
+    */
 
     label += `R${row}C${column}`;
 
@@ -1009,11 +1034,12 @@ export class Parser {
    *
    * @param exit exit on specific characters
    */
-  protected ParseGeneric(exit: number[] = [0]): ExpressionUnit | null {
+  protected ParseGeneric(exit: number[] = [0], explicit_group = false): ExpressionUnit | null {
     let stream: ExpressionUnit[] = [];
 
     for (; this.index < this.length;) {
       const unit = this.ParseNext(stream.length === 0);
+
       if (typeof unit === 'number') {
 
         if (exit.some((test) => unit === test)) {
@@ -1025,8 +1051,11 @@ export class Parser {
           // so we only have to worry about grouping. parse
           // up to the closing paren...
 
+          // actually now we have implicit calls, so we need
+          // to manage that here. 
+
           this.index++; // open paren
-          const group = this.ParseGeneric([CLOSE_PAREN]);
+          const group = this.ParseGeneric([CLOSE_PAREN], true);
           this.index++; // close paren
 
           // and wrap up in a group element to prevent reordering.
@@ -1051,6 +1080,21 @@ export class Parser {
           if (operator) {
             stream.push(operator);
           }
+          else if (explicit_group && unit === this.argument_separator_char) {
+
+            // adding a new unit type here to explicitly show we're in
+            // a group; prevents later passes from treating arguments as 
+            // fractions or something else. we just need to remove these
+            // later
+
+            stream.push({
+              type: 'group-separator',
+              position: this.index,
+              id: this.id_counter++,
+            });
+
+            this.index++;
+          }
           else {
             this.error = `unexpected character [1]: ${String.fromCharCode(unit)}, 0x${unit.toString(16)}`;
             this.valid = false;
@@ -1231,13 +1275,6 @@ export class Parser {
     // fix ordering of binary operations based on precedence; also
     // convert and validate ranges
 
-    // return this.BinaryToRange(this.ArrangeUnits(stream));
-    // return this.ArrangeUnits(stream);
-
-    // const arranged = this.ArrangeUnits(stream);
-    // const result = this.BinaryToComplex(arranged);
-    // return result;
-
     return this.BinaryToComplex(this.ArrangeUnits(stream));
 
   }
@@ -1612,206 +1649,13 @@ export class Parser {
 
 
   /**
-   * converts binary operations with a colon operator to ranges. this also
-   * validates that there are no colon operations with non-address operands
-   * (which is why it's called after precendence reordering; colon has the
-   * highest preference). recursive only over binary ops AND unary ops.
-   * 
-   * NOTE: there are other legal arguments to a colon operator. specifically:
-   * 
-   * (1) two numbers, in either order
-   *
-   * 15:16
-   * 16:16
-   * 16:15
-   *
-   * (2) with one or both optionally having a $
-   *
-   * 15:$16
-   * $16:$16
-   *
-   * (3) two column identifiers, in either order
-   * 
-   * A:F
-   * B:A
-   *
-   * (4) and the same with $
-   *
-   * $A:F
-   * $A:$F
+   * reorders operations for precendence
    * 
-   * because none of these are legal in any other context, we leave the 
-   * default treatment of them UNLESS they are arguments to the colon 
-   * operator, in which case we will grab them. that does mean we parse
-   * them twice, but (...)
+   * this method was written with the assumption that groups were
+   * always an error. that's no longer true, with implicit calls.
+   * we should still error if it's not an _explicit_ group, i.e. there's
+   * just a bunch of naked tokens.
    * 
-   * FIXME: will need some updated to rendering these, we don't have any
-   * handler for rendering infinity
-   */
-  protected BinaryToRangeX(unit: ExpressionUnit): ExpressionUnit {
-    if (unit.type === 'binary') {
-      if (unit.operator === ':') {
-
-        let range: UnitRange|undefined;
-        let label = '';
-
-        if (unit.left.type === 'address' && unit.right.type === 'address') {
-          // construct a label using the full text. there's a possibility,
-          // I suppose, that there are spaces (this should probably not be
-          // legal). this is a canonical label, though (generated)
-
-          // it might be better to let this slip, or treat it as an error
-          // and force a correction... not sure (TODO/FIXME)
-
-          const start_index = unit.left.position + unit.left.label.length;
-          const end_index = unit.right.position;
-
-          range = {
-            type: 'range',
-            id: this.id_counter++,
-            position: unit.left.position,
-            start: unit.left,
-            end: unit.right,
-            label:
-              unit.left.label +
-              this.expression.substring(start_index, end_index) +
-              unit.right.label,
-          };
-
-          label = range.start.label + ':' + range.end.label;
-
-          this.address_refcount[range.start.label]--;
-          this.address_refcount[range.end.label]--;
-
-          // remove entries from the list for start, stop
-          const positions = [unit.left.position, unit.right.position];
-          this.full_reference_list = this.full_reference_list.filter((test) => {
-            return (
-              test.position !== positions[0] && test.position !== positions[1]
-            );
-          });
-
-        }
-        else if ((unit.left.type === 'literal' || unit.left.type === 'identifier')
-                && (unit.right.type === 'literal' || unit.right.type === 'identifier')) {
-
-          // see if we can plausibly interpret both of these as rows or columns
-
-          const left = this.UnitToAddress(unit.left);
-          const right = this.UnitToAddress(unit.right);
-
-          // and they need to match
-
-          if (left && right
-              && ((left.column === Infinity && right.column === Infinity)
-                  || (left.row === Infinity && right.row === Infinity))) {
-
-            label = left.label + ':' + right.label;
-
-            // we don't support out-of-order ranges, so we should correct.
-            // they just won't work otherwise. (TODO/FIXME)
-           
-            range = {
-              type: 'range',
-              id: this.id_counter++,
-              position: unit.left.position,
-              start: left,
-              end: right,
-              label,
-            };
-
-          }
-                    
-        }
-
-        /*
-        else if ( unit.left.type === 'literal' 
-                  && unit.right.type === 'literal' 
-                  && typeof unit.left.value === 'number' 
-                  && typeof unit.right.value === 'number') {
-
-          // technically we don't want to support any number that has
-          // a decimal place, but I'm not sure we have a useful way of
-          // measuring that... could look at the original text?
-
-          if (unit.left.value > 0 
-              && unit.right.value > 0
-              && !/\./.test(unit.left.text||'')
-              && !/\./.test(unit.right.text||'')
-              ) {
-
-            label = unit.left.value.toString() + ':' + unit.right.value.toString();
-
-            console.info('m2:', label);
-
-            const left: UnitAddress = {
-              type: 'address',
-              position: unit.left.position,
-              label: unit.left.value.toString(),
-              row: unit.left.value - 1,
-              id: this.id_counter++,
-              column: Infinity,
-            };
-
-            const right: UnitAddress = {
-              type: 'address',
-              position: unit.right.position,
-              label: unit.right.value.toString(),
-              row: unit.right.value - 1,
-              id: this.id_counter++,
-              column: Infinity,
-            };
-
-            range = {
-              type: 'range',
-              id: this.id_counter++,
-              position: unit.left.position,
-              start: left,
-              end: right,
-              label,
-            };
-
-          }
-          
-        }
-        */
-
-        if (range) {
-
-          this.dependencies.ranges[label] = range;
-
-          // and add the range
-          this.full_reference_list.push(range);
-
-          return range;
-
-        }
-        else {
-          this.error = `unexpected character: :`;
-          this.valid = false;
-          // console.info('xx', unit);
-        }
-
-      }
-
-      // recurse
-
-      unit.left = this.BinaryToRangeX(unit.left);
-      unit.right = this.BinaryToRangeX(unit.right);
-    }
-
-    // this should no longer be required, because we explicitly check
-    // when we construct the unary operations...
-
-    // else if (unit.type === 'unary') {
-    //   unit.operand = this.BinaryToRange(unit.operand);
-    // }
-
-    return unit;
-  }
-
-  /**
-   * reorders operations for precendence
    */
   protected ArrangeUnits(stream: ExpressionUnit[]): ExpressionUnit {
 
@@ -1838,6 +1682,10 @@ export class Parser {
     for (let index = 0; index < stream.length; index++) {
       let element = stream[index];
 
+      if (element.type === 'group-separator') {
+        continue; // drop 
+      }
+
       // given that we need to support unary operators, the logic needs
       // to be a little different. operators are OK at any position, provided
       // we can construct either a unary or binary operation.
@@ -1848,14 +1696,7 @@ export class Parser {
           // in this case we do it with recursion.
 
           if (unary_operators[element.operator]) {
-
-            // MARK X
-
-            // const right = this.BinaryToRange(
-            //  this.ArrangeUnits(stream.slice(index + 1)),
-            //);
-
-            // const right = this.ArrangeUnits(stream.slice(index + 1));
+            
             const right = this.BinaryToComplex(this.ArrangeUnits(stream.slice(index + 1)));
 
             // this ensures we return the highest-level group, even if we recurse
@@ -1932,7 +1773,35 @@ export class Parser {
         if (stack.length === 1) {
           const a = stack[0].type;
 
-          if (a !== 'operator') {
+          // support for lambdas
+
+          if (element.type === 'group' && element.explicit) {
+            if (a === 'address' || a === 'call' || a === 'identifier' || a === 'implicit-call') {
+
+              // our parser seems to create implicit groups from these
+              // values in parens. we should fix that, but we can unpack it.
+
+              let args = element.elements;
+              if (args.length === 1 && args[0].type === 'group' && !args[0].explicit) {
+                args = args[0].elements;
+              }
+              
+              // create an implicit call. replace on the stack.
+
+              stack[0] = {
+                type: 'implicit-call',
+                call: stack[0],
+                args,
+                id: this.id_counter++,
+                position: stack[0].position,
+              };
+
+              continue;
+
+            }
+          }
+          /*
+          else if (a !== 'operator') {
 
             // console.warn("unexpected element", stack[0], element);
 
@@ -1947,6 +1816,7 @@ export class Parser {
             };
 
           }
+          */
 
         }
         
@@ -1996,6 +1866,8 @@ export class Parser {
         stack.splice(-2, 2, operation);
       }
       else {
+
+        /*
         this.error = `multiple expressions`;
         this.error_position = (element as {position?: number}).position;
         this.valid = false;
@@ -2005,9 +1877,22 @@ export class Parser {
           elements: stream,
           explicit: false,
         };
+        */
+
+        stack.push(element);
+
       }
     }
 
+    if (stack.length > 1) {
+      return {
+        type: 'group',
+        id: this.id_counter++,
+        elements: stack,
+        explicit: false,
+      };
+    }
+
     return stack[0];
   }
 
@@ -2385,6 +2270,20 @@ export class Parser {
 
     this.ConsumeWhiteSpace();
 
+    // UPDATE: UNLESS the token is an address, because that's not
+    // a legal function name. so change that precedence rule, address
+    // comes first.
+
+    // erm -- that's not 100% correct. LOG10 is a valid cell address
+    // and a valid function name. there might be others as well.
+
+    if (this.flags.spreadsheet_semantics) {
+      const address = this.ConsumeAddress(str, position);
+      if (address) return address;
+    }
+
+    // [FIXME: what about braces? (...)]
+
     const next_char = this.data[this.index];
     if (next_char === OPEN_PAREN) {
       const args = this.ConsumeArguments();
@@ -2404,8 +2303,9 @@ export class Parser {
       // range operator, and a second address. that will be turned into a range
       // later.
 
-      const address = this.ConsumeAddress(str, position);
-      if (address) return address;
+      // moved up
+      // const address = this.ConsumeAddress(str, position);
+      // if (address) return address;
 
       // check for structured reference, if we had square brackets
 
@@ -2638,6 +2538,14 @@ export class Parser {
     if (!r) return null; 
     position = r.position;
 
+    // special hack for LOG10. ugh. can't find any other functions with
+    // this problem, in english at least. btw what's the translation for
+    // log10?
+
+    if (c.column === 8508 && r.row === 9) {
+      return null;
+    }
+
     const label = sheet ?
       sheet + token.substr(sheet.length, position - index).toUpperCase() :
       token.substr(0, position - index).toUpperCase();