@gridengine/angular-datagrid-enterprise 0.4.0 → 0.6.0

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

@@ -1487,6 +1487,500 @@ class MasterDetailEngine {
     }
 }
 
+/** 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?.();
+    }
+}
+
+function toComparable(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (value instanceof Date)
+        return value.getTime();
+    return String(value);
+}
+function evaluateCondition(cond, row) {
+    const raw = row[cond.field];
+    const op = cond.operator;
+    const isEmpty = raw === null || raw === undefined || raw === '';
+    if (op === 'isEmpty')
+        return isEmpty;
+    if (op === 'isNotEmpty')
+        return !isEmpty;
+    const target = cond.value;
+    switch (op) {
+        case 'equals':
+            return toComparable(raw) === toComparable(target);
+        case 'notEquals':
+            return toComparable(raw) !== toComparable(target);
+        case 'contains':
+            return String(raw ?? '')
+                .toLowerCase()
+                .includes(String(target ?? '').toLowerCase());
+        case 'notContains':
+            return !String(raw ?? '')
+                .toLowerCase()
+                .includes(String(target ?? '').toLowerCase());
+        case 'startsWith':
+            return String(raw ?? '')
+                .toLowerCase()
+                .startsWith(String(target ?? '').toLowerCase());
+        case 'endsWith':
+            return String(raw ?? '')
+                .toLowerCase()
+                .endsWith(String(target ?? '').toLowerCase());
+        case 'greaterThan':
+        case 'greaterThanOrEqual':
+        case 'lessThan':
+        case 'lessThanOrEqual': {
+            const a = toComparable(raw);
+            const b = toComparable(target);
+            if (a === null || b === null || typeof a !== typeof b)
+                return false;
+            if (op === 'greaterThan')
+                return a > b;
+            if (op === 'greaterThanOrEqual')
+                return a >= b;
+            if (op === 'lessThan')
+                return a < b;
+            return a <= b;
+        }
+        default:
+            return false;
+    }
+}
+/** Evaluate a filter node against a row. */
+function evaluateFilter(node, row) {
+    if (node.kind === 'condition') {
+        return evaluateCondition(node, row);
+    }
+    const group = node;
+    let result;
+    if (group.children.length === 0) {
+        result = true; // an empty group matches everything
+    }
+    else if (group.combinator === 'and') {
+        result = group.children.every((child) => evaluateFilter(child, row));
+    }
+    else {
+        result = group.children.some((child) => evaluateFilter(child, row));
+    }
+    return group.not ? !result : result;
+}
+function toUrlSafe(b64) {
+    return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function fromUrlSafe(s) {
+    const b64 = s.replace(/-/g, '+').replace(/_/g, '/');
+    const pad = b64.length % 4 === 0 ? '' : '='.repeat(4 - (b64.length % 4));
+    return b64 + pad;
+}
+/** Serialize a filter tree to a URL-safe string. */
+function serializeFilter(node) {
+    return toUrlSafe(btoa(JSON.stringify(node)));
+}
+/** Deserialize a URL-safe string back into a filter tree. Throws if invalid. */
+function deserializeFilter(encoded) {
+    const parsed = JSON.parse(atob(fromUrlSafe(encoded)));
+    if (!parsed || (parsed.kind !== 'condition' && parsed.kind !== 'group')) {
+        throw new Error('Invalid filter payload');
+    }
+    return parsed;
+}
+class FilterPresetEngine {
+    _onSave;
+    _generateId;
+    _presets;
+    _seq = 0;
+    _onChange;
+    constructor(options = {}) {
+        this._onSave = options.onSave;
+        this._generateId = options.generateId ?? (() => `preset-${++this._seq}`);
+        this._presets = [...(options.presets ?? [])];
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    getPresets() {
+        return this._presets;
+    }
+    getPreset(id) {
+        return this._presets.find((p) => p.id === id);
+    }
+    /** Save a new preset (or replace one with the same name). Returns it. */
+    savePreset(name, filter, isShared = false) {
+        const existing = this._presets.find((p) => p.name === name);
+        const preset = existing
+            ? { ...existing, filter, isShared }
+            : { id: this._generateId(), name, filter, isShared };
+        if (existing) {
+            this._presets = this._presets.map((p) => (p.id === existing.id ? preset : p));
+        }
+        else {
+            this._presets = [...this._presets, preset];
+        }
+        this._onSave?.(preset);
+        this._notify();
+        return preset;
+    }
+    deletePreset(id) {
+        const next = this._presets.filter((p) => p.id !== id);
+        if (next.length !== this._presets.length) {
+            this._presets = next;
+            this._notify();
+        }
+    }
+    /** Filter an array of rows through a filter tree. */
+    applyFilter(node, rows) {
+        return rows.filter((row) => evaluateFilter(node, row));
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
+/**
+ * SavedViewsEngine — manages named grid views (column layout, sort, filter,
+ * group, density, etc.) across personal + admin-shared tiers. Server sync is
+ * delegated to async callbacks so the engine stays pure and Node-testable.
+ */
+class SavedViewsEngine {
+    _getSavedViews;
+    _onSaveView;
+    _onDeleteView;
+    _onViewChange;
+    _generateId;
+    _views;
+    _activeViewId = null;
+    _seq = 0;
+    _onChange;
+    constructor(options = {}) {
+        this._getSavedViews = options.getSavedViews;
+        this._onSaveView = options.onSaveView;
+        this._onDeleteView = options.onDeleteView;
+        this._onViewChange = options.onViewChange;
+        this._generateId = options.generateId ?? (() => `view-${++this._seq}`);
+        this._views = [...(options.views ?? [])];
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    /** Load views from the async source, replacing local state. */
+    async load() {
+        if (!this._getSavedViews)
+            return;
+        this._views = await this._getSavedViews();
+        this._notify();
+    }
+    getViews() {
+        return this._views;
+    }
+    getView(id) {
+        return this._views.find((v) => v.id === id);
+    }
+    /** Personal (non-shared) views. */
+    getPersonalViews() {
+        return this._views.filter((v) => !v.isShared);
+    }
+    /** Admin-shared views. */
+    getSharedViews() {
+        return this._views.filter((v) => v.isShared);
+    }
+    getActiveView() {
+        if (this._activeViewId === null)
+            return null;
+        return this.getView(this._activeViewId) ?? null;
+    }
+    /** Create a new view or update an existing one by name. Returns the view. */
+    async saveView(name, layout, options = {}) {
+        const existing = options.id
+            ? this._views.find((v) => v.id === options.id)
+            : this._views.find((v) => v.name === name);
+        const view = existing
+            ? { ...existing, name, layout, isShared: options.isShared ?? existing.isShared }
+            : { id: this._generateId(), name, layout, isShared: options.isShared };
+        if (existing) {
+            this._views = this._views.map((v) => (v.id === existing.id ? view : v));
+        }
+        else {
+            this._views = [...this._views, view];
+        }
+        await this._onSaveView?.(view);
+        this._notify();
+        return view;
+    }
+    /** Delete a view. If it was active, the active view is cleared. */
+    async deleteView(id) {
+        const next = this._views.filter((v) => v.id !== id);
+        if (next.length === this._views.length)
+            return;
+        this._views = next;
+        if (this._activeViewId === id) {
+            this._activeViewId = null;
+            this._onViewChange?.(null);
+        }
+        await this._onDeleteView?.(id);
+        this._notify();
+    }
+    /** Activate a view (or clear with null). Fires onViewChange. */
+    setActiveView(id) {
+        if (id !== null && !this.getView(id)) {
+            throw new Error(`SavedViewsEngine: unknown view '${id}'`);
+        }
+        if (this._activeViewId === id)
+            return;
+        this._activeViewId = id;
+        this._onViewChange?.(this.getActiveView());
+        this._notify();
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
 /*
  * Public API Surface of @gridengine/angular-datagrid-enterprise
  *
@@ -1499,5 +1993,5 @@ class MasterDetailEngine {
  * Generated bundle index. Do not edit.
  */
 
-export { ClipboardEngine, DataGridPro, FillHandleEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, MasterDetailEngine, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, SSRMEngine, TransactionEngine, UndoRedoManager, parseTSV, provideGridEngineLicense, toNumber, toTimestamp };
+export { AuditTrailEngine, CellPermissionEngine, ClipboardEngine, DEFAULT_MASK, DataGridPro, FillHandleEngine, FilterPresetEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, MasterDetailEngine, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, RowLockEngine, SSRMEngine, SavedViewsEngine, TransactionEngine, UndoRedoManager, deserializeFilter, evaluateFilter, parseTSV, provideGridEngineLicense, serializeFilter, toNumber, toTimestamp };
 //# sourceMappingURL=gridengine-angular-datagrid-enterprise.mjs.map