@trebco/treb 32.5.0 → 32.6.4

package/package.json

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

package/treb-base-types/src/import.ts

@@ -27,18 +27,22 @@ import type { Table } from './table';
 import type { DataValidation, AnnotationType, ConditionalFormat } from 'treb-data-model';
 
 export interface CellParseResult {
-  row: number,
-  column: number,
+  row: number;
+  column: number;
   type: SerializedValueType; // ValueType,
-  value: number|string|undefined|boolean,
-  calculated?: number|string|undefined|boolean,
+  value: number|string|undefined|boolean;
+  calculated?: number|string|undefined|boolean;
   calculated_type?: SerializedValueType; // ValueType,
-  style_ref?: number,
-  hyperlink?: string,
-  validation?: DataValidation,
-  merge_area?: IArea,
-  area?: IArea,
-  table?: Table,
+  style_ref?: number;
+  hyperlink?: string;
+  validation?: DataValidation;
+  merge_area?: IArea;
+  area?: IArea;
+
+  /** dynamic arrays */
+  spill?: IArea;
+  
+  table?: Table;
 }
 
 export interface AnchoredAnnotation {

package/treb-calculator/src/calculator.ts

@@ -1221,11 +1221,16 @@ export class Calculator extends Graph {
   public AttachSpillData(area: Area, cells?: Cells) {
 
     if (!cells) {
+
+      // can we assume active sheet here? actually I guess not, we'll 
+      // need to set that... 
+
       const sheet = area.start.sheet_id ? this.model.sheets.Find(area.start.sheet_id) : undefined;
       cells = sheet?.cells;
     }
 
     if (!cells) {
+      console.info({area, cells});
       throw new Error('invalid sheet ID in attach spill data');
     }
 

package/treb-charts/src/chart-types.ts

@@ -207,6 +207,7 @@ export interface HistogramData extends ColumnDataBaseType {
 export interface LineBaseData extends ChartDataBaseType {
   series?: NumberOrUndefinedArray[];
   series2?: SeriesType[];
+  stacked_series?: SeriesType[];
   scale: RangeScale;
   x_scale?: RangeScale;
   titles?: string[];
@@ -262,6 +263,7 @@ export interface BarData extends LineBaseData {
   type: 'bar';
   round?: boolean;
   space?: number;
+  stacked?: boolean;
 }
 
 export interface DonutDataBaseType extends ChartDataBaseType {

package/treb-charts/src/chart-utils.ts

@@ -1001,8 +1001,11 @@ export const CreateColumnChart = (
 
   const [data, labels, args_title, args_options] = args;
       
-  const series: SeriesType[] = TransformSeriesData(data);
-  const common = CommonData(series);
+  const options = args_options?.toString() || undefined;
+  const stacked = /stacked/i.test(options || '');
+
+  let series: SeriesType[] = TransformSeriesData(data);
+  let common = CommonData(series);
 
   let category_labels: string[] | undefined;
 
@@ -1041,15 +1044,50 @@ export const CreateColumnChart = (
 
   }
 
+  let stacked_series: SeriesType[]|undefined = undefined;
+  const legend = common.legend; // in case we munge it
+
+  if (stacked) {
+    stacked_series = series;
+
+    const map: Map<number, number> = new Map();
+    // const label_map: Map<number, string> = new Map();
+
+    for (const entry of series) {
+      for (const [index, key] of entry.x.data.entries()) {
+        if (key !== undefined) {
+          const value = entry.y.data[index] || 0;
+          map.set(key, value + (map.get(key) || 0));
+        }
+      }
+    }
+
+    const x_data = Array.from(map.keys()).sort((a, b) => a - b);
+    const y_data = x_data.map(key => map.get(key) || 0);
+
+    // console.info({stacked_series, map, x_data, y_data});
+
+    series = [{
+      x: { data: x_data, format: stacked_series[0]?.x?.format },
+      y: { data: y_data, format: stacked_series[0]?.y?.format },
+    }];
+
+    series[0].x.range = ArrayMinMax(x_data);
+    series[0].y.range = ArrayMinMax(y_data);
+
+    common = CommonData(series, Math.min(0, ...y_data));
+
+  }
+
   const title = args_title?.toString() || undefined;
-  const options = args_options?.toString() || undefined;
 
   const chart_data = {
     type,
-    legend: common.legend,
+    legend, // legend: common.legend,
     // legend_position: LegendPosition.right,
     legend_style: LegendStyle.marker,
     series2: series,
+    stacked_series,
     scale: common.y.scale,
     title,
     y_labels: type === 'bar' ? category_labels : common.y.labels, // swapped
@@ -1057,6 +1095,9 @@ export const CreateColumnChart = (
   };
 
   if (options) {
+    
+    (chart_data as BarData).stacked = stacked;
+
     (chart_data as BarData).round = /round/i.test(options);
     (chart_data as ChartDataBaseType).data_labels = /labels/i.test(options);
 

package/treb-charts/src/default-chart-renderer.ts

@@ -599,23 +599,33 @@ export class DefaultChartRenderer implements ChartRendererType {
             corners = [half_width, half_width, 0, 0];
           }
 
-          for (let s = 0; s < series_count; s++) {
-            const series = chart_data.series2[s];
-            const color_index = typeof series.index === 'number' ? series.index : s + 1;
+          if (chart_data.stacked_series) {
 
-            for (let i = 0; i < series.y.data.length; i++ ){
-              const value = series.y.data[i];
-              // const format = NumberFormatCache.Get(series.y.format || '0.00');
+            // step by group (stacked series)
+            for (let s = 0; s < chart_data.stacked_series[0].y.data.length; s++ ){
 
-              if (typeof value === 'number') {
+              const x = (area.left + s * column_width + space) ; // + s * width;
+              let y = 0;
+
+              // now check each series, grab s-th value
+              for (let t = 0; t < chart_data.stacked_series.length; t++) {
+
+                const series = chart_data.stacked_series[t];
+                const color_index = typeof series.index === 'number' ? series.index : t + 1;
 
-                // const x = Math.round(area.left + i * column_width + space) + s * width;
-                const x = (area.left + i * column_width + space) + s * width;
-                
                 let height = 0;
-                let y = 0;
                 // let negative = false;
 
+                const value = (series.y.data[s] || 0);
+
+                if (t === 0) {
+                  y = Math.min(chart_data.scale.min || 0, value);
+                }
+
+                height = Util.ApplyScale(value, area.height, chart_data.scale);
+                const base = area.bottom - height - Util.ApplyScale(y, area.height, chart_data.scale);
+
+                /*
                 if (zero) {
                   if (value > 0) {
                     height = Util.ApplyScale(value + chart_data.scale.min, area.height, chart_data.scale);
@@ -631,27 +641,77 @@ export class DefaultChartRenderer implements ChartRendererType {
                   height = Util.ApplyScale(value, area.height, chart_data.scale);
                   y = area.bottom - height;
                 }
+                */
 
-                // const bar_title = chart_data.titles ? chart_data.titles[i] : undefined;
-                const bar_title = undefined;
+                let bar_title = undefined;
+                let label = undefined;
+                let label_point = undefined;
 
-                if (height) {
+                this.renderer.RenderRectangle(new Area(
+                  x, base, x + width, base + height,
+                ), corners, ['chart-column', `series-${color_index}`], bar_title || undefined, label, label_point);
 
-                  const label = (chart_data.data_labels && !!series.y.labels) ? series.y.labels[i] : '';
-                  const label_point = {
-                    x: Math.round(x + width / 2),
-                    y: Math.round(y - 10),
-                  };
+                y += value;
 
-                  this.renderer.RenderRectangle(new Area(
-                    x, y, x + width, y + height,
-                  ), corners, ['chart-column', `series-${color_index}`], bar_title || undefined, label, label_point);
-                }
               }
+
+
             }
+          }
+          else {
+            for (let s = 0; s < series_count; s++) {
+              const series = chart_data.series2[s];
+              const color_index = typeof series.index === 'number' ? series.index : s + 1;
+
+              for (let i = 0; i < series.y.data.length; i++ ){
+                const value = series.y.data[i];
+
+                if (typeof value === 'number') {
+
+                  // const x = Math.round(area.left + i * column_width + space) + s * width;
+                  const x = (area.left + i * column_width + space) + s * width;
+                  
+                  let height = 0;
+                  let y = 0;
+                  // let negative = false;
+
+                  if (zero) {
+                    if (value > 0) {
+                      height = Util.ApplyScale(value + chart_data.scale.min, area.height, chart_data.scale);
+                      y = area.bottom - height - zero;
+                    }
+                    else {
+                      height = Util.ApplyScale(chart_data.scale.min - value, area.height, chart_data.scale);
+                      y = area.bottom - zero; // // area.bottom - height - zero;
+                      // negative = true;
+                    }
+                  }
+                  else {
+                    height = Util.ApplyScale(value, area.height, chart_data.scale);
+                    y = area.bottom - height;
+                  }
+
+                  // const bar_title = chart_data.titles ? chart_data.titles[i] : undefined;
+                  const bar_title = undefined;
+
+                  if (height) {
 
+                    const label = (chart_data.data_labels && !!series.y.labels) ? series.y.labels[i] : '';
+                    const label_point = {
+                      x: Math.round(x + width / 2),
+                      y: Math.round(y - 10),
+                    };
+
+                    this.renderer.RenderRectangle(new Area(
+                      x, y, x + width, y + height,
+                    ), corners, ['chart-column', `series-${color_index}`], bar_title || undefined, label, label_point);
+                  }
+                }
+              }
+
+            }
           }
-  
+
         }
 
       }

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

@@ -3011,6 +3011,15 @@ export class Sheet {
       this.name = data.name || ''; // wtf is this?
     }
 
+    // patching from import
+    for (const cell of this.cells.Iterate()) {
+      if (cell.spill) {
+        if (!cell.spill.start.sheet_id) {
+          cell.spill.SetSheetID(this.id);
+        }
+      }
+    }
+
     if (data.tab_color) {
       this.tab_color = data.tab_color;
     }

package/treb-export/src/import.ts

@@ -26,7 +26,7 @@ import Base64JS from 'base64-js';
 
 import type { AnchoredChartDescription, AnchoredImageDescription, AnchoredTextBoxDescription} from './workbook';
 import { ChartType, ConditionalFormatOperators, Workbook } from './workbook';
-import type { ParseResult } from 'treb-parser';
+import type { ExpressionUnit, ParseResult, UnitCall } from 'treb-parser';
 import { DecimalMarkType, Parser } from 'treb-parser';
 import type { RangeType, AddressType, HyperlinkType } from './address-type';
 import { is_range, ShiftRange, InRange, is_address } from './address-type';
@@ -42,6 +42,7 @@ import { ColumnWidthToPixels } from './column-width';
 import type { DataValidation, AnnotationType } from 'treb-data-model';
 import { ZipWrapper } from './zip-wrapper';
 import type { ConditionalFormat } from 'treb-data-model';
+import { LookupMetadata, type MetadataFlags } from './metadata';
 
 interface SharedFormula {
   row: number;
@@ -57,6 +58,7 @@ interface CellElementType {
     r?: string;
     t?: string;
     s?: string;
+    cm?: string;
   };
   v?: string|number|{
     t$: string;
@@ -147,6 +149,7 @@ export class Importer {
     element: CellElementType,
     shared_formulae: SharedFormulaMap,
     arrays: RangeType[],
+    dynamic_arrays: RangeType[],
     merges: RangeType[],
     links: HyperlinkType[],
     // validations: Array<{ address: ICellAddress, validation: DataValidation }>,
@@ -165,6 +168,15 @@ export class Importer {
       return undefined;
     }
 
+    // new (to us) metadata
+    let metadata_flags: MetadataFlags = {};
+    if (element.a$?.cm) {
+      const cm_index = Number(element.a$?.cm);
+      if (this.workbook?.metadata) {
+        metadata_flags = LookupMetadata(this.workbook.metadata, 'cell', cm_index).flags;
+      }
+    }
+
     // console.info(element);
 
     let value: undefined | number | boolean | string;
@@ -213,6 +225,8 @@ export class Importer {
 
         if (formula) {
 
+          // console.info("F", formula);
+
           // doing it like this is sloppy (also does not work properly).
           value = '=' + formula.replace(/^_xll\./g, '');
 
@@ -221,10 +235,66 @@ export class Importer {
             value = formula;
           }
           else {
+
             const parse_result = this.parser.Parse(formula); // l10n?
             if (parse_result.expression) {
-              this.parser.Walk(parse_result.expression, (unit) => {
+
+              const TrimPrefixes = (name: string) => {
+
+                if (/^_xll\./.test(name)) {
+                  name = name.substring(5);
+                }
+                if (/^_xlfn\./.test(name)) {
+                  console.info("xlfn:", name);
+                  name = name.substring(6);
+                }
+                if (/^_xlws\./.test(name)) {
+                  console.info("xlws:", name);
+                  name = name.substring(6);
+                }
+
+                return name;
+              };
+
+              const TreeWalker = (unit: ExpressionUnit) => {
+                
                 if (unit.type === 'call') {
+
+                  // if we see _xlfn.SINGLE, translate that into 
+                  // @ + the name of the first parameter...
+                  //
+                  // this is solving the case where single appears, but it 
+                  // doesn't solve the case where it does not appear -- they 
+                  // may be using the array flag of the cell as an indicator?
+                  // but how then do they know it _should_ be an array? not 
+                  // sure, and I don't see any other indication.
+
+                  if (/^_xlfn\.single/i.test(unit.name)) {
+
+                    const first = unit.args[0];
+                    if (first.type === 'call') {
+
+                      // we could do this in place, we don't need to copy...
+                      // although it seems like a good idea. also watch out,
+                      // these SINGLEs could be nested.
+
+                      const replacement: UnitCall = JSON.parse(JSON.stringify(first));
+                      replacement.name = '@' + TrimPrefixes(replacement.name);
+
+                      for (let i = 0; i < replacement.args.length; i++) {
+                        replacement.args[i] = this.parser.Walk2(replacement.args[i], TreeWalker);
+                      }
+
+                      return replacement;
+                    }
+                    else {
+                      console.info("_xlfn.SINGLE unexpected argument", unit.args[0]);
+                    }
+                  }
+
+                  unit.name = TrimPrefixes(unit.name);
+
+                  /*
                   if (/^_xll\./.test(unit.name)) {
                     unit.name = unit.name.substring(5);
                   }
@@ -236,9 +306,15 @@ export class Importer {
                     console.info("xlws:", unit.name);
                     unit.name = unit.name.substring(6);
                   }
+                  */
+
                 }
                 return true;
-              });
+
+              };
+
+              parse_result.expression = this.parser.Walk2(parse_result.expression, TreeWalker);
+
               value = '=' + this.parser.Render(parse_result.expression, { missing: '' });
             }
           }
@@ -274,10 +350,38 @@ export class Importer {
           }
         }
 
+        //
+        // arrays and spill/dynamic arrays
+        //
+
         if (typeof element.f !== 'string' &&  element.f.a$?.t === 'array') {
           const translated = sheet.TranslateAddress(element.f.a$.ref || '');
-          if (is_range(translated)) {
-            arrays.push(ShiftRange(translated, -1, -1));
+
+          // why are we checking "is_range" here? this should be valid 
+          // even if the ref attribute is one cell, if it explicitly
+          // says t="array"
+
+          // we will need to adjust it, though? yes, because the lists 
+          // only accept ranges. note that range type has a superfluous 
+          // sheet parameter? ...
+
+          let range = translated;
+          if (!is_range(range)) {
+            range = {
+              to: { ...range },
+              from: { ...range },
+              sheet: range.sheet,
+            };
+          }
+
+          // if (is_range(translated)) 
+          {
+            if (metadata_flags['dynamic-array']) {
+              dynamic_arrays.push(ShiftRange(range, -1, -1));
+            }
+            else {
+              arrays.push(ShiftRange(range, -1, -1));
+            }
           }
         }
 
@@ -317,12 +421,14 @@ export class Importer {
     // but perhaps we should check that... although at this point we have 
     // already added the array so we need to check for root
 
-    for (const array of arrays) {
-      if (InRange(array, shifted) && (shifted.row !== array.from.row || shifted.col !== array.from.col)) {
-        calculated_type = type;
-        calculated_value = value;
-        value = undefined;
-        type = 'undefined'; // ValueType.undefined;
+    for (const set of [arrays, dynamic_arrays]) {
+      for (const array of set) {
+        if (InRange(array, shifted) && (shifted.row !== array.from.row || shifted.col !== array.from.col)) {
+          calculated_type = type;
+          calculated_value = value;
+          value = undefined;
+          type = 'undefined'; // ValueType.undefined;
+        }
       }
     }
 
@@ -369,6 +475,20 @@ export class Importer {
       }
     }
 
+    for (const range of dynamic_arrays) {
+      if (InRange(range, shifted)) {
+        result.spill = {
+          start: {
+            row: range.from.row,
+            column: range.from.col,
+          }, end: {
+            row: range.to.row,
+            column: range.to.col,
+          },
+        }
+      }
+    }
+
     for (const range of arrays) {
       if (InRange(range, shifted)) {
         result.area = {
@@ -675,6 +795,7 @@ export class Importer {
     const data: CellParseResult[] = [];
     const shared_formulae: {[index: string]: SharedFormula} = {};
     const arrays: RangeType[] = [];
+    const dynamic_arrays: RangeType[] = [];
     const merges: RangeType[] = [];
     const conditional_formats: ConditionalFormat[] = [];
     const links: HyperlinkType[] = [];
@@ -967,7 +1088,7 @@ export class Importer {
       const cells = row.c ? Array.isArray(row.c) ? row.c : [row.c] : [];
 
       for (const element of cells) {
-        const cell = this.ParseCell(sheet, element as unknown as CellElementType, shared_formulae, arrays, merges, links); // , validations);
+        const cell = this.ParseCell(sheet, element as unknown as CellElementType, shared_formulae, arrays, dynamic_arrays, merges, links); // , validations);
         if (cell) {
           data.push(cell);
         }
@@ -1254,12 +1375,21 @@ export class Importer {
 
             break;
 
+          case ChartType.Histogram:
+            type = 'treb-chart';
+            func = 'Histogram.Plot';
+            if (series?.length) {
+              // ...
+            }
+            args[1] = descriptor.chart.title;
+            break;
+
           case ChartType.Box:
             type = 'treb-chart';
             func = 'Box.Plot';
             if (series?.length) {
               args[0] = `Group(${series.map(s => `Series(${s.title || ''},,${s.values||''})`).join(', ')})`;
-              console.info("S?", {series}, args[0])
+              // console.info("S?", {series}, args[0])
             }
             args[1] = descriptor.chart.title;
             break;
@@ -1317,6 +1447,10 @@ export class Importer {
               args[1] = series[0]?.categories || '';
             }
 
+            if (descriptor.chart.type === ChartType.Column && descriptor.chart.flags?.includes('stacked')) {
+              args[3] = '"stacked"';
+            }
+
             break;
         }