@trebco/treb 25.9.1 → 26.0.5

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

@@ -100,7 +100,7 @@ export interface ClickFunctionResult {
 export type ClickFunction = (options: ClickFunctionOptions) => ClickFunctionResult;
 
 
-/**
+/*
  * restructuring from the old system, which had lots of separate arrays for
  * things. for the most part I think having a single array (or object) with
  * objects will be more useful (if not necessarily more efficient). the
@@ -121,11 +121,11 @@ export type ClickFunction = (options: ClickFunctionOptions) => ClickFunctionResu
  * validation TODO: date, number, boolean, &c
  */
 export enum ValidationType {
-  List,
-  Date,
-  Range,
-  Number,
-  Boolean,
+  List = 'list',
+  Date = 'date',
+  Range = 'range',
+  Number = 'number',
+  Boolean = 'boolean',
 }
 
 export interface DataValidationBase {
@@ -133,25 +133,25 @@ export interface DataValidationBase {
 }
 
 export interface DataValidationRange extends DataValidationBase {
-  type: ValidationType.Range;
+  type: 'range'; // ValidationType.Range;
   area: IArea;
 }
 
 export interface DataValidationList extends DataValidationBase {
-  type: ValidationType.List;
+  type: 'list'; // ValidationType.List;
   list: CellValue[];
 }
 
 export interface DataValidationDate extends DataValidationBase {
-  type: ValidationType.Date;
+  type: 'date'; // ValidationType.Date;
 }
 
 export interface DataValidationNumber extends DataValidationBase {
-  type: ValidationType.Number;
+  type: 'number'; // ValidationType.Number;
 }
 
 export interface DataValidationBoolean extends DataValidationBase {
-  type: ValidationType.Boolean;
+  type: 'boolean'; // ValidationType.Boolean;
 }
 
 export type DataValidation 

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

@@ -29,7 +29,7 @@ import { Area, IsCellAddress } from './area';
 import type { DataValidation } from './cell';
 import { Cell } from './cell';
 import type { Table } from './table';
-import { ValueType, GetValueType } from './value-type';
+import { type SerializedValueType, ValueType, GetValueType, ValueTypeList } from './value-type';
 import type { CellValue, UnionValue } from './union';
 import type { Style } from './style';
 
@@ -80,10 +80,10 @@ export interface BaseCellData {
   area?: IArea;
   merge_area?: IArea;
   validation?: DataValidation;
-  calculated_type?: ValueType;
+  calculated_type?: SerializedValueType; //  ValueType;
   note?: string;
   hyperlink?: string;
-  type?: ValueType;
+  type?: SerializedValueType; // ValueType;
   sheet_id?: number;
   // locked?: boolean;
 }
@@ -132,6 +132,17 @@ export const IsNestedRowArray = (test: NestedRowData[]|NestedColumnData[]): test
 
 // ...
 
+
+/** 
+ * this is the reverse map, i.e. type => number 
+ * FIXME: why is this getting exported by the API generator?
+ * FIXME: I get why it's dynamic, but for practical purposes why not just 
+ * create a static map?
+ */
+const ValueTypeMap = 
+  ValueTypeList.map((key, index) => ({ [key]: index })).reduce((set, value) => ({...set, ...value}), {}) as Record<SerializedValueType, ValueType>;
+
+
 /**
  * collection of cells, basically a wrapper around an
  * array, with some accessor and control methods.
@@ -357,6 +368,53 @@ export class Cells {
     this.columns_ = columns;
   }
 
+  public SerializedTypeToValueType(type?: SerializedValueType|ValueType): ValueType|undefined {
+
+    if (!type) {
+      return undefined;
+    }
+
+    if (typeof type === 'number') {
+      return type as ValueType;
+    }
+
+    return ValueTypeMap[type] || undefined;
+
+  }
+
+  public ValueTypeToSerializedType(type?: ValueType): SerializedValueType|undefined {
+    return type ? ValueTypeList[type] : undefined;
+  }
+
+  /**
+   * this method is used for importing legacy data validation types. in those
+   * those we used a numeric enum. we're just dropping that altogether (c.f.
+   * ValueType, which we're keeping) so we need to translate for backcompat. 
+   * it's ugly, but it gets us to a better place. we can probably drop at some
+   * point in the future.
+   * 
+   * export enum ValidationType {
+   *   List = 'list',
+   *   Date = 'date',
+   *   Range = 'range',
+   *   Number = 'number',
+   *   Boolean = 'boolean',
+   * }
+   * 
+   */
+  public ImportDataValidation(value: DataValidation): DataValidation|undefined {
+
+    if (typeof (value as any).type === 'number') {
+      const types = ['list', 'date', 'range', 'number', 'boolean'];
+      (value as any).type = types[(value as any).type];
+      if (!value.type) {
+        return undefined;
+      }
+    }
+
+    return value;
+  }
+
   /**
    * UPDATE: adding optional style refs, for export
    */
@@ -423,7 +481,7 @@ export class Cells {
       if (typeof obj.calculated !== 'undefined') {
         // cell.calculated = obj.calculated;
         // cell.calculated_type = obj.calculated_type;
-        cell.SetCalculatedValue(obj.calculated, obj.calculated_type);
+        cell.SetCalculatedValue(obj.calculated, this.SerializedTypeToValueType(obj.calculated_type));
       }
 
       if (style_refs) {
@@ -494,7 +552,13 @@ export class Cells {
       }
 
       if (obj.validation) {
-        cell.validation = obj.validation;
+
+        // the old type used a numeric enum. we just dropped that in favor
+        // of a string enum, so we can export it as a type. but for backwards
+        // compatibility we still need to think about the numeric enum.
+
+        cell.validation = this.ImportDataValidation(obj.validation);
+
       }
 
     }
@@ -606,7 +670,9 @@ export class Cells {
               obj.hyperlink = cell.hyperlink;
             }
 
-            if (options.preserve_type) obj.type = cell.type;
+            if (options.preserve_type) {
+              obj.type = this.ValueTypeToSerializedType(cell.type);
+            }
             if (options.sheet_id) obj.sheet_id = options.sheet_id;
             if (options.calculated_value &&
                 typeof cell.calculated !== 'undefined') { // && cell.calculated_type !== ValueType.error) {
@@ -614,7 +680,7 @@ export class Cells {
 
               // always preserve error type, because we can't infer
               if (options.preserve_type || cell.calculated_type === ValueType.error) {
-                obj.calculated_type = cell.calculated_type;
+                obj.calculated_type = this.ValueTypeToSerializedType(cell.calculated_type);
               }
             }
             if (cell.table && table_head) {

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

@@ -20,7 +20,7 @@
  */
 
 import type { Style } from './style';
-import type { ValueType } from './value-type';
+import type { SerializedValueType, ValueType } from './value-type';
 import type { IArea } from './area';
 import type { AnnotationLayout } from './layout';
 import type { DataValidation } from './cell';
@@ -30,10 +30,10 @@ import type { AnnotationType } from 'treb-grid';
 export interface CellParseResult {
   row: number,
   column: number,
-  type: ValueType,
+  type: SerializedValueType; // ValueType,
   value: number|string|undefined|boolean,
   calculated?: number|string|undefined|boolean,
-  calculated_type?: ValueType,
+  calculated_type?: SerializedValueType; // ValueType,
   style_ref?: number,
   hyperlink?: string,
   validation?: DataValidation,

package/treb-base-types/src/value-type.ts

@@ -84,12 +84,44 @@ export const IsDimensionedQuantity = (value: unknown): value is DimensionedQuant
           && (typeof (value as DimensionedQuantity).unit === 'string');
 };
 
+/** 
+ * this is the list of value types. internally, we use an enum. I don't 
+ * want to change that, at least not at the moment, but that presents a
+ * problem for exporting types.
+ * 
+ * we'll switch to string types for import/export, although we still support
+ * importing the old numeric enum types for backwards compatibility.
+ */
+export const ValueTypeList = [
+  'undefined',
+  'formula',
+  'string',
+  'number',
+  'boolean',
+  'object',
+  'error',
+  'complex',
+  'array',
+  'dimensioned_quantity',
+] as const;
+
 /**
- * I _think_ using enums is faster. I'm not actually sure about that, though.
- * it stands to reason that a single int compare is faster than a string
- * compare, but you never know with javascript. undefined preferred over null.
- * formula implies a string.
- *
+ * string types for import/export
+ */
+export type SerializedValueType = typeof ValueTypeList[number];
+
+/**
+ * this enum goes back a long way and is pretty ingrained, so I don't 
+ * want to change it (at least not right now). but if we're exporting types, 
+ * using enums is a problem.
+ * 
+ * what we will do is keep the enum internally but switch the exported type
+ * to a string. the problem then becomes keeping the types matched up 
+ * properly. I can't arrive at a good way of doing that automatically. 
+ * 
+ * old comments:
+ * ---
+ * 
  * undefined is 0 so we can test it as falsy.
  *
  * we're passing this type information out to calculators, so it needs

package/treb-embed/src/types.ts

@@ -46,23 +46,61 @@ export enum SaveFileType {
  * I would like to do it, though, that `any` looks bad in the  public API.
  */
 export interface TREBDocument {
+
+  /** app name, as identifier */
   app: string;
+
+  /** app version. we'll warn if you use a file from a newer version */
   version: string;
+
+  /** 
+   * revision number. this is a value that increments on any document change,
+   * useful for checking if a document is "dirty".
+   */
   revision?: number;
+
+  /** document name */
   name?: string;
+
+  /** 
+   * opaque user data. we don't read or parse this, but applications can
+   * use it to store arbitrary data.
+   */
   user_data?: any;
-  sheet_data?: SerializedSheet|SerializedSheet[]; // NOTE: support old version, but it would be nice to drop
+
+  /**
+   * per-sheet data. this should be an array, but for historical reasons
+   * we still support a single sheet outside of an array.
+   */
+  sheet_data?: SerializedSheet|SerializedSheet[];
+
+  /** document decimal mark */
   decimal_mark?: '.' | ',';
+
+  /** active sheet. if unset we'll show the first un-hidden sheet */
   active_sheet?: number;
+  
+  /** 
+   * this document includes rendered calculated values. using this lets the
+   * app show a document faster, without requiring an initial calculation.
+   */
   rendered_values?: boolean;
   
-  // named_ranges?: {[index: string]: IArea};
+  /** document named ranges */
   named_ranges?: Record<string, IArea>;
 
-  macro_functions?: SerializedMacroFunction[];
+  /** document named expressions */
   named_expressions?: SerializedNamedExpression[];
+
+  /** document macro functions */
+  macro_functions?: SerializedMacroFunction[];
+
+  /** document tables */
   tables?: Table[];
+
+  /** document shared resources (usually images) */
   shared_resources?: Record<string, string>;
+
 }
 
 export interface ResizeEvent {

package/treb-export/src/export2.ts

@@ -510,6 +510,66 @@ export class Exporter {
   }
   */
 
+  /**
+   * FIXME: we might not always need this. 
+   */
+  public SheetStyle(sheet: SerializedSheet, style_cache: StyleCache) {
+
+    if (!sheet.sheet_style) {
+      return 0;
+    }
+
+    const options = style_cache.StyleOptionsFromProperties(sheet.sheet_style);
+    return style_cache.EnsureStyle(options);
+    
+  }
+
+  public RowStyle(sheet: SerializedSheet, style_cache: StyleCache, row: number) {
+
+    const cell_style_refs = sheet.styles || sheet.cell_style_refs || [];
+    const list: Style.Properties[] = [sheet.sheet_style];
+
+    if (sheet.row_style) {
+      let style = sheet.row_style[row];
+      if (typeof style === 'number') {
+        style = cell_style_refs[style];
+        if (style) {
+          list.push(style); 
+        }
+      }
+      else if (style) {
+        list.push(style); 
+      }
+    }
+
+    const options = style_cache.StyleOptionsFromProperties(Style.Composite(list));
+    return style_cache.EnsureStyle(options);
+
+  }
+
+  public ColumnStyle(sheet: SerializedSheet, style_cache: StyleCache, column: number) {
+
+    const cell_style_refs = sheet.styles || sheet.cell_style_refs || [];
+    const list: Style.Properties[] = [sheet.sheet_style];
+
+    if (sheet.column_style) {
+      let style = sheet.column_style[column];
+      if (typeof style === 'number') {
+        style = cell_style_refs[style];
+        if (style) {
+          list.push(style); 
+        }
+      }
+      else if (style) {
+        list.push(style); 
+      }
+    }
+
+    const options = style_cache.StyleOptionsFromProperties(Style.Composite(list));
+    return style_cache.EnsureStyle(options);
+
+  }
+
   public StyleFromCell(sheet: SerializedSheet, style_cache: StyleCache, row: number, column: number, style: Style.Properties = {}) {
 
     //if (row === 2 && column === 5)
@@ -1205,6 +1265,8 @@ export class Exporter {
       const cells = new Cells();
       cells.FromJSON(sheet.data, cell_style_refs);
 
+      // console.info({ss: sheet.sheet_style, sheet});
+
       // these are cells with style but no contents
 
       for (const entry of sheet.cell_styles) {
@@ -1249,7 +1311,20 @@ export class Exporter {
 
       // --
 
+      // 
+      // this is a map of column number -> column style. we need this 
+      // for two things: (1) so we can skip cells that are empty, but
+      // have a style from the column; and (2) so we can create the list
+      // of columns, including styles.
+      //
+      const column_style_map: number[] = [];
+
+      const sheet_style = this.SheetStyle(sheet, style_cache);
+
       for (let r = 0; r < cells.data.length; r++ ) {
+
+        const row_style = this.RowStyle(sheet, style_cache, r);
+
         if (cells.data[r] && cells.data[r].length) {  
 
           // push out the extent (reversed)
@@ -1262,6 +1337,11 @@ export class Exporter {
           const row: any = [];
 
           for (let c = 0; c < cells.data[r].length; c++) {
+
+            if (!column_style_map[c]) {
+              column_style_map[c] = this.ColumnStyle(sheet, style_cache, c);
+            }
+
             const cell = cells.data[r][c];
             if (cell) {
 
@@ -1447,6 +1527,17 @@ export class Exporter {
               // s is style, index into the style table 
               const s: number|undefined = this.StyleFromCell(sheet, style_cache, r, c, cell.style);
 
+              if (cell.type === ValueType.undefined) {
+
+                // you can skip if (1) there's a row style, and style === row style;
+                // (2) there's a column style, no row style, and style === column style
+
+                if ((row_style && s === row_style) || 
+                    (!row_style && (column_style_map[c] && s === column_style_map[c]))) {
+                  continue; // can skip
+                }
+              }
+
               // v (child element) is the value
               let v: CellValue = undefined;
               let t: string|undefined;
@@ -1516,7 +1607,13 @@ export class Exporter {
                 element.a$.t = t;
               }
               if (s !== undefined) {
+
+                // we could skip this if it's equal to row style,
+                // or there is no row style and it's equal to column style
+                // or there is no column style and it's equal to sheet style
+
                 element.a$.s = s;
+
               }
               if (f !== undefined) {
                 element.f = f;              
@@ -1530,11 +1627,12 @@ export class Exporter {
             }
           }
 
-          if (row.length) {
+          if (row.length || (row_style && row_style !== sheet_style)) {
+
             const row_data: any = {
               a$: {
                 r: r + 1,
-                spans: `${span.start + 1}:${span.end + 1}`,
+                spans: `${span.start + 1}:${span.end + 1}`, // this works out to 0:0 for an empty row, will that work?
               },
               c: row,
             };
@@ -1546,6 +1644,11 @@ export class Exporter {
               row_data.a$.ht = sheet.row_height[r] * 3 / 4;
             }
 
+            if (row_style && row_style !== sheet_style) {
+              row_data.a$.s = row_style;
+              row_data.a$.customFormat = 1;
+            }
+
             sheet_data.row.push(row_data);
           }
 
@@ -1563,6 +1666,10 @@ export class Exporter {
         index: number;
       }> = [];
 
+      // we only need to include column style if it's !== sheet style,
+      // because we'll have a default entry for columns that have the 
+      // sheet style. this is only for columns that are different.
+
       if (sheet.default_column_width) {
         dom.worksheet.sheetFormatPr.a$.defaultColWidth = // sheet.default_column_width * one_hundred_pixels / 100;
           PixelsToColumnWidth(sheet.default_column_width);
@@ -1582,7 +1689,14 @@ export class Exporter {
 
         }
 
+        let style = column_style_map[c];
+        if (style && style !== sheet_style) {
+          entry.style = style;
+        }
+
+        /*
         let style = sheet.column_style[c];
+       
         if (typeof style === 'number') {
           style = cell_style_refs[style];
           if (style) {
@@ -1592,6 +1706,7 @@ export class Exporter {
         else if (style) {
           entry.style = style_cache.EnsureStyle(style_cache.StyleOptionsFromProperties(style));
         }
+        */
 
         //if (sheet.column_style[c]) {
         //  entry.style = style_cache.EnsureStyle(style_cache.StyleOptionsFromProperties(sheet.column_style[c]));
@@ -1605,8 +1720,73 @@ export class Exporter {
       // we're short-cutting here, these should be arranged in blocks if
       // there's overlap. not sure how much of an issue that is though.
       
-      if (column_entries.length) {
-        for (const entry of column_entries) {
+      if (column_entries.length || sheet_style) {
+
+        const filled: any[] = [];
+        const default_column_width = PixelsToColumnWidth(sheet.default_column_width || 90);
+
+        // FIXME: can merge these two branches
+
+        { // if (sheet_style) {
+
+          let start_index = 0;
+          for (const entry of column_entries) {
+            if (!entry) { continue; }
+
+            // fill with defaults
+
+            if (sheet_style && (entry.index > start_index + 1)) {
+              filled.push({
+                a$: {
+                  min: start_index + 1,
+                  max: entry.index,
+                  style: sheet_style,
+                  width: default_column_width,
+                },
+              });
+            }
+
+            const a$: any = { 
+              min: entry.index + 1, 
+              max: entry.index + 1,
+            };
+            if (entry.style === undefined) {
+              a$.style = sheet_style;
+            }
+            else {
+              a$.style = entry.style;
+            }
+            if (entry.width !== undefined) {
+              a$.width = entry.width;
+              a$.customWidth = 1;
+            }
+            else {
+              a$.width = default_column_width;
+            }
+
+            filled.push({a$});
+
+            start_index = entry.index;
+            
+          }
+
+          if (sheet_style && (start_index < 16384)) { // OK, sure why not
+            filled.push({
+              a$: {
+                min: start_index + 1,
+                max: 16384,
+                style: sheet_style,
+                width: default_column_width,
+              },
+            });
+          }
+
+          dom.worksheet.cols.col = filled;
+
+        }
+
+        /*
+        else {
           dom.worksheet.cols.col = column_entries.map(entry => {
             const a$: any = { 
               min: entry.index + 1, 
@@ -1621,12 +1801,15 @@ export class Exporter {
             }
             else {
               a$.width = // (sheet.default_column_width || 100) / 100 * one_hundred_pixels;
-                PixelsToColumnWidth(sheet.default_column_width || 90);
+                default_column_width; // PixelsToColumnWidth(sheet.default_column_width || 90);
             }
             return {a$};
           });
         }
+        console.info({cols: dom.worksheet.cols});
+      */
       }
+
       else {
         delete dom.worksheet.cols;
       }