@gridengine/angular-datagrid-enterprise 0.6.0 → 0.8.0

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

@@ -1981,6 +1981,479 @@ class SavedViewsEngine {
     }
 }
 
+/**
+ * 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?.();
+    }
+}
+
+/**
+ * Return a copy of `columnDefs` whose cells honour a `CellPermissionEngine`:
+ * unreadable cells resolve to the engine's mask value (so they never reach
+ * renderers, sorting, filtering, or export), and non-editable cells become
+ * non-editable regardless of the column's own `editable`. Columns without a
+ * `field` (e.g. a checkbox-selection column) pass through unchanged.
+ */
+function applyCellPermissions(columnDefs, engine) {
+    return columnDefs.map((col) => {
+        const field = col.field;
+        if (!field)
+            return col;
+        const originalGetter = col.valueGetter;
+        const originalEditable = col.editable;
+        return {
+            ...col,
+            valueGetter: (data) => {
+                const row = data;
+                if (!engine.canRead(row, field))
+                    return engine.maskValue;
+                return originalGetter ? originalGetter(data) : row[field];
+            },
+            editable: (row) => {
+                if (!engine.canEdit(row, field))
+                    return false;
+                return typeof originalEditable === 'function'
+                    ? originalEditable(row)
+                    : (originalEditable ?? false);
+            },
+        };
+    });
+}
+/**
+ * Convert open-source grid column defs into `PdfColumn`s for `PDFExportEngine`,
+ * carrying each column's `headerName` and `valueFormatter`. Hidden columns and
+ * columns without a `field` are omitted.
+ */
+function toPdfColumns(columnDefs) {
+    const out = [];
+    for (const col of columnDefs) {
+        if (!col.field || col.hide)
+            continue;
+        const field = col.field;
+        const fmt = col.valueFormatter;
+        out.push({
+            field,
+            headerName: col.headerName ?? field,
+            format: fmt ? (value) => fmt(value) : undefined,
+        });
+    }
+    return out;
+}
+
 /*
  * Public API Surface of @gridengine/angular-datagrid-enterprise
  *
@@ -1993,5 +2466,5 @@ class SavedViewsEngine {
  * Generated bundle index. Do not edit.
  */
 
-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 };
+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, applyCellPermissions, deserializeFilter, evaluateFilter, parseCSV, parseTSV, provideGridEngineLicense, serializeFilter, toNumber, toPdfColumns, toTimestamp };
 //# sourceMappingURL=gridengine-angular-datagrid-enterprise.mjs.map