@trebco/treb 29.3.3 → 29.4.1

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

@@ -21,9 +21,6 @@
 
 // --- imports -----------------------------------------------------------------
 
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./content-types.d.ts" />
-
 import type {
   GridEvent, 
   SheetChangeEvent, GridOptions, 
@@ -103,6 +100,11 @@ import type { StateLeafVertex } from 'treb-calculator';
 
 // --- worker ------------------------------------------------------------------
 
+/**
+ * import type for our worker, plus markup files
+ */
+import './content-types.d.ts';
+
 /**
  * import the worker as a script file. tsc will read this on typecheck but 
  * that's actually to the good; when we build with esbuild we will inline
@@ -3005,7 +3007,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     this.grid.Reset();
     this.ResetInternal();
-    this.calculator.AttachModel();
+    // this.calculator.AttachModel();
     this.UpdateAC();
 
     this.Publish({ type: 'reset' });
@@ -3491,25 +3493,30 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   /**
    * set or clear cell valiation.
    * 
-   * @param address - target cell
+   * @param target - target cell/area
    * @param validation - a spreadsheet range, list of data, or undefined. pass
    * undefined to remove existing cell validation. 
    * @param error - setting an invalid value in the target cell is an error (and
    * is blocked). defaults to false.
    */
-  public SetValidation(address: AddressReference, validation?: RangeReference|CellValue[], error?: boolean) {
+  public SetValidation(target: RangeReference, validation?: RangeReference|CellValue[], error?: boolean) {
 
-    if (typeof address === 'string') {
-      const reference = this.model.ResolveAddress(address, this.grid.active_sheet);
-      address = IsCellAddress(reference) ? reference : reference.start;
+    if (typeof target === 'string') {
+      const reference = this.model.ResolveAddress(target, this.grid.active_sheet);
+      target = IsArea(reference) ? new Area(reference.start, reference.end) : new Area(reference);
+      // address = IsCellAddress(reference) ? reference : reference.start;
+    }
+
+    if (IsCellAddress(target)) {
+      target = new Area(target);
     }
 
     if (typeof validation === 'undefined' || Array.isArray(validation)) {
-      this.grid.SetValidation(address, validation, error);
+      this.grid.SetValidation(target, validation, error);
     }
     else {
       const range = this.model.ResolveArea(validation, this.grid.active_sheet);
-      this.grid.SetValidation(address, range, error);
+      this.grid.SetValidation(target, range, error);
     }
 
   }
@@ -4626,7 +4633,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
             // this one _is_ the grid cells
 
-            this.calculator.AttachModel();
+            // this.calculator.AttachModel();
             this.Publish({ type: 'load', source, });
             this.UpdateDocumentStyles();
 
@@ -5845,9 +5852,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
     this.grid.UpdateSheets(sheets, undefined, override_sheet || data.active_sheet);
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const [name, table] of this.model.tables.entries()) {
-      if (table.area.start.sheet_id) {
+    for (const table of this.model.tables.values()) {
+        if (table.area.start.sheet_id) {
         const sheet = model.sheets.Find(table.area.start.sheet_id);
         if (sheet) {
           for (let row = table.area.start.row; row <= table.area.end.row; row++) {

package/treb-embed/src/progress-dialog.ts

@@ -57,7 +57,6 @@ export type ResolutionFunction = () => void;
  */
 export class Dialog {
 
-  // private model: NodeModel;
   private model: Record<string, HTMLElement> = {};
 
   private layout_element: HTMLElement;
@@ -192,6 +191,10 @@ export class Dialog {
 
   }
 
+  public Node(name: string): HTMLElement|undefined {
+    return this.model[name];
+  }
+
   public Update(options: Partial<MessageDialogOptions>, delta = true): void {
     if (delta) {
       options = { ...this.options_, ... options};

package/treb-export/src/export2.ts

@@ -34,11 +34,11 @@ import { PixelsToColumnWidth } from './column-width';
 const XMLDeclaration = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n`;
 
 import { template } from './template-2';
-import type { SerializedModel, SerializedSheet } from 'treb-data-model';
+import type { SerializedModel, SerializedSheet, DataValidation } from 'treb-data-model';
 
-import type { IArea, ICellAddress, CellValue, DataValidation, CellStyle,
+import type { IArea, ICellAddress, CellValue, CellStyle,
          AnnotationLayout, Corner as LayoutCorner, Cell, Rectangle } from 'treb-base-types';
-import { Area, Cells, ValueType, Style, ValidationType } from 'treb-base-types';
+import { Area, Cells, ValueType, Style } from 'treb-base-types';
 
 // import * as xmlparser from 'fast-xml-parser';
 import type { XmlBuilderOptions} from 'fast-xml-parser';
@@ -1417,10 +1417,12 @@ export class Exporter {
       const merges: Area[] = [];
       const tables: TableDescription[] = [];
       
+      /*
       const validations: Array<{
         address: ICellAddress,
         validation: DataValidation,
       }> = [];
+      */
 
       // --
 
@@ -1606,12 +1608,14 @@ export class Exporter {
                 });
               }
 
+              /*
               if (cell.validation && (cell.validation.type === ValidationType.List || cell.validation.type === ValidationType.Range)) {
                 validations.push({
                   address: {row: r, column: c},
                   validation: cell.validation,
                 });
               }
+              */
 
               // short-circuit here
               if (cell.type === ValueType.formula && /^=?sparkline\./i.test(cell.value as string)) {
@@ -1929,37 +1933,46 @@ export class Exporter {
 
       // --- validation ----------------------------------------------------------
 
-      if (validations.length) {
+      if (sheet.data_validations?.length) {
 
         dom.worksheet.dataValidations = {
-          a$: { count: validations.length },
-          dataValidation: validations.map(validation => {
+          a$: { count: sheet.data_validations.length },
+          dataValidation: sheet.data_validations.map(validation => {
+
+            const sqref = validation.target.map(target => {
+              return new Area(target.start, target.end).spreadsheet_label;
+            }).join(' ');
+
             const entry: any = { 
               a$: {
                 type: 'list',
                 allowBlank: 1, 
                 showInputMessage: 1, 
                 showErrorMessage: 1, 
-                sqref: new Area(validation.address).spreadsheet_label,
+                sqref, // : new Area(validation.address).spreadsheet_label,
               },
             };
-            if (validation.validation.type === ValidationType.Range) {
+            if (validation.type === 'range') {
 
               const range: UnitRange = {
                 id: 0,
                 type: 'range',
                 label: '', position: 0, 
                 start: 
-                  {...validation.validation.area.start, absolute_column: true, absolute_row: true, id: 0, label: '', position: 0, type: 'address', }, 
+                  {...validation.area.start, absolute_column: true, absolute_row: true, id: 0, label: '', position: 0, type: 'address', }, 
                 end: 
-                  {...validation.validation.area.end, absolute_column: true, absolute_row: true, id: 0, label: '', position: 0, type: 'address', }
+                  {...validation.area.end, absolute_column: true, absolute_row: true, id: 0, label: '', position: 0, type: 'address', }
                 ,
               }
 
-              if (typeof validation.validation.area.start.sheet_id !== 'undefined') {
-                range.start.sheet = sheet_name_map[validation.validation.area.start.sheet_id];
+              console.info("AA", {validation});              
+
+              if (typeof validation.area.start.sheet_id !== 'undefined') {
+                range.start.sheet = sheet_name_map[validation.area.start.sheet_id];
               }
 
+              console.info("m1");
+
               /*
               const area = new Area(
                 {...validation.validation.area.start, absolute_column: true, absolute_row: true}, 
@@ -1971,8 +1984,8 @@ export class Exporter {
               entry.formula1 = this.parser.Render(range);
 
             }
-            else if (validation.validation.type === ValidationType.List) {
-              entry.formula1 = `"${validation.validation.list.join(',')}"`;
+            else if (validation.type === 'list') {
+              entry.formula1 = `"${validation.list.join(',')}"`;
             }
             return entry;
           }),

package/treb-export/src/import2.ts

@@ -30,8 +30,8 @@ import type { ParseResult } from 'treb-parser';
 import { Parser } from 'treb-parser';
 import type { RangeType, AddressType, HyperlinkType } from './address-type';
 import { is_range, ShiftRange, InRange, is_address } from './address-type';
-import type { ImportedSheetData, AnchoredAnnotation, CellParseResult, AnnotationLayout, Corner as LayoutCorner, ICellAddress, DataValidation, IArea, GradientStop, Color } from 'treb-base-types/src';
-import { ValidationType, type SerializedValueType } from 'treb-base-types/src';
+import type { ImportedSheetData, AnchoredAnnotation, CellParseResult, AnnotationLayout, Corner as LayoutCorner, IArea, GradientStop, Color } from 'treb-base-types';
+import type { SerializedValueType } from 'treb-base-types';
 import type { Sheet} from './workbook-sheet2';
 import { VisibleState } from './workbook-sheet2';
 import type { CellAnchor } from './drawing2/drawing2';
@@ -39,7 +39,7 @@ import { XMLUtils } from './xml-utils';
 
 // import { one_hundred_pixels } from './constants';
 import { ColumnWidthToPixels } from './column-width';
-import type { AnnotationType } from 'treb-data-model';
+import type { DataValidation, AnnotationType } from 'treb-data-model';
 import { ZipWrapper } from './zip-wrapper';
 import type { ConditionalFormat } from 'treb-data-model';
 
@@ -99,7 +99,7 @@ export class Importer {
     arrays: RangeType[],
     merges: RangeType[],
     links: HyperlinkType[],
-    validations: Array<{ address: ICellAddress, validation: DataValidation }>,
+    // validations: Array<{ address: ICellAddress, validation: DataValidation }>,
     ): CellParseResult | undefined {
 
     // must have, at minimum, an address (must be a single cell? FIXME)
@@ -285,12 +285,14 @@ export class Importer {
       }
     }
 
+    /*
     for (const validation of validations) {
       if (validation.address.row === shifted.row && validation.address.column === shifted.col) {
         result.validation = validation.validation;
         break;
       }
     }
+    */
 
     for (const range of merges) {
       if (InRange(range, shifted)) {
@@ -512,10 +514,15 @@ export class Importer {
     const conditional_formats: ConditionalFormat[] = [];
     const links: HyperlinkType[] = [];
     const row_styles: number[] = []; // may be sparse
+
+    /*
     const validations: Array<{
       address: ICellAddress,
       validation: DataValidation,
     }> = [];
+    */
+    const validations: DataValidation[] = [];
+
     const annotations: AnchoredAnnotation[] = [];
 
     const FindAll: (path: string) => any[] = XMLUtils.FindAll.bind(XMLUtils, sheet.sheet_data);
@@ -569,33 +576,68 @@ export class Importer {
       const formula = entry.formula1;
 
       if (ref && formula && type === 'list') {
-        let address: ICellAddress|undefined;
+        // let address: ICellAddress|undefined;
         let validation: DataValidation|undefined;
         let parse_result = this.parser.Parse(ref);
+        const target: IArea[] = [];
 
         // apparently these are encoded as ranges for merged cells...
 
+        // NOTE: actually you can have a range, then validation applies
+        // to every cell in the range. also you can have multiple ranges,
+        // apparently separated by spaces.
+
         if (parse_result.expression) {
           if (parse_result.expression.type === 'address') {
-            address = parse_result.expression;
+            // address = parse_result.expression;
+            target.push({start: parse_result.expression, end: parse_result.expression});
           }
           else if (parse_result.expression.type === 'range') {
-            address = parse_result.expression.start;
+            // address = parse_result.expression.start;
+            target.push(parse_result.expression);
           }
         }
 
         parse_result = this.parser.Parse(formula);
+
         if (parse_result.expression) {
           if (parse_result.expression.type === 'range') {
             validation = {
-              type: ValidationType.Range,
+              type: 'range',
               area: parse_result.expression,
+              target,
             };
           }
           else if (parse_result.expression.type === 'literal') {
             validation = {
-              type: ValidationType.List,
+              type: 'list',
+              target,
               list: parse_result.expression.value.toString().split(/,/).map(value => {
+
+                // there are no formulas here. value is a string, separated
+                // by commas. there is no way to escape a comma (AFAICT; not
+                // official, but search). if you did want a comma, you'd need
+                // to use a range.
+
+                // but the uptake is split on commas. after that you can try
+                // to check for numbers or bools, but they will be in the string.
+
+                // I think excel might sort the entries? not sure. don't do it
+                // for now.
+
+                const num = Number(value);
+                if (!isNaN(num)) {
+                  return num;
+                }
+                if (value.toLowerCase() === 'true') {
+                  return true;
+                }
+                if (value.toLowerCase() === 'false') {
+                  return false;
+                }
+                return value; // string
+
+                /*
                 const tmp = this.parser.Parse(value);
                 
                 // if type is "group", that means we saw some spaces. this 
@@ -612,13 +654,16 @@ export class Importer {
                   return tmp.expression.name;
                 }
                 return undefined;
+                */
+
               }),
             };
           }
         }
 
-        if (address && validation) {
-          validations.push({address, validation});
+        if (target.length && validation) {
+          // validations.push({address, validation});
+          validations.push(validation);
         }
 
       }
@@ -730,7 +775,7 @@ export class Importer {
       if (!Array.isArray(cells)) { cells = [cells]; }
 
       for (const element of cells) {
-        const cell = this.ParseCell(sheet, element, shared_formulae, arrays, merges, links, validations);
+        const cell = this.ParseCell(sheet, element, shared_formulae, arrays, merges, links); // , validations);
         if (cell) {
           data.push(cell);
         }
@@ -1178,6 +1223,7 @@ export class Importer {
       row_styles,
       annotations,
       conditional_formats,
+      data_validations: validations,
       styles: this.workbook?.style_cache?.CellXfToStyles() || [],
     };
 

package/treb-grid/src/layout/base_layout.ts

@@ -1295,19 +1295,8 @@ export abstract class BaseLayout {
       }
     }
 
-    /*
-    this.tooltip.style.fontFamily = theme.tooltip_font_face || '';
-    this.tooltip.style.fontSize = theme.tooltip_font_size ? `${theme.tooltip_font_size}pt` : '';
-    this.tooltip.style.backgroundColor = theme.tooltip_background || '';
-    this.tooltip.style.borderColor = theme.tooltip_background || ''; // for arrow
-    this.tooltip.style.color = theme.tooltip_color || '';
-    */
-
     // TODO: dropdown caret
 
-    // this.dropdown_list.style.fontFamily = theme.cell_font || '';
-    // const font_size = (theme.cell_font_size_value || 10) * this.scale;
-    // this.dropdown_list.style.fontSize = (font_size) + (theme.cell_font_size_unit || 'pt');
     this.dropdown_list.style.font = Style.Font(theme.grid_cell || {});
 
   }
@@ -1415,6 +1404,8 @@ export abstract class BaseLayout {
     this.dropdown_list.style.left = `${target_rect.left + 2}px`;
     this.dropdown_list.style.minWidth = `${target_rect.width}px`;
 
+    this.dropdown_list.style.fontSize = (this.scale.toFixed(2) + 'em');
+
     this.dropdown_list.textContent = '';
     for (const value of list) {
       const entry = this.DOM.Div(undefined, this.dropdown_list);

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

@@ -40,7 +40,6 @@ import {
   ValueType, 
   Localization, 
   IsCellAddress, 
-  ValidationType, 
   LoadThemeProperties,
   DefaultTheme,
   ComplexToString,
@@ -1465,20 +1464,22 @@ export class Grid extends GridBase {
    * and will render as a dropdown; the list can be a list of values or
    * a range reference.
    */
-  public SetValidation(target?: ICellAddress, data?: CellValue[]|IArea, error?: boolean): void {
+  public SetValidation(target?: IArea, data?: CellValue[]|IArea, error?: boolean): void {
 
     if (!target) {
       if (this.primary_selection.empty) {
         throw new Error('invalid target in set validation');
       }
-      target = this.primary_selection.target;
+      target = this.primary_selection.area;
     }
 
+    const area = new Area(target.start, target.end);
+
     // console.info({target, data});
 
     const command: DataValidationCommand = {
       key: CommandKey.DataValidation,
-      area: target,
+      area: { start: area.start, end: area.end },
       error,
     };
     
@@ -1502,9 +1503,11 @@ export class Grid extends GridBase {
     //
 
     if (!this.primary_selection.empty &&
-        (!target.sheet_id || target.sheet_id === this.active_sheet.id) && 
-        (this.primary_selection.target.row === target.row) && 
-        (this.primary_selection.target.column === target.column)) {
+        (!target.start.sheet_id || target.start.sheet_id === this.active_sheet.id) && 
+        area.Contains(this.primary_selection.target)) {
+
+        // (this.primary_selection.target.row === target.start.row) && 
+        // (this.primary_selection.target.column === target.start.column)) {
 
       // console.info('repaint selection');
 
@@ -4966,15 +4969,19 @@ export class Grid extends GridBase {
 
     }
 
-    if (cell.validation && cell.validation.error) {
+    const validation = this.active_sheet.GetValidation(target)[0];
+
+    // only consider the first result
+
+    if (validation && validation.error) {
       
       let list: CellValue[]|undefined;
       
-      if (cell.validation.type === ValidationType.List) {
-        list = cell.validation.list;
+      if (validation.type === 'list') {
+        list = validation.list;
       }
-      else if (cell.validation.type === ValidationType.Range) {
-        list = this.GetValidationRange(cell.validation.area);
+      else if (validation.type === 'range') {
+        list = this.GetValidationRange(validation.area);
       }
 
       if (list && list.length) {
@@ -6216,15 +6223,19 @@ export class Grid extends GridBase {
       // sync up, so it would be a separate function but called at the
       // same time.
 
-      if (data.validation && !data.style?.locked) {
+      // less true now that they're maintained separately
+      
+      const validation = this.active_sheet.GetValidation(this.primary_selection.target)[0];
+
+      if (validation && !data.style?.locked) {
         
         let list: CellValue[] | undefined;
         
-        if (data.validation.type === ValidationType.List) {
-          list = data.validation.list;
+        if (validation.type === 'list') {
+          list = validation.list;
         }
-        else if (data.validation.type === ValidationType.Range) {
-          list = this.GetValidationRange(data.validation.area);
+        else if (validation.type === 'range') {
+          list = this.GetValidationRange(validation.area);
         }
 
         if (list && list.length) {
@@ -6541,7 +6552,7 @@ export class Grid extends GridBase {
           // tsv_row.push(cell.formatted);
 
           let text_value = '';
-          if (cell.calculated) {
+          if (cell.calculated !== undefined) {
             if (cell.calculated_type === ValueType.complex) {
               text_value = ComplexToString(cell.calculated as Complex);
             }