@borgar/fx 4.10.2 → 4.11.0

package/lib/parseStructRef.spec.js

@@ -0,0 +1,160 @@
+/* eslint-disable object-property-newline, object-curly-newline */
+import { test, Test } from 'tape';
+import { parseStructRef } from './parseStructRef.js';
+
+Test.prototype.isSREqual = function isSREqual (expr, expect, opts) {
+  if (expect) {
+    expect = opts?.xlsx
+      ? {
+        workbookName: '',
+        sheetName: '',
+        table: '',
+        columns: [],
+        sections: [],
+        ...expect
+      }
+      : {
+        context: [],
+        table: '',
+        columns: [],
+        sections: [],
+        ...expect
+      };
+  }
+  this.deepEqual(parseStructRef(expr, opts), expect, expr);
+};
+
+test('parse structured references', t => {
+  t.isSREqual('table[col]', {
+    table: 'table',
+    columns: [ 'col' ]
+  });
+
+  t.isSREqual('[#All]', {
+    sections: [ 'all' ]
+  });
+
+  t.isSREqual('[column name]', {
+    columns: [ 'column name' ]
+  });
+
+  t.isSREqual('[column name]!foo', null);
+  t.isSREqual('[foo]bar', null);
+
+  t.isSREqual('[[my column]]', {
+    columns: [ 'my column' ]
+  });
+
+  t.isSREqual('[[my column]:otherColumn]', {
+    columns: [ 'my column', 'otherColumn' ]
+  });
+
+  t.isSREqual('[ [my column]:otherColumn ]', {
+    columns: [ 'my column', 'otherColumn ' ]
+  });
+
+  t.isSREqual('[ [my column]: otherColumn ]', {
+    columns: [ 'my column', ' otherColumn ' ]
+  });
+
+  t.isSREqual('[ @[ my column ]: otherColumn ]', {
+    columns: [ ' my column ', ' otherColumn ' ],
+    sections: [ 'this row' ]
+  });
+
+  t.isSREqual('[[#Data], [my column]:otherColumn]', {
+    columns: [ 'my column', 'otherColumn' ],
+    sections: [ 'data' ]
+  });
+
+  t.isSREqual('[ [#Data], [my column]:[\'@foo] ]', {
+    columns: [ 'my column', '@foo' ],
+    sections: [ 'data' ]
+  });
+
+  t.isSREqual('workbook.xlsx!tableName[ [#Data], [my column]:[\'@foo] ]', {
+    columns: [ 'my column', '@foo' ],
+    sections: [ 'data' ],
+    table: 'tableName',
+    context: [ 'workbook.xlsx' ]
+  });
+
+  t.isSREqual('[[#Data],[#data],[#Data],[#Data],[#Totals],[#Totals],[#Totals],foo]', {
+    columns: [ 'foo' ],
+    sections: [ 'data', 'totals' ]
+  });
+
+  t.isSREqual("'Sheet'!Table[Column]", {
+    columns: [ 'Column' ],
+    table: 'Table',
+    context: [ 'Sheet' ]
+  });
+
+  t.isSREqual("Sheet1!Table1[foo '[bar']]", {
+    columns: [ 'foo [bar]' ],
+    table: 'Table1',
+    context: [ 'Sheet1' ]
+  });
+
+  t.isSREqual('[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]', {
+    columns: [],
+    table: 'TMP8w0habhr',
+    context: [ 'myworkbook.xlsx', 'Sheet1' ],
+    sections: [ 'all' ]
+  });
+
+  t.end();
+});
+
+test('structured references parse in xlsx mode', t => {
+  t.isSREqual('[Workbook.xlsx]!Table[#Data]', {
+    workbookName: 'Workbook.xlsx',
+    table: 'Table',
+    sections: [ 'data' ]
+  }, { xlsx: true });
+
+  t.isSREqual('[Workbook.xlsx]Sheet1!Table[#Data]', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    table: 'Table',
+    sections: [ 'data' ]
+  }, { xlsx: true });
+
+  t.isSREqual('Sheet1!Table[#Data]', {
+    sheetName: 'Sheet1',
+    table: 'Table',
+    sections: [ 'data' ]
+  }, { xlsx: true });
+
+  t.end();
+});
+
+test('longform prase (in xlsx mode)', t => {
+  // thisRow should have no effect when parsing
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: true, thisRow: true });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: true, thisRow: false });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: false, thisRow: true });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: false, thisRow: false });
+
+  t.end();
+});
+

package/lib/stringifyStructRef.js

@@ -0,0 +1,80 @@
+import { stringifyPrefix, stringifyPrefixAlt } from './stringifyPrefix.js';
+
+function quoteColname (str) {
+  return str.replace(/([[\]#'@])/g, '\'$1');
+}
+
+function needsBraces (str) {
+  return !/^[a-zA-Z0-9\u00a1-\uffff]+$/.test(str);
+}
+
+function toSentenceCase (str) {
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+
+/**
+ * Get a string representation of a structured reference object.
+ *
+ * ```js
+ * stringifyStructRef({
+ *   context: [ 'workbook.xlsx' ],
+ *   sections: [ 'data' ],
+ *   columns: [ 'my column', '@foo' ],
+ *   table: 'tableName',
+ * });
+ * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'
+ * ```
+ *
+ * @param {ReferenceStruct} refObject A structured reference object
+ * @param {object} [options={}]  Options
+ * @param {boolean} [options.xlsx=false]  Switches to the `[1]Sheet1!A1` or `[1]!name` prefix syntax form for external workbooks. See: [Prefixes.md](./Prefixes.md)
+ * @param {boolean} [options.thisRow=false]  Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.
+ * @returns {string} The structured reference in string format
+ */
+export function stringifyStructRef (refObject, options = {}) {
+  const { xlsx, thisRow } = options;
+  let s = xlsx
+    ? stringifyPrefixAlt(refObject)
+    : stringifyPrefix(refObject);
+
+  if (refObject.table) {
+    s += refObject.table;
+  }
+  const numColumns = refObject.columns?.length ?? 0;
+  const numSections = refObject.sections?.length ?? 0;
+  // single section
+  if (numSections === 1 && !numColumns) {
+    s += `[#${toSentenceCase(refObject.sections[0])}]`;
+  }
+  // single column
+  else if (!numSections && numColumns === 1) {
+    s += `[${quoteColname(refObject.columns[0])}]`;
+  }
+  else {
+    s += '[';
+    // single [#this row] sections get normalized to an @ by default
+    const singleAt = !thisRow && numSections === 1 && refObject.sections[0].toLowerCase() === 'this row';
+    if (singleAt) {
+      s += '@';
+    }
+    else if (numSections) {
+      s += refObject.sections
+        .map(d => `[#${toSentenceCase(d)}]`)
+        .join(',');
+      if (numColumns) {
+        s += ',';
+      }
+    }
+    // a case of a single alphanumberic column with a [#this row] becomes [@col]
+    if (singleAt && refObject.columns.length === 1 && !needsBraces(refObject.columns[0])) {
+      s += quoteColname(refObject.columns[0]);
+    }
+    else if (numColumns) {
+      s += refObject.columns.slice(0, 2)
+        .map(d => (`[${quoteColname(d)}]`))
+        .join(':');
+    }
+    s += ']';
+  }
+  return s;
+}

package/lib/{sr.spec.js → stringifyStructRef.spec.js}

@@ -1,110 +1,6 @@
 /* eslint-disable object-property-newline, object-curly-newline */
-import { test, Test } from 'tape';
-import { parseStructRef, stringifyStructRef } from './sr.js';
-
-Test.prototype.isSREqual = function isSREqual (expr, expect, opts) {
-  if (expect) {
-    expect = opts?.xlsx
-      ? {
-        workbookName: '',
-        sheetName: '',
-        table: '',
-        columns: [],
-        sections: [],
-        ...expect
-      }
-      : {
-        context: [],
-        table: '',
-        columns: [],
-        sections: [],
-        ...expect
-      };
-  }
-  this.deepEqual(parseStructRef(expr, opts), expect, expr);
-};
-
-test('parse structured references', t => {
-  t.isSREqual('table[col]', {
-    table: 'table',
-    columns: [ 'col' ]
-  });
-
-  t.isSREqual('[#All]', {
-    sections: [ 'all' ]
-  });
-
-  t.isSREqual('[column name]', {
-    columns: [ 'column name' ]
-  });
-
-  t.isSREqual('[column name]!foo', null);
-  t.isSREqual('[foo]bar', null);
-
-  t.isSREqual('[[my column]]', {
-    columns: [ 'my column' ]
-  });
-
-  t.isSREqual('[[my column]:otherColumn]', {
-    columns: [ 'my column', 'otherColumn' ]
-  });
-
-  t.isSREqual('[ [my column]:otherColumn ]', {
-    columns: [ 'my column', 'otherColumn ' ]
-  });
-
-  t.isSREqual('[ [my column]: otherColumn ]', {
-    columns: [ 'my column', ' otherColumn ' ]
-  });
-
-  t.isSREqual('[ @[ my column ]: otherColumn ]', {
-    columns: [ ' my column ', ' otherColumn ' ],
-    sections: [ 'this row' ]
-  });
-
-  t.isSREqual('[[#Data], [my column]:otherColumn]', {
-    columns: [ 'my column', 'otherColumn' ],
-    sections: [ 'data' ]
-  });
-
-  t.isSREqual('[ [#Data], [my column]:[\'@foo] ]', {
-    columns: [ 'my column', '@foo' ],
-    sections: [ 'data' ]
-  });
-
-  t.isSREqual('workbook.xlsx!tableName[ [#Data], [my column]:[\'@foo] ]', {
-    columns: [ 'my column', '@foo' ],
-    sections: [ 'data' ],
-    table: 'tableName',
-    context: [ 'workbook.xlsx' ]
-  });
-
-  t.isSREqual('[[#Data],[#data],[#Data],[#Data],[#Totals],[#Totals],[#Totals],foo]', {
-    columns: [ 'foo' ],
-    sections: [ 'data', 'totals' ]
-  });
-
-  t.isSREqual("'Sheet'!Table[Column]", {
-    columns: [ 'Column' ],
-    table: 'Table',
-    context: [ 'Sheet' ]
-  });
-
-  t.isSREqual("Sheet1!Table1[foo '[bar']]", {
-    columns: [ 'foo [bar]' ],
-    table: 'Table1',
-    context: [ 'Sheet1' ]
-  });
-
-  t.isSREqual('[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]', {
-    columns: [],
-    table: 'TMP8w0habhr',
-    context: [ 'myworkbook.xlsx', 'Sheet1' ],
-    sections: [ 'all' ]
-  });
-
-  t.end();
-});
+import { test } from 'tape';
+import { stringifyStructRef } from './stringifyStructRef.js';
 
 test('serialize structured references', t => {
   t.is(
@@ -213,26 +109,7 @@ test('serialize structured references', t => {
   t.end();
 });
 
-test('structured references parse and serialize in xlsx mode', t => {
-  t.isSREqual('[Workbook.xlsx]!Table[#Data]', {
-    workbookName: 'Workbook.xlsx',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
-  t.isSREqual('[Workbook.xlsx]Sheet1!Table[#Data]', {
-    workbookName: 'Workbook.xlsx',
-    sheetName: 'Sheet1',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
-  t.isSREqual('Sheet1!Table[#Data]', {
-    sheetName: 'Sheet1',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
+test('structured references serialize in xlsx mode', t => {
   t.is(
     stringifyStructRef({
       context: [ 'Lorem', 'Ipsum' ],
@@ -279,31 +156,6 @@ test('structured references parse and serialize in xlsx mode', t => {
 });
 
 test('longform serialize (in xlsx mode)', t => {
-  // thisRow should have no effect when parsing
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: true, thisRow: true });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: true, thisRow: false });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: false, thisRow: true });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: false, thisRow: false });
-
   // thisRow should mean we don't see @'s in output
   t.is(
     stringifyStructRef({

package/lib/toCol.js

@@ -0,0 +1,23 @@
+const charFrom = String.fromCharCode;
+
+/**
+ * Convert a 0 based offset number to a column string
+ * representation (`2` = `"C"`).
+ *
+ * The method expects a number between 0 and 16383. Other input will
+ * return garbage.
+ *
+ * @param {number} columnIndex Zero based column index number
+ * @returns {string} The column string identifier
+ */
+export function toCol (columnIndex) {
+  return (
+    (columnIndex >= 702
+      ? charFrom(((((columnIndex - 702) / 676) - 0) % 26) + 65)
+      : '') +
+    (columnIndex >= 26
+      ? charFrom(((((columnIndex / 26) - 1) % 26) + 65))
+      : '') +
+    charFrom((columnIndex % 26) + 65)
+  );
+}

package/lib/toCol.spec.js

@@ -0,0 +1,11 @@
+import { test } from 'tape';
+import { toCol } from './toCol.js';
+
+// What happens when B2:A1 -> should work!
+test('toCol converts integers to column ids', t => {
+  t.is(toCol(0), 'A');
+  t.is(toCol(26), 'AA');
+  t.is(toCol(701), 'ZZ');
+  t.is(toCol(18277), 'ZZZ');
+  t.end();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgar/fx",
-  "version": "4.10.2",
+  "version": "4.11.0",
   "description": "Utilities for working with Excel formulas",
   "main": "dist/fx.js",
   "types": "dist/fx.d.ts",
@@ -48,12 +48,12 @@
     "@borgar/eslint-config": "~3.1.0",
     "@borgar/jsdoc-tsmd": "~0.2.1",
     "@rollup/plugin-babel": "~6.0.4",
+    "@rollup/plugin-terser": "~0.4.4",
     "babel-eslint": "~10.1.0",
     "eslint": "~8.56.0",
     "eslint-plugin-jsdoc": "~48.1.0",
     "jsdoc": "~4.0.2",
     "rollup": "~4.12.0",
-    "rollup-plugin-minification": "~0.2.0",
     "tap-min": "~3.0.0",
     "tape": "~5.7.5",
     "typescript": "~5.3.3"

package/rollup.config.mjs

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import babel from '@rollup/plugin-babel';
-import { terser } from 'rollup-plugin-minification';
+import terser from '@rollup/plugin-terser';
 
-const pkg = JSON.parse(fs.readFileSync('./package.json'));
+const pkg = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
 const isProd = process.env.NODE_ENV === 'production';
 
 export default {
@@ -11,12 +11,12 @@ export default {
     babel({
       babelHelpers: 'bundled',
       presets: [ '@babel/preset-env' ]
-    })
+    }),
+    isProd ? terser({ maxWorkers: 4 }) : null
   ],
   output: {
     file: pkg.main,
     format: 'cjs',
-    sourcemap: 'inline',
-    plugins: [ isProd && terser() ]
+    sourcemap: 'inline'
   }
 };