@rowsncolumns/functions 14.0.29

package/dist/esm/formulas/selection-status.js

@@ -0,0 +1,39 @@
+import { isNil } from "@rowsncolumns/utils";
+export const SELECTION_STATUS = (_, arg) => {
+    let sum = 0;
+    let count = 0;
+    let numCount = 0;
+    let min;
+    let max;
+    if (Array.isArray(arg.value)) {
+        for (const row of arg.value) {
+            for (const value of row) {
+                if (typeof value === "number") {
+                    sum += value;
+                    numCount++;
+                    if (min === undefined || value < min) {
+                        min = value;
+                    }
+                    if (max === undefined || value > max) {
+                        max = value;
+                    }
+                }
+                if (!isNil(value)) {
+                    count++;
+                }
+            }
+        }
+    }
+    // [sum, count, average, min, max, numericalCount]
+    // `numericalCount` is the count of cells holding numbers — distinct
+    // from `count` which counts any non-empty cell. Matches Excel and
+    // Sheets status-bar semantics.
+    return [
+        numCount === 0 ? undefined : sum,
+        count,
+        numCount === 0 ? undefined : sum / numCount,
+        min,
+        max,
+        numCount,
+    ];
+};

package/dist/esm/formulas/sequence.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+import { FormulaResultArray } from "@rowsncolumns/fast-formula-parser";
+export declare const SEQUENCE: (_: FormulaParser, rows: FunctionArgument, columns: FunctionArgument, start: FunctionArgument | undefined, step: FunctionArgument | undefined) => FormulaResultArray;
+//# sourceMappingURL=sequence.d.ts.map

package/dist/esm/formulas/sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../../formulas/sequence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAEL,kBAAkB,EACnB,MAAM,mCAAmC,CAAC;AAG3C,eAAO,MAAM,QAAQ,GACnB,GAAG,aAAa,EAChB,MAAM,gBAAgB,EACtB,SAAS,gBAAgB,EACzB,OAAO,gBAAgB,GAAG,SAAS,EACnC,MAAM,gBAAgB,GAAG,SAAS,uBA8BnC,CAAC"}

package/dist/esm/formulas/sequence.js

@@ -0,0 +1,24 @@
+import { FormulaError, } from "@rowsncolumns/fast-formula-parser";
+import { isNil } from "@rowsncolumns/utils";
+export const SEQUENCE = (_, rows, columns, start, step) => {
+    if (!rows.value || typeof rows?.value !== "number") {
+        throw new FormulaError("#NUM!", "Function SEQUENCE parameter 1 should be greater than or equal to 1.");
+    }
+    if (!isNil(columns) && typeof columns?.value !== "number") {
+        throw new FormulaError("#NUM!", "Function SEQUENCE parameter 2 should be greater than or equal to 1.");
+    }
+    const rowValue = rows.value;
+    const columnValue = columns?.value ?? 1;
+    let startValue = start?.value ?? 1;
+    const stepValue = step?.value ?? 1;
+    const results = [];
+    for (let i = 0; i < rowValue; i++) {
+        const rows = [];
+        for (let j = 0; j < columnValue; j++) {
+            rows.push(startValue);
+            startValue += stepValue;
+        }
+        results.push(rows);
+    }
+    return results;
+};

package/dist/esm/formulas/server.d.ts

@@ -0,0 +1,22 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+export declare const IMPORTDATA: (_parser: FormulaParser, _url: FunctionArgument) => Promise<never>;
+export declare const functions: {
+    IMPORTDATA: (_parser: FormulaParser, _url: FunctionArgument) => Promise<never>;
+    ARRAYFORMULA: (_: FormulaParser, arg: FunctionArgument) => import("@rowsncolumns/fast-formula-parser").FormulaResult;
+    STARRATING: (_: FormulaParser, arg: FunctionArgument) => import("@rowsncolumns/fast-formula-parser").RecursiveFormula;
+    HYPERLINK: (_: FormulaParser, url: FunctionArgument, title?: FunctionArgument) => import("@rowsncolumns/common-types").HyperlinkResult | undefined;
+    REALTIME: (parser: FormulaParser, arg: FunctionArgument) => string;
+    CRYPTOPRICE: (parser: FormulaParser, arg: FunctionArgument) => Promise<number[][]>;
+    IMAGE: (_: FormulaParser, url: FunctionArgument) => import("@rowsncolumns/common-types").ImageResult;
+    SELECTION_STATUS: (_: FormulaParser, arg: FunctionArgument) => (number | undefined)[];
+    MULTIPLY: (_: FormulaParser, factor1: FunctionArgument, factor2: FunctionArgument) => number;
+    UNIQUE: (_: FormulaParser, range: FunctionArgument, byColumnArg?: FunctionArgument, exactlyOnceArg?: FunctionArgument) => import("@rowsncolumns/fast-formula-parser").FormulaResult;
+    SEQUENCE: (_: FormulaParser, rows: FunctionArgument, columns: FunctionArgument, start: FunctionArgument | undefined, step: FunctionArgument | undefined) => import("@rowsncolumns/fast-formula-parser").FormulaResultArray;
+    JOIN: (_: FormulaParser, delimiter: FunctionArgument, ...args: FunctionArgument[]) => string;
+    SPLIT: (_: FormulaParser, text: FunctionArgument, delimiter: FunctionArgument, splitByEach?: FunctionArgument, removeEmptyText?: FunctionArgument) => string[][];
+    DATASOURCE: (parser: FormulaParser, data: FunctionArgument, limit: FunctionArgument) => import("@rowsncolumns/calculator").DataSource | undefined;
+    FORMULATEXT: (parser: FormulaParser<import("@rowsncolumns/common-types").CellData>, arg: FunctionArgument) => string;
+    SPARKLINE: (parser: FormulaParser, dataArg: FunctionArgument, optionsArg: FunctionArgument) => import("@rowsncolumns/common-types").SparkLineResult | undefined;
+};
+//# sourceMappingURL=server.d.ts.map

package/dist/esm/formulas/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../formulas/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AAsBnE,eAAO,MAAM,UAAU,GACrB,SAAS,aAAa,EACtB,MAAM,gBAAgB,mBAMvB,CAAC;AAEF,eAAO,MAAM,SAAS;0BATX,aAAa,QAChB,gBAAgB;;;;;;;;;;;;;;;;CAyB+B,CAAC"}

package/dist/esm/formulas/server.js

@@ -0,0 +1,37 @@
+import { FormulaError, } from "@rowsncolumns/fast-formula-parser";
+import { ARRAYFORMULA } from "./array-formula";
+import { CRYPTOPRICE } from "./crypto-price";
+import { DATASOURCE } from "./datasource";
+import { FORMULATEXT } from "./formula-text";
+import { HYPERLINK } from "./hyperlink";
+import { IMAGE } from "./image";
+import { JOIN } from "./join";
+import { MULTIPLY } from "./multiply";
+import { REALTIME } from "./real-time";
+import { SELECTION_STATUS } from "./selection-status";
+import { SEQUENCE } from "./sequence";
+import { SPARKLINE } from "./sparkline";
+import { SPLIT } from "./split";
+import { STARRATING } from "./star-rating";
+import { UNIQUE } from "./unique";
+export const IMPORTDATA = async (_parser, _url) => {
+    throw new FormulaError("#N/A", "IMPORTDATA is not available in the server calculation worker.");
+};
+export const functions = {
+    IMPORTDATA,
+    ARRAYFORMULA,
+    STARRATING,
+    HYPERLINK,
+    REALTIME,
+    CRYPTOPRICE,
+    IMAGE,
+    SELECTION_STATUS,
+    MULTIPLY,
+    UNIQUE,
+    SEQUENCE,
+    JOIN,
+    SPLIT,
+    DATASOURCE,
+    FORMULATEXT,
+    SPARKLINE,
+};

package/dist/esm/formulas/sparkline.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import { SparkLineResult } from "@rowsncolumns/common-types";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+export declare const SPARKLINE: (parser: FormulaParser, dataArg: FunctionArgument, optionsArg: FunctionArgument) => SparkLineResult | undefined;
+//# sourceMappingURL=sparkline.d.ts.map

package/dist/esm/formulas/sparkline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.d.ts","sourceRoot":"","sources":["../../../formulas/sparkline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AAGnE,eAAO,MAAM,SAAS,GACpB,QAAQ,aAAa,EACrB,SAAS,gBAAgB,EACzB,YAAY,gBAAgB,KAC3B,eAAe,GAAG,SA6DpB,CAAC"}

package/dist/esm/formulas/sparkline.js

@@ -0,0 +1,52 @@
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+export const SPARKLINE = (parser, dataArg, optionsArg) => {
+    if (parser.isPreview) {
+        return;
+    }
+    if (!dataArg) {
+        throw new FormulaError("#N/A", "Wrong number of arguments to SPARKLINE. Expected between 1 and 2 arguments, but got 0 arguments.");
+    }
+    // The options literal can arrive in either shape from
+    // fast-formula-parser:
+    //   - row form:  {"k1","v1","k2","v2"}  → [["k1","v1","k2","v2"]]
+    //   - pair form: {"k1","v1";"k2","v2"}  → [["k1","v1"],["k2","v2"]]
+    // `Object.fromEntries` only works correctly for the pair form — for
+    // the row form it iterates the inner array and reads positions 0/1
+    // as the single [key, value] pair, silently dropping everything
+    // else (which is how `color`, `colorHigh`/`colorLow` and the high/
+    // low flags vanish before the renderer sees them). Flatten and walk
+    // in stride 2 so both shapes round-trip every pair.
+    const options = {};
+    if (Array.isArray(optionsArg?.value)) {
+        const flat = optionsArg.value.flat(Infinity);
+        for (let i = 0; i + 1 < flat.length; i += 2) {
+            const key = flat[i];
+            if (key == null)
+                continue;
+            options[String(key)] = flat[i + 1];
+        }
+    }
+    const isNumber = (item) => typeof item === "number" && !isNaN(item);
+    const rawData = Array.isArray(dataArg.value)
+        ? dataArg.value.flat()
+        : [dataArg.value];
+    // Empty-cell handling: when the `emptycells` option is present
+    // (gap/zero/span — Excel's displayEmptyCellsAs) the renderer needs
+    // to know WHERE the empty cells were, so keep them as nulls.
+    // Without the option, compact them out — the legacy shape — so
+    // existing sparklines render byte-identical.
+    const preserveGaps = options.emptycells === "gap" ||
+        options.emptycells === "zero" ||
+        options.emptycells === "span";
+    const data = preserveGaps
+        ? rawData.map((item) => (isNumber(item) ? item : null))
+        : rawData.filter(isNumber);
+    if (data.filter(isNumber).length < 2) {
+        throw new FormulaError("#N/A", "SPARKLINE requires more data points. Expected: 2, found: 0.");
+    }
+    return {
+        kind: "sparkline",
+        data,
+        options,
+    };
+};

package/dist/esm/formulas/split.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+/**
+ * SPLIT(text, delimiter, [split_by_each], [remove_empty_text])
+ *
+ * Google Sheets semantics:
+ *  - split_by_each   (default TRUE): treat each character in `delimiter` as a
+ *    separate delimiter; when FALSE, split on the whole delimiter string.
+ *  - remove_empty_text (default TRUE): drop empty results.
+ */
+export declare const SPLIT: (_: FormulaParser, text: FunctionArgument, delimiter: FunctionArgument, splitByEach?: FunctionArgument, removeEmptyText?: FunctionArgument) => string[][];
+//# sourceMappingURL=split.d.ts.map

package/dist/esm/formulas/split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../formulas/split.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AAOnE;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,EAChB,MAAM,gBAAgB,EACtB,WAAW,gBAAgB,EAC3B,cAAc,gBAAgB,EAC9B,kBAAkB,gBAAgB,eAqCnC,CAAC"}

package/dist/esm/formulas/split.js

@@ -0,0 +1,44 @@
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isNil } from "@rowsncolumns/utils";
+/** Escape a character so it is literal inside a regex character class. */
+const escapeForCharClass = (s) => s.replace(/[\]\\^-]/g, "\\$&");
+/**
+ * SPLIT(text, delimiter, [split_by_each], [remove_empty_text])
+ *
+ * Google Sheets semantics:
+ *  - split_by_each   (default TRUE): treat each character in `delimiter` as a
+ *    separate delimiter; when FALSE, split on the whole delimiter string.
+ *  - remove_empty_text (default TRUE): drop empty results.
+ */
+export const SPLIT = (_, text, delimiter, splitByEach, removeEmptyText) => {
+    if (!text || isNil(text.value)) {
+        throw new FormulaError("#NA!", "Invalid text");
+    }
+    if (!delimiter || isNil(delimiter.value)) {
+        throw new FormulaError("#NA!", "Invalid delimiter");
+    }
+    const textValue = String(text.value);
+    const delim = String(delimiter.value);
+    const byEach = splitByEach && !isNil(splitByEach.value)
+        ? Boolean(splitByEach.value)
+        : true;
+    const removeEmpty = removeEmptyText && !isNil(removeEmptyText.value)
+        ? Boolean(removeEmptyText.value)
+        : true;
+    let parts;
+    if (byEach) {
+        // Split on ANY single character present in `delim`.
+        parts =
+            delim.length === 0
+                ? [textValue]
+                : textValue.split(new RegExp(`[${escapeForCharClass(delim)}]`));
+    }
+    else {
+        // Split on the whole delimiter string.
+        parts = delim.length === 0 ? [textValue] : textValue.split(delim);
+    }
+    if (removeEmpty) {
+        parts = parts.filter((part) => part !== "");
+    }
+    return [parts];
+};

package/dist/esm/formulas/star-rating.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+import { RecursiveFormula } from "@rowsncolumns/fast-formula-parser";
+export declare const STARRATING: (_: FormulaParser, arg: FunctionArgument) => RecursiveFormula;
+//# sourceMappingURL=star-rating.d.ts.map

package/dist/esm/formulas/star-rating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"star-rating.d.ts","sourceRoot":"","sources":["../../../formulas/star-rating.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAEL,gBAAgB,EACjB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,UAAU,GACrB,GAAG,aAAa,EAChB,KAAK,gBAAgB,KACpB,gBAOF,CAAC"}

package/dist/esm/formulas/star-rating.js

@@ -0,0 +1,9 @@
+import { FormulaError, } from "@rowsncolumns/fast-formula-parser";
+export const STARRATING = (_, arg) => {
+    if (!arg?.value || typeof arg?.value === "string") {
+        throw new FormulaError("#VALUE!", "Required argument not provided");
+    }
+    return {
+        _formulaResult: `=REPT(CHAR(11088),${arg.value})`,
+    };
+};

package/dist/esm/formulas/unique.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionArgument } from "@rowsncolumns/calculator";
+import type FormulaParser from "@rowsncolumns/fast-formula-parser";
+/**
+ * UNIQUE(range, [by_column], [exactly_once])
+ *
+ * Google Sheets semantics:
+ *  - by_column     (default FALSE): dedupe rows; when TRUE, dedupe columns.
+ *  - exactly_once  (default FALSE): return distinct records; when TRUE, return
+ *    only records that appear exactly once.
+ */
+export declare const UNIQUE: (_: FormulaParser, range: FunctionArgument, byColumnArg?: FunctionArgument, exactlyOnceArg?: FunctionArgument) => import("@rowsncolumns/fast-formula-parser").FormulaResult;
+//# sourceMappingURL=unique.d.ts.map

package/dist/esm/formulas/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","sourceRoot":"","sources":["../../../formulas/unique.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAC;AAgBnE;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GACjB,GAAG,aAAa,EAChB,OAAO,gBAAgB,EACvB,cAAc,gBAAgB,EAC9B,iBAAiB,gBAAgB,8DAgDlC,CAAC"}

package/dist/esm/formulas/unique.js

@@ -0,0 +1,58 @@
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { isNil } from "@rowsncolumns/utils";
+/** Transpose a rectangular 2D array. */
+const transpose = (matrix) => {
+    if (matrix.length === 0)
+        return [];
+    const cols = matrix[0].length;
+    const out = [];
+    for (let c = 0; c < cols; c++) {
+        out.push(matrix.map((row) => row[c]));
+    }
+    return out;
+};
+/**
+ * UNIQUE(range, [by_column], [exactly_once])
+ *
+ * Google Sheets semantics:
+ *  - by_column     (default FALSE): dedupe rows; when TRUE, dedupe columns.
+ *  - exactly_once  (default FALSE): return distinct records; when TRUE, return
+ *    only records that appear exactly once.
+ */
+export const UNIQUE = (_, range, byColumnArg, exactlyOnceArg) => {
+    if (!range) {
+        throw new FormulaError("#NA!", "Wrong number of arguments to UNIQUE. Expected atleast 1 arguments, but got 0 arguments.");
+    }
+    // If the argument is not a cell or range ref
+    if (!range.isCellRef && !range.isRangeRef) {
+        return range.value;
+    }
+    if (range.isCellRef) {
+        return range.value;
+    }
+    const byColumn = byColumnArg && !isNil(byColumnArg.value)
+        ? Boolean(byColumnArg.value)
+        : false;
+    const exactlyOnce = exactlyOnceArg && !isNil(exactlyOnceArg.value)
+        ? Boolean(exactlyOnceArg.value)
+        : false;
+    const matrix = range.value;
+    // Records are the units we dedupe over: rows by default, columns when
+    // by_column is TRUE (transpose so the dedupe loop is uniform).
+    const records = byColumn ? transpose(matrix) : matrix;
+    const order = [];
+    const countByKey = new Map();
+    const firstByKey = new Map();
+    for (const record of records) {
+        const key = JSON.stringify(record);
+        if (!countByKey.has(key)) {
+            order.push(key);
+            firstByKey.set(key, record);
+        }
+        countByKey.set(key, (countByKey.get(key) ?? 0) + 1);
+    }
+    const resultRecords = order
+        .filter((key) => (exactlyOnce ? countByKey.get(key) === 1 : true))
+        .map((key) => firstByKey.get(key));
+    return byColumn ? transpose(resultRecords) : resultRecords;
+};

package/dist/esm/function-descriptions.d.ts

@@ -0,0 +1,3 @@
+import type { CalculatorFunction } from "@rowsncolumns/common-types";
+export declare const functionDescriptions: CalculatorFunction[];
+//# sourceMappingURL=function-descriptions.d.ts.map

package/dist/esm/function-descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-descriptions.d.ts","sourceRoot":"","sources":["../../function-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EA23SpD,CAAC"}