@trebco/treb 29.4.1 → 29.5.0

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

@@ -45,9 +45,10 @@ import {
   ComplexToString,
   IsComplex,
   TextPartFlag,
+  IsArea,
 } from 'treb-base-types';
 
-import type { ExpressionUnit } from 'treb-parser';
+import type { ExpressionUnit, UnitAddress } from 'treb-parser';
 import { 
   DecimalMarkType, 
   ArgumentSeparatorType, 
@@ -1746,16 +1747,80 @@ export class Grid extends GridBase {
 
   }
 
+  /**
+   * render the given data as R1C1. the source address is a base for 
+   * rendering relative addresses (is there a case for this method
+   * handling absolute offsets as well? ...)
+   * 
+   * NOTE: this method modifies the input data (at least it does if
+   * it's an array). so this method should only be called with scratchpad
+   * data.
+   * 
+   */
+  public FormatR1C1(data: CellValue|CellValue[][], source: ICellAddress|IArea) {
+
+    // normalize
+
+    if (IsArea(source)) {
+      source = source.start;
+    }
+
+    if (!Array.isArray(data)) {
+      data = [[data]];
+    }
+
+    const base: UnitAddress = {
+      type: 'address',
+      label: '',
+      row: source.row,
+      column: source.column, 
+      sheet: source.sheet_id ? this.model.sheets.Name(source.sheet_id) : this.active_sheet.name,
+      position: 0,
+      id: 0,
+    };
+
+    for (let r = 0; r < data.length; r++) {
+      const row = data[r];
+      for (let c = 0; c < row.length; c++) {
+        const cell = row[c];
+        if (typeof cell === 'string' && cell[0] === '=') {
+
+          const parse_result = this.parser.Parse(cell);
+          if (parse_result.expression) {
+            row[c] = '=' + this.parser.Render(parse_result.expression, {
+              missing: '',
+              r1c1: true,
+              r1c1_base: {
+                ...base,
+                row: source.row + r,
+                column: source.column + c,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return data;
+    
+  }
+
   /**
    * get data in a given range, optionally formulas
    * API method
    */
-   public GetRange(range: ICellAddress | IArea, type?: 'formula'|'formatted'): CellValue|CellValue[][]|undefined {
+   public GetRange(range: ICellAddress | IArea, type?: 'formatted'|'A1'|'R1C1'): CellValue|CellValue[][]|undefined {
 
     if (IsCellAddress(range)) {
       const sheet = this.model.sheets.Find(range.sheet_id || this.active_sheet.id);
       if (sheet) {
-        if (type === 'formula') { return sheet.cells.RawValue(range); }
+        if (type === 'A1' || type === 'R1C1') { 
+          const data = sheet.cells.RawValue(range); 
+          if (type === 'R1C1') {
+            return this.FormatR1C1(data, range);
+          }
+          return data;
+        }
         if (type === 'formatted') { return sheet.GetFormattedRange(range); }
         return sheet.cells.GetRange(range);
       }
@@ -1764,7 +1829,13 @@ export class Grid extends GridBase {
 
     const sheet = this.model.sheets.Find(range.start.sheet_id || this.active_sheet.id);
     if (sheet) {
-      if (type === 'formula') { return sheet.cells.RawValue(range.start, range.end); }
+      if (type === 'A1' || type === 'R1C1') { 
+        const data = sheet.cells.RawValue(range.start, range.end); 
+        if (type === 'R1C1') {
+          return this.FormatR1C1(data, range);
+        }
+        return data;
+      }
       if (type === 'formatted') { return sheet.GetFormattedRange(range.start, range.end); }
       return sheet.cells.GetRange(range.start, range.end);
     }
@@ -1889,6 +1960,9 @@ export class Grid extends GridBase {
 
       if (!Is2DArray(data)) {
 
+        // we don't allow this anymore (at least we say we don't)
+
+
         // flat array -- we can recycle. recycling is R style (values, not rows).
         // in any event convert to [][]
 
@@ -1920,6 +1994,56 @@ export class Grid extends GridBase {
         }
 
       }
+      else {
+        if (recycle) {
+
+          // recycle 2D array. we'll do this if the target range is a multiple
+          // (or larger) of the source array. in blocks.
+
+          if (range.rows > data.length) {
+            const recycle_rows = Math.floor(range.rows / data.length);
+            if (recycle_rows > 1) {
+              const source = [...data];
+              for (let i = 0; i < recycle_rows; i++) {
+                const clone = JSON.parse(JSON.stringify(source));
+                data.push(...clone);
+              }  
+            }
+          }
+
+          let cols = 0;
+          for (const row of data) {
+            cols = Math.max(cols, row.length);
+          }
+
+          if (range.columns > cols) {
+            const recycle_columns = Math.floor(range.columns / cols);
+            if (recycle_columns > 1) {
+
+              for (const row of data) {
+
+                // pad out all rows first, jic
+                while (row.length < cols) {
+                  row.push(undefined);
+                }
+
+                // now recycle
+                const source = [...row];
+                for (let i = 0; i < recycle_columns; i++) {
+                  const clone = JSON.parse(JSON.stringify(source));
+                  row.push(...clone);
+                }
+
+              }
+
+              // ...
+
+              // console.info({recycle_columns});
+            }
+          }
+
+        }
+      }
 
       if (transpose) { data = this.Transpose(data); }
 
@@ -2224,12 +2348,13 @@ export class Grid extends GridBase {
     // const context = Sheet.measurement_canvas.getContext('2d');
     // if (!context) return;
 
-    let width = 12;
-    const padding = 4 * 2; // FIXME: parameterize
+    let width = 0;
+    const padding = 12; // 4 * 2; // FIXME: parameterize
 
     if (!allow_shrink) width = sheet.GetColumnWidth(column);
 
     for (let row = 0; row < sheet.cells.rows; row++) {
+
       const cell = sheet.CellData({ row, column });
       let text = cell.formatted || '';
       if (typeof text !== 'string') {
@@ -2246,7 +2371,9 @@ export class Grid extends GridBase {
       }
     }
 
-    sheet.SetColumnWidth(column, width);
+    if (width > padding + 2) {
+      sheet.SetColumnWidth(column, width);
+    }
 
   }
 
@@ -7141,7 +7268,7 @@ export class Grid extends GridBase {
 
     if (auto) {
       for (const entry of column) {
-        this.AutoSizeColumn(sheet, entry, false);
+        this.AutoSizeColumn(sheet, entry, true);
       }
     }
     else {

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

@@ -593,7 +593,7 @@ export class GridBase {
    * @param column column, columns, or undefined means all columns
    * @param width target width, or undefined means auto-size
    */
-  public SetColumnWidth(column?: number | number[], width = 0): void {
+  public SetColumnWidth(column?: number | number[], width?: number): void {
     this.ExecCommand({
       key: CommandKey.ResizeColumns,
       column,
@@ -2514,11 +2514,20 @@ export class GridBase {
 
             // translate...
             if (unit.offset_column) {
+              unit.absolute_column = false;
               unit.column = unit.column + address.column;
             }
+            else {
+              unit.absolute_column = true;
+            }
+
             if (unit.offset_row) {
+              unit.absolute_row = false;
               unit.row = unit.row + address.row;
             }
+            else {
+              unit.absolute_row = true;
+            }
 
           }
           return true;

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

@@ -401,6 +401,16 @@ export type ParserFlags = Partial<OptionalParserFlags> & RequiredParserFlags;
 
 export interface RenderOptions {
   offset: { rows: number; columns: number };
+
+  /** 
+   * render in R1C1 format. this will be relative if the R1C1 base
+   * address is set; otherwise absolute. 
+   */
+  r1c1?: boolean;
+
+  /** base for offsetting relative R1C1 addresses */
+  r1c1_base?: UnitAddress;
+
   missing: string;
   convert_decimal: DecimalMarkType;
   convert_argument_separator: ArgumentSeparatorType;

package/treb-parser/src/parser.ts

@@ -489,14 +489,12 @@ export class Parser {
 
     switch (unit.type) {
       case 'address':
-        return this.AddressLabel(unit, offset);
+        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base) : this.AddressLabel(unit, offset);
 
       case 'range':
-        return (
-          this.AddressLabel(unit.start, offset) +
-          ':' +
-          this.AddressLabel(unit.end, offset)
-        );
+        return options.r1c1 ? 
+          this.R1C1Label(unit.start, options.r1c1_base) + ':' + this.R1C1Label(unit.end, options.r1c1_base) : 
+          this.AddressLabel(unit.start, offset) + ':' + this.AddressLabel(unit.end, offset);
 
       case 'missing':
         return missing;
@@ -823,7 +821,35 @@ export class Parser {
     return s;
   }
 
-  /** generates address label ("C3") from address (0-based) */
+  /**
+   * generates absolute or relative R1C1 address
+   */
+  protected R1C1Label(
+    address: UnitAddress,
+    base?: UnitAddress,
+  ): string {
+
+    let label = '';
+
+    if (address.sheet) { // && (!base?.sheet || base?.sheet !== address.sheet)) {
+      label = (QuotedSheetNameRegex.test(address.sheet) ?
+        '\'' + address.sheet + '\'' : address.sheet) + '!';
+    }
+
+    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}`;
+
+    return label;
+  }
+
+  /** 
+   * generates address label ("C3") from address (0-based).
+   * 
+   * @param offset - offset by some number of rows or columns 
+   * @param r1c1 - if set, return data in R1C1 format. 
+   */
   protected AddressLabel(
     address: UnitAddress,
     offset: { rows: number; columns: number },
@@ -839,12 +865,6 @@ export class Parser {
     let label = '';
     if (address.sheet) {
 
-      /*
-      if (address.sheet === '__REF') {
-        return '#REF'; // magic
-      }
-      */
-
       label = (QuotedSheetNameRegex.test(address.sheet) ?
         '\'' + address.sheet + '\'' : address.sheet) + '!';
     }