@trebco/treb 29.1.6 → 29.2.0

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v29.1. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v29.2. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trebco/treb",
-  "version": "29.1.6",
+  "version": "29.2.0",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-calculator/src/expression-calculator.ts

@@ -501,6 +501,9 @@ export class ExpressionCalculator {
     const func = this.library.Get(outer.name);
 
     if (!func) {
+
+      // console.info('missing function', outer.name);
+
       return () => NameError();
     }
 

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

@@ -89,6 +89,45 @@ const inverse_normal = (q: number): number => {
 
 };
 
+const edate_calc = (start: number, months: number) => {
+  
+  let date = new Date(LotusDate(start));
+  let month = date.getUTCMonth() + months;
+  let year = date.getUTCFullYear();
+
+  // if we don't ensure the time we'll wind up hitting boundary cases
+
+  date.setUTCHours(12);
+  date.setUTCMinutes(0);
+  date.setUTCSeconds(0);
+  date.setUTCMilliseconds(0);
+
+  while (month < 0) {
+    month += 12;
+    year--;
+  }
+  while (month > 11) {
+    month -= 12;
+    year++;
+  }
+
+  date.setUTCMonth(month);
+  date.setUTCFullYear(year);
+
+  // if this rolls over the month, then we need to go back to the 
+  // last valid day of the month. so jan 31 + 1 month needs to equal
+  // feb 28 (feb 29 in leap year).
+
+  const check_month = date.getUTCMonth();
+  if (check_month !== month) {
+    const days = date.getUTCDate();
+    date = new Date(date.getTime() - (days * 86400 * 1000));
+  }
+
+  return date;
+
+};
+
 const zlookup_arguments = [
   {
     name: "Lookup value",
@@ -329,6 +368,85 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  // --- FIXME: break out date functions? --------------------------------------
+
+  EDate: {
+    arguments: [
+      { 
+        name: 'Start date',
+        unroll: true,
+      },
+      {
+        name: 'Months',
+        unroll: true,
+      },
+    ],
+    fn: (start: number, months = 0) => {
+      if (typeof start !== 'number' || typeof months !== 'number') {
+        return ArgumentError();
+      }
+      const date = edate_calc(start, months);
+      return { type: ValueType.number, value: UnlotusDate(date.getTime(), false) };
+    }
+  },
+
+  EOMonth: {
+    arguments: [
+      { 
+        name: 'Start date',
+        unroll: true,
+      },
+      {
+        name: 'Months',
+        unroll: true,
+      },
+    ],
+    fn: (start: number, months = 0) => {
+
+      // this is the same as edate, except it advances to the end of the
+      // month. so jan 15, 2023 plus one month -> feb 28, 2023 (last day).
+
+      if (typeof start !== 'number' || typeof months !== 'number') {
+        return ArgumentError();
+      }
+      const date = edate_calc(start, months);
+
+      const month = date.getUTCMonth();
+      switch (month) {
+        case 1: // feb, special
+          {
+            const year = date.getUTCFullYear();
+            if (year % 4 === 0 && (year === 1900 || (year % 100 !== 0))) {
+              date.setUTCDate(29);
+            } 
+            else {
+              date.setUTCDate(28);
+            }
+          }
+          break;
+
+        case 0: // jan
+        case 2:
+        case 4:
+        case 6: // july
+        case 7: // august
+        case 9:
+        case 11: // dec
+          date.setUTCDate(31);
+          break;
+
+        default:
+          date.setUTCDate(30);
+          break;
+      }
+      
+
+      
+      return { type: ValueType.number, value: UnlotusDate(date.getTime(), false) };
+
+    }
+  },
+
   Now: {
     description: 'Returns current time',
     volatile: true,
@@ -429,6 +547,8 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
   },
 
+  // ---------------------------------------------------------------------------
+
   IfError: {
     description: 'Returns the original value, or the alternate value if the original value contains an error',
     arguments: [{ name: 'original value', allow_error: true, boxed: true }, { name: 'alternate value' }],

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

@@ -136,10 +136,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 +150,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 +230,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-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-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

@@ -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);
     }
 
-    /*
-    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 && (