@trebco/treb 30.6.2 → 30.8.2

package/treb-embed/src/embedded-spreadsheet.ts

@@ -246,8 +246,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
   /* * @internal */
   // public static export_worker_text = '';  
 
-  /** @internal */
-  public static treb_embedded_script_path = '';
+  /* * @internal */
+  // public static treb_embedded_script_path = '';
 
   /** 
    * @internal 
@@ -4840,6 +4840,53 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
               return reject(event.data.error || 'unknown error');
             }
 
+            if (this.parser.decimal_mark !== DecimalMarkType.Period) {
+              
+              // console.info("IMPORT WARNING 2", event.data);
+
+              // FIXME: unify w/ the convert locale method
+
+              const target_decimal_mark = this.parser.decimal_mark;
+              const target_argument_separator = this.parser.argument_separator;
+              this.parser.Save();
+              this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+              const translate = (formula: string): string | undefined => {
+                const parse_result = this.parser.Parse(formula);
+                if (!parse_result.expression) { return undefined; }
+                return '=' + this.parser.Render(
+                  parse_result.expression, { 
+                    missing: '', 
+                    convert_decimal: target_decimal_mark, 
+                    convert_argument_separator: target_argument_separator,
+                  });
+              };
+
+              for (const named of event.data.results) {
+                named.expression = translate(named.expression);                
+              }
+
+              for (const sheet of event.data.results.sheets || []) {
+
+                for (const cell of sheet.cells || []) {
+                  if (cell.type === 'formula' && cell.value) {
+                    cell.value = translate(cell.value);
+                  }
+                }
+
+                if (sheet.annotations){
+                  for (const annotation of sheet.annotations) {
+                    if (annotation.formula) {
+                      annotation.formula = translate(annotation.formula);
+                    }
+                  }
+                }
+              }
+
+              this.parser.Restore();
+
+            }
+
             this.grid.FromImportData(event.data.results);
 
             this.ResetInternal();
@@ -5914,6 +5961,15 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       }
     }
 
+    if (data.named) {
+      for (const named of data.named) {
+        const translated = translate(named.expression);
+        if (translated) {
+          named.expression = translated;
+        }
+      }
+    }
+
     if (data.sheet_data) {
 
       const sheets = Array.isArray(data.sheet_data) ? data.sheet_data : [data.sheet_data];

package/treb-export/src/import2.ts

@@ -27,10 +27,10 @@ import Base64JS from 'base64-js';
 import type { AnchoredChartDescription, AnchoredImageDescription, AnchoredTextBoxDescription} from './workbook2';
 import { ChartType, ConditionalFormatOperators, Workbook } from './workbook2';
 import type { ParseResult } from 'treb-parser';
-import { Parser } from 'treb-parser';
+import { DecimalMarkType, 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, IArea, GradientStop, Color, HTMLColor, ThemeColor } from 'treb-base-types';
+import { type ImportedSheetData, type AnchoredAnnotation, type CellParseResult, type AnnotationLayout, type Corner as LayoutCorner, type IArea, type GradientStop, type Color, type HTMLColor, type ThemeColor, Area } from 'treb-base-types';
 import type { SerializedValueType } from 'treb-base-types';
 import type { Sheet} from './workbook-sheet2';
 import { VisibleState } from './workbook-sheet2';
@@ -341,7 +341,7 @@ export class Importer {
 
   }
 
-  public ParseConditionalFormat(address: RangeType|AddressType, rule: any): ConditionalFormat|undefined {
+  public ParseConditionalFormat(address: RangeType|AddressType, rule: any): ConditionalFormat|ConditionalFormat[]|undefined {
 
     const area = this.AddressToArea(address);
     const operators = ConditionalFormatOperators;
@@ -365,11 +365,13 @@ export class Importer {
             area,
             style,
             unique: (rule.a$.type === 'uniqueValues'),
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+
           };
         }
 
       case 'cellIs':
-        if (rule.a$.operator && rule.formula) {
+        if (rule.a$.operator && (rule.formula || typeof rule.formula === 'number')) {
           let style = {};
 
           if (rule.a$.dxfId) {
@@ -379,10 +381,26 @@ export class Importer {
             }
           }
 
+          if (rule.a$.operator === 'between') {
+            if (Array.isArray(rule.formula) && rule.formula.length === 2
+                && typeof rule.formula[0] === 'number' && typeof rule.formula[1] === 'number') {
+
+              return {
+                type: 'cell-match',
+                expression: '',
+                between: rule.formula, // special case? ugh
+                area,
+                style,
+                priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+              };
+
+            }
+          }
+
           const operator = operators[rule.a$.operator || ''];
 
           if (!operator) {
-            console.info('unhandled cellIs operator:', rule.a$.operator);
+            console.info('unhandled cellIs operator:', rule.a$.operator, {rule});
           }
           else {
             return {
@@ -390,10 +408,14 @@ export class Importer {
               expression: operator + ' ' + rule.formula,
               area,
               style,
+              priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
             };
           }
 
         }
+        else {
+          console.info("miss?", rule);
+        }
         break;
 
       case 'containsErrors':
@@ -427,11 +449,51 @@ export class Importer {
             }
           }
 
+          if (rule.a$.type === 'expression' && (area.start.row !== area.end.row || area.start.column !== area.end.column)) {
+
+            // (1) this is only required if there are relative references
+            //     in the formula. so we could check and short-circuit.
+            //
+            // (2) I'd like to find a way to apply this as a single formula,
+            //     so there's only one rule required.
+
+            this.parser.Save();
+            this.parser.SetLocaleSettings(DecimalMarkType.Period);
+
+            const list: ConditionalFormat[] = [];
+            const a2 = new Area(area.start, area.end);
+
+            const parse_result = this.parser.Parse(rule.formula);
+            if (parse_result.expression) {
+              for (const cell of a2) {
+                const f = this.parser.Render(parse_result.expression, {
+                  missing: '',
+                  offset: { rows: cell.row - area.start.row, columns: cell.column - area.start.column }
+                });
+
+                list.push({
+                  type: 'expression',
+                  expression: f,
+                  style,
+                  area: { start: cell, end: cell },
+                  priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+                })
+
+                // console.info(f);
+              }
+            }
+
+            this.parser.Restore();
+            return list;
+
+          }
+
           return {
             type: 'expression',
             expression: rule.formula,
             area,
             style,
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
           };
 
         }
@@ -479,6 +541,8 @@ export class Importer {
             stops,
             color_space: 'RGB',
             area,
+            priority: rule.a$.priority ? Number(rule.a$.priority) : undefined,
+
           };
 
         }
@@ -545,7 +609,12 @@ export class Importer {
             for (const rule of rules) {
               const format = this.ParseConditionalFormat(area, rule);
               if (format) {
-                conditional_formats.push(format);
+                if (Array.isArray(format)) {
+                  conditional_formats.push(...format);
+                }
+                else {
+                  conditional_formats.push(format);
+                }
               }
             }
           }

package/treb-export/src/workbook2.ts

@@ -39,10 +39,15 @@ import { ZipWrapper } from './zip-wrapper';
 import type { CellStyle, ThemeColor } from 'treb-base-types';
 import type { SerializedNamed } from 'treb-data-model';
 
+/**
+ * @privateRemarks -- FIXME: not sure about the equal/equals thing. need to check.
+ */
 export const ConditionalFormatOperators: Record<string, string> = {
   greaterThan: '>',
+  greaterThanOrEqual: '>=',
   greaterThanOrEquals: '>=',
   lessThan: '<',
+  lessThanOrEqual: '<=',
   lessThanOrEquals: '<=',
   equal: '=',
   notEqual: '<>',

package/treb-grid/src/editors/editor.ts

@@ -163,7 +163,7 @@ export interface NodeDescriptor {
 
 export class Editor<E = FormulaEditorEvent> extends EventSource<E|FormulaEditorEvent> {
 
-  protected static readonly FormulaChars = ('$^&*(-+={[<>/~%' + Localization.argument_separator).split(''); // FIXME: i18n
+  protected static readonly FormulaChars = ('$^&*(-+={[<>/~%@' + Localization.argument_separator).split(''); // FIXME: i18n
 
   /**
    * the current edit cell. in the event we're editing a merged or

package/treb-parser/src/parser.ts

@@ -136,9 +136,10 @@ const binary_operators_precendence: PrecedenceList = {
   ':': 13, // range operator
 };
 
-/**
+/* *
  * binary ops are sorted by length so we can compare long ops first
- */
+   switching to a composite w/ unary operators
+ * /
 const binary_operators = Object.keys(binary_operators_precendence).sort(
   (a, b) => b.length - a.length,
 );
@@ -147,8 +148,17 @@ const binary_operators = Object.keys(binary_operators_precendence).sort(
  * unary operators. atm we have no precedence issues, unary operators
  * always have absolute precedence. (for numbers, these are properly part
  * of the number, but consider `=-SUM(1,2)` -- this is an operator).
+ * 
+ * implicit intersection operator should now have precedence over +/-.
+ */
+const unary_operators: PrecedenceList = { '@': 50, '-': 100, '+': 100 };
+
+/**
+ * to avoid the double - and +, we're just adding our one extra unary
+ * operator. doing this dynamically would be silly, although this does
+ * make this code more fragile.
  */
-const unary_operators: PrecedenceList = { '-': 100, '+': 100 };
+const composite_operators: string[] = [...Object.keys(binary_operators_precendence), '@'].sort((a, b) => b.length - a.length);
 
 /**
  * parser for spreadsheet language.
@@ -2092,7 +2102,7 @@ export class Parser {
   }
 
   protected ConsumeOperator(): ExpressionUnit | null {
-    for (const operator of binary_operators) {
+    for (const operator of composite_operators) {
       if (this.expression.substr(this.index, operator.length) === operator) {
         const position = this.index;
         this.index += operator.length;