@ngxsmk/cdk 1.3.1 → 2.0.0

package/esm2022/spreadsheet/plugin/validation-plugin.mjs

@@ -0,0 +1,71 @@
+/**
+ * ValidationPlugin validates cell values against registered rules.
+ */
+export class ValidationPlugin {
+    constructor() {
+        this.name = 'validation';
+        this.priority = 40;
+        this._engine = null;
+        this._rules = new Map();
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    /** Register a validation rule for a column. */
+    addRule(rule) {
+        this._rules.set(rule.colId, rule.validator);
+    }
+    /** Remove a validation rule. */
+    removeRule(colId) {
+        this._rules.delete(colId);
+    }
+    /** Validate a single cell value. Returns null if valid, error string if not. */
+    validate(colId, value) {
+        const rule = this._rules.get(colId);
+        return rule ? rule(value) : null;
+    }
+    /** Validate all cells and return errors indexed by "row:colId". */
+    validateAll() {
+        const errors = new Map();
+        if (!this._engine)
+            return errors;
+        const rows = this._engine.rowData();
+        const cols = this._engine.columnDefs();
+        for (let r = 0; r < rows.length; r++) {
+            for (const col of cols) {
+                const val = rows[r].cells[col.id]?.value;
+                const err = this.validate(col.id, val);
+                if (err) {
+                    const key = `${r}:${col.id}`;
+                    errors.set(key, [err]);
+                }
+            }
+        }
+        return errors;
+    }
+    onBeforeEdit(_rowIndex, _colId) {
+        return true;
+    }
+    onAfterEdit(rowIndex, colId, _oldValue, newValue) {
+        const err = this.validate(colId, newValue);
+        if (err && this._engine) {
+            const rows = [...this._engine.rowData()];
+            const row = rows[rowIndex];
+            if (row) {
+                const cell = row.cells[colId];
+                rows[rowIndex] = {
+                    ...row,
+                    cells: {
+                        ...row.cells,
+                        [colId]: {
+                            value: newValue,
+                            meta: { ...cell?.meta, errors: [err], type: cell?.meta?.type ?? 'text' },
+                        },
+                    },
+                };
+                this._engine.rowData.set(rows);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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