@trebco/treb 23.6.5 → 25.0.0-rc2

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

@@ -0,0 +1,60 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import { Area, ICellAddress } from 'treb-base-types';
+
+/**
+ * FIXME: this is broken. we treat this as a simple javascript object,
+ * cloning and creating via JSON, but area is a class instance.
+ * 
+ * that means cloned objects won't work properly (if anyone is relying on 
+ * that object).
+ */
+export interface GridSelection {
+
+  /** target or main cell in the selection */
+  target: ICellAddress;
+
+  /** selection area */
+  area: Area;
+
+  /** there is nothing selected, even though this object exists */
+  empty?: boolean;
+
+  /** for cacheing addtional selections. optimally don't serialize */
+  rendered?: boolean;
+
+}
+
+/**
+ * create an empty selection
+ */
+export const CreateSelection = (): GridSelection => {
+  return {
+    target: {row: 0, column: 0},
+    area: new Area({row: 0, column: 0}),
+    empty: true,
+  };
+};
+
+export const CloneSelection = (rhs: GridSelection): GridSelection => {
+  return JSON.parse(JSON.stringify(rhs));
+};

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

@@ -0,0 +1,369 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import { IArea, Area } from 'treb-base-types';
+
+/**
+ * I want to repurpose named ranges (a little) to allow either values or 
+ * arbitrary expressions. this is sort of 1/2 way between named ranges and
+ * "macro functions".
+ * 
+ * not sure if we should change named ranges, or create a side path for 
+ * "named expressions".
+ */
+
+export class NamedRangeCollection {
+
+  private forward: {[index: string]: Area} = {};
+  private backward: Array<{name: string; range: Area}> = [];
+
+  /** FIXME: why not an accessor? */
+  public Count(): number {
+    return this.backward.length;
+  }
+
+  /** FIXME: why not just use toJSON? */
+  public Serialize(): Record<string, IArea> {
+    return JSON.parse(JSON.stringify(this.Map()));
+  }
+
+  public Deserialize(data?: Record<string, IArea>): void {
+    this.Reset();
+    if (data) {
+      for (const key of Object.keys(data)) {
+        this.SetName(key, new Area(data[key].start, data[key].end), false);
+      }
+      this.RebuildList();
+    }
+  }
+
+  /**
+   * match an area, optionally a target within a larger area (for selections).
+   * we don't use the selection directly, as we may need to adjust target for
+   * merge area.
+   */
+  public MatchSelection(area: Area, target?: Area): string|undefined {
+
+    if (!area.start.sheet_id) { 
+      throw new Error('match selection without sheet id'); 
+    }
+
+    let label: string|undefined;
+    for (const entry of this.List()) {
+      if (entry.range.start.sheet_id === area.start.sheet_id) {
+        if (entry.range.Equals(area)) {
+          label = entry.name; // don't break, in case there's a match for target which takes precendence.
+        }
+        if (target?.Equals(entry.range)) {
+          return entry.name;
+        }
+      }
+    }
+    return label;
+  }
+
+  /**
+   * add name. names are case-insensitive. if the name already
+   * exists, it will be overwritten.
+   * 
+   * update: returns success (FIXME: proper errors)
+   */
+  public SetName(name: string, range: Area, apply = true): boolean {
+    const validated = this.ValidateNamed(name);
+    if (!validated) {
+      console.warn('invalid name');
+      return false;
+    }
+    if (range.entire_column || range.entire_row) {
+      console.warn('invalid range');
+      return false;
+    }
+    this.forward[validated] = range;
+    if (apply) {
+      this.RebuildList();
+    }
+    return true;
+  }
+
+  public SetNames(list: {[index: string]: IArea}): void {
+    for (const key of Object.keys(list)) {
+      const area = list[key];
+      this.SetName(key, new Area(area.start, area.end), false);
+    }
+    this.RebuildList();
+  }
+
+  public ClearName(name: string, apply = true): void {
+    delete this.forward[name];
+    if (apply) {
+      this.RebuildList();
+    }
+  }
+
+  /**
+   * if we delete a sheet, remove ranges in that sheet
+   * @param sheet_id 
+   */
+  public RemoveRangesForSheet(sheet_id: number, apply = true) {
+
+    const temp: {[index: string]: Area} = {};
+    const list = this.List();    
+    
+    for (const entry of list) {
+      if (entry.range.start.sheet_id !== sheet_id) {
+        temp[entry.name] = entry.range;
+      }
+    }
+
+    this.forward = temp;
+
+    if (apply) {
+      this.RebuildList();
+    }
+  }
+
+  public Reset(): void {
+    this.forward = {};
+    this.backward = [];
+  }
+
+  public Get(name: string) {
+    return this.forward[name.toUpperCase()];
+  }
+
+  /** FIXME: accessor */
+  public Map() {
+    return this.forward;
+  }
+
+  /** FIXME: accessor */
+  public List() {
+    return this.backward;
+  }
+
+  /**
+   * named range rules:
+   *
+   * - legal characters are alphanumeric, underscore and dot.
+   * - must start with letter or underscore (not a number or dot).
+   * - cannot look like a spreadsheet address, which is 1-3 letters followed by numbers.
+   *
+   * returns a normalized name (just caps, atm)
+   */
+  public ValidateNamed(name: string): string|false {
+    name = name.trim();
+    if (!name.length) return false;
+    if (/^[A-Za-z]{1,3}\d+$/.test(name)) return false;
+    if (/[^A-Za-z\d_.]/.test(name)) return false;
+    if (/^[^A-Za-z_]/.test(name)) return false;
+    return name.toUpperCase();
+  }
+
+  // was in sheet
+
+
+  /**
+   * fix named range references after row/column insert/delete
+   */
+  public PatchNamedRanges(sheet_id: number, before_column: number, column_count: number, before_row: number, row_count: number) {
+
+    const copy = this.List().slice(0);
+
+    for (const entry of copy) {
+
+      const key = entry.name;
+      const range = entry.range;
+
+      if (range.start.sheet_id !== sheet_id) {
+        console.info('skipping name', key);
+        continue;
+      }
+
+      if (column_count && before_column <= range.end.column) {
+
+        /*
+        // (1) we are before the insert point, not affected
+
+        if (before_column > range.end.column) {
+          continue;
+        }
+        */
+
+        if (column_count > 0) {
+
+          // (2) it's an insert and we are past the insert point:
+          //     increment [start] and [end] by [count]
+
+          if (before_column <= range.start.column) {
+            range.Shift(0, column_count);
+          }
+
+          // (3) it's an insert and we contain the insert point:
+          //     increment [end] by [count]
+
+          else if (before_column > range.start.column && before_column <= range.end.column) {
+            range.ConsumeAddress({row: range.end.row, column: range.end.column + column_count});
+          }
+
+          else {
+            console.warn(`PNR X case 1`, before_column, column_count, JSON.stringify(range));
+          }
+
+        }
+        else if (column_count < 0) {
+
+          // (4) it's a delete and we are past the delete point (before+count):
+          //     decrement [start] and [end] by [count]
+
+          if (before_column - column_count <= range.start.column) {
+            range.Shift(0, column_count);
+          }
+
+          // (5) it's a delete and contains the entire range
+
+          else if (before_column <= range.start.column && before_column - column_count > range.end.column) {
+            this.ClearName(key, false);
+          }
+
+          // (6) it's a delete and contains part of the range. clip the range.
+
+          else if (before_column <= range.start.column) {
+            const last_column = before_column - column_count - 1;
+            this.SetName(key, new Area({
+              row: range.start.row, column: last_column + 1 + column_count, sheet_id }, {
+                row: range.end.row, column: range.end.column + column_count }), false);
+          }
+
+          else if (before_column <= range.end.column) {
+            const last_column = before_column - column_count - 1;
+
+            if (last_column >= range.end.column) {
+              this.SetName(key, new Area({
+                row: range.start.row, column: range.start.column, sheet_id }, {
+                  row: range.end.row, column: before_column - 1 }), false);
+            }
+            else {
+              this.SetName(key, new Area({
+                row: range.start.row, column: range.start.column, sheet_id }, {
+                  row: range.end.row, column: range.start.column + range.columns + column_count - 1}), false);
+            }
+
+          }
+
+          else {
+            console.warn(`PNR X case 2`, before_column, column_count, JSON.stringify(range));
+          }
+
+        }
+      }
+
+
+      if (row_count && before_row <= range.end.row) {
+
+        /*
+        // (1) we are before the insert point, not affected
+
+        if (before_row > range.end.row) {
+          continue;
+        }
+        */
+
+        if (row_count > 0) {
+
+          // (2) it's an insert and we are past the insert point:
+          //     increment [start] and [end] by [count]
+
+          if (before_row <= range.start.row) {
+            range.Shift(row_count, 0);
+          }
+
+          // (3) it's an insert and we contain the insert point:
+          //     increment [end] by [count]
+
+          else if (before_row > range.start.row && before_row <= range.end.row) {
+            range.ConsumeAddress({row: range.end.row + row_count, column: range.end.column});
+          }
+
+          else {
+            console.warn(`PNR X case 3`, before_row, row_count, JSON.stringify(range));
+          }
+
+        }
+        else if (row_count < 0) {
+
+          // (4) it's a delete and we are past the delete point (before+count):
+          //     decrement [start] and [end] by [count]
+
+          if (before_row - row_count <= range.start.row) {
+            range.Shift(row_count, 0);
+          }
+
+          // (5) it's a delete and contains the entire range
+
+          else if (before_row <= range.start.row && before_row - row_count > range.end.row) {
+            this.ClearName(key, false);
+          }
+
+          // (6) it's a delete and contains part of the range. clip the range.
+
+          else if (before_row <= range.start.row) {
+            const last_row = before_row - row_count - 1;
+            this.SetName(key, new Area({
+              column: range.start.column, row: last_row + 1 + row_count, sheet_id }, {
+                column: range.end.column, row: range.end.row + row_count }), false);
+          }
+
+          else if (before_row <= range.end.row) {
+            const last_row = before_row - row_count - 1;
+            if (last_row >= range.end.row) {
+              this.SetName(key, new Area({
+                column: range.start.column, row: range.start.row, sheet_id }, {
+                  column: range.end.column, row: before_row - 1 }), false);
+            }
+            else {
+              this.SetName(key, new Area({
+                column: range.start.column, row: range.start.row, sheet_id }, {
+                  column: range.end.column, row: range.start.row + range.rows + row_count - 1 }), false);
+            }
+
+          }
+
+          else {
+            console.warn(`PNR X case 4`, before_row, row_count, JSON.stringify(range));
+          }
+
+        }
+      }
+
+    }
+
+    this.RebuildList();
+
+  }
+
+  public RebuildList(): void {
+    this.backward = [];
+    for (const key of Object.keys(this.forward)) {
+      this.backward.push({ name: key, range: this.forward[key] });
+    }
+  }
+
+}

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

@@ -0,0 +1,202 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import { DOMUtilities as DOM } from '../util/dom_utilities';
+import { NumberFormat, NumberFormatCache, ValueParser } from 'treb-format';
+import { ValueType } from 'treb-base-types';
+import { EventSource } from 'treb-utils';
+
+export interface ScaleEvent {
+  type: 'scale';
+  // action: 'increase'|'decrease'|number;
+  value: number;
+  keep_focus?: boolean;
+}
+
+/**
+ * updated scale control, broken out. this is based on what we did for
+ * project planning, which worked out rather nicely.
+ */
+
+export class ScaleControl extends EventSource<ScaleEvent> {
+
+  private input: HTMLInputElement;
+  private slider: HTMLInputElement;
+  private scale = 0;
+  private format: NumberFormat;
+
+  private timeout = 0;
+
+  public constructor(public container: HTMLElement) {
+    super();
+
+    this.format = NumberFormatCache.Get('0.0');
+
+    // not sure what this extra div was for, we don't need it
+    // const div = DOM.CreateDiv('treb-scale-control-2', container);
+
+    this.input = DOM.Create('input', 'treb-scale-input', /* div */ container);
+    const popup = DOM.CreateDiv('treb-slider-container', /* div */ container);
+
+    /*
+    this.input.addEventListener('keyup', (event) => {
+      switch (event.key) {
+        case 'ArrowUp':
+        case 'ArrowDown':
+          event.stopPropagation();
+          event.preventDefault();
+          break;
+      }
+    });
+    */
+
+    // is this for some x-browser issue? or did we just not 
+    // know which event to use and this is old junk?
+
+    this.input.addEventListener('keypress', (event) => {
+      switch (event.key) {
+        case 'ArrowUp':
+        case 'ArrowDown':
+          event.stopPropagation();
+          event.preventDefault();
+          console.info('mark?');
+          break;
+      }
+    })
+
+    // this is the one we want
+
+    this.input.addEventListener('keydown', (event) => {
+      switch (event.key) {
+        case 'Enter':
+          this.input.blur();
+          break;
+
+        case 'ArrowUp':
+          this.Tick(-1);
+          break;
+
+        case 'ArrowDown':
+          this.Tick(1);
+          break;
+
+        case 'Escape':
+          this.input.value = this.format.Format(this.scale) + '%';
+          this.input.blur();
+          break;
+
+        default:
+          return;
+
+      }
+
+      event.stopPropagation();
+      event.preventDefault();
+
+    });
+
+    // select text on click
+    this.input.addEventListener('focusin', () => this.input.select());
+
+    this.input.addEventListener('change', () => {
+
+      // what we're doing here is a little unusual. we always treat
+      // the value as a percent, even if there's no percent sign.
+
+      // for that to work, if there is a percent sign, we need to remove
+      // it before we continue. then try to parse as a number.
+
+      let text = this.input.value;
+      text = text.replace(/%/g, '');
+
+      const value = ValueParser.TryParse(text);
+      if (value.type === ValueType.number) {
+        this.UpdateScale(Number(value.value), true);
+      }
+      else {
+        this.input.value = this.format.Format(this.scale) + '%';
+      }
+
+    });
+
+    this.slider = DOM.Create<HTMLInputElement>('input', undefined, popup, undefined, {
+      type: 'range',
+      min: '50',
+      max: '200',
+      value: '100',
+      step: '2.5',
+    });
+
+    this.slider.addEventListener('input', () => {
+      this.UpdateScale(Number(this.slider.value), true);
+    });
+
+    /* div */ container.addEventListener('wheel', (event: WheelEvent) => {
+      event.stopPropagation();
+      event.preventDefault();
+      this.Tick(event.deltaY)
+    });
+
+  }
+
+  public Tick(value: number): void {
+
+    // not sure what alternate case I am worried about here,
+    // sideways wheel? shift key?
+
+    // normalize
+
+    const scale = Math.round(this.scale / 2.5) * 2.5;
+
+    if (value > 0) {
+      this.UpdateScale(scale - 2.5, true, true);
+    }
+    else if (value < 0){
+      this.UpdateScale(scale + 2.5, true, true);
+    }
+
+  }
+
+  public UpdateScale(scale: number, notify = false, keep_focus = false): void {
+
+    scale = Math.max(50, Math.min(200, scale));
+    if (scale !== this.scale) { 
+      this.scale = scale;
+      this.input.value = this.format.Format(scale) + '%';
+      this.slider.value = scale.toFixed(1);
+      
+      if (notify) {
+        if (!this.timeout) {
+          this.timeout = requestAnimationFrame(() => {
+            this.timeout = 0;
+            this.Publish({
+              type: 'scale', 
+              value: this.scale / 100,
+              keep_focus,
+            });
+          });
+        }
+      }
+    }
+  }
+
+}
+

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

@@ -0,0 +1,72 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+/**
+ * options for serializing data
+ * 
+ * @privateRemarks
+ * essentially a placeholder for options; we only have one at the moment.
+ *
+ * note that the underlying cells container has its own set of options. we
+ * are explicitly not using that so we can add things that are beyond that
+ * scope.
+ *
+ * still, we might just wrap that object [FIXME/TODO].
+ */
+export interface SerializeOptions {
+
+  /** optimize for size */
+  optimize?: 'size'|'speed';
+
+  /** include the rendered/calculated value in export */
+  rendered_values?: boolean;
+
+  /** 
+   * preserve cell type
+   * @internal
+   */
+  preserve_type?: boolean;
+
+  /** 
+   * expand arrays so cells have individual values
+   * @internal
+   */
+  expand_arrays?: boolean;
+
+  /** translate colors to xlsx-friendly values */
+  export_colors?: boolean;
+
+  /** export cells that have no value, but have a border or background color */
+  decorated_cells?: boolean;
+
+  /** prune unused rows/columns */
+  shrink?: boolean;
+
+  /** 
+   * include tables. tables will be serialized in the model, so we can
+   * drop them from cells. but you can leave them in if that's useful.
+   */
+  tables?: boolean;
+
+  /** share resources (images, for now) to prevent writing data URIs more than once */
+  share_resources?: boolean;
+
+}