@trebco/treb 28.17.5 → 29.1.2

package/treb-charts/src/util.ts

@@ -19,6 +19,7 @@
  * 
  */
 
+// import type { UnionValue } from 'treb-base-types';
 import type { RangeScale} from 'treb-utils';
 import { Scale } from 'treb-utils';
 
@@ -39,40 +40,7 @@ export class Util {
    * suggestion -- we try to get as close as possible.
    */
   public static Scale(min: number, max: number, count = 6.5, limit_count?: boolean, discrete?: boolean): RangeScale {
-
-    /*
-    const range = max - min;
-    const log10 = // Math.log10(range);
-      Math.log(range) / Math.log(10); // just avoid the problem
-
-    const scale = Math.floor(Math.abs(log10)) * (log10 < 0 ? -1 : 1) - 1;
-    const steps = [.1, .25, .5, 1, 2.5, 5, 10, 25, 100];
-
-    let step = -1;
-    let delta = 0;
-
-    for (const x of steps) {
-      const test_step = x * Math.pow(10, scale);
-      const test_min = Math.floor(min / test_step) * test_step;
-      const test_max = Math.ceil(max / test_step) * test_step;
-      const test_count = (test_max - test_min) / test_step;
-      const test_delta = Math.abs(test_count - count);
-
-      if (step < 0 || test_delta < delta){
-        delta = test_delta;
-        step = test_step;
-      }
-      else if (step >= 0 && test_delta > delta) break;
-    }
-
-    min = Math.floor(min / step) * step;
-    max = Math.ceil(max / step) * step;
-    count = Math.round((max - min) / step); // accounts for fp errors
-
-    return { scale, step, count, min, max };
-    */
     return Scale(min, max, count, limit_count, discrete);
-    
   }
 
   public static Range(data: Array<number|undefined>) {
@@ -95,13 +63,13 @@ export class Util {
     return range * (value - scale.min) / (scale.max - scale.min);
   }
 
-  /**
+  /* *
    * flatten. we support holes in data, which means undefined values
    * in arrays, but don't push an empty value at the top level (if
    * that makes sense).
    *
-   * @param args
-   */
+   * @deprecated
+   * /
   public static Flatten(args: any) {
     let flat: any[] = [];
     if (Array.isArray(args)) {
@@ -119,5 +87,26 @@ export class Util {
     }
     return flat;
   }
+  */
+
+  public static Flatten<T>(args?: T|T[]|T[][]) {
+    let flat: T[] = [];
+    if (Array.isArray(args)) {
+      for (const element of args) {
+        if (Array.isArray(element)) {
+          flat = flat.concat(this.Flatten(element));
+        }
+        else {
+          flat.push(element);
+        }
+      }
+    } 
+    else if (typeof args !== 'undefined') {
+      flat.push(args);
+    }
+    return flat;
+  }
 
 }
+  
+

package/treb-data-model/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "treb-data-model",
+  "version": "16.1.10",
+  "main": "src/index.ts"
+}

package/{treb-grid/src/types → treb-data-model/src}/annotation.ts

@@ -194,7 +194,7 @@ export interface AnnotationTextBoxData extends AnnotationDataBase {
       }[],
     }[];
   };
-};
+}
 
 export interface AnnotationExternalData extends AnnotationDataBase {
   type: 'external';
@@ -230,7 +230,7 @@ export class Annotation {
   public scaled_rect?: Rectangle;
 
   /** also opaque data, but not serialized. */
-  public temp: any = {};
+  public temp: unknown = {};
 
   public view: ViewData[] = [];
 

package/{treb-grid/src/types → treb-data-model/src}/conditional_format.ts

@@ -1,3 +1,23 @@
+/*
+ * 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-2024 trebco, llc. 
+ * info@treb.app
+ * 
+ */
 
 import type { CellStyle, EvaluateOptions, IArea, Color, Gradient, GradientStop, UnionValue } from 'treb-base-types';
 

package/{treb-grid/src/types → treb-data-model/src}/data_model.ts

@@ -20,11 +20,13 @@
  */
 
 import type { Sheet } from './sheet';
+import { SheetCollection } from './sheet_collection';
 import type { IArea, ICellAddress, Table, CellStyle } from 'treb-base-types';
 import type { SerializedSheet } from './sheet_types';
-import { NamedRangeCollection } from './named_range';
-import { type ExpressionUnit, type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex } from 'treb-parser';
+import { type ExpressionUnit, type UnitAddress, type UnitStructuredReference, type UnitRange, Parser, QuotedSheetNameRegex, DecimalMarkType, ArgumentSeparatorType } from 'treb-parser';
 import { Area, IsCellAddress, Style } from 'treb-base-types';
+import type { CompositeNamed, SerializedNamed } from './named';
+import { NamedRangeManager } from './named';
 
 export interface ConnectedElementType {
   formula: string;
@@ -49,173 +51,255 @@ export interface MacroFunction extends SerializedMacroFunction {
 }
 
 /**
- * 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)
+ * FIXME: this should move out of the grid module, grid should be focused on view
  */
-export class SheetCollection {
+export class DataModel {
+
+  public readonly parser: Parser = new Parser();
+
+  /** document metadata */
+  public document_name?: string;
 
   /** 
-   * 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.
+   * document metadata. this is opaque to everyone except the user, so
+   * we're intentionally leaving it as unknown except where users have 
+   * direct access (embedded spreadsheet). 
    */
-  public get list() {
-    return this.sheets_.slice(0);
-  }
+  public user_data?: unknown;
 
   /**
-   * length of list
+   * 
    */
-  public get length() {
-    return this.sheets_.length;
-  }
+  public readonly sheets = new SheetCollection();
 
-  /** map of (normalized) name -> sheet */
-  protected names: Map<string, Sheet> = new Map();
+  /** new composite collection (TODO: add macro functions too?) */
+  public readonly named = new NamedRangeManager();
 
-  /** map of id -> sheet */
-  protected ids: Map<number, Sheet> = new Map();
+  /** macro functions are functions written in spreadsheet language */
+  public readonly macro_functions: Map<string, MacroFunction> = new Map();
 
-  /** the actual list */
-  private sheets_: Sheet[] = [];
+  /** index for views */
+  public view_count = 0;
 
   /**
-   * remove any existing sheets and add the passed list. updates indexes.
+   * base style properties moved to model, so we can have a single
+   * and consistent reference.
    */
-  public Assign(sheets: Sheet[]) {
-    this.sheets_ = [...sheets];
-    this.UpdateIndexes();
-  }
+  public theme_style_properties: CellStyle = JSON.parse(JSON.stringify(Style.DefaultProperties));
 
-  /** 
-   * add a new sheet to the end of the list (push). updates indexes. 
+  /**
+   * 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 Add(sheet: Sheet) {
-    this.sheets_.push(sheet);
-    this.UpdateIndexes();
-  }
+  public tables: Map<string, Table> = new Map();
 
   /** 
-   * wrapper for array splice. updates indexes. 
+   * we're wrapping up the get name method so we can check for a sheet
+   * name -- we have the list of sheet names. we could pass that to the 
+   * name list manager but it's easier for us to intercept the call.
+   * I thought about wrapping up more API functions here, but that seems
+   * unecessary atm.
    */
-  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 {
+  public GetName(name: string, scope: number) {
+
+    // helpfully this is not a legal character in names or sheets, so
+    // we don't need a full parser to handle the split. watch out for
+    // quoted sheet names.
 
-    // console.info('get', typeof id);
+    const parts = name.split(/!/);
 
-    if (typeof id === 'string') {
-      return this.names.get(id.toLocaleUpperCase());
+    if (parts.length === 1) {
+      return this.named.Get_(name, scope);
     }
-    else {
-      return this.ids.get(id);
+
+    let sheet_name = parts[0];
+
+    // can we just test with indexes? surely faster
+
+    if (/^'.*?'$/.test(sheet_name)) {
+      sheet_name = sheet_name.substring(1, sheet_name.length - 1);
     }
+    
+    const sheet = this.sheets.ID(sheet_name);
+    return this.named.Get_(parts[1], sheet || 0, true); // require scope in this case
 
-    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;
+  /**
+   * from import, we get ranges and expressions in the same format. we 
+   * need to check if something is a range -- if so, it will just be 
+   * a single address or range. in that case store it as a named range.
+   */
+  public UnserializeComposite(names: CompositeNamed[], active_sheet?: Sheet) {
+
+    this.parser.Save();
+    this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
+    
+    const sorted = names.map(named => {
+      const parse_result = this.parser.Parse(named.expression); 
+      if (parse_result.expression) {
+        if (parse_result.expression.type === 'address' || parse_result.expression.type === 'range') {
+          return {
+            ...named,
+            expression: undefined,
+            area: parse_result.expression.type === 'address' ? {
+              start: parse_result.expression,
+              end: parse_result.expression,
+            } : parse_result.expression,
+          } as SerializedNamed;
+        }
+        return {
+          ...named
+        } as SerializedNamed;
+      }
+      return undefined;
+    }).filter((test): test is SerializedNamed => !!test);
+
+    this.parser.Restore();
+    this.UnserializeNames(sorted, active_sheet);
+
   }
 
-  /** not sure why this is private, makes it a little more complicated */
-  public UpdateIndexes(): void {
+  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet) {
+
+    for (const entry of names) {
+
+      const scope = (typeof entry.scope === 'string') ? this.sheets.ID(entry.scope) : undefined;
+
+      if (entry.expression) {
+
+        const parse_result = this.parser.Parse(entry.expression);
+
+        if (parse_result.valid && parse_result.expression) {
+          this.parser.Walk(parse_result.expression, unit => {
+            if (unit.type === 'address' || unit.type === 'range') {
+              if (unit.type === 'range') {
+                unit = unit.start;
+              }
+              if (!unit.sheet_id) {
+                if (unit.sheet) {
+                  unit.sheet_id = this.sheets.ID(unit.sheet);
+                }
+              }
+              if (!unit.sheet_id) {
+                unit.sheet_id = active_sheet?.id;
+              }
+              return false; // don't continue in ranges
+            }
+            return true;
+          });
+
+          this.named.SetNamedExpression(entry.name, parse_result.expression, scope);
+          
+        }
+
+      }
+      else if (entry.area) {
+        if (entry.area.start.sheet) {
 
-    this.names.clear();
-    this.ids.clear();
+          const area = new Area({
+            ...entry.area.start,
+            sheet_id: this.sheets.ID(entry.area.start.sheet),
+          }, entry.area.end);
 
-    for (const sheet of this.sheets_) {
-      const uc = sheet.name.toLocaleUpperCase();
-      this.names.set(uc, sheet);
-      this.ids.set(sheet.id, sheet);
+          if (area.start.sheet_id) {
+            this.named.SetNamedRange(entry.name, area, scope);
+          }
+          else {
+            console.warn("missing sheet ID?", entry.area.start.sheet);
+          }
+        }
+        else {
+          console.warn("missing sheet name?");
+        }
+      }
     }
 
   }
 
+  /**
+   * serialize names. ranges are easy, but make sure there's a sheet name
+   * in each address (and remove the ID). expressions are a little more 
+   * complicated.
+   */
+  public SerializeNames(active_sheet?: Sheet): SerializedNamed[] {
+    const list: SerializedNamed[] = [];
 
-}
+    for (const entry of this.named.list) {
 
-/**
- * FIXME: this should move out of the grid module, grid should be focused on view
- */
-export class DataModel {
+      const named: SerializedNamed = {
+        name: entry.name,
+        // scope: entry.scope,
+      };
 
-  public readonly parser: Parser = new Parser();
+      if (entry.scope) {
+        named.scope = this.sheets.Name(entry.scope);
+      }
 
-  /** document metadata */
-  public document_name?: string;
+      if (entry.type === 'expression') {
 
-  /** document metadata */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public user_data?: any;
+        this.parser.Walk(entry.expression, unit => {
+          if (unit.type === 'address' || unit.type === 'range') {
 
-  /** 
-   * list of sheets. we _should_ index these by ID, so we 
-   * don't have to look up. FIXME/TODO
-   */
-  // public sheets: Sheet[] = [];
+            const test = unit.type === 'range' ? unit.start : unit;
+            test.absolute_column = test.absolute_row = true;
 
-  /**
-   * this prevents assignment, but not push/pop/splice (baby steps)
-   */
-  // public get sheets(): Sheet[] {
-  //  return this._sheets;
-  //}
-  public readonly sheets = new SheetCollection();
+            if (!test.sheet) {
+              if (test.sheet_id) {
+                test.sheet = this.sheets.Name(test.sheet_id);
+              }
+              if (!test.sheet) {
+                test.sheet = active_sheet?.name;
+              }
+            }
 
-  /** named ranges are document-scope, we don't support sheet-scope names */
-  public readonly named_ranges = new NamedRangeCollection;
+            if (unit.type === 'range') {
+              unit.end.absolute_column = unit.end.absolute_row = true;
+            }
 
-  /** macro functions are functions written in spreadsheet language */
-  // public macro_functions: Record<string, MacroFunction> = {};
-  public readonly macro_functions: Map<string, MacroFunction> = new Map();
+            return false;
+          }
+          /*
 
-  /** 
-   * 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();
+          // if we do the function export thing, we need to call that here
+          // (exporting functions to fix missing arguments or add decorators).
+          // we're not doing that, at least not yet.
 
-  /** index for views */
-  public view_count = 0;
+          else if (unit.type === 'call' && options.export_functions) {
+            // ...
+          }
+          */
+          return true;
+        });
 
-  /**
-   * base style properties moved to model, so we can have a single
-   * and consistent reference.
-   */
-  public theme_style_properties: CellStyle = JSON.parse(JSON.stringify(Style.DefaultProperties));
+        named.expression = this.parser.Render(entry.expression, { missing: '' });
 
-  /**
-   * 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();
+      }
+      else {
+        named.area = {
+          start: {
+            ...entry.area.start,
+            sheet: this.sheets.Name(entry.area.start.sheet_id || 0) || '',
+            sheet_id: undefined, // in favor of name
+            absolute_column: true,
+            absolute_row: true,
+          },
+          end: {
+            ...entry.area.end,
+            absolute_column: true,
+            absolute_row: true,
+          },
+        };
+      }
+
+      list.push(named);
+
+    }
+
+    return list;
+  }
 
   /**
    * putting this here temporarily. it should probably move into a table
@@ -332,7 +416,7 @@ export class DataModel {
    * @param address 
    * @param active_sheet 
    */
-  public AddressToLabel(address: ICellAddress|IArea, active_sheet?: Sheet) {
+  public AddressToLabel(address: ICellAddress|IArea) {
 
     const start = IsCellAddress(address) ? address : address.start;
     const parts = IsCellAddress(address) ? 
@@ -369,15 +453,6 @@ export class DataModel {
         return true;
       }
 
-      /*
-      const lc = target.sheet.toLowerCase();
-      for (const sheet of this.model.sheets.list) {
-        if (sheet.name.toLowerCase() === lc) {
-          target.sheet_id = sheet.id;
-          return true;
-        }
-      }
-      */
     }
     else if (context?.sheet_id) {
       target.sheet_id = context.sheet_id;
@@ -435,12 +510,20 @@ export class DataModel {
       }
       else if (parse_result.expression && parse_result.expression.type === 'identifier') {
 
+        const named = this.GetName(parse_result.expression.name, active_sheet.id);
+        if (named?.type === 'range') {
+          return named.area;
+        }
+
+        /*
         // is named range guaranteed to have a sheet ID? (I think yes...)
 
         const named_range = this.named_ranges.Get(parse_result.expression.name);
         if (named_range) {
           return named_range;
         }
+        */
+
       }
 
       return { row: 0, column: 0 }; // default for string types -- broken
@@ -479,6 +562,9 @@ export class DataModel {
 
 }
 
+/**
+ * @internal
+ */
 export interface ViewModel {
   active_sheet: Sheet;
   view_index: number;
@@ -492,9 +578,21 @@ export interface SerializedNamedExpression {
 export interface SerializedModel {
   sheet_data: SerializedSheet[];
   active_sheet: number;
+
+  /** @deprecated */
   named_ranges?: Record<string, IArea>;
+
+  /** @deprecated */
+  named_expressions?: SerializedNamedExpression[];
+
+  /** 
+   * new type for consolidated named ranges & expressions. the old
+   * types are retained for backwards compatibility on import but we won't 
+   * export them anymore.
+   */
+  named?: SerializedNamed[];
+
   macro_functions?: MacroFunction[];
   tables?: Table[];
-  named_expressions?: SerializedNamedExpression[];
   decimal_mark?: ','|'.';
 }

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

@@ -0,0 +1,45 @@
+/*
+ * 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-2024 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+export { DataModel } from './data_model';
+
+export type { 
+  MacroFunction, 
+  ConnectedElementType,
+  SerializedNamedExpression, 
+  SerializedModel, 
+  ViewModel, 
+  SerializedMacroFunction,
+} from './data_model';
+
+export type { SerializedNamed, CompositeNamed } from './named';
+
+export { Sheet } from './sheet';
+export type { SerializedSheet, FreezePane, LegacySerializedSheet } from './sheet_types';
+export * from './conditional_format';
+export type { GridSelection } from './sheet_selection';
+export type { SerializeOptions } from './serialize_options';
+
+export { Annotation } from './annotation';
+export type { ViewData as AnnotationViewData } from './annotation';
+export type { AnnotationData, AnnotationType } from './annotation';
+
+