@trebco/treb 31.9.1 → 32.1.1

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

@@ -351,6 +351,54 @@ export const BaseFunctionLibrary: FunctionMap = {
     fn: () => { return { type: ValueType.number, value: Math.random() }},
   },
 
+  RandArray: {
+    volatile: true,
+    arguments: [
+      {name: 'rows'},
+      {name: 'columns'},
+      {name: 'min'}, 
+      {name: 'max'},
+      {name: 'integer'},
+    ],
+    description: 'Returns an array of uniformly-distributed random numbers',
+    fn: (rows = 1, columns = 1, min = 0, max = 1, integer = false) => {
+      const value: UnionValue[][] = [];
+
+      if (integer) {
+        const range = max - min + 1;
+        for (let i = 0; i < rows; i++) {
+          const row: UnionValue[] = [];
+          for (let j = 0; j < columns; j++) {
+            row.push({
+              type: ValueType.number,
+              value: Math.floor(Math.random() * range + min),
+            });
+          }
+          value.push(row);
+        }
+      }
+      else {
+        const range = max - min;
+
+        for (let i = 0; i < rows; i++) {
+          const row: UnionValue[] = [];
+          for (let j = 0; j < columns; j++) {
+            row.push({
+              type: ValueType.number,
+              value: Math.random() * range + min,
+            });
+          }
+          value.push(row);
+        }
+      }
+
+      return {
+        type: ValueType.array,
+        value,
+      }
+    },
+  },
+
   RandBetween: {
     arguments: [{name: 'min'}, {name: 'max'}],
     volatile: true,

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

@@ -0,0 +1,96 @@
+
+import type { FunctionMap } from '../descriptors';
+import type { UnionValue} from 'treb-base-types';
+import { ValueType } from 'treb-base-types';
+import type { ExpressionUnit } from 'treb-parser';
+
+export const LambdaFunctionLibrary: FunctionMap = {
+
+  Lambda: {
+
+    // FIXME: we could use the create_binding_context callback
+    // here to validate the original parameters, might be useful
+
+    description: 'Creates a function',
+    arguments: [
+      { name: 'Argument', repeat: true, boxed: true, passthrough: true },
+      { name: 'Function', boxed: true, passthrough: true },
+    ],
+
+    fn: (...args: ExpressionUnit[]) => {
+      return {
+        type: ValueType.function, 
+
+        // FIXME: lock down this type
+
+        value: {
+
+          // we should probably clone these
+
+          bindings: args.slice(0, args.length - 1),
+          func: args[args.length - 1],
+
+          alt: 'LAMBDA',    // metadata
+          type: 'function', // metadata
+        },
+      };
+
+    }
+
+  },
+
+  Let: {
+
+    // this function has weird semantics we don't normally see -- 
+    // the first two arguments repeat, and the last one is constant.
+    // our tooltips aren't prepared for this.
+
+    // also it creates temporary names, we'll need to create some sort
+    // of temporary binding context. complicated!
+
+    description: 'Binds values to names for a calculation',
+    arguments: [
+      { name: 'Name', repeat: true },
+      { name: 'Value', repeat: true },
+      { name: 'Calculation', boxed: true },
+    ],
+
+    create_binding_context: ({args, descriptors}) => {
+      
+      if (args.length % 2 !== 1) {
+        return undefined; // error
+      }
+      
+      const context: Record<string, ExpressionUnit> = {};
+
+      for (let i = 0; i < args.length - 1; i += 2) {
+        const name = args[i];
+        const value = args[i+1];
+
+        if (name.type === 'identifier') {
+          context[name.name] = value;
+        }
+        else {
+          return undefined; // error
+        }
+
+      }
+      
+      return {
+        context,
+        args: args.slice(-1),
+        argument_descriptors: descriptors.slice(-1),
+      }
+    },
+
+    fn: (arg?: UnionValue) => {
+      return arg ? arg : { type: ValueType.undefined };
+    },
+
+  },
+
+};
+
+
+
+

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

@@ -111,13 +111,17 @@ export class DataModel {
   }
 
   /**
-   * 
+   * @param force_locale - always parse assuming a locale like en-us (comma
+   * argument separators). the current thinking is that this is required for
+   * XLSX import, although that might be incorrect.
    */
-  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet) {
+  public UnserializeNames(names: SerializedNamed[], active_sheet?: Sheet, force_locale = false) {
 
     this.parser.Save();
-    this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
-    
+    if (force_locale) {
+      this.parser.SetLocaleSettings(DecimalMarkType.Period, ArgumentSeparatorType.Comma);
+    }
+
     //const sorted = names.map(named => {
     for (const named of names) {
 
@@ -197,6 +201,7 @@ export class DataModel {
       const named: SerializedNamed = {
         name: entry.name,
         expression: '',
+        type: entry.type,
       };
 
       if (entry.scope) {
@@ -239,6 +244,11 @@ export class DataModel {
           return true;
         });
 
+        // this is using the current locale settings, but unserialize
+        // assumes we are unserializing in US-style locale. I think we
+        // do that because excel always uses that? not sure, but we need
+        // to be consistent.
+
         named.expression = this.parser.Render(entry.expression, { missing: '' });
 
       }
@@ -601,9 +611,9 @@ export class DataModel {
    * be inlined (assuming it's only called in one place), but we are breaking
    * it out so we can develop/test/manage it.
    */
-  public TranslateFunction(value: string): string {
+  public TranslateFunction(value: string, options?: { r1c1?: boolean }): string {
     if (this.language_map) {
-      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false);
+      return this.TranslateInternal(value, this.language_map, this.language_model?.boolean_true, this.language_model?.boolean_false, options);
     }
     return value;
   }
@@ -612,14 +622,14 @@ export class DataModel {
    * translate from local language -> common (english).
    * @see TranslateFunction
    */
-  public UntranslateFunction(value: string): string {
+  public UntranslateFunction(value: string, options?: { r1c1?: boolean }): string {
     if (this.reverse_language_map) {
-      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE');
+      return this.TranslateInternal(value, this.reverse_language_map, 'TRUE', 'FALSE', options);
     }
     return value;
   }
 
-  public UntranslateData(value: CellValue|CellValue[]|CellValue[][]): CellValue|CellValue[]|CellValue[][] {
+  public UntranslateData(value: CellValue|CellValue[]|CellValue[][], options?: { r1c1?: boolean }): CellValue|CellValue[]|CellValue[][] {
 
     if (Array.isArray(value)) {
 
@@ -628,7 +638,7 @@ export class DataModel {
       if (Is2DArray(value)) {
         return value.map(row => row.map(entry => {
           if (entry && typeof entry === 'string' && entry[0] === '=') {
-            return this.UntranslateFunction(entry);
+            return this.UntranslateFunction(entry, options);
           }
           return entry;
         }));
@@ -636,7 +646,7 @@ export class DataModel {
       else {
         return value.map(entry => {
           if (entry && typeof entry === 'string' && entry[0] === '=') {
-            return this.UntranslateFunction(entry);
+            return this.UntranslateFunction(entry, options);
           }
           return entry;
         });
@@ -646,7 +656,7 @@ export class DataModel {
     else if (value && typeof value === 'string' && value[0] === '=') {
 
       // single value
-      value = this.UntranslateFunction(value);
+      value = this.UntranslateFunction(value, options);
 
     }
 
@@ -663,7 +673,10 @@ export class DataModel {
    * FIXME: it's about time we started using proper maps, we dropped 
    * support for IE11 some time ago.
    */
-  private TranslateInternal(value: string, map: Record<string, string>, boolean_true?: string, boolean_false?: string): string {
+  private TranslateInternal(value: string, map: Record<string, string>, boolean_true?: string, boolean_false?: string, options?: { r1c1?: boolean }): string {
+
+    this.parser.Save();
+    this.parser.flags.r1c1 = options?.r1c1;
 
     const parse_result = this.parser.Parse(value);
 
@@ -694,10 +707,12 @@ export class DataModel {
       if (modified) {
         return '=' + this.parser.Render(parse_result.expression, { 
           missing: '', boolean_true, boolean_false,
+          r1c1: options?.r1c1,
         });
       }
     }
 
+    this.parser.Restore();
     return value;
 
   }

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

@@ -33,6 +33,7 @@ interface NamedRange {
   area: Area;
 }
 
+/** @internal */
 export type Named = (NamedExpression | NamedRange) & {
   name: string;     // canonical name
   scope?: number;   // scope to sheet by ID
@@ -57,6 +58,12 @@ export interface SerializedNamed {
   /** scope is a sheet name (not ID) */
   scope?: string;
 
+  /** 
+   * adding type. this is optional, it's not used by tooling. it's 
+   * just for informational purpopses for clients.
+   */
+  type?: 'range'|'expression';
+
 }
 
 /**

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

@@ -1631,6 +1631,23 @@ export class Sheet {
       cell.rendered_type = ValueType.dimensioned_quantity; // who cares about rendered_type? (...)
 
     }
+    else if (type === ValueType.function) {
+
+      /*
+      // FIXME: lock down this type (function)
+
+      if ((cell.calculated as any)?.alt) {
+        cell.formatted = (cell.calculated as any).alt.toString();
+        cell.rendered_type = ValueType.string;
+      }
+      else 
+      */
+     
+      {
+        cell.formatted = '𝑓()'; // FIXME
+        cell.rendered_type = ValueType.string;
+      }
+    }
     else {
 
       // why is this being treated as a number? (...)

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

@@ -49,9 +49,9 @@ import type {
     CondifionalFormatExpressionOptions,
     ConditionalFormatCellMatchOptions,
     ConditionalFormatCellMatch,
-
     LanguageModel, 
     TranslatedFunctionDescriptor,
+    SerializedNamed,
 
    } from 'treb-data-model';
 
@@ -4172,7 +4172,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
    * 
    * @public
    */
-  public Resolve(reference: string): ICellAddress | IArea | undefined {
+  public Resolve(reference: string, options?: { r1c1?: boolean }): ICellAddress | IArea | undefined {
 
     // API v1 OK
 
@@ -4183,7 +4183,7 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     // FIXME: we're using the sheet EnsureAddress method, but that should
     // move either in here or into some sort of helper class
 
-    const result = this.model.ResolveAddress(reference, this.grid.active_sheet);
+    const result = this.model.ResolveAddress(reference, this.grid.active_sheet, options);
 
     if (IsCellAddress(result)) {
       return result.sheet_id ? result : undefined;
@@ -4418,6 +4418,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
 
   }
 
+  public ListNames(): SerializedNamed[] {
+    return this.model.SerializeNames();    
+  }
+
   /**
    * Create a named range or named expression. A named range refers to an
    * address or range. A named expression can be any value or formula. To set 
@@ -6445,7 +6449,10 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
     model.named.Reset(); 
 
     if (data.named) {
+
+      // use locale setting for parsing
       this.model.UnserializeNames(data.named, this.grid.active_sheet);
+
     }
     else {
 
@@ -6482,6 +6489,8 @@ export class EmbeddedSpreadsheet<USER_DATA_TYPE = unknown> {
       if (data.named_expressions) {
         for (const pair of data.named_expressions) {
 
+        // use locale setting for parsing
+
           this.model.UnserializeNames([{
             name: pair.name,
             expression: pair.expression,

package/treb-embed/style/theme-defaults.scss

@@ -33,24 +33,6 @@
 $primary-selection-color: #4caaf1;
 $primary-selection-color-unfocused: #acc0cf;
 
-/*
-$alternate-selection-color-1: rgb(251, 177, 60);
-$alternate-selection-color-2: rgb(64, 192, 64);
-$alternate-selection-color-3: rgb(182, 109, 13);
-$alternate-selection-color-4: rgb(33, 118, 174);
-$alternate-selection-color-5: rgb(254, 104, 71);
-
-/ * *
- * slightly darkening colors for text highlighting
- * algo: convert to HSL; if L > .5, regenerate with L = .5; back to RGB (why?)
- * /
-$text-reference-color-1: rgb(250, 155, 5);
-$text-reference-color-2: rgb(58, 173, 58);
-$text-reference-color-3: rgb(182, 109, 13);
-$text-reference-color-4: rgb(33, 118, 174);
-$text-reference-color-5: rgb(254, 47, 1);
-*/
-
 .treb-main.treb-main {
 
   --alternate-selection-color-1: rgb(251, 177, 60);
@@ -324,25 +306,21 @@ $text-reference-color-5: rgb(254, 47, 1);
 
     /* span:nth-of-type(2n) { */
     span.highlight-2 {
-      // color: $text-reference-color-2;
       color: var(--text-reference-color-2);
     }
 
     /* span:nth-of-type(3n) { */
     span.highlight-3 {
-      // color: $text-reference-color-3;
       color: var(--text-reference-color-3);
     }
 
     /* span:nth-of-type(4n) { */
     span.highlight-4 {
-      // color: $text-reference-color-4;
       color: var(--text-reference-color-4);
     }
 
     /* span:nth-of-type(5n) { */
     span.highlight-5 {
-      // color: $text-reference-color-5;
       color: var(--text-reference-color-5);
     }
 

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

@@ -1284,7 +1284,7 @@ export class Grid extends GridBase {
     this.model.named.Reset();
 
     if (import_data.named) {
-      this.model.UnserializeNames(import_data.named, this.active_sheet);
+      this.model.UnserializeNames(import_data.named, this.active_sheet, true);
     }
 
     // FIXME: do we need to rebuild autocomplete here (A: yes)
@@ -2350,11 +2350,12 @@ export class Grid extends GridBase {
       
 
     // this is public so we need to (un)translate.
-    data = this.model.UntranslateData(data);
+    // console.info("PRE", {r1c1}, data);
+    data = this.model.UntranslateData(data, { r1c1 });
+    // console.info("POST", data, "\n");
     
      // single value, easiest
     if (!Array.isArray(data)) {
-
       if (recycle || array) {
         this.ExecCommand({ key: CommandKey.SetRange, area: range, value: data, array, r1c1 });
       }

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

@@ -167,6 +167,17 @@ export interface UnitCall extends BaseUnit {
 
 }
 
+/**
+ * new call type: implicit. we might merge these.
+ */
+export interface UnitImplicitCall extends BaseUnit {
+  type: 'implicit-call';
+  position: number;
+  args: ExpressionUnit[];
+  call: ExpressionUnit;
+
+}
+
 /**
  * this isn't an output type (unless parsing fails), but it's useful
  * to be able to pass these around with the same semantics.
@@ -177,6 +188,14 @@ export interface UnitOperator extends BaseUnit {
   operator: string;
 }
 
+/**
+ * also not an output type
+ */
+export interface UnitGroupSeparator extends BaseUnit {
+  type: 'group-separator';
+  position: number;
+}
+
 /**
  * expression unit representing a binary operation. operations may be
  * re-ordered based on precendence.
@@ -259,9 +278,11 @@ export type BaseExpressionUnit =
 | UnitArray
 | UnitIdentifier
 | UnitCall
+| UnitImplicitCall
 | UnitMissing
 | UnitGroup
 | UnitOperator
+| UnitGroupSeparator
 | UnitBinary
 | UnitUnary
 | UnitAddress