@gridengine/angular-datagrid-enterprise 0.5.0 → 0.7.0

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

@@ -1723,6 +1723,684 @@ class RowLockEngine {
     }
 }
 
+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?.();
+    }
+}
+
+/**
+ * Parse delimited text into a matrix of string cells. Handles quoted fields
+ * containing the delimiter, newlines, and escaped quotes (`""`), plus `\n` and
+ * `\r\n` line endings.
+ */
+function parseCSV(text, delimiter = ',') {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let inQuotes = false;
+    let i = 0;
+    const pushCell = () => {
+        row.push(cell);
+        cell = '';
+    };
+    const pushRow = () => {
+        pushCell();
+        rows.push(row);
+        row = [];
+    };
+    while (i < text.length) {
+        const ch = text[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') {
+                    cell += '"';
+                    i += 2;
+                    continue;
+                }
+                inQuotes = false;
+                i++;
+                continue;
+            }
+            cell += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = true;
+            i++;
+            continue;
+        }
+        if (ch === delimiter) {
+            pushCell();
+            i++;
+            continue;
+        }
+        if (ch === '\r') {
+            pushRow();
+            if (text[i + 1] === '\n')
+                i++;
+            i++;
+            continue;
+        }
+        if (ch === '\n') {
+            pushRow();
+            i++;
+            continue;
+        }
+        cell += ch;
+        i++;
+    }
+    if (cell.length > 0 || row.length > 0) {
+        pushRow();
+    }
+    return rows;
+}
+function normalizeHeader(h) {
+    return h.trim().toLowerCase().replace(/[\s_-]+/g, '');
+}
+function coerce(raw, type) {
+    const trimmed = raw.trim();
+    switch (type) {
+        case 'number': {
+            if (trimmed === '')
+                return { ok: true, value: null };
+            const n = Number(trimmed.replace(/,/g, ''));
+            if (Number.isNaN(n))
+                return { ok: false, value: raw, message: `"${raw}" is not a number` };
+            return { ok: true, value: n };
+        }
+        case 'boolean': {
+            const t = trimmed.toLowerCase();
+            if (['true', '1', 'yes', 'y'].includes(t))
+                return { ok: true, value: true };
+            if (['false', '0', 'no', 'n', ''].includes(t))
+                return { ok: true, value: false };
+            return { ok: false, value: raw, message: `"${raw}" is not a boolean` };
+        }
+        case 'date': {
+            if (trimmed === '')
+                return { ok: true, value: null };
+            const ts = Date.parse(trimmed);
+            if (Number.isNaN(ts))
+                return { ok: false, value: raw, message: `"${raw}" is not a valid date` };
+            return { ok: true, value: new Date(ts).toISOString() };
+        }
+        case 'string':
+        default:
+            return { ok: true, value: raw };
+    }
+}
+class ExcelImportEngine {
+    _columns;
+    _headers = [];
+    _dataRows = [];
+    /** sourceHeader → targetField (null = unmapped). */
+    _mapping = new Map();
+    constructor(options) {
+        this._columns = options.columns;
+        if (options.columnMapping) {
+            for (const [header, field] of Object.entries(options.columnMapping)) {
+                this._mapping.set(header, field);
+            }
+        }
+    }
+    /**
+     * Load a matrix of raw cells.
+     * @param matrix        Full sheet, including the header row when hasHeaderRow.
+     * @param hasHeaderRow  When true (default) the first row is treated as headers.
+     */
+    loadMatrix(matrix, hasHeaderRow = true) {
+        if (matrix.length === 0) {
+            this._headers = [];
+            this._dataRows = [];
+            return;
+        }
+        if (hasHeaderRow) {
+            this._headers = matrix[0].map((h) => String(h ?? ''));
+            this._dataRows = matrix.slice(1);
+        }
+        else {
+            this._headers = matrix[0].map((_, idx) => `Col${idx + 1}`);
+            this._dataRows = matrix;
+        }
+        this._autoMap();
+    }
+    /** Parse delimited text and load it as the source matrix. */
+    loadCSV(text, delimiter = ',', hasHeaderRow = true) {
+        this.loadMatrix(parseCSV(text, delimiter), hasHeaderRow);
+    }
+    _autoMap() {
+        const fieldByNorm = new Map();
+        for (const col of this._columns) {
+            fieldByNorm.set(normalizeHeader(col.headerName), col.field);
+            fieldByNorm.set(normalizeHeader(col.field), col.field);
+        }
+        for (const header of this._headers) {
+            if (this._mapping.has(header))
+                continue; // respect explicit mapping
+            const match = fieldByNorm.get(normalizeHeader(header));
+            this._mapping.set(header, match ?? null);
+        }
+    }
+    getHeaders() {
+        return this._headers;
+    }
+    /** Current source-header → target-field mapping. */
+    getMapping() {
+        const out = {};
+        for (const header of this._headers) {
+            out[header] = this._mapping.get(header) ?? null;
+        }
+        return out;
+    }
+    /** Manually map (or unmap with null) a source header to a target field. */
+    setMapping(sourceHeader, field) {
+        this._mapping.set(sourceHeader, field);
+    }
+    /** Source headers not yet mapped to a target field. */
+    getUnmappedHeaders() {
+        return this._headers.filter((h) => !this._mapping.get(h));
+    }
+    /** Target fields that have no source column mapped to them. */
+    getUnmappedFields() {
+        const mapped = new Set(this._headers.map((h) => this._mapping.get(h)).filter((f) => !!f));
+        return this._columns.map((c) => c.field).filter((f) => !mapped.has(f));
+    }
+    /** Validate all data rows against the mapped column types. */
+    validate() {
+        return this._process().errors;
+    }
+    /** Build validated rows (rows with errors are still returned, best-effort). */
+    buildRows() {
+        return this._process().rows;
+    }
+    /** Full preview: rows plus any validation errors. */
+    preview() {
+        return this._process();
+    }
+    _process() {
+        const rows = [];
+        const errors = [];
+        const fieldToSourceIndex = new Map();
+        this._headers.forEach((header, idx) => {
+            const field = this._mapping.get(header);
+            if (field)
+                fieldToSourceIndex.set(field, idx);
+        });
+        this._dataRows.forEach((sourceRow, rowIndex) => {
+            const row = {};
+            for (const col of this._columns) {
+                const srcIdx = fieldToSourceIndex.get(col.field);
+                const raw = srcIdx === undefined ? '' : String(sourceRow[srcIdx] ?? '');
+                const type = col.type ?? 'string';
+                if (col.required && raw.trim() === '') {
+                    errors.push({ rowIndex, field: col.field, value: raw, message: `${col.headerName} is required` });
+                }
+                const result = coerce(raw, type);
+                if (!result.ok) {
+                    errors.push({ rowIndex, field: col.field, value: raw, message: result.message ?? `Invalid ${type}` });
+                    row[col.field] = raw; // keep raw for user correction
+                }
+                else {
+                    row[col.field] = result.value;
+                }
+            }
+            rows.push(row);
+        });
+        return { rows, errors };
+    }
+    /** Number of data rows currently loaded (excludes the header row). */
+    get rowCount() {
+        return this._dataRows.length;
+    }
+}
+
+const DEFAULTS = {
+    pageSize: 'A4',
+    orientation: 'landscape',
+    rowsPerPage: 25,
+};
+class PDFExportEngine {
+    _columns;
+    _options;
+    _now;
+    constructor(options) {
+        const { columns, now, ...pdfOptions } = options;
+        this._columns = columns;
+        this._options = pdfOptions;
+        this._now = now ?? (() => new Date());
+    }
+    /** Build the paginated document model from the given (already-visible) rows. */
+    build(rows) {
+        const rowsPerPage = Math.max(1, this._options.rowsPerPage ?? DEFAULTS.rowsPerPage);
+        const pageSize = this._options.pageSize ?? DEFAULTS.pageSize;
+        const orientation = this._options.orientation ?? DEFAULTS.orientation;
+        const generatedAt = this._now().toISOString();
+        const columnHeaders = this._columns.map((c) => c.headerName);
+        const pageCount = Math.max(1, Math.ceil(rows.length / rowsPerPage));
+        const pages = [];
+        for (let p = 0; p < pageCount; p++) {
+            const slice = rows.slice(p * rowsPerPage, (p + 1) * rowsPerPage);
+            pages.push({
+                header: { title: this._options.title, logo: this._options.logo, generatedAt },
+                footer: { text: this._options.footer, pageNumber: p + 1, pageCount },
+                columnHeaders,
+                rows: slice.map((row) => this._formatRow(row)),
+            });
+        }
+        return { pageSize, orientation, pages };
+    }
+    _formatRow(row) {
+        return this._columns.map((col) => {
+            const value = row[col.field];
+            if (col.format)
+                return col.format(value, row);
+            return value === null || value === undefined ? '' : String(value);
+        });
+    }
+}
+
+class FormEditorEngine {
+    _rows;
+    _rowIdField;
+    _onSave;
+    _onDelete;
+    _index = -1; // -1 = panel closed
+    _draft = null;
+    _onChange;
+    constructor(options) {
+        this._rows = [...options.rows];
+        this._rowIdField = options.rowIdField ?? 'id';
+        this._onSave = options.onSave;
+        this._onDelete = options.onDelete;
+    }
+    subscribe(listener) {
+        this._onChange = listener;
+        return () => {
+            if (this._onChange === listener)
+                this._onChange = undefined;
+        };
+    }
+    /** Replace the row set; keeps the panel on the same rowId if still present. */
+    setRows(rows) {
+        const currentId = this.isOpen ? this._rowId(this._rows[this._index]) : undefined;
+        this._rows = [...rows];
+        if (currentId !== undefined) {
+            const idx = this._rows.findIndex((r) => this._rowId(r) === currentId);
+            if (idx === -1) {
+                this.close();
+                return;
+            }
+            this._index = idx;
+            this._draft = { ...this._rows[idx] };
+        }
+        this._notify();
+    }
+    get isOpen() {
+        return this._index >= 0 && this._index < this._rows.length;
+    }
+    get index() {
+        return this._index;
+    }
+    /** Open the panel on a row by its ID. */
+    openById(rowId) {
+        const idx = this._rows.findIndex((r) => this._rowId(r) === rowId);
+        if (idx === -1)
+            throw new Error(`FormEditorEngine: no row with id '${rowId}'`);
+        this._openAt(idx);
+    }
+    /** Open the panel on a row by index. */
+    openAt(index) {
+        if (index < 0 || index >= this._rows.length) {
+            throw new Error(`FormEditorEngine: index ${index} out of range`);
+        }
+        this._openAt(index);
+    }
+    close() {
+        this._index = -1;
+        this._draft = null;
+        this._notify();
+    }
+    _openAt(index) {
+        this._index = index;
+        this._draft = { ...this._rows[index] };
+        this._notify();
+    }
+    /** The current editable draft (a copy of the row plus unsaved edits). */
+    getDraft() {
+        return this._draft ? { ...this._draft } : null;
+    }
+    /** The original (unedited) row currently open. */
+    getOriginal() {
+        return this.isOpen ? this._rows[this._index] : null;
+    }
+    setFieldValue(field, value) {
+        if (!this._draft)
+            throw new Error('FormEditorEngine: no row open');
+        this._draft[field] = value;
+        this._notify();
+    }
+    /** True when the draft differs from the original row. */
+    get isDirty() {
+        if (!this._draft || !this.isOpen)
+            return false;
+        const original = this._rows[this._index];
+        const keys = new Set([...Object.keys(original), ...Object.keys(this._draft)]);
+        for (const key of keys) {
+            if (!Object.is(original[key], this._draft[key]))
+                return true;
+        }
+        return false;
+    }
+    /** Revert unsaved edits. */
+    revert() {
+        if (!this.isOpen)
+            return;
+        this._draft = { ...this._rows[this._index] };
+        this._notify();
+    }
+    get canGoPrev() {
+        return this._index > 0;
+    }
+    get canGoNext() {
+        return this._index >= 0 && this._index < this._rows.length - 1;
+    }
+    next() {
+        if (this.canGoNext)
+            this._openAt(this._index + 1);
+    }
+    prev() {
+        if (this.canGoPrev)
+            this._openAt(this._index - 1);
+    }
+    /** Save the draft: commits it into the row set and calls onSave. */
+    async save() {
+        if (!this._draft || !this.isOpen)
+            throw new Error('FormEditorEngine: no row open');
+        const saved = { ...this._draft };
+        this._rows[this._index] = saved;
+        await this._onSave?.(saved);
+        this._notify();
+    }
+    /** Delete the open row: removes it and keeps the panel on the next row. */
+    async delete() {
+        if (!this.isOpen)
+            throw new Error('FormEditorEngine: no row open');
+        const row = this._rows[this._index];
+        this._rows = this._rows.filter((_, i) => i !== this._index);
+        await this._onDelete?.(row);
+        if (this._rows.length === 0) {
+            this.close();
+        }
+        else {
+            this._openAt(Math.min(this._index, this._rows.length - 1));
+        }
+    }
+    _rowId(row) {
+        const id = row[this._rowIdField];
+        if (id === undefined || id === null) {
+            throw new Error(`FormEditorEngine: row has no '${this._rowIdField}' field.`);
+        }
+        return id;
+    }
+    _notify() {
+        this._onChange?.();
+    }
+}
+
 /*
  * Public API Surface of @gridengine/angular-datagrid-enterprise
  *
@@ -1735,5 +2413,5 @@ class RowLockEngine {
  * Generated bundle index. Do not edit.
  */
 
-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 };
+export { AuditTrailEngine, CellPermissionEngine, ClipboardEngine, DEFAULT_MASK, DataGridPro, ExcelImportEngine, FillHandleEngine, FilterPresetEngine, FormEditorEngine, FormulaEngine, GridLicenseWatermark, LicenseManager, MasterDetailEngine, PDFExportEngine, PRODUCT_ID, PURCHASE_URL, RangeSelectionEngine, RowLockEngine, SSRMEngine, SavedViewsEngine, TransactionEngine, UndoRedoManager, deserializeFilter, evaluateFilter, parseCSV, parseTSV, provideGridEngineLicense, serializeFilter, toNumber, toTimestamp };
 //# sourceMappingURL=gridengine-angular-datagrid-enterprise.mjs.map