@gridengine/angular-datagrid-enterprise 0.3.0 → 0.5.0

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

@@ -1083,6 +1083,646 @@ class FormulaEngine {
     }
 }
 
+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?.();
+    }
+}
+
+/** Default mask string used for unreadable cells. */
+const DEFAULT_MASK = '●●●';
+class CellPermissionEngine {
+    _policy;
+    _rowIdField;
+    _maskValue;
+    _cache = new Map();
+    constructor(options) {
+        this._policy = options.policy;
+        this._rowIdField = options.rowIdField ?? 'id';
+        this._maskValue = options.maskValue ?? DEFAULT_MASK;
+    }
+    /** The resolved permission for a cell (cached). */
+    getPermission(row, field) {
+        const key = this._key(row, field);
+        let perm = this._cache.get(key);
+        if (!perm) {
+            perm = this._policy(row, field);
+            this._cache.set(key, perm);
+        }
+        return perm;
+    }
+    canRead(row, field) {
+        return this.getPermission(row, field).canRead;
+    }
+    canEdit(row, field) {
+        const perm = this.getPermission(row, field);
+        return perm.canRead && perm.canEdit; // an unreadable cell can never be edited
+    }
+    /** The display value for a cell, masked when not readable. */
+    getDisplayValue(row, field) {
+        return this.canRead(row, field) ? row[field] : this._maskValue;
+    }
+    /** The value for copy/export; unreadable cells return '' so data never leaks. */
+    getExportValue(row, field) {
+        return this.canRead(row, field) ? row[field] : '';
+    }
+    /** True if the given value is the mask placeholder. */
+    isMasked(value) {
+        return value === this._maskValue;
+    }
+    get maskValue() {
+        return this._maskValue;
+    }
+    /** Clear one row's cached permissions, or the whole cache when omitted. */
+    clearCache(rowId) {
+        if (rowId === undefined) {
+            this._cache.clear();
+            return;
+        }
+        const prefix = `${rowId}\u0000`;
+        for (const key of this._cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this._cache.delete(key);
+            }
+        }
+    }
+    _key(row, field) {
+        const id = row[this._rowIdField];
+        if (id === undefined || id === null) {
+            throw new Error(`CellPermissionEngine: row has no '${this._rowIdField}' field. Set rowIdField to match your data.`);
+        }
+        return `${id}\u0000${field}`;
+    }
+}
+
+/**
+ * AuditTrailEngine — records an immutable log of every cell edit (who/what/when
+ * + prev/next values) in a bounded in-memory ring buffer, emitting each entry
+ * via `onEntry` for persistence. Pure logic.
+ */
+class AuditTrailEngine {
+    _userId;
+    _onEntry;
+    _maxEntries;
+    _now;
+    _entries = [];
+    _onChange;
+    constructor(options = {}) {
+        this._userId = options.userId;
+        this._onEntry = options.onEntry;
+        this._maxEntries = options.maxEntries ?? 1000;
+        this._now = options.now ?? Date.now;
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    /** Record a cell edit; no-op edits (prev === next) return null. */
+    record(rowId, field, prevValue, nextValue) {
+        if (Object.is(prevValue, nextValue))
+            return null;
+        const entry = {
+            timestamp: this._now(),
+            userId: this._userId,
+            rowId,
+            field,
+            prevValue,
+            nextValue,
+        };
+        this._entries.push(entry);
+        if (this._entries.length > this._maxEntries) {
+            this._entries.shift();
+        }
+        this._onEntry?.(entry);
+        this._notify();
+        return entry;
+    }
+    /** All entries, oldest first (read-only snapshot). */
+    getEntries() {
+        return this._entries;
+    }
+    /** Entries for a specific row, oldest first. */
+    getEntriesForRow(rowId) {
+        return this._entries.filter((e) => e.rowId === rowId);
+    }
+    /** Entries for a specific cell (row + field), oldest first. */
+    getEntriesForCell(rowId, field) {
+        return this._entries.filter((e) => e.rowId === rowId && e.field === field);
+    }
+    get size() {
+        return this._entries.length;
+    }
+    /** Discard all entries. */
+    clear() {
+        this._entries = [];
+        this._notify();
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
+class RowLockEngine {
+    _currentUserId;
+    _getLockedRows;
+    _onLockConflict;
+    _rowIdField;
+    _now;
+    _locks = new Map();
+    _onChange;
+    constructor(options = {}) {
+        this._currentUserId = options.currentUserId;
+        this._getLockedRows = options.getLockedRows;
+        this._onLockConflict = options.onLockConflict;
+        this._rowIdField = options.rowIdField ?? 'id';
+        this._now = options.now ?? Date.now;
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    /** Load locks from the async source and replace local state. */
+    async refresh() {
+        if (!this._getLockedRows)
+            return;
+        const locks = await this._getLockedRows();
+        this._locks = new Map(locks.map((l) => [l.rowId, l]));
+        this._notify();
+    }
+    /** Optimistically lock a row for a user. */
+    lockRow(rowId, userId, displayName) {
+        this._locks.set(rowId, {
+            rowId,
+            lockedByUserId: userId,
+            lockedByDisplayName: displayName,
+            lockedAt: this._now(),
+        });
+        this._notify();
+    }
+    /** Remove a lock. */
+    unlockRow(rowId) {
+        if (this._locks.delete(rowId))
+            this._notify();
+    }
+    /** Remove all locks. */
+    clear() {
+        if (this._locks.size === 0)
+            return;
+        this._locks.clear();
+        this._notify();
+    }
+    /** The lock for a row, or undefined if unlocked. */
+    getLock(rowId) {
+        return this._locks.get(rowId);
+    }
+    /** True if the row is locked by anyone. */
+    isLocked(rowId) {
+        return this._locks.has(rowId);
+    }
+    /** True if the row is locked by someone OTHER than the current user. */
+    isLockedByOther(rowId) {
+        const lock = this._locks.get(rowId);
+        if (!lock)
+            return false;
+        return lock.lockedByUserId !== this._currentUserId;
+    }
+    /** All current locks. */
+    getLocks() {
+        return Array.from(this._locks.values());
+    }
+    get size() {
+        return this._locks.size;
+    }
+    /**
+     * Whether the row may be edited by the current user. If it's locked by
+     * another user, fires `onLockConflict` and returns false.
+     */
+    canEditRow(row) {
+        const rowId = this._rowId(row);
+        const lock = this._locks.get(rowId);
+        if (!lock)
+            return true;
+        if (lock.lockedByUserId === this._currentUserId)
+            return true;
+        this._onLockConflict?.(row, lock.lockedByDisplayName ?? lock.lockedByUserId);
+        return false;
+    }
+    _rowId(row) {
+        const id = row[this._rowIdField];
+        if (id === undefined || id === null) {
+            throw new Error(`RowLockEngine: row has no '${this._rowIdField}' field. Set rowIdField to match your data.`);
+        }
+        return id;
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
 /*
  * Public API Surface of @gridengine/angular-datagrid-enterprise
  *
@@ -1095,5 +1735,5 @@ class FormulaEngine {
  * Generated bundle index. Do not edit.
  */
 
-export { ClipboardEngine, DataGridPro, FillHandleEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, UndoRedoManager, parseTSV, provideGridEngineLicense, toNumber, toTimestamp };
+export { AuditTrailEngine, CellPermissionEngine, ClipboardEngine, DEFAULT_MASK, DataGridPro, FillHandleEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, MasterDetailEngine, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, RowLockEngine, SSRMEngine, TransactionEngine, UndoRedoManager, parseTSV, provideGridEngineLicense, toNumber, toTimestamp };
 //# sourceMappingURL=gridengine-angular-datagrid-enterprise.mjs.map