@trebco/treb 23.6.2 → 25.0.0-rc1

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

@@ -0,0 +1,216 @@
+/*
+ * 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 { Rectangle, ICellAddress, AnnotationLayout } from 'treb-base-types';
+
+/**
+ * new annotation class. annotations are arbitrary content
+ * inserted into the sheet, using a floating div element. the
+ * class is serialized with the sheet, so the caller can recreate
+ * the content if desired.
+ *
+ * because there's an element of layout involved, callers should
+ * interact with annotations through the grid class rather than the
+ * sheet.
+ * 
+ * we are redesigning layout so that instead of a rectangle, in 
+ * coordinate space, annotations use extents and offsets in cell space.
+ * so layout should now have a TL cell and a BR cell plus offsets for 
+ * each. Offset is implemented as a % of the given cell, so offsets are 
+ * inverted in the TL/BR cells.
+ * 
+ * UPDATE: actually while the inverted BR offset makes intuitive sense,
+ * it doesn't make technical sense -- easier to always calcluate offsets
+ * in the same direction. so offsets are always positive.
+ * 
+ * we'll leave the old extent in there (for now, at least) to prevent
+ * any unintended consequences. 
+ *
+ * UPDATE: adding a view interface for view-specific data. this is prep
+ * for supporting annotations in split views; we have to change how we
+ * manage nodes and callbacks.
+ *  
+ */
+
+let key_generator = 100;
+
+/**
+ * moving view-specific data into a separate interface to support split.
+ * nothing in view is serialized.
+ */
+export interface ViewData {
+
+  /** flag indicating we have inflated this. not serialized */
+  inflated?: boolean;
+
+  /** if function exists, will be called when the annotation is resized */
+  resize_callback?: () => void;
+  
+  /** if function exists, will be called when the annotation needs to update */
+  update_callback?: () => void;
+
+  /** layout node */
+  node?: HTMLDivElement;
+
+  /** content node */
+  content_node?: HTMLDivElement;
+
+  /** view-specific dirty flag */
+  dirty?: boolean;
+
+}
+
+export class Annotation {
+
+  public get key(): number { return this.key_; }
+
+  /** coordinates, in sheet space */
+  public rect?: Rectangle;
+
+  // public get rect(): Rectangle|undefined { return this.rect_; }
+
+  /** display coordinates, possibly scaled. not persisted. */
+  public scaled_rect?: Rectangle;
+
+  /** the new layout, persisted and takes preference over the old one */
+  public layout?: AnnotationLayout;
+
+  /** opaque data. this is serialized, so it's persistent data */
+  public data: any = {};
+
+  // opaque string which will be added to the class of any containing node 
+  // public class_name?: string;
+
+  /** type, for filtering. ensure a value */
+  public type = '';
+
+  /** also opaque data, but not serialized. */
+  public temp: any = {};
+
+  /* * flag indicating we have inflated this. not serialized */
+  // public inflated = false;
+
+  /* * if function exists, will be called when the annotation is resized */
+  // public resize_callback?: () => void;
+
+  /* * if function exists, will be called when the annotation needs to update */
+  // public update_callback?: () => void;
+
+  /** annotation can be resized. this is advisory, for UI */
+  public resizable = true;
+
+  /** annotation can be moved. this is advisory, for UI */
+  public movable = true;
+
+  /** annotation can be removed/deleted. this is advisory, for UI */
+  public removable = true;
+
+  /** annotation can be selected. this is advisory, for UI */
+  public selectable = true;
+
+  /** move when resizing/inserting rows/columns */
+  public move_with_cells = true;
+
+  /** resize when resizing/inserting rows/columns */
+  public resize_with_cells = true;
+
+  /* * layout node, obviously not serialized */
+  // public node?: HTMLDivElement;
+
+  /* * content node */
+  // public content_node?: HTMLDivElement;
+
+  public view: ViewData[] = [];
+
+  /**
+   * advisory, meaning we probably need an update if there's an opportunity.
+   * only advisory and not persisted.
+   */
+  public dirty?: boolean;
+
+  /**
+   * optional formula. the formula will be updated on structure events
+   * (insert/delete row/column).
+   */
+  public formula = '';
+
+  /** 
+   * extent, useful for exporting. we could probably serialize this,
+   * just be sure to clear it when layout changes so it will be
+   * recalculated.
+   * 
+   * the idea is to know the bottom/right row/column of the annotation,
+   * so when we preserve/restore the sheet we don't trim those rows/columns.
+   * they don't need any data, but it just looks bad. we can do this 
+   * dynamically but since it won't change all that often, we might 
+   * as well precalculate.
+   */
+  public extent?: ICellAddress;
+
+  private key_ = (key_generator++);
+
+  /**
+   * constructor takes a property bag (from json, generally). note that
+   * if you are iterating keys on `this`, there has to be an initial value
+   * or the key won't exist.
+   */
+  constructor(opts: Partial<Annotation>&{rect?: Partial<Rectangle>} = {}) {
+    for (const key of Object.keys(this) as Array<keyof Annotation>){
+      if (key !== 'layout' // && key !== 'rect' 
+          && opts[key]) { // key !== 'cell_address' && opts[key]) {
+        (this as any)[key] = opts[key];
+      }
+    }
+
+    if (opts.layout) {
+      this.layout = JSON.parse(JSON.stringify(opts.layout));
+    }
+    if (opts.rect) {
+      this.rect = Rectangle.Create(opts.rect);
+    }
+  }
+
+  /**
+   * serialization method drops node and trims
+   */
+  public toJSON(): Partial<Annotation> {
+    const result: Partial<Annotation> = {}; // { rect: this.rect };
+
+    if (this.data) result.data = this.data;
+    if (this.formula) result.formula = this.formula;
+    if (this.type) result.type = this.type;
+    // if (this.class_name) result.class_name = this.class_name;
+
+    if (!this.resizable) result.resizable = this.resizable;
+    if (!this.movable) result.movable = this.movable;
+    if (!this.removable) result.removable = this.removable;
+    if (!this.selectable) result.selectable = this.selectable;
+
+    if (!this.move_with_cells) result.move_with_cells = this.move_with_cells;
+    if (!this.resize_with_cells) result.resize_with_cells = this.resize_with_cells;
+
+    if (this.layout) result.layout = this.layout;
+    if (this.extent) result.extent = this.extent;
+
+    return result;
+  }
+
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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
+ * 
+ */
+
+// switching to string constants to make it easier to set manually
+
+export enum BorderConstants {
+  None = 'none',
+  All = 'all',
+  Outside = 'outside',
+  Top = 'top',
+  Bottom = 'bottom',
+  Left = 'left',
+  Right = 'right',
+  // DoubleTop = 'double-top',
+  // DoubleBottom = 'double-bottom',
+}

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

@@ -0,0 +1,31 @@
+/*
+ * 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 type { ICellAddress, CellValue, ValueType, Style } from 'treb-base-types';
+
+export interface ClipboardCellData {
+  address: ICellAddress;
+  data: CellValue;
+  type: ValueType;
+  style?: Style.Properties;
+  array?: {rows: number, columns: number};
+}

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

@@ -0,0 +1,334 @@
+/*
+ * 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 type { Sheet } from './sheet';
+import type { IArea, ICellAddress, Table } from 'treb-base-types';
+import type { SerializedSheet } from './sheet_types';
+import { NamedRangeCollection } from './named_range';
+import type { ExpressionUnit, UnitAddress, UnitStructuredReference, UnitRange } from 'treb-parser';
+import { Style } from 'treb-base-types';
+
+export interface MacroFunction {
+  name: string;
+  function_def: string;
+  argument_names?: string[];
+  // argument_default_values?: any[]; // <- new
+  description?: string;
+  expression?: ExpressionUnit;
+}
+
+/**
+ * we spend a lot of time looking up sheets by name, or id, or 
+ * sometimes index. it makes sense to have a class that can 
+ * support all of these, ideally without looping.
+ * 
+ * we just have to make sure that no one is assigning to the
+ * array, or we'll lose track. 
+ * 
+ * also there are some operations -- rename, in particular -- that
+ * require updating indexes.
+ * 
+ * 
+ * FIXME: new file (1 class per file)
+ */
+export class SheetCollection {
+
+  /** 
+   * returns a read-only copy of the list. useful for indexing or 
+   * functional-style calls. it's not actually read-only, but it's a 
+   * copy, so changes will be ignored.
+   */
+  public get list() {
+    return this.sheets_.slice(0);
+  }
+
+  /**
+   * length of list
+   */
+  public get length() {
+    return this.sheets_.length;
+  }
+
+  /** map of (normalized) name -> sheet */
+  protected names: Map<string, Sheet> = new Map();
+
+  /** map of id -> sheet */
+  protected ids: Map<number, Sheet> = new Map();
+
+  /** the actual list */
+  private sheets_: Sheet[] = [];
+
+  /**
+   * remove any existing sheets and add the passed list. updates indexes.
+   */
+  public Assign(sheets: Sheet[]) {
+    this.sheets_ = [...sheets];
+    this.UpdateIndexes();
+  }
+
+  /** 
+   * add a new sheet to the end of the list (push). updates indexes. 
+   */
+  public Add(sheet: Sheet) {
+    this.sheets_.push(sheet);
+    this.UpdateIndexes();
+  }
+
+  /** 
+   * wrapper for array splice. updates indexes. 
+   */
+  public Splice(insert_index: number, delete_count: number, ...items: Sheet[]) {
+    this.sheets_.splice(insert_index, delete_count, ...items);
+    this.UpdateIndexes();
+  }
+  
+  /**
+   * so our new strategy is to add lookup methods first -- then 
+   * we can fix the underlying storage implementation.
+   * 
+   * NOTE we normalize strings here so you do not need to do it (don't)
+   */
+   public Find(id: string|number): Sheet|undefined {
+
+    // console.info('get', typeof id);
+
+    if (typeof id === 'string') {
+      return this.names.get(id.toLocaleUpperCase());
+    }
+    else {
+      return this.ids.get(id);
+    }
+
+    return undefined;
+  }
+
+  /** get name for sheet with given id */
+  public Name(id: number): string|undefined {
+    return this.ids.get(id)?.name || undefined;
+  }
+
+  /** get ID for sheet with given name */
+  public ID(name: string): number|undefined {
+    return this.names.get(name.toLocaleUpperCase())?.id || undefined;
+  }
+
+  /** not sure why this is private, makes it a little more complicated */
+  public UpdateIndexes(): void {
+
+    this.names.clear();
+    this.ids.clear();
+
+    for (const sheet of this.sheets_) {
+      const uc = sheet.name.toLocaleUpperCase();
+      this.names.set(uc, sheet);
+      this.ids.set(sheet.id, sheet);
+    }
+
+  }
+
+
+}
+
+/**
+ * FIXME: this should move out of the grid module, grid should be focused on view
+ */
+export class DataModel {
+
+  /** document metadata */
+  public document_name?: string;
+
+  /** document metadata */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public user_data?: any;
+
+  /** 
+   * list of sheets. we _should_ index these by ID, so we 
+   * don't have to look up. FIXME/TODO
+   */
+  // public sheets: Sheet[] = [];
+
+  /**
+   * this prevents assignment, but not push/pop/splice (baby steps)
+   */
+  // public get sheets(): Sheet[] {
+  //  return this._sheets;
+  //}
+  public readonly sheets = new SheetCollection();
+
+  /** named ranges are document-scope, we don't support sheet-scope names */
+  public readonly named_ranges = new NamedRangeCollection;
+
+  /** macro functions are functions written in spreadsheet language */
+  // public macro_functions: Record<string, MacroFunction> = {};
+  public readonly macro_functions: Map<string, MacroFunction> = new Map();
+
+  /** 
+   * new, for parametric. these might move to a different construct. 
+   */
+  //public named_expressions: Record<string, ExpressionUnit> = {};
+  public readonly named_expressions: Map<string, ExpressionUnit> = new Map();
+
+  /** index for views */
+  public view_count = 0;
+
+  /**
+   * base style properties moved to model, so we can have a single
+   * and consistent reference.
+   */
+  public theme_style_properties: Style.Properties = JSON.parse(JSON.stringify(Style.DefaultProperties));
+
+  /**
+   * tables are global, because we need to reference them by name; and they
+   * need unique names, so we need to keep track of names. name matching is
+   * icase so we lc the names before inserting.
+   */
+  public tables: Map<string, Table> = new Map();
+
+  /**
+   * putting this here temporarily. it should probably move into a table
+   * manager class or something like that.
+   */
+  public ResolveStructuredReference(ref: UnitStructuredReference, context: ICellAddress): UnitAddress|UnitRange|undefined {
+
+    let table: Table|undefined;
+
+    // if there's no table specified, it means "I am in the table".
+    // in that case we need to find the table from the cell.
+
+    if (ref.table) {
+      table = this.tables.get(ref.table.toLowerCase());
+    }
+    else {
+      if (context.sheet_id) {
+        const sheet = this.sheets.Find(context.sheet_id);
+        const cell = sheet?.CellData(context);
+        table = cell?.table;
+      }
+    }
+
+    if (!table) {
+      return undefined; // table not found
+    }
+
+    // resolve the column
+    const reference_column = ref.column.toLowerCase();
+    let column = -1;
+
+    if (table.columns) { // FIXME: make this required
+      for (let i = 0; i < table.columns.length; i++) {
+        if (reference_column === table.columns[i]) {
+          column = table.area.start.column + i;
+          break;
+        }
+      }
+    }
+
+    if (column < 0) {
+      return undefined; // invalid column
+    }
+
+    // for row scope, make sure we're in a valid row.
+    
+    if (ref.scope === 'row') {
+
+      const row = context.row;
+      if (row < table.area.start.row || row > table.area.end.row) {
+        return undefined; // invalid row for "this row"
+      }
+
+      // OK, we can use this
+
+      return {
+        label: ref.label,
+        type: 'address',
+        row, 
+        column,
+        sheet_id: table.area.start.sheet_id,
+        id: ref.id,
+        position: ref.position,
+      };
+
+    }
+    else {
+
+      // the difference between 'all' and 'column' is that 'all' includes
+      // the first (header) row and the last (totals) row, if we have one.
+
+      let start_row = table.area.start.row;
+      let end_row = table.area.end.row; 
+
+      if (ref.scope === 'column') { 
+        start_row++; // skip headers
+        if (table.totals_row) {
+          end_row--; // skip totals
+        }
+      }
+
+      return {
+        label: ref.label,
+        type: 'range',
+        position: ref.position,
+        id: ref.id,
+        start: {
+          type: 'address',
+          row: start_row,
+          column,
+          sheet_id: table.area.start.sheet_id,
+          label: ref.label,
+          position: ref.position,
+          id: 0,
+        },
+        end: {
+          type: 'address',
+          row: end_row,
+          column,
+          label: ref.label,
+          position: ref.position,
+          id: 0,
+        },
+      }
+
+    }
+    
+    return undefined;
+  }
+  
+}
+
+export interface ViewModel {
+  active_sheet: Sheet;
+  view_index: number;
+}
+
+export interface SerializedNamedExpression {
+  name: string;
+  expression: string;
+}
+
+export interface SerializedModel {
+  sheet_data: SerializedSheet[];
+  active_sheet: number;
+  named_ranges?: Record<string, IArea>;
+  macro_functions?: MacroFunction[];
+  tables?: Table[];
+  named_expressions?: SerializedNamedExpression[];
+  decimal_mark?: ','|'.';
+}

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

@@ -0,0 +1,81 @@
+/*
+ * 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
+ * 
+ */
+
+/**
+ * generic method for mouse drag handling. this method will insert an
+ * event mask to capture mouse events over the whole window, and call
+ * optional functions on events.
+ *
+ * @param classes optional list of classes to attach to the mask node
+ * @param move callback function on mouse move events
+ * @param end callback function on end (mouse up or button up)
+ */
+export function MouseDrag(
+    mask_node: HTMLElement,
+    classes: string|string[] = [],
+    move?: (event: MouseEvent) => void,
+    end?: (event: MouseEvent) => void) {
+
+  if (typeof classes === 'string') {
+    classes = [classes];
+  }
+
+  // eslint-disable-next-line prefer-const
+  let cleanup: () => void;
+
+  const handle_up = (event: MouseEvent) => {
+    event.stopPropagation();
+    event.preventDefault();
+    cleanup();
+    // if (end) end.call(this, event);
+    if (end) { end(event); }
+  };
+
+  const handle_move = (event: MouseEvent) => {
+    event.stopPropagation();
+    event.preventDefault();
+    if (!event.buttons) {
+      cleanup();
+      // if (end) end.call(this, event);
+      if (end) { end(event); }
+      return;
+    }
+    // if (move) move.call(this, event);
+    if (move) { move(event); }
+  };
+
+  cleanup = () => {
+    mask_node.style.display = 'none';
+    mask_node.removeEventListener('mousemove', handle_move);
+    mask_node.removeEventListener('mouseup', handle_up);
+    for (const class_entry of classes) mask_node.classList.remove(class_entry);
+  };
+
+  for (const class_entry of classes) mask_node.classList.add(class_entry);
+  mask_node.style.display = 'block';
+
+  // listeners are only added if we're going to use the callbacks.
+  // still safe to call remove listener even if they're not added.
+
+  if (move) mask_node.addEventListener('mousemove', handle_move);
+  if (end) mask_node.addEventListener('mouseup', handle_up);
+
+}