@trebco/treb 28.10.5 → 28.13.2

package/treb-calculator/src/primitives.ts

@@ -309,6 +309,17 @@ export const Equals = (a: UnionValue, b: UnionValue): UnionValue => {
 
   }
 
+  // this is standard (icase) string equality. we might also need
+  // to handle wildcard string matching, although it's not the 
+  // default case for = operators.
+
+  if (a.type === ValueType.string && b.type === ValueType.string) {
+    return { 
+      type: ValueType.boolean, 
+      value: a.value.toLowerCase() === b.value.toLowerCase(),
+    };
+  }
+
   return { type: ValueType.boolean, value: a.value == b.value }; // note ==
 };
 

package/treb-calculator/src/utilities.ts

@@ -302,3 +302,58 @@ export const ApplyAsArray2 = (base: (a: any, b: any, ...rest: any[]) => UnionVal
   }
 };
 
+
+/**
+ * parse a string with wildcards into a regex pattern
+ * 
+ * from
+ * https://exceljet.net/glossary/wildcard
+ * 
+ * Excel has 3 wildcards you can use in your formulas:
+ *
+ * Asterisk (*) - zero or more characters
+ * Question mark (?) - any one character
+ * Tilde (~) - escape for literal character (~*) a literal question mark (~?), or a literal tilde (~~)
+ * 
+ * they're pretty liberal with escaping, nothing is an error, just roll with it
+ * 
+ */
+export const ParseWildcards = (text: string): string => {
+
+  const result: string[] = [];
+  const length = text.length;
+
+  const escaped_chars = '[\\^$.|?*+()';
+
+  for (let i = 0; i < length; i++) {
+    let char = text[i];
+    switch (char) {
+
+      case '*':
+        result.push('.', '*');
+        break;
+
+      case '?':
+        result.push('.');
+        break;
+
+      case '~':
+        char = text[++i] || '';
+      
+      // eslint-disable-next-line no-fallthrough
+      default:
+        for (let j = 0; j < escaped_chars.length; j++) {
+          if (char === escaped_chars[j]) {
+            result.push('\\');
+            break;
+          }
+        }
+        result.push(char);
+        break;
+
+    }
+  }
+
+  return result.join('');
+
+};

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

@@ -310,7 +310,7 @@ export const TransformSeriesData = (raw_data?: UnionValue, default_x?: UnionValu
 };
 
 /** get a unified scale, and formats */
-export const CommonData = (series: SeriesType[], y_floor?: number, y_ceiling?: number) => {
+export const CommonData = (series: SeriesType[], y_floor?: number, y_ceiling?: number, x_floor?: number, x_ceiling?: number) => {
 
   let x_format = '';
   let y_format = '';
@@ -362,7 +362,14 @@ export const CommonData = (series: SeriesType[], y_floor?: number, y_ceiling?: n
       }
     }
   }
-  
+
+  if (typeof x_floor !== 'undefined') {
+    x_min = Math.min(x_min, x_floor);
+  }
+  if (typeof x_ceiling !== 'undefined') {
+    x_min = Math.max(x_min, x_ceiling);
+  }
+
   if (typeof y_floor !== 'undefined') {
     y_min = Math.min(y_min, y_floor);
   }
@@ -438,7 +445,21 @@ const ApplyLabels = (series_list: SeriesType[], pattern: string, category_labels
 export const CreateBubbleChart = (args: UnionValue[]): ChartData => {
 
   const series: SeriesType[] = TransformSeriesData(args[0]);
-  const common = CommonData(series);
+
+  let y_floor: number|undefined = undefined;
+  let x_floor: number|undefined = undefined;
+  
+  for (const entry of series) {
+
+    if (typeof entry.x.range?.min === 'number' && entry.x.range.min > 0 && entry.x.range.min < 50) {
+      x_floor = 0;
+    }
+    if (typeof entry.y.range?.min === 'number' && entry.y.range.min > 0 && entry.y.range.min < 50) {
+      y_floor = 0;
+    }
+  }
+
+  const common = CommonData(series, y_floor, undefined, x_floor);
   const title = args[1]?.toString() || undefined;
   const options = args[2]?.toString() || undefined;
 

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

@@ -196,6 +196,8 @@ export class DefaultChartRenderer implements ChartRendererType {
 
     // now do type-specific rendering
 
+    let zeros: number[]|undefined = [];
+
     switch (chart_data.type) {
     case 'scatter':
       this.renderer.RenderPoints(area, chart_data.x, chart_data.y, 'mc mc-correlation series-1');
@@ -203,10 +205,17 @@ export class DefaultChartRenderer implements ChartRendererType {
 
     case 'bubble':
 
+      if (chart_data.x_scale.min <= 0 && chart_data.x_scale.max >= 0) {
+        zeros[0] = Math.round(Math.abs(chart_data.x_scale.min / chart_data.x_scale.step));
+      }      
+      if (chart_data.y_scale.min <= 0 && chart_data.y_scale.max >= 0) {
+        zeros[1] = Math.round(Math.abs(chart_data.y_scale.max / chart_data.y_scale.step));
+      }
+
       this.renderer.RenderGrid(area, 
         chart_data.y_scale.count, 
         chart_data.x_scale.count + 1, // (sigh)
-        'chart-grid');
+        'chart-grid', zeros);
 
       for (const [index, series] of chart_data.series.entries()) {
         const series_index = (typeof series.index === 'number') ? series.index : index + 1;

package/treb-charts/src/renderer.ts

@@ -968,23 +968,54 @@ export class ChartRenderer {
 
   }
 
-  public RenderGrid(area: Area, y_count: number, x_count = 0, classes?: string | string[]): void {
+  public RenderGrid(area: Area, y_count: number, x_count = 0, classes?: string | string[], zeros?: number[]): void {
 
     const d: string[] = [];
+    const d2: string[] = [];
 
     let step = area.height / y_count;
     for (let i = 0; i <= y_count; i++) {
+
       const y = Math.round(area.top + step * i) - 0.5;
-      d.push(`M${area.left} ${y} L${area.right} ${y}`);
+
+      if (zeros && zeros[1] === i) {
+        d2.push(`M${area.left} ${y} L${area.right} ${y}`);
+      }
+      else {
+        d.push(`M${area.left} ${y} L${area.right} ${y}`);
+      }
     }
 
     step = area.width / (x_count - 1);
     for (let i = 0; i < x_count; i++) {
+
       const x = Math.round(area.left + step * i) - 0.5;
-      d.push(`M${x} ${area.top} L${x} ${area.bottom}`);
+
+      if (zeros && zeros[0] === i) {
+        d2.push(`M${x} ${area.top} L${x} ${area.bottom}`);
+      }
+      else {
+        d.push(`M${x} ${area.top} L${x} ${area.bottom}`);
+      }
     }
 
     this.group.appendChild(SVGNode('path', {d, class: classes}));
+    if (d2.length) {
+
+      if (classes) {
+        if (!Array.isArray(classes)) {
+          classes = classes + ' zero';
+        }
+        else {
+          classes.push('zero');
+        }
+      }
+      else {
+        classes = 'zero';
+      }
+
+      this.group.appendChild(SVGNode('path', {d: d2, class: classes}));
+    }
 
   }
 

package/treb-charts/style/charts.scss

@@ -104,6 +104,11 @@
   /* grid */
   .chart-grid, .chart-ticks {
     stroke: var(--treb-chart-grid-color, #ddd);
+
+    &.zero {
+      stroke: var(--treb-chart-grid-zero-color, var(--treb-chart-grid-color, #999));
+    }
+
   }
 
   /* mouse elements */

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

@@ -42,6 +42,8 @@ import type {
   CondifionalFormatExpressionOptions,
   ConditionalFormatCellMatchOptions,
   ConditionalFormatCellMatch,
+  MacroFunction,
+  SerializedNamedExpression,
 } from 'treb-grid';
 
 import {
@@ -413,7 +415,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   }
 
   /** for destruction */
-  protected view?: HTMLElement;
+  protected view_node?: HTMLElement;
 
   /** for destruction */
   protected key_listener?: (event: KeyboardEvent) => void;
@@ -844,7 +846,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       // elements. but we don't add a default; rather we use a template
 
       const template = container.querySelector('.treb-view-template') as HTMLTemplateElement;
-      this.view = template.content.firstElementChild?.cloneNode(true) as HTMLElement;
+      this.view_node = template.content.firstElementChild?.cloneNode(true) as HTMLElement;
 
       // this is a little weird but we're inserting at the front. the 
       // reason for this is that we only want to use one resize handle,
@@ -852,13 +854,13 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
       // we could work around this, really we're just being lazy.
 
-      container.prepend(this.view);
+      container.prepend(this.view_node);
 
       
       // this.node = container;
       // this.node = this.view;
 
-      this.view.addEventListener('focusin', () => {
+      this.view_node.addEventListener('focusin', () => {
         if (this.focus_target !== this) {
           this.Publish({ type: 'focus-view' });
           this.focus_target = this;
@@ -878,14 +880,14 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
       // const view = container.querySelector('.treb-view') as HTMLElement;
 
-      this.grid.Initialize(this.view, toll_initial_render);
+      this.grid.Initialize(this.view_node, toll_initial_render);
 
       // dnd
 
       if (this.options.dnd) {
-        this.view.addEventListener('dragenter', (event) => this.HandleDrag(event));
-        this.view.addEventListener('dragover', (event) => this.HandleDrag(event));
-        this.view.addEventListener('drop', (event) => this.HandleDrop(event));
+        this.view_node.addEventListener('dragenter', (event) => this.HandleDrag(event));
+        this.view_node.addEventListener('dragover', (event) => this.HandleDrag(event));
+        this.view_node.addEventListener('drop', (event) => this.HandleDrop(event));
       }
 
       // set up grid events
@@ -1244,19 +1246,19 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       sheet.grid.grid_events.CancelAll();
       sheet.events.CancelAll();
       
-      if (sheet.view?.parentElement) {
+      if (sheet.view_node?.parentElement) {
 
         // remove listener
         if (sheet.key_listener) {
-          sheet.view.parentElement.removeEventListener('keydown', sheet.key_listener);
+          sheet.view_node.parentElement.removeEventListener('keydown', sheet.key_listener);
         }
 
         // remove node
-        sheet.view.parentElement.removeChild(sheet.view);
+        sheet.view_node.parentElement.removeChild(sheet.view_node);
       }            
 
       // in case other view was focused
-      this.view?.focus();
+      this.view_node?.focus();
 
       // usually this results in us getting larger, we may need to update
       this.Resize();
@@ -1285,7 +1287,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     const view = this.CreateView();
     view.grid.EnsureActiveSheet(true);
 
-    view.view?.addEventListener('focusin', () => {
+    view.view_node?.addEventListener('focusin', () => {
       if (this.focus_target !== view) {
         this.Publish({ type: 'focus-view' });
         this.focus_target = view;
@@ -2244,12 +2246,16 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     this.parser.flags.r1c1 = r1c1;
 
     if (argument_separator === ',') {
-      this.parser.argument_separator = ArgumentSeparatorType.Comma;
-      this.parser.decimal_mark = DecimalMarkType.Period;
+      this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+      // this.parser.argument_separator = ArgumentSeparatorType.Comma;
+      // this.parser.decimal_mark = DecimalMarkType.Period;
     }
     else {
-      this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
-      this.parser.decimal_mark = DecimalMarkType.Comma;
+      this.parser.SetLocaleSettings(DecimalMarkType.Comma);
+
+      // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+      // this.parser.decimal_mark = DecimalMarkType.Comma;
     }
 
     const result = this.parser.Parse(formula);
@@ -2354,12 +2360,16 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       */
 
       if (argument_separator === ',') {
-        this.parser.argument_separator = ArgumentSeparatorType.Comma;
-        this.parser.decimal_mark = DecimalMarkType.Period;
+        this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+        // this.parser.argument_separator = ArgumentSeparatorType.Comma;
+        // this.parser.decimal_mark = DecimalMarkType.Period;
       }
       else {
-        this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
-        this.parser.decimal_mark = DecimalMarkType.Comma;
+        this.parser.SetLocaleSettings(DecimalMarkType.Comma);
+
+        // this.parser.argument_separator = ArgumentSeparatorType.Semicolon;
+        // this.parser.decimal_mark = DecimalMarkType.Comma;
       }
 
       // const r1c1_state = this.parser.flags.r1c1;
@@ -2749,13 +2759,14 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
         // FIXME: type
 
-        const serialized: SerializedModel = this.grid.Serialize({
+        const serialized: SerializedModel = this.Serialize({ // this.grid.Serialize({
           rendered_values: true,
           expand_arrays: true,
           export_colors: true,
           decorated_cells: true,
           tables: true,
           share_resources: false,
+          export_functions: true,
         });
 
         // why do _we_ put this in, instead of the grid method? 
@@ -3523,6 +3534,9 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   /**
    * Create a macro function.
    * 
+   * FIXME: this needs a control for argument separator, like other
+   * functions that use formulas (@see SetRange)
+   * 
    * @public
    */
   public DefineFunction(name: string, argument_names: string | string[] = '', function_def = '0'): void {
@@ -3592,7 +3606,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       ...options,
     };
 
-    const grid_data = this.grid.Serialize(options);
+    // const grid_data = this.grid.Serialize(options);
+    const grid_data = this.Serialize(options);
 
     // NOTE: these are not really env vars. we replace them at build time
     // via a webpack plugin. using the env syntax lets them look "real" at
@@ -4405,6 +4420,121 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   // --- internal (protected) methods ------------------------------------------
 
+  // --- moved from grid/grid base ---------------------------------------------
+
+  
+  /**
+   * serialize data model. moved from grid/grid base. this is moved so we 
+   * have access to the calculator, which we want so we can do function 
+   * translation on some new functions that don't necessarily map 1:1 to 
+   * XLSX functions. we can also do cleanup on functions where we're less
+   * strict about arguments (ROUND, for example).
+   * 
+   */
+  protected Serialize(options: SerializeOptions = {}): SerializedModel {
+
+    const active_sheet = this.grid.active_sheet; // I thought this was in view? (...)
+
+    active_sheet.selection = JSON.parse(JSON.stringify(this.grid.GetSelection()));
+
+    // same for scroll offset
+
+    const scroll_offset = this.grid.ScrollOffset();
+    if (scroll_offset) {
+      active_sheet.scroll_offset = scroll_offset; // this.grid.layout.scroll_offset;
+    }    
+
+    // NOTE: annotations moved to sheets, they will be serialized in the sheets
+
+    const sheet_data = this.model.sheets.list.map((sheet) => sheet.toJSON(options));
+
+    // OK, not serializing tables in cells anymore. old comment about this:
+    // 
+    // at the moment, tables are being serialized in cells. if we put them
+    // in here, then we have two records of the same data. that would be bad.
+    // I think this is probably the correct place, but if we put them here
+    // we need to stop serializing in cells. and I'm not sure that there are 
+    // not some side-effects to that. hopefully not, but (...)
+    // 
+
+    let tables: Table[] | undefined;
+    if (this.model.tables.size > 0) {
+      tables = Array.from(this.model.tables.values());
+    }
+
+    // NOTE: moving into a structured object (the sheet data is also structured,
+    // of course) but we are moving things out of sheet (just  named ranges atm))
+
+    let macro_functions: MacroFunction[] | undefined;
+
+    if (this.model.macro_functions.size) {
+      macro_functions = [];
+      for (const macro of this.model.macro_functions.values()) {
+        macro_functions.push({
+          ...macro,
+          expression: undefined,
+        });
+      }
+    }
+
+    // when serializing named expressions, we have to make sure
+    // that there's a sheet name in any address/range. 
+
+    const named_expressions: SerializedNamedExpression[] = [];
+    if (this.model.named_expressions) {
+
+      for (const [name, expr] of this.model.named_expressions) {
+        this.parser.Walk(expr, unit => {
+          if (unit.type === 'address' || unit.type === 'range') {
+            const test = unit.type === 'range' ? unit.start : unit;
+
+            test.absolute_column = test.absolute_row = true;
+
+            if (!test.sheet) {
+              if (test.sheet_id) {
+                const sheet = this.model.sheets.Find(test.sheet_id);
+                if (sheet) {
+                  test.sheet = sheet.name;
+                }
+              }
+              if (!test.sheet) {
+                test.sheet = active_sheet.name;
+              }
+            }
+
+            if (unit.type === 'range') {
+              unit.end.absolute_column = unit.end.absolute_row = true;
+            }
+
+            return false;
+          }
+          else if (unit.type === 'call' && options.export_functions) {
+            // ...
+          }
+          return true;
+        });
+        const rendered = this.parser.Render(expr, { missing: '' });
+        named_expressions.push({
+          name, expression: rendered
+        });
+      }
+    }
+
+    return {
+      sheet_data,
+      active_sheet: active_sheet.id,
+      named_ranges: this.model.named_ranges.Count() ?
+        this.model.named_ranges.Serialize() :
+        undefined,
+      macro_functions,
+      tables,
+      named_expressions: named_expressions.length ? named_expressions : undefined,
+    };
+
+  }
+
+  // --- /moved ----------------------------------------------------------------
+
   /**
    * 
    */
@@ -5531,14 +5661,18 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // FIXME: also we should unify on types for decimal, argument separator
 
     if (data.decimal_mark === '.') {
-      parser.decimal_mark = DecimalMarkType.Period;
-      parser.argument_separator = ArgumentSeparatorType.Comma;
+      // parser.decimal_mark = DecimalMarkType.Period;
+      // parser.argument_separator = ArgumentSeparatorType.Comma;
+      parser.SetLocaleSettings(DecimalMarkType.Period);
+
       target_decimal_mark = DecimalMarkType.Comma;
       target_argument_separator = ArgumentSeparatorType.Semicolon;
     }
     else {
-      parser.decimal_mark = DecimalMarkType.Comma;
-      parser.argument_separator = ArgumentSeparatorType.Semicolon;
+      // parser.decimal_mark = DecimalMarkType.Comma;
+      // parser.argument_separator = ArgumentSeparatorType.Semicolon;
+      parser.SetLocaleSettings(DecimalMarkType.Comma);
+
       target_decimal_mark = DecimalMarkType.Period;
       target_argument_separator = ArgumentSeparatorType.Comma;
     }

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

@@ -33,6 +33,7 @@
   --treb-autocomplete-tooltip-color: #fff;
   --treb-chart-background: #000;
   --treb-chart-grid-color: #976;
+  --treb-chart-grid-zero-color: #fdd;
   --treb-chart-text-color: #fff;
   --treb-dialog-background: #000;
   --treb-dialog-color: #fff;