@svgrid/enterprise 3.0.1 → 3.0.2

package/dist/sheet/parse.js

@@ -0,0 +1,108 @@
+/**
+ * Precedence-climbing parser over the token stream.
+ *
+ * One structural choice worth naming: a whole-column reference like `A:A`
+ * lexes as a range whose `to.row` is null, and the evaluator fills that in
+ * from the sheet's last used row. Resolving it here instead would bake the
+ * row count into the AST, and the AST is cached across edits that change it.
+ */
+import { PRECEDENCE, FormulaError, } from './ast.js';
+import { tokenize } from './tokenize.js';
+export function parse(tokens) {
+    let pos = 0;
+    const peek = () => tokens[pos];
+    const next = () => tokens[pos++];
+    function expression(minPrec) {
+        let left = postfix(primary());
+        for (;;) {
+            const t = peek();
+            if (!t || t.t !== 'op')
+                break;
+            const prec = PRECEDENCE[t.v];
+            if (prec === undefined || prec < minPrec)
+                break;
+            next();
+            // Left-associative for everything except `^`, which Excel binds right.
+            const nextMin = t.v === '^' ? prec : prec + 1;
+            left = { k: 'binary', op: t.v, left, right: expression(nextMin) };
+        }
+        return left;
+    }
+    /** Excel's `%` is POSTFIX and divides by a hundred: `50%` is 0.5 and
+     *  `A1*5%` is five percent of A1. There is no binary modulo operator in
+     *  Excel at all; `MOD()` is the function. */
+    function postfix(node) {
+        let out = node;
+        while (peek()?.t === 'op' && peek().v === '%') {
+            next();
+            out = { k: 'unary', op: '%', arg: out };
+        }
+        return out;
+    }
+    function primary() {
+        const t = next();
+        if (!t)
+            throw new FormulaError('#PARSE!');
+        switch (t.t) {
+            case 'num': return { k: 'num', v: t.v };
+            case 'str': return { k: 'str', v: t.v };
+            case 'bool': return { k: 'bool', v: t.v };
+            case 'ref': return { k: 'ref', ref: t.ref };
+            case 'range': return { k: 'range', from: t.from, to: t.to };
+            case 'name': return { k: 'name', name: t.v };
+            case 'table':
+                return t.columnTo === undefined
+                    ? { k: 'table', table: t.table, column: t.column, specifier: t.specifier }
+                    : {
+                        k: 'table', table: t.table, column: t.column,
+                        columnTo: t.columnTo, specifier: t.specifier,
+                    };
+            case 'lparen': {
+                const inner = expression(1);
+                const close = next();
+                if (!close || close.t !== 'rparen')
+                    throw new FormulaError('#PARSE!');
+                return inner;
+            }
+            case 'fn': {
+                const open = next();
+                if (!open || open.t !== 'lparen')
+                    throw new FormulaError('#PARSE!');
+                const args = [];
+                if (peek()?.t !== 'rparen') {
+                    args.push(expression(1));
+                    while (peek()?.t === 'comma') {
+                        next();
+                        args.push(expression(1));
+                    }
+                }
+                const close = next();
+                if (!close || close.t !== 'rparen')
+                    throw new FormulaError('#PARSE!');
+                return { k: 'fn', name: t.v, args };
+            }
+            case 'op': {
+                // Unary. Binds tighter than every binary operator except `^`, so
+                // `-2^2` is -(2^2) as in Excel, and `-A1*2` is (-A1)*2.
+                if (t.v === '-')
+                    return { k: 'unary', op: '-', arg: expression(5) };
+                if (t.v === '+')
+                    return { k: 'unary', op: '+', arg: expression(5) };
+                throw new FormulaError('#PARSE!');
+            }
+            default:
+                throw new FormulaError('#PARSE!');
+        }
+    }
+    const node = expression(1);
+    if (pos < tokens.length)
+        throw new FormulaError('#PARSE!');
+    return node;
+}
+/** Tokenize and parse one formula. Accepts the leading `=` or not. */
+export function parseFormula(src) {
+    const body = src.startsWith('=') ? src.slice(1) : src;
+    if (body.trim() === '')
+        throw new FormulaError('#PARSE!');
+    return parse(tokenize(body));
+}

package/dist/sheet/paste-special.d.ts

@@ -0,0 +1,164 @@
+import { type CellFormatEntry } from './format-store.js';
+export type PasteWhat = 'all' | 'values' | 'formulas' | 'formats';
+export type PasteOperation = 'none' | 'add' | 'subtract' | 'multiply' | 'divide';
+export type PasteSpecialOptions = {
+    what?: PasteWhat;
+    operation?: PasteOperation;
+    transpose?: boolean;
+    /** Leave the destination untouched where the source cell is empty. */
+    skipBlanks?: boolean;
+};
+/** One cell on its way through the clipboard. */
+export type ClipboardCell = {
+    /** What the cell displays. Always present; this is the TSV half. */
+    text: string;
+    /** The number behind a formatted display, when there is one: written as
+     *  `x:num` so a spreadsheet takes the number rather than re-parsing the
+     *  text. A parsed cell carries the number in `text` instead. */
+    value?: string;
+    /** The formula source, when the cell holds one. */
+    formula?: string;
+    format?: CellFormatEntry;
+};
+export type ClipboardGrid = ClipboardCell[][];
+/**
+ * A number format the way Excel writes it in `mso-number-format`: quoted,
+ * every literal escaped with a backslash and a double quote as `\0022`.
+ * Excel reads the property back from inline styles, which is how a paste
+ * into it keeps `#,##0.00` rather than guessing a format from the text.
+ */
+export declare function msoNumberFormat(code: string): string;
+/**
+ * Serialise a grid to the two clipboard flavours.
+ *
+ * The marker class is how `parseClipboardHtml` knows a paste came from a grid
+ * and can trust the `data-formula` attributes; HTML from anywhere else is
+ * read for text and styles only.
+ */
+export declare function buildClipboardPayload(grid: ClipboardGrid, 
+/** Where the copy came from, so a pasted formula knows how far it moved.
+ *  Omit for a synthetic payload; references then paste unshifted. */
+origin?: {
+    row: number;
+    col: number;
+}): {
+    text: string;
+    html: string;
+};
+/** Whether a formula is written in R1C1, as Google Sheets writes them. */
+export declare function isR1C1(formula: string): boolean;
+/**
+ * An R1C1 formula as A1, for the cell it lands in. `R[-1]C` is the cell
+ * above wherever the formula sits, `R2C3` is $C$2 anywhere, and a bare
+ * `RC` is the cell itself. Quoted strings and sheet names pass through.
+ */
+export declare function r1c1ToA1(formula: string, row: number, col: number): string;
+/** Parse a TSV clipboard into a grid of text-only cells. */
+export declare function parseClipboardText(text: string): ClipboardGrid;
+export declare function numFmtFromMso(value: string): string | undefined;
+/**
+ * Parse clipboard HTML into a grid.
+ *
+ * Uses DOMParser rather than a regex: clipboard HTML from Excel is full of
+ * conditional comments, namespaced tags and unclosed elements, and a parser
+ * that already handles all of that ships in the browser.
+ *
+ * Returns null when the HTML holds no table, so the caller falls back to TSV.
+ */
+export declare function readClipboardOrigin(html: string): {
+    row: number;
+    col: number;
+} | null;
+export declare function parseClipboardHtml(html: string): ClipboardGrid | null;
+/** Read whichever flavour is richer. */
+export declare function parseClipboard(payload: {
+    text?: string;
+    html?: string;
+}): ClipboardGrid;
+/** What one destination cell should become. */
+export type PasteResolution = {
+    kind: 'skip';
+} | {
+    kind: 'value';
+    value: string;
+} | {
+    kind: 'format';
+    format: CellFormatEntry | undefined;
+} | {
+    kind: 'both';
+    value: string;
+    format: CellFormatEntry | undefined;
+};
+/**
+ * Decide what lands in one cell. Pure, so the whole option matrix is testable
+ * without a clipboard or a grid.
+ *
+ * `offset` is how far the destination sits from where the source was copied,
+ * which is what lets a pasted formula shift its relative references. `at`
+ * is the destination itself, which an R1C1 formula (Google Sheets writes
+ * them so) needs to become A1; it then needs no offset, being relative to
+ * wherever it lands.
+ */
+export declare function resolvePasteCell(source: ClipboardCell | undefined, existing: unknown, opts: PasteSpecialOptions, offset?: {
+    rows: number;
+    cols: number;
+}, at?: {
+    row: number;
+    col: number;
+}): PasteResolution;
+/**
+ * A block from another application says nothing about where it was copied
+ * from, and Excel's formulas come in A1 as written: `=B2*C2` beside a
+ * price and a quantity. Pasted anywhere but A1 with no shift, that formula
+ * reads the wrong cells. What CAN be known is whether the block is
+ * self-contained: with the block read as if copied from A1, a formula whose
+ * every reference falls inside the block (a totals column, a running sum,
+ * the blocks people copy) is kept and moves with the paste from that A1;
+ * one that reaches outside is pasted as its value, which is right wherever
+ * the block lands. R1C1 formulas (Google Sheets) are left alone: they are
+ * resolved against the cell they land in.
+ */
+export declare function anchorForeignFormulas(grid: ClipboardGrid): {
+    grid: ClipboardGrid;
+    origin: {
+        row: number;
+        col: number;
+    } | null;
+};
+/**
+ * Where each source cell lands.
+ *
+ * The reference offset is the same for every cell, not per-cell: source and
+ * destination both advance together as the grid is walked, so the shift is
+ * just `destination - origin`. Computing it per cell is how you end up
+ * translating by the destination's absolute position, which is wrong
+ * everywhere except the top-left corner.
+ *
+ * With no `origin` the offset is zero. That is right rather than lazy: a
+ * formula pasted in from another application has no position in this sheet to
+ * have moved from.
+ *
+ * `fill` is the selection's size. A block that fits it a whole number of
+ * times is repeated over it, as Excel repeats a copied cell across a
+ * selected range (or two copied rows over six selected ones); each repeat
+ * gets its own offset, so a repeated formula points where a hand-copied one
+ * would. Otherwise the block lands at the destination and keeps its shape.
+ */
+export declare function planPaste(grid: ClipboardGrid, destination: {
+    row: number;
+    col: number;
+}, opts?: PasteSpecialOptions, origin?: {
+    row: number;
+    col: number;
+} | null, fill?: {
+    rows: number;
+    cols: number;
+}): Array<{
+    row: number;
+    col: number;
+    source: ClipboardCell;
+    offset: {
+        rows: number;
+        cols: number;
+    };
+}>;