@trebco/treb 27.7.6 → 27.11.1

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

@@ -21,10 +21,10 @@
 
 import type { FunctionMap } from '../descriptors';
 import * as Utils from '../utilities';
-import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError } from '../function-error';
+import { ReferenceError, NotImplError, NAError, ArgumentError, DivideByZeroError, ValueError, NameError } from '../function-error';
 import type { UnionValue, 
          RenderFunctionResult, RenderFunctionOptions, Complex } from 'treb-base-types';
-import { Box, ValueType, GetValueType, ComplexOrReal } from 'treb-base-types';
+import { Box, ValueType, GetValueType, ComplexOrReal, IsComplex } from 'treb-base-types';
 import { Sparkline } from './sparkline';
 import { LotusDate, UnlotusDate } from 'treb-format';
 
@@ -427,7 +427,7 @@ export const BaseFunctionLibrary: FunctionMap = {
       description: 'Counts cells that contain numbers',
       fn: (...args: unknown[]): UnionValue => {
         return Box(Utils.FlattenUnboxed(args).reduce((a: number, b: unknown) => {
-          if (typeof b === 'number') return a + 1;
+          if (typeof b === 'number' || IsComplex(b)) return a + 1;
           return a;
         }, 0));
       },
@@ -456,7 +456,7 @@ export const BaseFunctionLibrary: FunctionMap = {
     },
 
     Not: {
-      fn: (...args: unknown[]): UnionValue => {
+      fn: Utils.ApplyAsArray((...args: unknown[]): UnionValue => {
         if (args.length === 0) {
           return ArgumentError();
         }
@@ -464,7 +464,7 @@ export const BaseFunctionLibrary: FunctionMap = {
           return Box(!args[0]);
         }
         return Box(true);
-      }
+      })
     },
 
     If: {
@@ -1126,6 +1126,167 @@ export const BaseFunctionLibrary: FunctionMap = {
       fn: (...args: unknown[]): UnionValue => {
         return { type: ValueType.object, value: args, key: 'sparkline-data' };
       },
+    },
+
+    UniqueValues: {
+      arguments: [
+        { name: 'range', boxed: true },
+      ],
+      visibility: 'internal',
+      fn: (area: UnionValue): UnionValue => {
+
+        if (area.type === ValueType.array) {
+
+          const cols = area.value.length;
+          const rows = area.value[0]?.length;
+
+          // how is uniqueness defined in this context? (...)
+
+          const Normalize = (cell?: UnionValue): string|number|boolean => {
+
+            if (!cell) {
+              return '';
+            }
+            else switch (cell.type) {
+            case ValueType.string:
+            case ValueType.number:
+            case ValueType.boolean:
+              return cell.value;
+
+            case ValueType.undefined:
+              return '';
+
+            default:
+              console.info("check", cell, cell.value)
+              return cell.value?.toString() || '';
+            }
+
+          };
+
+          const set: Set<number|string|boolean> = new Set();
+          const duplicates: Set<number|string|boolean> = new Set();
+
+          for (const column of area.value) {
+            for (const cell of column) {
+              const normalized = Normalize(cell);
+              if (set.has(normalized)) {
+                duplicates.add(normalized);
+              }
+              else {
+                set.add(normalized);
+              }
+            }
+          }
+
+          const result: UnionValue[][] = [];
+          for (const column of area.value) {
+            const column_result: UnionValue[] = [];
+            for (const cell of column) {
+              const value = Normalize(cell);
+              column_result.push({
+                type: ValueType.boolean,
+                value: !duplicates.has(value),
+              });
+            }
+            result.push(column_result);
+          }
+
+          return {
+            type: ValueType.array,
+            value: result,
+          };
+
+        }
+
+        // if it's not an array, by definition it's unique
+
+        return {
+          type: ValueType.boolean,
+          value: true,
+        }
+
+      },
+    },
+
+    Gradient: {
+      arguments: [
+        { name: 'range', boxed: true },
+        { name: 'min', },
+        { name: 'max', },
+      ],
+      visibility: 'internal',
+      fn: (area: UnionValue, static_min?: number, static_max?: number): UnionValue => {
+
+        const tmp = Utils.FlattenBoxed([area]);
+
+        let sum = 0;
+        let count = 0;
+        let min = 0; 
+        let max = 0;
+
+        for (const ref of tmp as UnionValue[]) {
+          if (ref.type === ValueType.error) {
+            return ref;
+          }
+          if (ref.type === ValueType.number) {
+            if (count === 0) {
+              min = ref.value;
+              max = ref.value;
+            }
+            else {
+              min = Math.min(min, ref.value);
+              max = Math.max(max, ref.value);
+            }
+            count++;
+          }
+        }
+
+        if (typeof static_max === 'number') {
+          max = static_max;
+        }
+        if (typeof static_min === 'number') {
+          min = static_min;
+        }
+
+        let range = max - min;
+
+        let rows = 1;
+        let columns = 1;
+
+        if (area.type === ValueType.array) {
+
+          rows = area.value.length;
+          columns = area.value[0]?.length || 0;
+
+          const result: UnionValue[][] = [];
+          for (let r = 0; r < rows; r++) {
+            const row: UnionValue[] = [];
+            for (let c = 0; c < columns; c++) {
+              const src = area.value[r][c];
+              if (src.type === ValueType.number) {
+                let calc = 0;
+                if (range > 0) {
+                  calc = (src.value - min) / range;
+                }
+                row.push({ type: ValueType.number, value: calc });
+              }
+              else {
+                row.push({ type: ValueType.undefined });
+              }
+
+            }
+            result.push(row);
+          }
+  
+          return { type: ValueType.array, value: result };
+  
+
+        }
+        else {
+          return ArgumentError();
+        }
+  
+      },
     }
 
 };

package/treb-calculator/src/index.ts

@@ -19,9 +19,9 @@
  * 
  */
 
-export * from './calculator';
-// export * from './pack-results';
-
-// for annotations that have dependencies
-
-export {LeafVertex} from './dag/leaf_vertex';
+export * from './calculator';
+// export * from './pack-results';
+
+// for annotations that have dependencies
+
+export type { LeafVertex } from './dag/graph';

package/treb-calculator/src/notifier-types.ts

@@ -19,7 +19,7 @@
  * 
  */
 
-import type { LeafVertex } from './dag/leaf_vertex';
+import type { LeafVertex } from './dag/graph';
 import type { Area } from 'treb-base-types';
 
 export interface NotifierType {

package/treb-calculator/src/utilities.ts

@@ -180,10 +180,10 @@ export const UndefinedToEmptyString = (args: any[]): any[] => {
 export const ApplyArrayFunc = (base: (...args: any[]) => any) => {
   return (a: any) => {
     if (Array.isArray(a)) {
-      const tmp = [];
+      const tmp: any[] = [];
       const rows = a[0].length;
       for (let c = 0; c < a.length; c++) {
-        const col = [];
+        const col: any[] = [];
         for (let r = 0; r < rows; r++) col[r] = base(a[c][r]);
         tmp.push(col);
       }

package/treb-charts/src/util.ts

@@ -38,7 +38,7 @@ export class Util {
    * given a passed range, find the best scale range. count is just a
    * suggestion -- we try to get as close as possible.
    */
-  public static Scale(min: number, max: number, count = 6.5): RangeScale {
+  public static Scale(min: number, max: number, count = 6.5, limit_count?: boolean, discrete?: boolean): RangeScale {
 
     /*
     const range = max - min;
@@ -71,7 +71,7 @@ export class Util {
 
     return { scale, step, count, min, max };
     */
-    return Scale(min, max, count);
+    return Scale(min, max, count, limit_count, discrete);
     
   }
 

package/treb-embed/src/custom-element/global.d.ts

@@ -5,7 +5,9 @@
 declare global {
   interface HTMLElementTagNameMap {
     'treb-spreadsheet': HTMLElement & {
-      sheet: EmbeddedSpreadsheet|undefined;
+      instance: {
+        sheet: EmbeddedSpreadsheet | undefined;
+      } | undefined;
     };
   }
 }

package/treb-embed/src/custom-element/spreadsheet-constructor.ts

@@ -19,8 +19,11 @@ interface ElementOptions {
   classes: string|string[];
 }
 
-const Element = <T extends HTMLElement>(tag: string, parent?: HTMLElement|DocumentFragment, options: Partial<ElementOptions> = {}, attrs: Record<string, string> = {}): T => {
-  const element = document.createElement(tag) as T;
+/**
+ * FIXME: unify this with DOMUtils
+ */
+const Element = <K extends keyof HTMLElementTagNameMap>(tag: K, parent?: HTMLElement|DocumentFragment, options: Partial<ElementOptions> = {}, attrs: Record<string, string> = {}): HTMLElementTagNameMap[K] => {
+  const element = document.createElement(tag);
   if (options.classes) {
 
     // you can't use an array destructure in a ternary expression? TIL
@@ -105,21 +108,12 @@ export class SpreadsheetConstructor {
 
       const style_node = document.head.querySelector('style[treb-stylesheet]');
       if (!style_node) {
-        const style = document.createElement('style');
+        const style = Element('style');
         style.setAttribute('treb-stylesheet', '');
         style.textContent = css;
         document.head.prepend(style);
       }
 
-      /*
-      if (!SpreadsheetConstructor.stylesheets_attached) {
-        const style = document.createElement('style');
-        style.textContent = css;
-        document.head.prepend(style);
-        SpreadsheetConstructor.stylesheets_attached = true;
-      }
-      */
-
     }
 
   }
@@ -509,9 +503,9 @@ export class SpreadsheetConstructor {
 
         const resize_parent = root.querySelector('.treb-main') as HTMLElement; // was document.body
 
-        resizer = Element<HTMLDivElement>('div', resize_parent, { classes: 'treb-resize-rect' });
+        resizer = Element('div', resize_parent, { classes: 'treb-resize-rect' });
 
-        mask = Element<HTMLDivElement>('div', resize_parent, { 
+        mask = Element('div', resize_parent, { 
           classes: 'treb-resize-mask', 
           style: 'cursor: nw-resize;',
         });
@@ -724,7 +718,7 @@ export class SpreadsheetConstructor {
               }
 
             }
-            Element<HTMLButtonElement>('button', fragment, { style, title, data: { command: 'set-color', color: JSON.stringify(entry.color) } });
+            Element('button', fragment, { style, title, data: { command: 'set-color', color: JSON.stringify(entry.color) } });
           }
         }
 
@@ -733,7 +727,7 @@ export class SpreadsheetConstructor {
       this.swatch_lists.theme?.replaceChildren(fragment);
 
       fragment = document.createDocumentFragment();
-      Element<HTMLButtonElement>('button', fragment, { 
+      Element('button', fragment, { 
         classes: 'treb-default-color',
         title: 'Default color', 
         data: { command: 'set-color', color: JSON.stringify({}) },
@@ -748,7 +742,7 @@ export class SpreadsheetConstructor {
 
       for (const text of [...colors, ...additional_colors]) {
         const style = `background: ${text.toLowerCase()};`;
-        Element<HTMLButtonElement>('button', fragment, { style, title: text, data: { command: 'set-color', color: JSON.stringify({text: text.toLowerCase()})}});
+        Element('button', fragment, { style, title: text, data: { command: 'set-color', color: JSON.stringify({text: text.toLowerCase()})}});
       }
 
       this.swatch_lists.other?.replaceChildren(fragment);
@@ -777,7 +771,7 @@ export class SpreadsheetConstructor {
     }
 
     const Button = (format: string) => {
-      return Element<HTMLButtonElement>('button', undefined, {
+      return Element('button', undefined, {
         text: format, data: { format, command: 'number-format' },
       });
     };
@@ -785,7 +779,7 @@ export class SpreadsheetConstructor {
     const fragment = document.createDocumentFragment();
     fragment.append(...number_formats.map(format => Button(format)));
 
-    fragment.append(Element<HTMLDivElement>('div', undefined, {}, {separator: ''}));
+    fragment.append(Element('div', undefined, {}, {separator: ''}));
     fragment.append(...date_formats.map(format => Button(format)));
 
     format_menu.textContent = '';