@trebco/treb 29.1.6 → 29.3.1

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

@@ -20,15 +20,15 @@
  */
 
 import { Area } from 'treb-base-types';
-import type { SerializedArea, IArea } from 'treb-base-types';
+import type { IArea } from 'treb-base-types';
 import type { ExpressionUnit } from 'treb-parser';
 
-export interface NamedExpression {
+interface NamedExpression {
   type: 'expression';
   expression: ExpressionUnit;
 }
 
-export interface NamedRange {
+interface NamedRange {
   type: 'range';
   area: Area;
 }
@@ -38,44 +38,23 @@ export type Named = (NamedExpression | NamedRange) & {
   scope?: number;   // scope to sheet by ID
 };
 
-/** 
- * serialized type 
- * 
- * @privateRemarks
- * 
- * for the external type we switch on the presence of the area
- * or the expression. area uses a type that includes sheet names
- * (IArea should allow that?). expression here is a string.
+/**
+ * serialized type is a composite of expression/range. we determine
+ * what it is when parsing the expression. this simplifies passing these
+ * things around.
  * 
- * we could theoretically switch the internal type the same way
- * and drop the string keys. something to think about.
+ * (named expressions and ranges they have slightly different behavior, 
+ * which is why we have a distinction at all).
  * 
- * when serialized, scope is either the sheet name or nothing 
- * (implicit global scope).
  */
 export interface SerializedNamed {
-  name: string;
-  area?: SerializedArea;
-  expression?: string;
-  scope?: string;
-}
-
-/**
- * this is a type we're using in imports. it consolidates the 
- * two types. we should maybe switch as well, at least for
- * serialized representation? something to think about.
- */
-export interface CompositeNamed {
 
   name: string;
 
-  /** 
-   * could be a address/range or a function expression. we'll distinguish
-   * when we parse it.
-   */
+  /** expression or address/area */
   expression: string;
 
-  /** resolved sheet name */
+  /** scope is a sheet name (not ID) */
   scope?: string;
 
 }
@@ -136,10 +115,12 @@ export class NamedRangeManager {
 
     const validated = this.ValidateNamed(name);
     if (!validated) {
-      console.warn('invalid name');
+      console.warn('invalid name', {name});
       return false;
     }
 
+    /*
+
     if (named.type === 'range') {
 
       // why is this considered invalid here? I've seen it done. 
@@ -148,12 +129,14 @@ export class NamedRangeManager {
 
       if (named.area.entire_column || named.area.entire_row) {
         console.info({named});
-        console.warn(`invalid range`);
+        console.warn('invalid range');
         return false;
       }
 
     }
 
+    */
+
     // this.named.set(name.toLowerCase(), named);
     this.named.set(this.ScopedName(name, named.scope), named);
 
@@ -226,14 +209,26 @@ export class NamedRangeManager {
    * - must start with letter or underscore (not a number or dot).
    * - cannot look like a spreadsheet address, which is 1-3 letters followed by numbers.
    *
+   * - apparently questuon marks are legal, but not in first position. atm 
+   *   our parser will reject.
+   * 
    * returns a normalized name (just caps, atm)
    */
   public ValidateNamed(name: string): string|false {
     name = name.trim();
+
+    // 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;
-    if (/[^A-Za-z\d_.]/.test(name)) return false;
+
+    // can only contain legal characters
+    if (/[^A-Za-z\d_.?]/.test(name)) return false;
+
+    // must start with ascii letter or underscore
     if (/^[^A-Za-z_]/.test(name)) return false;
+
     return name.toUpperCase();
   }
 

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

@@ -3282,9 +3282,20 @@ export class Sheet {
       // stop rule. if you go forwards, you need some sort of indicator 
       // or flag).
 
+      const area = JSON.parse(JSON.stringify(format.area));
+      
+      if (area.start.row === null || area.end.row === null) {
+        area.start.row = 0;
+        area.end.row = this.cells.rows - 1;
+      }
+      if (area.start.column === null || area.end.column === null) {
+        area.start.column = 0;
+        area.end.column = this.cells.columns - 1;
+      }
+
+      const result = format.internal?.vertex?.result;
+
       if (format.type === 'gradient') {
-        const area = JSON.parse(JSON.stringify(format.area));
-        const result = format.internal?.vertex?.result;
 
         if (result && format.internal?.gradient) {
           const property: 'fill'|'text' = format.property ?? 'fill';
@@ -3322,16 +3333,13 @@ export class Sheet {
 
         // handle types expression, cell-match and duplicate-values
 
-        const area = JSON.parse(JSON.stringify(format.area));
-        const result = format.internal?.vertex?.result;
-
         if (result) {
 
           if (result.type === ValueType.array) {
             for (let row = area.start.row; row <= area.end.row; row++) {
               for (let column = area.start.column; column <= area.end.column; column++) {
                 const value = result.value[column - area.start.column][row - area.start.row];
-                if ((value.type === ValueType.boolean || value.type === ValueType.number) && !!value.value) {
+                if (value && (value.type === ValueType.boolean || value.type === ValueType.number) && !!value.value) {
                   if (!temp[row]) { temp[row] = []; }
                   if (!temp[row][column] ) { temp[row][column] = []; }
                   temp[row][column].push(format.style);

package/treb-export/src/export2.ts

@@ -54,7 +54,7 @@ import { AddRel } from './relationship';
 import { type DOMContent, XMLOptions2 } from './xml-utils';
 
 import type { UnitAddress, UnitRange, ExpressionUnit} from 'treb-parser';
-import { Parser, QuotedSheetNameRegex } from 'treb-parser';
+import { Parser } from 'treb-parser';
 
 // FIXME: move
 import type { ChartOptions } from './drawing2/chart2';
@@ -2464,92 +2464,13 @@ export class Exporter {
           }
         }
 
-        if (entry.area) {
-          let sheet_name = '';
-          const area = new Area(entry.area.start, entry.area.end);
-          area.start.absolute_column = area.start.absolute_row = true;
-          area.end.absolute_column = area.end.absolute_row = true;
-
-          if (entry.area.start.sheet) {
-            sheet_name = entry.area.start.sheet;
-          }
-          else if (entry.area.start.sheet_id) {
-            for (const sheet of source.sheet_data) {
-              if (sheet.id === area.start.sheet_id) {
-                sheet_name = sheet.name || '';
-                break;
-              }
-            }
-          }
-  
-          if (sheet_name) {
-            if (QuotedSheetNameRegex.test(sheet_name)) {
-              sheet_name = `'${sheet_name}'`;
-            }
-            sheet_name += '!';
-          }
-  
-          // console.info({key, area, lx: area.spreadsheet_label, sheet_name });
-          definedNames.definedName.push({
-            a$: { name: entry.name, localSheetId: scope },
-            t$: sheet_name + area.spreadsheet_label,
-          });
-  
-        }
-        else if (entry.expression) {
-          definedNames.definedName.push({
-            a$: { name: entry.name, localSheetId: scope },
-            t$: entry.expression,
-          });
-        }
-
-      }
-    }
-
-    console.info("DB", definedNames);
-
-    /*
-    if (source.named_ranges) {
-      const keys = Object.keys(source.named_ranges);
-      for (const key of keys) {
-        let sheet_name = '';
-        const area = new Area(source.named_ranges[key].start, source.named_ranges[key].end);
-        area.start.absolute_column = area.start.absolute_row = true;
-        area.end.absolute_column = area.end.absolute_row = true;
-
-        if (area.start.sheet_id) {
-          for (const sheet of source.sheet_data) {
-            if (sheet.id === area.start.sheet_id) {
-              sheet_name = sheet.name || '';
-              break;
-            }
-          }
-        }
-
-        if (sheet_name) {
-          if (QuotedSheetNameRegex.test(sheet_name)) {
-            sheet_name = `'${sheet_name}'`;
-          }
-          sheet_name += '!';
-        }
-
-        // console.info({key, area, lx: area.spreadsheet_label, sheet_name });
         definedNames.definedName.push({
-          a$: { name: key },
-          t$: sheet_name + area.spreadsheet_label,
-        });
-
-      }
-    }
-    if (source.named_expressions) {
-      for (const entry of source.named_expressions) {
-        definedNames.definedName.push({
-          a$: { name: entry.name },
+          a$: { name: entry.name, localSheetId: scope },
           t$: entry.expression,
         });
+
       }
     }
-    */
 
     if (!definedNames.definedName.length) {
       definedNames = undefined;

package/treb-export/src/import2.ts

@@ -348,21 +348,23 @@ export class Importer {
       case 'duplicateValues':
       case 'uniqueValues':
 
-        let style = {};
+        {
+          let style = {};
 
-        if (rule.a$.dxfId) {
-          const index = Number(rule.a$.dxfId);
-          if (!isNaN(index)) {
-            style = this.workbook?.style_cache.dxf_styles[index] || {};
+          if (rule.a$.dxfId) {
+            const index = Number(rule.a$.dxfId);
+            if (!isNaN(index)) {
+              style = this.workbook?.style_cache.dxf_styles[index] || {};
+            }
           }
-        }
 
-        return {
-          type: 'duplicate-values',
-          area,
-          style,
-          unique: (rule.a$.type === 'uniqueValues'),
-        };
+          return {
+            type: 'duplicate-values',
+            area,
+            style,
+            unique: (rule.a$.type === 'uniqueValues'),
+          };
+        }
 
       case 'cellIs':
         if (rule.a$.operator && rule.formula) {
@@ -392,7 +394,10 @@ export class Importer {
         }
         break;
 
+      case 'containsErrors':
+      case 'notContainsErrors':
       case 'expression':
+
         if (rule.formula) {
 
           if (typeof rule.formula !== 'string') {
@@ -436,7 +441,7 @@ export class Importer {
           const stops: GradientStop[] = [];
           for (const [index, entry] of rule.colorScale.cfvo.entries()) {
             let value = 0;
-            let color: Color = {};
+            const color: Color = {};
 
             const color_element = rule.colorScale.color[index];
             if (color_element.a$.rgb) {

package/treb-export/src/workbook2.ts

@@ -39,7 +39,7 @@ import { Sheet, VisibleState } from './workbook-sheet2';
 import type { RelationshipMap } from './relationship';
 import { ZipWrapper } from './zip-wrapper';
 import type { CellStyle } from 'treb-base-types';
-import type { CompositeNamed } from 'treb-data-model';
+import type { SerializedNamed } from 'treb-data-model';
 
 
 /*
@@ -155,7 +155,7 @@ export class Workbook {
   /* * defined names. these can be ranges or expressions. */
   // public defined_names: Record<string, string> = {};
 
-  public named: Array<CompositeNamed & {local_scope?: number}> = [];
+  public named: Array<SerializedNamed & {local_scope?: number}> = [];
 
   /** the workbook "rels" */
   public rels: RelationshipMap = {};

package/treb-format/src/format.ts

@@ -70,15 +70,17 @@ export const UnlotusDate = (value: number, local = true): number => {
   if (local) {
 
     const local_date = new Date(value);
-    const utc_date = new Date();
-
-    utc_date.setUTCMilliseconds(local_date.getUTCMilliseconds());
-    utc_date.setUTCSeconds(local_date.getUTCSeconds());
-    utc_date.setUTCMinutes(local_date.getUTCMinutes());
-    utc_date.setUTCHours(local_date.getHours());
-    utc_date.setUTCDate(local_date.getDate());
-    utc_date.setUTCMonth(local_date.getMonth());
-    utc_date.setUTCFullYear(local_date.getFullYear());
+    const utc_date = new Date(
+      local_date.getFullYear(),
+      local_date.getMonth(),
+      local_date.getDate(),
+      local_date.getHours(),
+      local_date.getMinutes(),
+      local_date.getSeconds(),
+      local_date.getMilliseconds(),
+    );
+
+    // console.info("Converting local", utc_date.toUTCString());
 
     value = utc_date.getTime();
 

package/treb-format/src/value_parser.ts

@@ -322,7 +322,7 @@ class ValueParserType {
           }
 
           return {
-            value: UnlotusDate(date),
+            value: UnlotusDate(date, true),
             type: ValueType.number,
             hints,
           };

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

@@ -83,7 +83,7 @@ import type { GridEvent } from './grid_events';
 import { ErrorCode } from './grid_events';
 
 import type { 
-  CompositeNamed,
+  SerializedNamed,
   DataModel, 
   GridSelection,
   LegacySerializedSheet, 
@@ -890,7 +890,7 @@ export class Grid extends GridBase {
     import_data: {
       sheets: ImportedSheetData[],
       // names?: Record<string, string|number>,
-      named?: CompositeNamed[],
+      named?: SerializedNamed[],
       active_tab?: number,
     },
     render = false,
@@ -970,79 +970,11 @@ export class Grid extends GridBase {
     this.model.sheets.UpdateIndexes();
 
     this.model.named.Reset();
-    // this.model.named_ranges.Reset();
-    // this.model.named_expressions.clear();
-    // console.info({IDX: import_data.named});
 
     if (import_data.named) {
-      this.model.UnserializeComposite(import_data.named, this.active_sheet);
+      this.model.UnserializeNames(import_data.named, this.active_sheet);
     }
 
-    /*
-    if (import_data.names) {
-      
-      console.info("IDN", { names: import_data.names })
-
-      for (const name of Object.keys(import_data.names)) {
-
-        const validated = this.model.named.ValidateNamed(name);
-
-        if (!validated) {
-          console.warn(`invalid name: ${name}`, import_data.names[name]);
-          continue;
-        }
-
-        const label = import_data.names[name];
-        if (typeof label === 'number') {
-          // console.info('dropping (temp)', name, label);
-        }
-        else {
-          const parse_result = this.parser.Parse(label);
-
-          if (parse_result.expression) {
-            if (parse_result.expression.type === 'range') {
-              const sheet_id = name_map[parse_result.expression.start.sheet || ''];
-              if (sheet_id) {
-                parse_result.expression.start.sheet_id = sheet_id;
-                this.model.named.SetNamedRange(validated, new Area(parse_result.expression.start, parse_result.expression.end));
-              }
-            }
-            else if (parse_result.expression.type === 'address') {
-              const sheet_id = name_map[parse_result.expression.sheet || ''];
-              if (sheet_id) {
-                parse_result.expression.sheet_id = sheet_id;
-                this.model.named.SetNamedRange(validated, new Area(parse_result.expression));
-              }
-            }
-            else {
-
-              // we need to map sheet names to sheet IDs in named
-              // expressions, if they have any addresses/references.
-
-              const expr = parse_result.expression;
-              this.parser.Walk(expr, unit => {
-                if (unit.type === 'address' || unit.type === 'range') {
-                  if (unit.type === 'range') {
-                    unit = unit.start;
-                  }
-                  if (!unit.sheet_id) {
-                    unit.sheet_id = name_map[unit.sheet || ''] || 0; // default is bad here -- do we have an active sheet yet?
-                  }
-                  return false;
-                }
-                return true;
-              });
-
-              this.model.named.SetNamedExpression(validated, expr);
-
-            }
-          }
-        }
-      }
-      // this.model.named_ranges.RebuildList();
-    }
-    */
-
     // FIXME: do we need to rebuild autocomplete here (A: yes)
     // ...
 
@@ -1597,7 +1529,7 @@ export class Grid extends GridBase {
    */
   public SetName(name: string, range?: ICellAddress | Area, expression?: string, scope?: number, overwrite = false): void {
 
-    // console.info('setname', name, range, expression, scope, overwrite);
+    // console.info('setname', { name, range, expression, scope, overwrite });
 
     // validate/translate name first
 

package/treb-parser/src/parser.ts

@@ -89,6 +89,7 @@ const CLOSE_BRACE = 0x7d;
 const OPEN_SQUARE_BRACKET = 0x5b;
 const CLOSE_SQUARE_BRACKET = 0x5d;
 
+const QUESTION_MARK = 0x3f;
 const EXCLAMATION_MARK = 0x21;
 // const COLON = 0x3a; // became an operator
 const SEMICOLON = 0x3b;
@@ -2100,6 +2101,11 @@ export class Parser {
 
         // I think that's all the rules for structured references.
 
+        // testing question marks, which are legal in defined names
+        // (but I think not in table names or column names)
+
+        || (char === QUESTION_MARK && square_bracket === 0)
+
         /*
 
         || (this.flags.r1c1 && (