@trebco/treb 29.7.5 → 29.8.3

package/dist/treb.d.ts

@@ -1,4 +1,4 @@
-/*! API v29.7. Copyright 2018-2024 trebco, llc. All rights reserved. LGPL: https://treb.app/license */
+/*! API v29.8. 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.7.5",
+  "version": "29.8.3",
   "license": "LGPL-3.0-or-later",
   "homepage": "https://treb.app",
   "repository": {

package/treb-calculator/src/calculator.ts

@@ -43,6 +43,7 @@ import { InformationFunctionLibrary } from './functions/information-functions';
 import { StatisticsFunctionLibrary, StatisticsFunctionAliases } from './functions/statistics-functions';
 import { ComplexFunctionLibrary } from './functions/complex-functions';
 import { MatrixFunctionLibrary } from './functions/matrix-functions';
+import { RegexFunctionLibrary } from './functions/regex-functions';
 
 import { Variance } from './functions/statistics-functions';
 
@@ -222,7 +223,7 @@ export class Calculator extends Graph {
       InformationFunctionLibrary, // etc
       ComplexFunctionLibrary,
       MatrixFunctionLibrary,
-
+      RegexFunctionLibrary,
       );
    
     // aliases

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

@@ -923,6 +923,91 @@ export const BaseFunctionLibrary: FunctionMap = {
 
     },
 
+    /**
+     * 
+     */
+    Filter: {
+      description: "Filter an array using a second array.",
+      arguments: [
+        { name: 'source', description: 'Source array' },
+        { name: 'filter', description: 'Filter array' },
+        // if_empty
+      ],
+
+      fn: (source: CellValue|CellValue[][], filter: CellValue|CellValue[][]) => {
+
+        if (typeof source === 'undefined' || typeof filter === 'undefined') {
+          return ArgumentError();
+        }
+
+        if (!Array.isArray(source)) {
+          source = [[source]];
+        }
+        if (!Array.isArray(filter)) {
+          filter = [[filter]];
+        }
+
+        const source_cols = source.length;
+        const source_rows = source[0].length;
+
+        const filter_cols = filter.length;
+        const filter_rows = filter[0].length;
+
+        // prefer rows
+
+        if (source_rows === filter_rows) {
+
+          const result: UnionValue[][] = [];
+
+          for (let i = 0; i < source_cols; i++) {
+            result.push([]);
+          }
+
+          for (const [index, entry] of filter[0].entries()) {
+
+            // FIXME: don't allow strings? errors? (...)
+
+            if (entry) {
+              for (let i = 0; i < source_cols; i++) {
+                result[i].push(Box(source[i][index]));
+              }
+            }
+ 
+          }
+          
+          return {
+            type: ValueType.array,
+            value: result,
+          }
+
+        }
+        else if (source_cols === filter_cols) {
+
+          const result: UnionValue[][] = [];
+
+          for (const [index, [entry]] of filter.entries()) {
+
+            // FIXME: don't allow strings? errors? (...)
+
+            if (entry) {
+              result.push(source[index].map(value => Box(value)));
+            }
+ 
+          }
+          
+          return {
+            type: ValueType.array,
+            value: result,
+          }
+
+        }
+
+        return ArgumentError();
+
+      },
+
+    },
+
     /**
      * sort arguments, but ensure we return empty strings to
      * fill up the result array

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

@@ -0,0 +1,205 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2024 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import type { FunctionMap } from '../descriptors';
+import { ValueType } from 'treb-base-types';
+import { ArgumentError } from '../function-error';
+
+export const RegexFunctionLibrary: FunctionMap = {
+
+  RegexExtract: {
+    description: 'Extract text using a regular expression',
+    arguments: [
+      {
+        name: 'text',
+        unroll: true,
+      },
+      {
+        name: 'pattern',
+        unroll: true,
+      },
+      {
+        name: 'return mode',
+        unroll: true,
+        default: 0,
+        
+      },
+      {
+        name: 'case insensitive',
+        unroll: true,
+        default: false,
+
+      }
+    ],
+    fn: (text: string, pattern: string, return_mode = 0, icase = false) => {
+
+      const args: string[] = [];
+      if (icase) {
+        args.push('i');
+      }
+      if (return_mode === 1) {
+        args.push('g');
+      }
+
+      const rex = new RegExp(pattern, args.length ? args.join('') : undefined);
+
+      switch (return_mode) {
+        case 0:
+          {
+            const result = text.match(rex);
+            return {
+              type: ValueType.string,
+              value: (result === null) ? '' : result[0] ?? '',
+            }
+          }
+
+        case 1:
+          {
+            const result = Array.from(text.matchAll(rex));
+            console.info({result});
+
+            return {
+              type: ValueType.array,
+              value: [result.map(entry => ({
+                type: ValueType.string,
+                value: entry[0] || '',
+              }))],
+            }
+          }
+        case 2:
+          {
+            const result = text.match(rex);
+            if (result === null) {
+              return {
+                type: ValueType.string,
+                value: '',
+              };
+            }
+
+            const arr = Array.from(result).slice(1);
+            return {
+              type: ValueType.array,
+              value: [
+                arr.map(value => ({
+                  type: ValueType.string,
+                  value,
+                }))
+              ],
+            };
+          }
+
+        default:
+          return ArgumentError();
+      }
+
+    },
+  },
+
+  RegexReplace: {
+    arguments: [
+      {
+        name: 'text',
+        unroll: true,
+      },
+      {
+        name: 'pattern',
+        unroll: true,
+      },
+      {
+        name: 'replacement',
+        unroll: true,
+      },
+      {
+        name: 'occurrence',
+        unroll: true,
+        default: 0,
+      },
+      {
+        name: 'case insensitive',
+        unroll: true,
+        default: false,
+      }
+    ],
+    description: 'Replace text in a string using a regex',
+    fn: (text: string, pattern: string, replacement: string, occurrence = 0, icase = false) => {
+
+      const args: string[] = ['g'];
+      if (icase) {
+        args.push('i');
+      }
+
+      const rex = new RegExp(pattern, args.length ? args.join('') : undefined);
+      
+      if (occurrence === 0) {
+        return {
+          type: ValueType.string,
+          value: (text as any).replaceAll(rex, replacement), // huh?
+        };
+      }
+
+      if (occurrence < 0) {
+        const count = Array.from(text.matchAll(rex)).length;
+        occurrence += (count + 1);
+      }
+
+      const value = text.replace(rex, (match) => {
+        if (--occurrence === 0) {
+          return replacement;
+        }
+        return match;
+      });
+
+      return {
+        type: ValueType.string,
+        value,
+      };
+
+    },
+  },
+
+  RegexTest: {
+    arguments: [
+      {
+        name: 'text',
+        unroll: true,
+      },
+      {
+        name: 'pattern',
+        unroll: true,
+      },
+      {
+        name: 'case insensitive',
+        unroll: true,
+        default: false,
+
+      }
+    ],
+    description: 'Match text against a regular expression',
+    fn: (text: string, pattern: string, icase = false) => {
+      const rex = new RegExp(pattern, icase ? 'i' : undefined);
+      return { 
+        type: ValueType.boolean,
+        value: rex.test(text),
+      };
+    },
+  },
+
+};

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

@@ -6885,6 +6885,27 @@ export class Grid extends GridBase {
     else {
 
       const area = this.active_sheet.RealArea(this.primary_selection.area);
+
+      const column_width: number[] = [];
+      const row_height: number[] = [];
+
+      if (this.primary_selection.area.entire_column) {
+        for (let c = area.start.column; c <= area.end.column; c++) {
+          const width = this.active_sheet.GetColumnWidth(c);
+          if (width !== this.active_sheet.default_column_width) {
+            column_width[c - area.start.column] = width;
+          }
+        }
+      }
+      if (this.primary_selection.area.entire_row) {
+        for (let r = area.start.row; r <= area.end.row; r++) {
+          const height = this.active_sheet.GetRowHeight(r);
+          if (height !== this.active_sheet.default_row_height) {
+            row_height[r - area.start.row] = height;
+          }
+        }
+      }
+
       const columns = area.columns;
       const rows = area.rows;
 
@@ -6961,7 +6982,12 @@ export class Grid extends GridBase {
       if (event.clipboardData) {
         event.clipboardData.clearData();
         event.clipboardData.setData('text/plain', tsv);
-        event.clipboardData.setData('text/x-treb', JSON.stringify({ source: area, data: treb_data }));
+        event.clipboardData.setData('text/x-treb', JSON.stringify({ 
+          source: area, 
+          data: treb_data,
+          column_width, 
+          row_height,
+        }));
       }
     }
 
@@ -7114,7 +7140,14 @@ export class Grid extends GridBase {
     if (treb_data) {
 
       try {
-        const object_data = JSON.parse(treb_data);
+
+        const object_data: {
+          source: Area, 
+          data: ClipboardCellData[],
+          column_width?: number[], 
+          row_height?: number[],
+        } = JSON.parse(treb_data);
+
         const source_area = new Area(object_data.source.start, object_data.source.end);
 
         // recycle...
@@ -7220,6 +7253,32 @@ export class Grid extends GridBase {
 
           });
 
+          if (object_data.column_width?.length) {
+            for (const [index, width] of object_data.column_width.entries()) {
+              if (typeof width === 'number') {
+                const column = index + paste_area.start.column;
+                commands.push({
+                  key: CommandKey.ResizeColumns, 
+                  column, 
+                  width,
+                });
+              }
+            }
+          }
+
+          if (object_data.row_height?.length) {
+            for (const [index, height] of object_data.row_height.entries()) {
+              if (typeof height === 'number') {
+                const row = index + paste_area.start.row;
+                commands.push({
+                  key: CommandKey.ResizeRows,
+                  row,
+                  height,
+                });
+              }
+            }
+          }
+          
         }
 
       }

package/tsproject.json

@@ -18,7 +18,7 @@
     "noEmitHelpers": true,
     "verbatimModuleSyntax": true,
     "lib": [
-      "dom", "es2015"
+      "dom", "ESNext"
     ],
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true