@trebco/treb 28.13.2 → 28.15.0

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v28.13. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v28.15. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
 
 /**
  * add our tag to the map
@@ -1077,7 +1077,7 @@ export interface FreezePane {
     rows: number;
     columns: number;
 }
-export type AnnotationType = 'treb-chart' | 'image' | 'external';
+export type AnnotationType = 'treb-chart' | 'image' | 'textbox' | 'external';
 export declare type BorderConstants = "none" | "all" | "outside" | "top" | "bottom" | "left" | "right";
 
 /**
@@ -1274,6 +1274,9 @@ export interface CellStyle {
     /** border color */
     border_bottom_fill?: Color;
 
+    /** text indent */
+    indent?: number;
+
     /**
      * cell is locked for editing
      */
@@ -1805,7 +1808,7 @@ export interface SerializedGridSelection {
     /** for cacheing addtional selections. optimally don't serialize */
     rendered?: boolean;
 }
-export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData;
+export type AnnotationData = AnnotationChartData | AnnotationImageData | AnnotationExternalData | AnnotationTextBoxData;
 export interface ImageSize {
     width: number;
     height: number;
@@ -1888,6 +1891,19 @@ export interface AnnotationImageData extends AnnotationDataBase {
 export interface AnnotationChartData extends AnnotationDataBase {
     type: 'treb-chart';
 }
+export interface AnnotationTextBoxData extends AnnotationDataBase {
+    type: 'textbox';
+    data: {
+        style?: CellStyle;
+        paragraphs: {
+            style?: CellStyle;
+            content: {
+                text: string;
+                style?: CellStyle;
+            }[];
+        }[];
+    };
+}
 export interface AnnotationExternalData extends AnnotationDataBase {
     type: 'external';
     data: Record<string, string>;

package/package.json

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

package/treb-base-types/src/style.ts

@@ -145,6 +145,9 @@ export interface CellStyle {
   /** border color */
   border_bottom_fill?: Color;
 
+  /** text indent */
+  indent?: number;
+
   /**
    * cell is locked for editing
    * 

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

@@ -806,15 +806,11 @@ export class ExpressionCalculator {
 
   }
 
-  //protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: UnionValue[][], right: UnionValue[][]): UnionValue[][] {
   protected ElementwiseBinaryExpression(fn: Primitives.PrimitiveBinaryExpression, left: ArrayUnion, right: ArrayUnion): ArrayUnion {
 
     const columns = Math.max(left.value.length, right.value.length);
     const rows = Math.max(left.value[0].length, right.value[0].length);
 
-    // const columns = Math.max(left.length, right.length);
-    // const rows = Math.max(left[0].length, right[0].length);
-
     const left_values = this.RecycleArray(left.value, columns, rows);
     const right_values = this.RecycleArray(right.value, columns, rows);
 
@@ -822,8 +818,16 @@ export class ExpressionCalculator {
 
     for (let c = 0; c < columns; c++) {
       const col: UnionValue[] = [];
+
       for (let r = 0; r < rows; r++ ) {
-        col[r] = fn(left_values[c][r], right_values[c][r]);
+
+        // handle undefineds. this is unfortunate. shouldn't the recycle 
+        // function do that? ...CHECK/TODO/FIXME
+
+        col[r] = fn(
+          left_values[c][r] || { type: ValueType.undefined }, 
+          right_values[c][r] || { type: ValueType.undefined });
+        
       }
       value.push(col);
     }

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

@@ -88,6 +88,98 @@ const inverse_normal = (q: number): number => {
 
 };
 
+const zlookup_arguments = [
+  {
+    name: "Lookup value",
+  },
+  {
+    name: "Table",
+  },
+  {
+    name: "Result index",
+  },
+  {
+    name: "Inexact",
+    default: true,
+  },
+];
+
+/**
+ * unified VLOOKUP/HLOOKUP. ordinarily we'd call it XLOOKUP but that's taken.
+ * FIXME: can't use use that function for this? 
+ */
+const ZLookup = (value: any, table: any[][], col: number, inexact = true, transpose = false): UnionValue => {
+
+  if (transpose) {
+    table = Utils.TransposeArray(table);
+  }
+
+  col = Math.max(0, col - 1);
+
+  // inexact is the default. this assumes that the data is sorted,
+  // either numerically or alphabetically. it returns the closest
+  // value without going over -- meaning walk the list, and when
+  // you're over return the _previous_ item. except if there's an
+  // exact match, I guess, in that case return the exact match.
+  
+  // FIXME: there's a hint in the docs for XLOOKUP that this might
+  // be using a binary search. not sure why, but that might be 
+  // correct.
+
+  if (inexact) {
+
+    let result: any = table[col][0];
+
+    if (typeof value === 'number') {
+
+      let compare = Number(table[0][0]);
+      if (isNaN(compare) || compare > value) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = Number(table[0][i]);
+        if (isNaN(compare) || compare > value) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+    else {
+
+      value = value.toLowerCase(); // ?
+      let compare: string = (table[0][0] || '').toString().toLowerCase();
+      if (compare.localeCompare(value) > 0) {
+        return NAError();
+      }
+
+      for (let i = 1; i < table[0].length; i++) {
+        compare = (table[0][i] || '').toString().toLowerCase();
+        if (compare.localeCompare(value) > 0) {
+          break;
+        }
+        result = table[col][i];
+
+      }
+
+    }
+
+    return Box(result);
+
+  }
+  else {
+    for (let i = 0; i < table[0].length; i++) {
+      if (table[0][i] == value) { // ==
+        return Box(table[col][i]);
+      }
+    }
+    return NAError();
+  }
+
+};
+
 /**
  * alternate functions. these are used (atm) only for changing complex 
  * behavior.
@@ -803,90 +895,275 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
     */
    
-    /**
-     * FIXME: does not implement inexact matching (what's the algo for
-     * that, anyway? nearest? price is right style? what about ties?)
+    /*
+     * unsaid anywhere (that I can locate) aboud XLOOKUP is that lookup 
+     * array must be one-dimensional. it can be either a row or a column,
+     * but one dimension must be one. that simplifies things quite a bit.
+     * 
+     * there's a note in the docs about binary search over the data -- 
+     * that might explain how inexact VLOOKUP works as well. seems an odd
+     * choice but maybe back in the day it made sense
      */
-    VLookup: {
-
+    XLOOKUP: {
       arguments: [
-        {
-          name: "Lookup value",
-        },
-        {
-          name: "Table",
-        },
-        {
-          name: "Result index",
-        },
-        {
-          name: "Inexact",
-          default: true,
-        },
+        { name: 'Lookup value', },
+        { name: 'Lookup array',  },
+        { name: 'Return array',  },
+        { name: 'Not found', boxed: true },
+        { name: 'Match mode', default: 0, },
+        { name: 'Search mode', default: 1, },
       ],
+      xlfn: true,
+      fn: (
+          lookup_value: any, 
+          lookup_array: any[][], 
+          return_array: any[][],
+          not_found?: UnionValue,
+          match_mode = 0,
+          search_mode = 1,
+          ): UnionValue => {
+
+        // FIXME: we could I suppose be more graceful about single values
+        // if passed instead of arrays
+        
+        if (!Array.isArray(lookup_array)) {
+          console.info("lookup is not an array");
+          return ValueError();
+        }
 
-      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        const first = lookup_array[0];
+        if (!Array.isArray(first)) {
+          console.info("lookip is not a 2d array");
+          return ValueError();
+        }
 
-        col = Math.max(0, col - 1);
+        if (lookup_array.length !== 1 && first.length !== 1) {
+          console.info("lookup array has invalid dimensions");
+          return ValueError();
+        }
 
-        // inexact is the default. this assumes that the data is sorted,
-        // either numerically or alphabetically. it returns the closest
-        // value without going over -- meaning walk the list, and when
-        // you're over return the _previous_ item. except if there's an
-        // exact match, I guess, in that case return the exact match.
-        
-        if (inexact) {
+        // FIXME: is it required that the return array be (at least) the 
+        // same size? we can return undefineds, but maybe we should error
+
+        if (!Array.isArray(return_array)) {
+          console.info("return array is not an array");
+          return ValueError();
+        }
 
-          let result: any = table[col][0];
+        let transpose = (lookup_array.length === 1);
+        if (transpose) {
+          lookup_array = Utils.TransposeArray(lookup_array);
+          return_array = Utils.TransposeArray(return_array);
+        }
 
-          if (typeof value === 'number') {
+        // maybe reverse...
 
-            let compare = Number(table[0][0]);
-            if (isNaN(compare) || compare > value) {
-              return NAError();
-            }
+        if (search_mode < 0) {
+          lookup_array.reverse();
+          return_array.reverse();
+        }
+
+        //
+        // return value at index, transpose if necessary, and return
+        // an array. we might prefer to return a scalar if there's only 
+        // one value, not sure what's the intended behavior
+        // 
+        const ReturnIndex = (index: number): UnionValue => {
 
-            for (let i = 1; i < table[0].length; i++) {
-              compare = Number(table[0][i]);
-              if (isNaN(compare) || compare > value) {
-                break;
+          const values = return_array[index];
+
+          if (!values) {
+            return { type: ValueType.undefined };
+          }
+          
+          if (!Array.isArray(values)) {
+            return Box(values);
+          }
+
+          let boxes = [values.map(value => Box(value))];
+          
+          if (transpose) {
+            boxes = Utils.TransposeArray(boxes);
+          }
+
+          return {
+            type: ValueType.array,
+            value: boxes,
+          }
+
+        };
+      
+        // if value is not a string, then we can ignore wildcards.
+        // in that case convert to exact match.
+
+        if (match_mode === 2 && typeof lookup_value !== 'string') {
+          match_mode = 0;
+        }
+
+        // what does inexact matching mean in this case if the lookup
+        // value is a string or boolean? (...)
+
+        if ((match_mode === 1 || match_mode === -1) && typeof lookup_value === 'number') {
+
+          let min_delta = 0;
+          let index = -1;
+
+          for (let i = 0; i < lookup_array.length; i++) {
+            const value = lookup_array[i][0];
+           
+
+            if (typeof value === 'number') {
+
+              // check for exact match first, just in case
+              if (value === lookup_value) {
+                return ReturnIndex(i); 
+              }
+
+              const delta = Math.abs(value - lookup_value);
+
+              if ((match_mode === 1 && value > lookup_value) || (match_mode === -1 && value < lookup_value)){
+                if (index < 0 || delta < min_delta) {
+                  min_delta = delta;
+                  index = i;
+                }
               }
-              result = table[col][i];
 
             }
+          }
 
+          if (index >= 0) {
+            return ReturnIndex(index);
           }
-          else {
 
-            value = value.toLowerCase(); // ?
-            let compare: string = (table[0][0] || '').toString().toLowerCase();
-            if (compare.localeCompare(value) > 0) {
-              return NAError();
-            }
+        }
+        
+        switch (match_mode) {
+
+          case 2:
+            {
+              // wildcard string match. we only handle strings for 
+              // this case (see above).
+
+              const pattern = Utils.ParseWildcards(lookup_value);
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
 
-            for (let i = 1; i < table[0].length; i++) {
-              compare = (table[0][i] || '').toString().toLowerCase();
-              if (compare.localeCompare(value) > 0) {
-                break;
+              for (let i = 0; i < lookup_array.length; i++) {
+                let value = lookup_array[i][0];
+                if (typeof value === 'string' && regex.exec(value)) {
+                  return ReturnIndex(i);
+                }
               }
-              result = table[col][i];
 
             }
+            break;
 
-          }
+          case 0:
+            if (typeof lookup_value === 'string') {
+              lookup_value = lookup_value.toLowerCase();
+            }
+            for (let i = 0; i < lookup_array.length; i++) {
+              let value = lookup_array[i][0];
+ 
+              if (typeof value === 'string') {
+                value = value.toLowerCase();
+              }
+              if (value === lookup_value) {
+                return ReturnIndex(i);
+              }
+            }
 
-          return Box(result);
+            break;
+        }
+
+        /*
+        const flat_lookup = Utils.FlattenUnboxed(lookup_array);
+        const flat_return = Utils.FlattenUnboxed(return_array);
 
+        // maybe reverse... 
+
+        if (search_mode < 0) {
+          flat_lookup.reverse();
+          flat_return.reverse();
         }
-        else {
-          for (let i = 0; i < table[0].length; i++) {
-            if (table[0][i] == value) { // ==
-              return Box(table[col][i]);
+
+        // if value is not a string, then we can ignore wildcards.
+        // in that case convert to exact match.
+
+        if (match_mode === 2 && typeof lookup_value !== 'string') {
+          match_mode = 0;
+        }
+
+        switch (match_mode) {
+          case 2:
+
+            {
+
+              // wildcard string match. we only handle strings
+              // for wildcard matching (handled above).
+
+              const pattern = Utils.ParseWildcards(lookup_value);
+              const regex = new RegExp('^' + pattern + '$', 'i'); //.exec(lookup_value);
+
+              for (let i = 0; i < flat_lookup.length; i++) {
+                let value = flat_lookup[i];
+                if (typeof value === 'string' && regex.exec(value)) {
+                  return Box(flat_return[i]);
+                }
+              }
+ 
+
             }
-          }
-          return NAError();
+
+            break;
+
+          case 0: 
+          
+            // return exact match or NA/default. in this case
+            // "exact" means icase (but not wildcard)
+
+            if (typeof lookup_value === 'string') {
+              lookup_value = lookup_value.toLowerCase();
+            }
+            for (let i = 0; i < flat_lookup.length; i++) {
+              let value = flat_lookup[i];
+              if (typeof value === 'string') {
+                value = value.toLowerCase();
+              }
+              if (value === lookup_value) {
+                return Box(flat_return[i]);
+              }
+            }
+
+            break;
         }
+        */
+
+        // FIXME: if we're expecting to return an array maybe we should
+        // pack it up as an array? if it's not already an array? (...)
+
+        return (not_found && not_found.type !== ValueType.undefined) ? not_found : NAError();
+
+      },
+    },
 
+    /**
+     * copied from HLOOKUP, fix that one first
+     */
+    HLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, true);
+      },
+    },
+
+    /**
+     * FIXME: does not implement inexact matching (what's the algo for
+     * that, anyway? nearest? price is right style? what about ties?)
+     */
+    VLookup: {
+      arguments: [...zlookup_arguments],
+      fn: (value: any, table: any[][], col: number, inexact = true): UnionValue => {
+        return ZLookup(value, table, col, inexact, false);
       },
     },
 

package/treb-embed/markup/layout.html

@@ -38,7 +38,7 @@
         <div data-bind='message' class='treb-embed-dialog-message'></div>
         <div data-bind='about' class='treb-embed-dialog-body'></div>
       </div>
-      <button type='button' title='Close dialog' data-bind='close' class='treb-close-box'>
+      <button type='button' data-title='close_dialog' data-bind='close' class='treb-close-box'>
         <svg viewBox='0 0 16 16'>
           <path d='M11.854 4.146a.5.5 0 0 1 0 .708l-7 7a.5.5 0 0 1-.708-.708l7-7a.5.5 0 0 1 .708 0z'/>
           <path d='M4.146 4.146a.5.5 0 0 0 0 .708l7 7a.5.5 0 0 0 .708-.708l-7-7a.5.5 0 0 0-.708 0z'/>
@@ -62,6 +62,9 @@
 
         <div class="treb-formula-bar notranslate" hidden>
           <div class="treb-address-label"><div></div></div>
+          <button class="treb-insert-function-button"
+                  data-title="insert_function" 
+                  data-conditional="insert-function">𝑓<small>(x)</small></button>
           <div class="treb-editor-container">
             <div contenteditable="true"></div>
           </div>
@@ -95,7 +98,7 @@
           -->
   
           <!-- converted to button, more appropriate -->
-          <button class="treb-delete-tab" title="Delete current sheet" data-command="delete-tab" data-conditional="delete-tab">
+          <button class="treb-delete-tab" data-title="delete_sheet" data-command="delete-tab" data-conditional="delete-tab">
             <svg tabindex="-1" viewbox='0 0 16 16'><path d='M4,4 L12,12 M12,4 L4,12'/></svg>
           </button>
   
@@ -105,7 +108,8 @@
           </div>
 
           <!-- converted to button, more appropriate -->
-          <button class="treb-add-tab" data-command="add-tab" data-conditional="add-tab" title="Add sheet">+</button>
+          <button class="treb-add-tab" data-command="add-tab" data-conditional="add-tab" 
+                  data-title="add_sheet">+</button>
   
           <!-- 
             we removed the junk node with "flex grow" to split the layout, in
@@ -125,7 +129,8 @@
         
         <div class="treb-revert-indicator" 
               data-command="revert-indicator"
-              title="This document has been modified from the original version."></div>
+              data-title="document_modified"
+              ></div>
 
       </div> <!-- /treb-view -->
     </template>
@@ -133,13 +138,13 @@
   </div>
 
   <div class="treb-layout-sidebar treb-animate">
-    <button data-command="recalculate" title="Recalculate"></button>
-    <button data-command="toggle-toolbar" data-conditional="toolbar" title="Toggle toolbar"></button>
-    <button data-command="export-xlsx" data-conditional="export" title="Export as XLSX"></button>
-    <button data-command="revert" data-conditional="revert" title="Revert to original version"></button>
-    <button data-command="about" title="What's this?"></button>
+    <button data-command="recalculate" data-title="recalculate"></button>
+    <button data-command="toggle-toolbar" data-conditional="toolbar" data-title="toggle_toolbar"></button>
+    <button data-command="export-xlsx" data-conditional="export" data-title="export"></button>
+    <button data-command="revert" data-conditional="revert" data-title="revert"></button>
+    <button data-command="about" data-title="about"></button>
   </div>
 
-  <button class="treb-toggle-sidebar-button" title="Toggle sidebar"></button>
+  <button class="treb-toggle-sidebar-button" data-title="toggle_sidebar"></button>
 
 </div>

package/treb-embed/markup/toolbar.html

@@ -49,12 +49,12 @@
 
   <div class="group">
     <button data-command="wrap-text" title="Wrap text"></button>
-    <button data-command="merge-cells" data-id="merge" data-title="Merge cells" data-active-title="Unmerge cells"></button>
-    <button data-command="lock-cells" data-title="Lock cells" data-active-title="Unlock cells"></button>
-    <button data-command="freeze-panes" data-title="Freeze panes" data-active-title="Unfreeze panes" freeze-button></button>
-    <button data-command="insert-table" data-icon="table" data-title="Insert table" data-active-title="Remove table" table-button></button>
+    <button data-command="merge-cells" data-id="merge" data-inactive-title="Merge cells" data-active-title="Unmerge cells"></button>
+    <button data-command="lock-cells" data-inactive-title="Lock cells" data-active-title="Unlock cells"></button>
+    <button data-command="freeze-panes" data-inactive-title="Freeze panes" data-active-title="Unfreeze panes" freeze-button></button>
+    <button data-command="insert-table" data-icon="table" data-inactive-title="Insert table" data-active-title="Remove table" table-button></button>
     <div class="treb-menu">
-      <button data-icon="comment" data-title="Comment" data-active-title="Update comment"></button>
+      <button data-icon="comment" data-inactive-title="Comment" data-active-title="Update comment"></button>
       <div class="treb-comment-box">
         <textarea></textarea>
         <div>