@trebco/treb 29.3.4 → 29.5.0

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';
@@ -592,7 +593,7 @@ export class GridBase {
    * @param column column, columns, or undefined means all columns
    * @param width target width, or undefined means auto-size
    */
-  public SetColumnWidth(column?: number | number[], width = 0): void {
+  public SetColumnWidth(column?: number | number[], width?: number): void {
     this.ExecCommand({
       key: CommandKey.ResizeColumns,
       column,
@@ -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);
+
     }
 
   }
@@ -2493,11 +2514,20 @@ export class GridBase {
 
             // translate...
             if (unit.offset_column) {
+              unit.absolute_column = false;
               unit.column = unit.column + address.column;
             }
+            else {
+              unit.absolute_column = true;
+            }
+
             if (unit.offset_row) {
+              unit.absolute_row = false;
               unit.row = unit.row + address.row;
             }
+            else {
+              unit.absolute_row = true;
+            }
 
           }
           return true;
@@ -2794,8 +2824,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 +2945,7 @@ export class GridBase {
     }
 
     // conditionals
-    this.PatchConditionals({
+    this.PatchConditionalsAndValidations({
         sheet: target_sheet, 
         before_column: 0, 
         column_count: 0, 
@@ -3217,7 +3293,7 @@ export class GridBase {
     }
     
     // conditionals
-    this.PatchConditionals({
+    this.PatchConditionalsAndValidations({
       sheet: target_sheet, 
       before_column: command.before_column, 
       column_count: command.count, 
@@ -4029,8 +4105,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-types.ts

@@ -401,6 +401,16 @@ export type ParserFlags = Partial<OptionalParserFlags> & RequiredParserFlags;
 
 export interface RenderOptions {
   offset: { rows: number; columns: number };
+
+  /** 
+   * render in R1C1 format. this will be relative if the R1C1 base
+   * address is set; otherwise absolute. 
+   */
+  r1c1?: boolean;
+
+  /** base for offsetting relative R1C1 addresses */
+  r1c1_base?: UnitAddress;
+
   missing: string;
   convert_decimal: DecimalMarkType;
   convert_argument_separator: ArgumentSeparatorType;

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;
       }
     }
 
@@ -489,14 +489,12 @@ export class Parser {
 
     switch (unit.type) {
       case 'address':
-        return this.AddressLabel(unit, offset);
+        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base) : this.AddressLabel(unit, offset);
 
       case 'range':
-        return (
-          this.AddressLabel(unit.start, offset) +
-          ':' +
-          this.AddressLabel(unit.end, offset)
-        );
+        return options.r1c1 ? 
+          this.R1C1Label(unit.start, options.r1c1_base) + ':' + this.R1C1Label(unit.end, options.r1c1_base) : 
+          this.AddressLabel(unit.start, offset) + ':' + this.AddressLabel(unit.end, offset);
 
       case 'missing':
         return missing;
@@ -823,7 +821,35 @@ export class Parser {
     return s;
   }
 
-  /** generates address label ("C3") from address (0-based) */
+  /**
+   * generates absolute or relative R1C1 address
+   */
+  protected R1C1Label(
+    address: UnitAddress,
+    base?: UnitAddress,
+  ): string {
+
+    let label = '';
+
+    if (address.sheet) { // && (!base?.sheet || base?.sheet !== address.sheet)) {
+      label = (QuotedSheetNameRegex.test(address.sheet) ?
+        '\'' + address.sheet + '\'' : address.sheet) + '!';
+    }
+
+    const row = (address.absolute_row || !base) ? (address.row + 1).toString() : `[${address.row - base.row}]`;
+    const column = (address.absolute_column || !base) ? (address.column + 1).toString() : `[${address.column - base.column}]`;
+
+    label += `R${row}C${column}`;
+
+    return label;
+  }
+
+  /** 
+   * generates address label ("C3") from address (0-based).
+   * 
+   * @param offset - offset by some number of rows or columns 
+   * @param r1c1 - if set, return data in R1C1 format. 
+   */
   protected AddressLabel(
     address: UnitAddress,
     offset: { rows: number; columns: number },
@@ -839,12 +865,6 @@ export class Parser {
     let label = '';
     if (address.sheet) {
 
-      /*
-      if (address.sheet === '__REF') {
-        return '#REF'; // magic
-      }
-      */
-
       label = (QuotedSheetNameRegex.test(address.sheet) ?
         '\'' + address.sheet + '\'' : address.sheet) + '!';
     }
@@ -2415,8 +2435,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 +2483,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 +2511,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 };
   }