@trebco/treb 29.3.4 → 29.4.1

package/treb-calculator/src/functions/base-functions.ts

@@ -1936,8 +1936,8 @@ for (const name of Object.getOwnPropertyNames(Math)) {
   case 'function':
     // console.info("MATH FUNC", name);
     BaseFunctionLibrary[name] = {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      fn: (...args: any) => {
+      // description: 'Math function',
+      fn: (...args: unknown[]) => {
         return Box(value(...args));
       },
       category: ['Math Functions'],

package/treb-calculator/src/functions/statistics-functions.ts

@@ -343,7 +343,37 @@ export const StatisticsFunctionLibrary: FunctionMap = {
       return { type: ValueType.number, value: (flat[lo-1] + flat[hi-1]) / 2 };
 
     },
-  }
+  },
+
+  Rank: {
+    arguments: [
+      { name: 'Value', },
+      { name: 'Source', },
+      { name: 'Order', },
+    ],
+    fn: (value: number, source: CellValue[], order = 0) => {
+
+      if (typeof value !== 'number') {
+        return ArgumentError();
+      }
+
+      const numbers = Utils.FlattenNumbers(source);
+      numbers.sort(order ? (a, b) => a - b : (a, b) => b - a);
+
+      for (let i = 0; i < numbers.length; i++) {
+        if (numbers[i] === value) {
+          return {
+            type: ValueType.number,
+            value: i + 1,
+          };
+        }
+      }
+
+      return ValueError();
+
+    },
+  },
+
 
 };
 

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

@@ -0,0 +1,44 @@
+
+import type { IArea, CellValue } from 'treb-base-types';
+
+/** @internal */
+export interface DataValidationRange {
+  type: 'range'; 
+  area: IArea;
+}
+
+/** @internal */
+export interface DataValidationList {
+  type: 'list'; 
+  list: CellValue[];
+}
+
+/** @internal */
+export interface DataValidationDate {
+  type: 'date'; 
+}
+
+/** @internal */
+export interface DataValidationNumber {
+  type: 'number'; 
+}
+
+/** @internal */
+export interface DataValidationBoolean {
+  type: 'boolean'; 
+}
+
+/** @internal */
+export type DataValidation 
+  = (DataValidationList
+  | DataValidationRange
+  | DataValidationNumber
+  | DataValidationDate
+  | DataValidationBoolean) & {
+
+  error?: boolean;
+  // target: Area[];  // can be multple so we'll default to array
+  target: IArea[];
+
+}
+

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

@@ -73,7 +73,7 @@ export class DataModel {
   public readonly sheets = new SheetCollection();
 
   /** new composite collection (TODO: add macro functions too?) */
-  public readonly named = new NamedRangeManager();
+  public readonly named = new NamedRangeManager(this.parser);
 
   /** macro functions are functions written in spreadsheet language */
   public readonly macro_functions: Map<string, MacroFunction> = new Map();
@@ -152,15 +152,19 @@ export class DataModel {
             [ parse_result.expression, parse_result.expression ];
 
           if (start.sheet) {
-            const area = new Area({...start, sheet_id: this.sheets.ID(start.sheet), }, end);
-  
-            if (area.start.sheet_id) {
-              this.named.SetNamedRange(named.name, area, scope);
+            if (/^\[\d+\]/.test(start.sheet)) {
+              console.warn('named range refers to an external file');
             }
             else {
-              console.warn("missing sheet ID?", start);
+              const area = new Area({...start, sheet_id: this.sheets.ID(start.sheet), }, end);
+    
+              if (area.start.sheet_id) {
+                this.named.SetNamedRange(named.name, area, scope);
+              }
+              else {
+                console.warn("missing sheet ID?", start);
+              }
             }
-
           }
           else {
             console.warn("missing sheet name?", start);

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

@@ -42,4 +42,4 @@ export { Annotation } from './annotation';
 export type { ViewData as AnnotationViewData } from './annotation';
 export type { AnnotationData, AnnotationType } from './annotation';
 
-
+export * from './data-validation';

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

@@ -21,7 +21,7 @@
 
 import { Area } from 'treb-base-types';
 import type { IArea } from 'treb-base-types';
-import type { ExpressionUnit } from 'treb-parser';
+import type { ExpressionUnit, Parser } from 'treb-parser';
 
 interface NamedExpression {
   type: 'expression';
@@ -82,6 +82,8 @@ export class NamedRangeManager {
     return this.named.values();
   }
 
+  constructor(public parser: Parser) {}
+
   /** shorthand for setting named expression */
   public SetNamedExpression(name: string, expression: ExpressionUnit, scope?: number) {
     return this.SetName({
@@ -206,30 +208,53 @@ export class NamedRangeManager {
    * named range rules:
    *
    * - legal characters are alphanumeric, underscore and dot.
+   * 
    * - must start with letter or underscore (not a number or dot).
+   *   UPDATE: also possibly a backslash? not sure if that's escaping or not.
+   * 
    * - cannot look like a spreadsheet address, which is 1-3 letters followed by numbers.
-   *
+   *   UPDATE: actually this is legal if the number is "0". that's the only
+   *   number. I don't think our parser will process this correctly, so until
+   *   then keep it illegal.
+   * 
    * - apparently questuon marks are legal, but not in first position. atm 
    *   our parser will reject.
    * 
+   * - FIXME: we should block R1C1-looking notation as well
+   * 
    * returns a normalized name (just caps, atm)
    */
   public ValidateNamed(name: string): string|false {
-    name = name.trim();
+
+    // normalize
+    name = name.trim().toUpperCase();
 
     // can't be empty
     if (!name.length) return false;
 
-    // can't look like a spreadsheet address
-    if (/^[A-Za-z]{1,3}\d+$/.test(name)) return false;
-
-    // can only contain legal characters
-    if (/[^A-Za-z\d_.?]/.test(name)) return false;
+    // can only contain legal characters [FIXME: backslash is legal?]
+    if (/[^A-Z\d_.?]/.test(name)) return false;
 
     // must start with ascii letter or underscore
-    if (/^[^A-Za-z_]/.test(name)) return false;
+    if (/^[^A-Z_]/.test(name)) return false;
+
+    // these are not legal for some reason -- they look like R1C1?
+    if (name === 'R' || name === 'C') {
+      return false;
+    }
+
+    // FIXME: should we just use a parser? we're adding more and more regexes.
+
+    // can't look like a spreadsheet address, unless the row is === 0
+    if (/^[A-Z]{1,3}[1-9]\d*$/.test(name)) return false;
+
+    // can't look like R1C1 either (we already checked for R and C)
+    if (/^R[[\]\d]+C/.test(name)) {
+      return false;
+    }
 
-    return name.toUpperCase();
+    return name;
+    
   }
 
   /**

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

@@ -43,6 +43,7 @@ import type { GridSelection } from './sheet_selection';
 import { CreateSelection } from './sheet_selection';
 import { Annotation } from './annotation';
 import type { ConditionalFormatList } from './conditional_format';
+import type { DataValidation } from './data-validation';
 
 // --- constants --------------------------------------------------------------
 
@@ -163,6 +164,11 @@ export class Sheet {
    */
   public conditional_formats: ConditionalFormatList = [];
 
+  /**
+   * @internal
+   */
+  public data_validation: DataValidation[] = [];
+
   /**
    * @internal
    * 
@@ -255,6 +261,7 @@ export class Sheet {
    */
   private conditional_format_checklist: IArea[] = [];
 
+
   // --- accessors ------------------------------------------------------------
 
   // public get column_header_count() { return this.column_header_count_; }
@@ -383,6 +390,11 @@ export class Sheet {
       sheet.conditional_formats = source.conditional_formats;
     }
 
+    sheet.data_validation = (source.data_validations || []).map(validation => ({
+      ...validation,
+      target: (validation.target||[]).map(target => new Area(target.start, target.end)),
+    }));
+
     // persist ID, name
 
     if (source.id) {
@@ -740,6 +752,45 @@ export class Sheet {
 
   }
 
+  /** add a data validation. */
+  public AddValidation(validation: DataValidation) {
+    this.data_validation.push({
+      ...validation,
+      target: (validation.target||[]).map(target => new Area(target.start, target.end)), // ensure class instance
+    });
+  }
+
+  /** 
+   * remove validations from area. must be an exact match (FIXME).
+   * if there are multiple areas, only remove the matching area.
+   */
+  public RemoveValidations(area: IArea) {
+
+    const check = new Area(area.start, area.end);
+    this.data_validation = this.data_validation.filter(validation => {
+      validation.target = validation.target.filter(compare => !check.Equals2(compare));
+      return validation.target.length > 0;
+    });
+  }
+
+  /** return data validation(s) that apply to a given address */
+  public GetValidation(address: ICellAddress) {
+
+    // switch to imperative
+
+    const list: DataValidation[] = [];
+    for (const entry of this.data_validation) {
+      for (const area of entry.target) {
+        if ((area as Area).Contains(address)) {
+          list.push(entry);
+          break;
+        }
+      }
+    }
+
+    return list;
+
+  }
 
   public Activate(DOM: DOMContext) {
 
@@ -2665,6 +2716,11 @@ export class Sheet {
       JSON.parse(JSON.stringify(this.conditional_formats.map(format => ({...format, internal: undefined })))) : 
       undefined;
 
+    // yes, here. we should have a serialized type so we know to convert. TODO
+
+    const data_validations = this.data_validation.length ? JSON.parse(JSON.stringify(this.data_validation)) : undefined;
+     
+
     const result: SerializedSheet = {
 
       // not used atm, but in the event we need to gate
@@ -2688,6 +2744,7 @@ export class Sheet {
       column_style,
 
       conditional_formats,
+      data_validations,
 
       row_pattern: row_pattern.length ? row_pattern : undefined,
 
@@ -2886,6 +2943,10 @@ export class Sheet {
       this.conditional_formats.push(format);
     }
 
+    for (const validation of data.data_validations || []) {
+      this.AddValidation(validation);
+    }
+
     if (data.hidden) {
       this.visible = false;
     }

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

@@ -23,6 +23,7 @@ import type { IArea, SerializedCellData, CellStyle } from 'treb-base-types';
 import type { AnnotationData } from './annotation';
 import type { GridSelection, SerializedGridSelection } from './sheet_selection';
 import type { ConditionalFormatList } from './conditional_format';
+import type { DataValidation } from './data-validation';
 
 export interface UpdateHints {
   data?: boolean;
@@ -72,6 +73,9 @@ export interface SerializedSheet {
   /** @internal */
   conditional_formats?: ConditionalFormatList;
 
+  /** @internal */
+  data_validations?: DataValidation[];
+
   /** 
    * @deprecated use `styles` instead
    */

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