@gridengine/angular-datagrid-enterprise 0.2.0 → 0.4.0

package/fesm2022/gridengine-angular-datagrid-enterprise.mjs

@@ -778,6 +778,715 @@ class UndoRedoManager {
     }
 }
 
+/**
+ * FormulaEngine — evaluates Excel-like formula strings against row data.
+ * Formulas start with '=' and reference other columns by field name.
+ *
+ * Functions: SUM, AVG, MIN, MAX, COUNT, IF, CONCAT, ROUND, ABS, FLOOR, CEIL,
+ * LEN, UPPER, LOWER. Bare identifiers that aren't function names are treated as
+ * field lookups on the current row.
+ *
+ * Error values: '#ERROR!', '#DIV/0!', '#REF!', '#CIRCULAR!', '#NAME?'.
+ * A formula that directly/transitively references its own cell yields
+ * '#CIRCULAR!'.
+ */
+class Parser {
+    _src;
+    _pos = 0;
+    constructor(src) {
+        this._src = src.trim();
+    }
+    parse() {
+        const node = this._parseExpr();
+        this._skipWS();
+        if (this._pos < this._src.length) {
+            throw new Error(`Unexpected character at position ${this._pos}: '${this._src[this._pos]}'`);
+        }
+        return node;
+    }
+    _skipWS() {
+        while (this._pos < this._src.length && /\s/.test(this._src[this._pos])) {
+            this._pos++;
+        }
+    }
+    _consume(ch) {
+        this._skipWS();
+        if (this._src[this._pos] !== ch) {
+            throw new Error(`Expected '${ch}' at position ${this._pos}`);
+        }
+        this._pos++;
+    }
+    _parseExpr() {
+        return this._parseComparison();
+    }
+    _parseComparison() {
+        let left = this._parseAddSub();
+        this._skipWS();
+        while (this._pos < this._src.length) {
+            const ch = this._src[this._pos];
+            const ch2 = this._src.slice(this._pos, this._pos + 2);
+            if (ch2 === '==' || ch2 === '!=' || ch2 === '<=' || ch2 === '>=') {
+                this._pos += 2;
+                const right = this._parseAddSub();
+                left = { kind: 'binary', op: ch2, left, right };
+            }
+            else if (ch === '<' || ch === '>') {
+                this._pos++;
+                const right = this._parseAddSub();
+                left = { kind: 'binary', op: ch, left, right };
+            }
+            else {
+                break;
+            }
+            this._skipWS();
+        }
+        return left;
+    }
+    _parseAddSub() {
+        let left = this._parseMulDiv();
+        this._skipWS();
+        while (this._pos < this._src.length &&
+            (this._src[this._pos] === '+' || this._src[this._pos] === '-')) {
+            const op = this._src[this._pos++];
+            const right = this._parseMulDiv();
+            left = { kind: 'binary', op, left, right };
+            this._skipWS();
+        }
+        return left;
+    }
+    _parseMulDiv() {
+        let left = this._parseUnary();
+        this._skipWS();
+        while (this._pos < this._src.length &&
+            (this._src[this._pos] === '*' || this._src[this._pos] === '/')) {
+            const op = this._src[this._pos++];
+            const right = this._parseUnary();
+            left = { kind: 'binary', op, left, right };
+            this._skipWS();
+        }
+        return left;
+    }
+    _parseUnary() {
+        this._skipWS();
+        if (this._src[this._pos] === '-') {
+            this._pos++;
+            return { kind: 'unary', op: '-', operand: this._parseUnary() };
+        }
+        return this._parsePrimary();
+    }
+    _parsePrimary() {
+        this._skipWS();
+        const ch = this._src[this._pos];
+        if (ch === undefined) {
+            throw new Error('Unexpected end of expression');
+        }
+        if (ch === '(') {
+            this._pos++;
+            const node = this._parseExpr();
+            this._consume(')');
+            return node;
+        }
+        if (ch === '"' || ch === "'") {
+            return this._parseString(ch);
+        }
+        if (ch === '.' || (ch >= '0' && ch <= '9')) {
+            return this._parseNumber();
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            return this._parseIdentifier();
+        }
+        throw new Error(`Unexpected token at position ${this._pos}: '${ch}'`);
+    }
+    _parseString(quote) {
+        this._pos++; // skip opening quote
+        let s = '';
+        while (this._pos < this._src.length && this._src[this._pos] !== quote) {
+            s += this._src[this._pos++];
+        }
+        this._pos++; // skip closing quote
+        return { kind: 'string', value: s };
+    }
+    _parseNumber() {
+        let s = '';
+        while (this._pos < this._src.length && /[\d.]/.test(this._src[this._pos])) {
+            s += this._src[this._pos++];
+        }
+        if (this._src[this._pos] === 'e' || this._src[this._pos] === 'E') {
+            s += this._src[this._pos++];
+            if (this._src[this._pos] === '+' || this._src[this._pos] === '-') {
+                s += this._src[this._pos++];
+            }
+            while (this._pos < this._src.length && /\d/.test(this._src[this._pos])) {
+                s += this._src[this._pos++];
+            }
+        }
+        return { kind: 'number', value: Number(s) };
+    }
+    _parseIdentifier() {
+        let name = '';
+        while (this._pos < this._src.length && /[\w]/.test(this._src[this._pos])) {
+            name += this._src[this._pos++];
+        }
+        this._skipWS();
+        if (this._src[this._pos] === '(') {
+            this._pos++;
+            const args = [];
+            this._skipWS();
+            if (this._src[this._pos] !== ')') {
+                args.push(this._parseExpr());
+                this._skipWS();
+                while (this._src[this._pos] === ',') {
+                    this._pos++;
+                    args.push(this._parseExpr());
+                    this._skipWS();
+                }
+            }
+            this._consume(')');
+            return { kind: 'call', fn: name.toUpperCase(), args };
+        }
+        return { kind: 'field', name };
+    }
+}
+const FUNCTIONS = {
+    SUM: (args) => args.reduce((acc, v) => acc + (Number(v) || 0), 0),
+    AVG: (args) => args.length === 0 ? 0 : args.reduce((acc, v) => acc + (Number(v) || 0), 0) / args.length,
+    MIN: (args) => Math.min(...args.map(Number)),
+    MAX: (args) => Math.max(...args.map(Number)),
+    COUNT: (args) => args.filter((v) => !isNaN(Number(v)) && v !== '' && v != null).length,
+    CONCAT: (args) => args.join(''),
+    ROUND: ([n, d]) => Number(Number(n).toFixed(Number(d ?? 0))),
+    ABS: ([n]) => Math.abs(Number(n)),
+    FLOOR: ([n]) => Math.floor(Number(n)),
+    CEIL: ([n]) => Math.ceil(Number(n)),
+    LEN: ([s]) => String(s ?? '').length,
+    UPPER: ([s]) => String(s ?? '').toUpperCase(),
+    LOWER: ([s]) => String(s ?? '').toLowerCase(),
+    IF: ([cond, t, f]) => (cond ? t : f),
+};
+function evalBinary(op, l, r) {
+    switch (op) {
+        case '+':
+            return typeof l === 'string' || typeof r === 'string'
+                ? String(l) + String(r)
+                : Number(l) + Number(r);
+        case '-':
+            return Number(l) - Number(r);
+        case '*':
+            return Number(l) * Number(r);
+        case '/': {
+            const divisor = Number(r);
+            return divisor === 0 ? '#DIV/0!' : Number(l) / divisor;
+        }
+        case '==':
+            return l == r;
+        case '!=':
+            return l != r;
+        case '<':
+            return Number(l) < Number(r);
+        case '<=':
+            return Number(l) <= Number(r);
+        case '>':
+            return Number(l) > Number(r);
+        case '>=':
+            return Number(l) >= Number(r);
+        default:
+            return '#ERROR!';
+    }
+}
+function evaluate(node, row, visiting) {
+    switch (node.kind) {
+        case 'number':
+            return node.value;
+        case 'string':
+            return node.value;
+        case 'field': {
+            const key = node.name;
+            if (visiting.has(key))
+                return '#CIRCULAR!';
+            const raw = row[key];
+            if (typeof raw === 'string' && raw.startsWith('=')) {
+                visiting.add(key);
+                try {
+                    const ast = new Parser(raw.slice(1)).parse();
+                    return evaluate(ast, row, visiting);
+                }
+                finally {
+                    visiting.delete(key);
+                }
+            }
+            if (raw === undefined)
+                return '#REF!';
+            return raw;
+        }
+        case 'unary': {
+            const v = evaluate(node.operand, row, visiting);
+            if (typeof v === 'string' && v.startsWith('#'))
+                return v;
+            return -Number(v);
+        }
+        case 'binary': {
+            const l = evaluate(node.left, row, visiting);
+            const r = evaluate(node.right, row, visiting);
+            if (typeof l === 'string' && l.startsWith('#'))
+                return l;
+            if (typeof r === 'string' && r.startsWith('#'))
+                return r;
+            return evalBinary(node.op, l, r);
+        }
+        case 'call': {
+            const fn = FUNCTIONS[node.fn];
+            if (!fn)
+                return '#NAME?';
+            const args = node.args.map((a) => evaluate(a, row, visiting));
+            const err = args.find((a) => typeof a === 'string' && a.startsWith('#'));
+            if (err)
+                return err;
+            return fn(args);
+        }
+    }
+}
+class FormulaEngine {
+    _formulaFields;
+    constructor(options) {
+        this._formulaFields = options.formulaFields;
+    }
+    /** Evaluate all formula fields for a row, returning a new (unmutated) row. */
+    evaluateRow(row) {
+        const result = { ...row };
+        for (const [field, formula] of Object.entries(this._formulaFields)) {
+            result[field] = this.evaluateFormula(formula, row, field);
+        }
+        return result;
+    }
+    /** Evaluate a single formula string against a row. */
+    evaluateFormula(formula, row, selfField) {
+        const expr = formula.startsWith('=') ? formula.slice(1) : formula;
+        try {
+            const ast = new Parser(expr).parse();
+            const visiting = selfField ? new Set([selfField]) : new Set();
+            return evaluate(ast, row, visiting);
+        }
+        catch {
+            return '#ERROR!';
+        }
+    }
+    /** Whether a formula string is parseable (no evaluation). */
+    isValidFormula(formula) {
+        const expr = formula.startsWith('=') ? formula.slice(1) : formula;
+        try {
+            new Parser(expr).parse();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+class SSRMEngine {
+    _dataSource;
+    blockSize;
+    maxBlocksInCache;
+    _blocks = new Map();
+    _accessClock = 0;
+    _totalCount = null;
+    _filterModel = {};
+    _sortModel = [];
+    _groupKeys = [];
+    _onChange;
+    constructor(options) {
+        this._dataSource = options.dataSource;
+        this.blockSize = options.blockSize ?? 100;
+        this.maxBlocksInCache = options.maxBlocksInCache ?? 10;
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    setFilterModel(model) {
+        this._filterModel = model;
+        this._invalidateAll();
+    }
+    setSortModel(model) {
+        this._sortModel = model;
+        this._invalidateAll();
+    }
+    setGroupKeys(keys) {
+        this._groupKeys = keys;
+        this._invalidateAll();
+    }
+    /** Total row count from the last server response (null = not yet known). */
+    getTotalCount() {
+        return this._totalCount;
+    }
+    /**
+     * Get the row at an absolute zero-based index, fetching the containing block
+     * if needed. Returns null while the block is loading.
+     */
+    getRow(rowIndex) {
+        const blockIndex = Math.floor(rowIndex / this.blockSize);
+        const block = this._getOrCreateBlock(blockIndex);
+        if (block.state === 'loaded') {
+            const localIndex = rowIndex - blockIndex * this.blockSize;
+            return block.rows[localIndex] ?? null;
+        }
+        return null;
+    }
+    /** Rows for the viewport [startRow, endRow); missing slots are null. */
+    getRowSlice(startRow, endRow) {
+        const result = [];
+        for (let i = startRow; i < endRow; i++) {
+            result.push(this.getRow(i));
+        }
+        return result;
+    }
+    getBlockState(blockIndex) {
+        return this._blocks.get(blockIndex)?.state ?? 'idle';
+    }
+    getBlocks() {
+        return this._blocks;
+    }
+    /** Evict all cached blocks and reset total count. */
+    invalidateAll() {
+        this._invalidateAll();
+    }
+    /** Evict a specific block (e.g. after a row mutation on that page). */
+    invalidateBlock(blockIndex) {
+        this._blocks.delete(blockIndex);
+        this._notify();
+    }
+    _getOrCreateBlock(blockIndex) {
+        let block = this._blocks.get(blockIndex);
+        if (!block) {
+            if (this._blocks.size >= this.maxBlocksInCache) {
+                this._evictOldest();
+            }
+            block = { index: blockIndex, state: 'idle', rows: [], lastAccessed: ++this._accessClock };
+            this._blocks.set(blockIndex, block);
+        }
+        block.lastAccessed = ++this._accessClock;
+        if (block.state === 'idle' || block.state === 'error') {
+            this._fetchBlock(block);
+        }
+        return block;
+    }
+    _fetchBlock(block, retryCount = 0) {
+        block.state = 'loading';
+        this._notify();
+        const startRow = block.index * this.blockSize;
+        const params = {
+            startRow,
+            endRow: startRow + this.blockSize,
+            filterModel: this._filterModel,
+            sortModel: this._sortModel,
+            groupKeys: this._groupKeys,
+        };
+        this._dataSource
+            .getRows(params)
+            .then((result) => {
+            block.state = 'loaded';
+            block.rows = result.rows;
+            block.error = undefined;
+            this._totalCount = result.totalCount;
+            this._notify();
+        })
+            .catch((err) => {
+            if (retryCount < 3) {
+                const delay = Math.pow(2, retryCount) * 1000; // 1s, 2s, 4s
+                setTimeout(() => this._fetchBlock(block, retryCount + 1), delay);
+            }
+            else {
+                block.state = 'error';
+                block.error = err;
+                this._notify();
+            }
+        });
+    }
+    _evictOldest() {
+        let oldest = null;
+        for (const block of this._blocks.values()) {
+            if (!oldest || block.lastAccessed < oldest.lastAccessed) {
+                oldest = block;
+            }
+        }
+        if (oldest) {
+            this._blocks.delete(oldest.index);
+        }
+    }
+    _invalidateAll() {
+        this._blocks.clear();
+        this._totalCount = null;
+        this._notify();
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
+class TransactionEngine {
+    _rowIdField;
+    _onCommit;
+    _onRollback;
+    _baseRows;
+    _dirty = new Map();
+    constructor(opts) {
+        this._rowIdField = opts.rowIdField ?? 'id';
+        this._onCommit = opts.onTransactionCommit;
+        this._onRollback = opts.onTransactionRollback;
+        this._baseRows = [...opts.initialRows];
+    }
+    /** Stage new rows; an existing ID is treated as an update instead. */
+    addRows(rows) {
+        for (const row of rows) {
+            const id = this._rowId(row);
+            const existing = this._findBase(id);
+            if (existing !== null) {
+                this._stageUpdate(id, existing, row);
+            }
+            else {
+                this._dirty.set(id, { state: 'added', original: null, current: { ...row } });
+            }
+        }
+    }
+    /** Stage updates for existing rows; unknown IDs are ignored with a warning. */
+    updateRows(rows) {
+        for (const row of rows) {
+            const id = this._rowId(row);
+            const existing = this._dirty.get(id);
+            if (existing?.state === 'added') {
+                existing.current = { ...existing.current, ...row };
+            }
+            else {
+                const base = this._findBase(id);
+                if (base === null) {
+                    console.warn(`TransactionEngine.updateRows: row with id '${id}' not found.`);
+                    continue;
+                }
+                this._stageUpdate(id, existing?.original ?? base, row);
+            }
+        }
+    }
+    /** Stage rows for removal by ID; a still-staged add is simply cancelled. */
+    removeRows(ids) {
+        for (const id of ids) {
+            const existing = this._dirty.get(id);
+            if (existing?.state === 'added') {
+                this._dirty.delete(id);
+                continue;
+            }
+            const base = this._findBase(id);
+            if (base === null) {
+                console.warn(`TransactionEngine.removeRows: row with id '${id}' not found.`);
+                continue;
+            }
+            this._dirty.set(id, { state: 'removed', original: existing?.original ?? base, current: base });
+        }
+    }
+    commitTransaction() {
+        const delta = this._buildDelta();
+        for (const [id, entry] of this._dirty) {
+            if (entry.state === 'added') {
+                this._baseRows.push(entry.current);
+            }
+            else if (entry.state === 'updated') {
+                const idx = this._baseRows.findIndex((r) => this._rowId(r) === id);
+                if (idx !== -1)
+                    this._baseRows[idx] = entry.current;
+            }
+            else if (entry.state === 'removed') {
+                this._baseRows = this._baseRows.filter((r) => this._rowId(r) !== id);
+            }
+        }
+        this._dirty.clear();
+        this._onCommit?.(delta);
+    }
+    rollbackTransaction() {
+        this._dirty.clear();
+        this._onRollback?.();
+    }
+    /** True if there are any staged (uncommitted) changes. */
+    isDirty() {
+        return this._dirty.size > 0;
+    }
+    /** All current staged changes, grouped by kind. */
+    getDirtyRows() {
+        const added = [];
+        const updated = [];
+        const removed = [];
+        for (const entry of this._dirty.values()) {
+            if (entry.state === 'added')
+                added.push(entry.current);
+            else if (entry.state === 'updated')
+                updated.push(entry.current);
+            else if (entry.state === 'removed' && entry.original !== null)
+                removed.push(entry.original);
+        }
+        return { added, updated, removed };
+    }
+    /** The merged row list: base rows with staged changes applied. */
+    getDisplayRows() {
+        const rows = [];
+        for (const baseRow of this._baseRows) {
+            const id = this._rowId(baseRow);
+            const entry = this._dirty.get(id);
+            if (!entry) {
+                rows.push(baseRow);
+            }
+            else if (entry.state === 'updated') {
+                rows.push(entry.current);
+            }
+            // 'removed' rows are omitted; 'added' rows are appended below.
+        }
+        for (const entry of this._dirty.values()) {
+            if (entry.state === 'added')
+                rows.push(entry.current);
+        }
+        return rows;
+    }
+    /** Replace the base rows (e.g. after a refresh); staged changes are kept. */
+    resetRows(rows) {
+        this._baseRows = [...rows];
+    }
+    _rowId(row) {
+        const id = row[this._rowIdField];
+        if (id === undefined || id === null) {
+            throw new Error(`TransactionEngine: row has no '${this._rowIdField}' field. Set rowIdField to match your data.`);
+        }
+        return id;
+    }
+    _findBase(id) {
+        return this._baseRows.find((r) => this._rowId(r) === id) ?? null;
+    }
+    _stageUpdate(id, original, next) {
+        this._dirty.set(id, { state: 'updated', original, current: { ...original, ...next } });
+    }
+    _buildDelta() {
+        const added = [];
+        const updated = [];
+        const removedIds = [];
+        for (const [id, entry] of this._dirty) {
+            if (entry.state === 'added')
+                added.push(entry.current);
+            else if (entry.state === 'updated')
+                updated.push(entry.current);
+            else if (entry.state === 'removed')
+                removedIds.push(id);
+        }
+        return { added, updated, removedIds };
+    }
+}
+
+class MasterDetailEngine {
+    _getDetailRowData;
+    _onExpand;
+    _rowIdField;
+    _expanded = new Set();
+    _cache = new Map();
+    _onChange;
+    constructor(options) {
+        this._getDetailRowData = options.getDetailRowData;
+        this._onExpand = options.onExpand;
+        this._rowIdField = options.rowIdField ?? 'id';
+    }
+    /** Subscribe to state changes. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    isExpanded(rowId) {
+        return this._expanded.has(rowId);
+    }
+    getLoadState(rowId) {
+        return this._cache.get(rowId)?.state ?? 'idle';
+    }
+    /** Cached detail rows, or an empty array if not yet loaded. */
+    getDetailData(rowId) {
+        return this._cache.get(rowId)?.data ?? [];
+    }
+    /** Expand a master row, triggering a load if not already cached. */
+    expand(masterRow) {
+        const id = this._rowId(masterRow);
+        if (this._expanded.has(id))
+            return;
+        this._expanded.add(id);
+        this._onExpand?.(masterRow, true);
+        this._notify();
+        this._ensureLoaded(masterRow, id);
+    }
+    /** Collapse a master row; cached data is retained for re-expansion. */
+    collapse(masterRow) {
+        const id = this._rowId(masterRow);
+        if (!this._expanded.has(id))
+            return;
+        this._expanded.delete(id);
+        this._onExpand?.(masterRow, false);
+        this._notify();
+    }
+    toggle(masterRow) {
+        if (this.isExpanded(this._rowId(masterRow))) {
+            this.collapse(masterRow);
+        }
+        else {
+            this.expand(masterRow);
+        }
+    }
+    /** Pre-fetch detail data without expanding (e.g. hover prefetch). */
+    prefetch(masterRow) {
+        this._ensureLoaded(masterRow, this._rowId(masterRow));
+    }
+    /** Invalidate one row's cache, or the entire cache when rowId is omitted. */
+    invalidateCache(rowId) {
+        if (rowId !== undefined) {
+            this._cache.delete(rowId);
+        }
+        else {
+            this._cache.clear();
+        }
+        this._notify();
+    }
+    /** Collapse all expanded rows. Cache is preserved. */
+    collapseAll() {
+        this._expanded.clear();
+        this._notify();
+    }
+    /** A read-only snapshot of currently expanded row IDs. */
+    getExpandedIds() {
+        return this._expanded;
+    }
+    _rowId(row) {
+        const id = row[this._rowIdField];
+        if (id === undefined || id === null) {
+            throw new Error(`MasterDetailEngine: row has no '${this._rowIdField}' field. Set rowIdField to the correct field name.`);
+        }
+        return id;
+    }
+    _ensureLoaded(masterRow, id) {
+        const existing = this._cache.get(id);
+        if (existing && (existing.state === 'loading' || existing.state === 'loaded'))
+            return;
+        this._cache.set(id, { state: 'loading', data: [] });
+        this._notify();
+        this._getDetailRowData(masterRow)
+            .then((data) => {
+            this._cache.set(id, { state: 'loaded', data });
+            this._notify();
+        })
+            .catch((error) => {
+            this._cache.set(id, { state: 'error', data: [], error });
+            this._notify();
+        });
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
 /*
  * Public API Surface of @gridengine/angular-datagrid-enterprise
  *
@@ -790,5 +1499,5 @@ class UndoRedoManager {
  * Generated bundle index. Do not edit.
  */
 
-export { ClipboardEngine, DataGridPro, FillHandleEngine, GridLicenseWatermark, LicenseManager, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, UndoRedoManager, parseTSV, provideGridEngineLicense, toNumber, toTimestamp };
+export { ClipboardEngine, DataGridPro, FillHandleEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, MasterDetailEngine, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, SSRMEngine, TransactionEngine, UndoRedoManager, parseTSV, provideGridEngineLicense, toNumber, toTimestamp };
 //# sourceMappingURL=gridengine-angular-datagrid-enterprise.mjs.map