@trebco/treb 29.3.4 → 29.4.1

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);
             }

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

@@ -37,11 +37,12 @@
 
 import { EventSource } from 'treb-utils';
 import type { DataModel, ConditionalFormat, // MacroFunction, SerializedModel, SerializedNamedExpression, 
-              ViewModel } from 'treb-data-model';
+              ViewModel, 
+              DataValidation} from 'treb-data-model';
 
 import type { Parser, UnitAddress} from 'treb-parser';
 import { type ExpressionUnit, IllegalSheetNameRegex, ParseCSV, DecimalMarkType } from 'treb-parser';
-import { Area, IsCellAddress, ValidationType, ValueType, DefaultTableSortOptions } from 'treb-base-types';
+import { Area, IsCellAddress, ValueType, DefaultTableSortOptions } from 'treb-base-types';
 import type { ICellAddress, IArea, Cell, CellValue, CellStyle, Table, TableSortOptions, TableTheme, Complex, PatchOptions as PatchAreaOptions } from 'treb-base-types';
 
 import { Sheet, type SerializeOptions, type Annotation } from 'treb-data-model';
@@ -922,34 +923,54 @@ export class GridBase {
 
   protected SetValidationInternal(command: DataValidationCommand): void {
 
-    let cell: Cell|undefined;
-
     const sheet = this.FindSheet(command.area);
-
-    if (sheet) {
-      cell = sheet.cells.GetCell(command.area, true);
+    if (!sheet) {
+      throw new Error('invalid sheet in set validation');
     }
 
-    if (!cell) {
-      throw new Error('invalid cell in set validation');
-    }
+    const target = {start: command.area.start, end: command.area.end };
 
     if (command.range) {
+
+      sheet.AddValidation({
+        type: 'range',
+        error: !!command.error,
+        area: command.range,
+        target: [target],
+      });
+
+      /*
       cell.validation = {
         type: ValidationType.Range,
         area: command.range,
         error: !!command.error,
       };
+      */
+
     }
     else if (command.list) {
+
+      sheet.AddValidation({
+        type: 'list',
+        error: !!command.error,
+        list: JSON.parse(JSON.stringify(command.list)),
+        target: [target],
+      });
+
+      /*
       cell.validation = {
         type: ValidationType.List,
         list: JSON.parse(JSON.stringify(command.list)),
         error: !!command.error,
       }
+      */
+
     }
     else {
-      cell.validation = undefined;
+      // cell.validation = undefined;
+
+      sheet.RemoveValidations(target);
+
     }
 
   }
@@ -2794,8 +2815,54 @@ export class GridBase {
   /**
    * patch sheet conditionals for insert/delete row/column operations.
    * some of them may be deleted.
+   * 
+   * UPDATE: using this routine to also patch data validations
    */
-  protected PatchConditionals(options: PatchOptions) {
+  protected PatchConditionalsAndValidations(options: PatchOptions) {
+
+    if (options.sheet.data_validation.length) {
+
+      const delete_list: Set<DataValidation> = new Set();
+      for (const validation of options.sheet.data_validation) {
+
+        const targets: IArea[] = [];
+        for (const area of validation.target) {
+          const updated = Area.PatchArea(area, options);
+          if (updated) {
+            targets.push(updated);
+          }
+        }
+
+        if (targets.length > 0) {
+
+          validation.target = targets;
+
+          // format the range, if necessary
+
+          if (validation.type === 'range') {
+            if (validation.area.start.sheet_id === options.sheet.id) {
+              const updated = Area.PatchArea(validation.area, options);
+              if (updated) {
+                validation.area = updated;
+              }
+              else {
+                delete_list.add(validation);
+              }
+            }
+          }
+
+        }
+        else {
+          delete_list.add(validation);
+        }
+        
+      }
+
+      if (delete_list.size) {
+        options.sheet.data_validation = options.sheet.data_validation.filter(test => !delete_list.has(test));
+      }
+
+    }
 
     if (options.sheet.conditional_formats?.length) {
 
@@ -2869,7 +2936,7 @@ export class GridBase {
     }
 
     // conditionals
-    this.PatchConditionals({
+    this.PatchConditionalsAndValidations({
         sheet: target_sheet, 
         before_column: 0, 
         column_count: 0, 
@@ -3217,7 +3284,7 @@ export class GridBase {
     }
     
     // conditionals
-    this.PatchConditionals({
+    this.PatchConditionalsAndValidations({
       sheet: target_sheet, 
       before_column: command.before_column, 
       column_count: command.count, 
@@ -4029,8 +4096,8 @@ export class GridBase {
           // COEDITING: ok
 
           this.SetValidationInternal(command);
-          if (!command.area.sheet_id || command.area.sheet_id === this.active_sheet.id) {
-            flags.render_area = Area.Join(new Area(command.area), flags.render_area);
+          if (!command.area.start.sheet_id || command.area.start.sheet_id === this.active_sheet.id) {
+            flags.render_area = Area.Join(new Area(command.area.start, command.area.end), flags.render_area);
           }
           break;
 

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

@@ -225,7 +225,8 @@ export interface SetNameCommand {
 
 export interface DataValidationCommand {
   key: CommandKey.DataValidation;
-  area: ICellAddress;
+  area: IArea;
+
   range?: IArea;
   list?: CellValue[];
   error?: boolean;

package/treb-parser/src/parser.ts

@@ -409,7 +409,7 @@ export class Parser {
     for (let i = 0; i < n; i++) {
       transposed[i] = [];
       for (let j = 0; j < m; j++) {
-        transposed[i][j] = arr[j][i];
+        transposed[i][j] = arr[j] ? arr[j][i] : undefined;
       }
     }
 
@@ -2415,8 +2415,11 @@ export class Parser {
     if (!c) return null;
     position = c.position;
 
+    // things that look like an address but have row 0 are legal
+    // as names. so this should be a token if r === 0.
+
     const r = this.ConsumeAddressRow(position);
-    if (!r) return null;
+    if (!r) return null; 
     position = r.position;
 
     const label = sheet ?
@@ -2460,7 +2463,11 @@ export class Parser {
 
   /**
    * consumes a row, possibly absolute ($). returns the numeric row
-   * (0-based) and metadata
+   * (0-based) and metadata. 
+   * 
+   * note that something like "X0" is a legal token, because 0 is not
+   * a valid row. but at the same time it can't have a $ in it. although
+   * maybe "X$0" is a token but not a valid name? dunno
    */
   protected ConsumeAddressRow(position: number): 
     { 
@@ -2484,7 +2491,18 @@ export class Parser {
       else break;
     }
 
-    if (start === position) return false;
+    if (start === position) {
+      return false;
+    }
+
+    // handle token X0. should ~maybe~ handle this only if !absolute
+    // temp leaving this separate from the above test just so it's clear
+    // what we are doing
+
+    if (value === 0) {
+      return false; 
+    }
+
     return { absolute, row: value - 1, position };
   }