@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/renderer/models/cell.class.mjs

@@ -0,0 +1,389 @@
+/**
+ * Cell class - represents individual cell instances
+ * Combines ColumnConfig (Flyweight) with CellState (unique per instance)
+ */
+import { createCellState, createMemento, restoreFromMemento, canEdit, isCellValid } from './cell-state.interface';
+import { CellLifecycleState, EditMode } from '../../models/cell-types';
+/**
+ * Cell class implementing the Flyweight pattern
+ * - References shared ColumnConfig (Flyweight)
+ * - Owns unique CellState (Flyweight Context)
+ */
+export class Cell {
+    constructor(columnConfig, initialValue, rowData, rowIndex) {
+        /**
+         * History of state mementos for undo/redo
+         */
+        this.history = [];
+        /**
+         * Current position in history
+         */
+        this.historyIndex = -1;
+        /**
+         * Maximum history size
+         */
+        this.maxHistorySize = 10;
+        this.columnConfig = columnConfig;
+        this.state = createCellState(initialValue);
+        this.rowData = rowData;
+        this.rowIndex = rowIndex;
+        // Save initial state to history
+        this.saveToHistory();
+    }
+    /**
+     * Get current cell value
+     */
+    getValue() {
+        return this.state.value;
+    }
+    /**
+     * Set cell value
+     * @param value New value
+     * @param skipValidation Skip validation (useful for programmatic sets)
+     */
+    setValue(value, skipValidation = false) {
+        const previousValue = this.state.value;
+        // Call before change hook
+        if (this.columnConfig.hooks?.onChange) {
+            this.columnConfig.hooks.onChange(this.createEvent(value, previousValue));
+        }
+        this.state.value = value;
+        this.state.isDirty = true;
+        this.state.lastModified = new Date();
+        // Validate if not skipped
+        if (!skipValidation) {
+            const validationResult = this.validate();
+            if (!validationResult.valid) {
+                return false;
+            }
+        }
+        this.saveToHistory();
+        return true;
+    }
+    /**
+     * Render cell value as formatted string (delegates to formatter strategy)
+     */
+    render() {
+        if (!this.columnConfig.formatter) {
+            return String(this.state.value ?? '');
+        }
+        if (this.columnConfig.formatter.formatWithContext) {
+            return this.columnConfig.formatter.formatWithContext(this.state.value, this.rowData, this.columnConfig.key);
+        }
+        // Ensure format method exists before calling it
+        if (this.columnConfig.formatter.format) {
+            return this.columnConfig.formatter.format(this.state.value);
+        }
+        // Fallback if formatter exists but has no methods
+        return String(this.state.value ?? '');
+    }
+    /**
+     * Validate cell value (delegates to validator strategy)
+     */
+    validate() {
+        // Clear previous errors
+        this.state.error = undefined;
+        this.state.errors = undefined;
+        this.state.lastValidated = new Date();
+        if (!this.columnConfig.validator) {
+            return { valid: true };
+        }
+        const result = this.columnConfig.validator.validateWithContext
+            ? this.columnConfig.validator.validateWithContext(this.state.value, this.rowData, this.columnConfig.key)
+            : this.columnConfig.validator.validate(this.state.value);
+        if (!result.valid) {
+            this.state.error = result.error;
+            this.state.errors = result.errors;
+            this.state.lifecycleState = CellLifecycleState.ERROR;
+            // Call validation error hook
+            if (this.columnConfig.hooks?.onValidationError) {
+                this.columnConfig.hooks.onValidationError(this.createEvent(this.state.value));
+            }
+        }
+        return result;
+    }
+    /**
+     * Start edit mode
+     */
+    startEdit() {
+        // Check if cell can be edited
+        if (!this.canEdit()) {
+            return false;
+        }
+        // Call before edit hook
+        if (this.columnConfig.hooks?.beforeEdit) {
+            this.columnConfig.hooks.beforeEdit(this.createEvent(this.state.value));
+        }
+        // Save current value as previous
+        this.state.previousValue = this.state.value;
+        this.state.isEditing = true;
+        this.state.lifecycleState = CellLifecycleState.EDITING;
+        // Call on edit hook
+        if (this.columnConfig.hooks?.onEdit) {
+            this.columnConfig.hooks.onEdit(this.createEvent(this.state.value));
+        }
+        return true;
+    }
+    /**
+     * Save edited value
+     * @param newValue The new value from editor
+     */
+    saveEdit(newValue) {
+        if (!this.state.isEditing) {
+            return false;
+        }
+        // Call before save hook
+        if (this.columnConfig.hooks?.beforeSave) {
+            this.columnConfig.hooks.beforeSave(this.createEvent(newValue, this.state.previousValue));
+        }
+        // Parse value if parser is provided
+        let parsedValue = newValue;
+        if (this.columnConfig.parser) {
+            try {
+                parsedValue = this.columnConfig.parser.parse(newValue);
+            }
+            catch (error) {
+                this.state.error = `Failed to parse value: ${error}`;
+                return false;
+            }
+        }
+        // Validate
+        const previousValue = this.state.value;
+        this.state.value = parsedValue;
+        const validationResult = this.validate();
+        if (!validationResult.valid) {
+            this.state.value = previousValue; // Revert on validation failure
+            return false;
+        }
+        // Mark as dirty if value changed
+        this.state.isDirty = this.state.value !== this.state.originalValue;
+        this.state.isEditing = false;
+        this.state.lifecycleState = CellLifecycleState.DISPLAY;
+        this.state.lastModified = new Date();
+        // Save to history
+        this.saveToHistory();
+        // Call after save hook
+        if (this.columnConfig.hooks?.onSave) {
+            this.columnConfig.hooks.onSave(this.createEvent(parsedValue, previousValue));
+        }
+        // Call after edit hook
+        if (this.columnConfig.hooks?.afterEdit) {
+            this.columnConfig.hooks.afterEdit(this.createEvent(parsedValue));
+        }
+        return true;
+    }
+    /**
+     * Cancel edit and revert to previous value
+     */
+    cancelEdit() {
+        if (!this.state.isEditing) {
+            return;
+        }
+        // Revert to previous value
+        if (this.state.previousValue !== undefined) {
+            this.state.value = this.state.previousValue;
+        }
+        this.state.isEditing = false;
+        this.state.lifecycleState = CellLifecycleState.DISPLAY;
+        this.state.error = undefined;
+        this.state.errors = undefined;
+        // Call cancel hook
+        if (this.columnConfig.hooks?.onCancel) {
+            this.columnConfig.hooks.onCancel(this.createEvent(this.state.value));
+        }
+        // Call after edit hook
+        if (this.columnConfig.hooks?.afterEdit) {
+            this.columnConfig.hooks.afterEdit(this.createEvent(this.state.value));
+        }
+    }
+    /**
+     * Reset cell to original value
+     */
+    reset() {
+        if (this.state.originalValue !== undefined) {
+            this.state.value = this.state.originalValue;
+            this.state.isDirty = false;
+            this.state.error = undefined;
+            this.state.errors = undefined;
+            this.state.isEditing = false;
+            this.state.lifecycleState = CellLifecycleState.DISPLAY;
+        }
+    }
+    /**
+     * Check if cell can be edited
+     */
+    canEdit() {
+        return (this.columnConfig.editable === true &&
+            this.columnConfig.editMode !== EditMode.NONE &&
+            canEdit(this.state));
+    }
+    /**
+     * Check if cell is valid
+     */
+    isValid() {
+        return isCellValid(this.state);
+    }
+    /**
+     * Check if cell is dirty (modified)
+     */
+    isDirty() {
+        return this.state.isDirty;
+    }
+    /**
+     * Check if cell is in edit mode
+     */
+    isEditing() {
+        return this.state.isEditing;
+    }
+    /**
+     * Set focus state on this cell
+     */
+    focus() {
+        this.state.isFocused = true;
+    }
+    /**
+     * Remove focus from this cell
+     */
+    blur() {
+        this.state.isFocused = false;
+    }
+    /**
+     * Check if this cell is focused
+     */
+    isFocused() {
+        return this.state.isFocused ?? false;
+    }
+    /**
+     * Get current cell state (Memento pattern)
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Restore cell state from snapshot (Memento pattern)
+     */
+    restoreState(state) {
+        this.state = { ...state };
+    }
+    /**
+     * Get column configuration (readonly access)
+     */
+    getColumnConfig() {
+        return this.columnConfig;
+    }
+    /**
+     * Get row data context
+     */
+    getRowData() {
+        return this.rowData;
+    }
+    /**
+     * Get row index
+     */
+    getRowIndex() {
+        return this.rowIndex;
+    }
+    /**
+     * Set loading state
+     */
+    setLoading(isLoading) {
+        this.state.isLoading = isLoading;
+    }
+    /**
+     * Set disabled state
+     */
+    setDisabled(isDisabled) {
+        this.state.isDisabled = isDisabled;
+    }
+    /**
+     * Set readonly state
+     */
+    setReadonly(isReadonly) {
+        this.state.isReadonly = isReadonly;
+    }
+    /**
+     * Save current state to history
+     */
+    saveToHistory() {
+        // Remove any states after current position (for redo invalidation)
+        this.history = this.history.slice(0, this.historyIndex + 1);
+        // Add current state
+        this.history.push(createMemento(this.state));
+        this.historyIndex = this.history.length - 1;
+        // Limit history size
+        if (this.history.length > this.maxHistorySize) {
+            this.history.shift();
+            this.historyIndex--;
+        }
+    }
+    /**
+     * Undo last change
+     */
+    undo() {
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            const memento = this.history[this.historyIndex];
+            this.state = restoreFromMemento(this.state, memento);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Redo last undone change
+     */
+    redo() {
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            const memento = this.history[this.historyIndex];
+            this.state = restoreFromMemento(this.state, memento);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if undo is available
+     */
+    canUndo() {
+        return this.historyIndex > 0;
+    }
+    /**
+     * Check if redo is available
+     */
+    canRedo() {
+        return this.historyIndex < this.history.length - 1;
+    }
+    /**
+     * Create cell event for hooks
+     */
+    createEvent(value, previousValue) {
+        return {
+            value,
+            previousValue: previousValue ?? this.state.previousValue,
+            rowData: this.rowData,
+            columnKey: this.columnConfig.key,
+            rowIndex: this.rowIndex
+        };
+    }
+    /**
+     * Get cell metadata
+     */
+    getMetadata(key) {
+        return this.state.metadata?.[key];
+    }
+    /**
+     * Set cell metadata
+     */
+    setMetadata(key, value) {
+        if (!this.state.metadata) {
+            this.state.metadata = {};
+        }
+        this.state.metadata[key] = value;
+    }
+    /**
+     * Clear all metadata
+     */
+    clearMetadata() {
+        this.state.metadata = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell.class.js","sourceRoot":"","sources":["../../../../../../projects/smart-table/src/lib/renderer/models/cell.class.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cell class - represents individual cell instances\n * Combines ColumnConfig (Flyweight) with CellState (unique per instance)\n */\n\nimport { ColumnConfig } from '../../models/column-config.interface';\nimport { CellState, createCellState, CellStateMemento, createMemento, restoreFromMemento, canEdit, isCellValid } from './cell-state.interface';\nimport { ValidationResult, CellLifecycleState, CellEvent, EditMode } from '../../models/cell-types';\n\n/**\n * Cell class implementing the Flyweight pattern\n * - References shared ColumnConfig (Flyweight)\n * - Owns unique CellState (Flyweight Context)\n */\nexport class Cell<T = any> {\n  /**\n   * Shared column configuration (Flyweight - reference only, not owned)\n   */\n  private readonly columnConfig: ColumnConfig<T>;\n\n  /**\n   * Unique cell state (owned by this instance)\n   */\n  private state: CellState<T>;\n\n  /**\n   * Row data context (reference to parent row data)\n   */\n  private rowData?: any;\n\n  /**\n   * Row index in table\n   */\n  private rowIndex?: number;\n\n  /**\n   * History of state mementos for undo/redo\n   */\n  private history: CellStateMemento<T>[] = [];\n\n  /**\n   * Current position in history\n   */\n  private historyIndex: number = -1;\n\n  /**\n   * Maximum history size\n   */\n  private readonly maxHistorySize: number = 10;\n\n  constructor(\n    columnConfig: ColumnConfig<T>,\n    initialValue: T,\n    rowData?: any,\n    rowIndex?: number\n  ) {\n    this.columnConfig = columnConfig;\n    this.state = createCellState(initialValue);\n    this.rowData = rowData;\n    this.rowIndex = rowIndex;\n    \n    // Save initial state to history\n    this.saveToHistory();\n  }\n\n  /**\n   * Get current cell value\n   */\n  getValue(): T {\n    return this.state.value;\n  }\n\n  /**\n   * Set cell value\n   * @param value New value\n   * @param skipValidation Skip validation (useful for programmatic sets)\n   */\n  setValue(value: T, skipValidation: boolean = false): boolean {\n    const previousValue = this.state.value;\n\n    // Call before change hook\n    if (this.columnConfig.hooks?.onChange) {\n      this.columnConfig.hooks.onChange(this.createEvent(value, previousValue));\n    }\n\n    this.state.value = value;\n    this.state.isDirty = true;\n    this.state.lastModified = new Date();\n\n    // Validate if not skipped\n    if (!skipValidation) {\n      const validationResult = this.validate();\n      if (!validationResult.valid) {\n        return false;\n      }\n    }\n\n    this.saveToHistory();\n    return true;\n  }\n\n  /**\n   * Render cell value as formatted string (delegates to formatter strategy)\n   */\n  render(): string {\n    if (!this.columnConfig.formatter) {\n      return String(this.state.value ?? '');\n    }\n\n    if (this.columnConfig.formatter.formatWithContext) {\n      return this.columnConfig.formatter.formatWithContext(\n        this.state.value,\n        this.rowData,\n        this.columnConfig.key\n      );\n    }\n\n    // Ensure format method exists before calling it\n    if (this.columnConfig.formatter.format) {\n      return this.columnConfig.formatter.format(this.state.value);\n    }\n\n    // Fallback if formatter exists but has no methods\n    return String(this.state.value ?? '');\n  }\n\n  /**\n   * Validate cell value (delegates to validator strategy)\n   */\n  validate(): ValidationResult {\n    // Clear previous errors\n    this.state.error = undefined;\n    this.state.errors = undefined;\n    this.state.lastValidated = new Date();\n\n    if (!this.columnConfig.validator) {\n      return { valid: true };\n    }\n\n    const result = this.columnConfig.validator.validateWithContext\n      ? this.columnConfig.validator.validateWithContext(\n          this.state.value,\n          this.rowData,\n          this.columnConfig.key\n        )\n      : this.columnConfig.validator.validate(this.state.value);\n\n    if (!result.valid) {\n      this.state.error = result.error;\n      this.state.errors = result.errors;\n      this.state.lifecycleState = CellLifecycleState.ERROR;\n\n      // Call validation error hook\n      if (this.columnConfig.hooks?.onValidationError) {\n        this.columnConfig.hooks.onValidationError(this.createEvent(this.state.value));\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Start edit mode\n   */\n  startEdit(): boolean {\n    // Check if cell can be edited\n    if (!this.canEdit()) {\n      return false;\n    }\n\n    // Call before edit hook\n    if (this.columnConfig.hooks?.beforeEdit) {\n      this.columnConfig.hooks.beforeEdit(this.createEvent(this.state.value));\n    }\n\n    // Save current value as previous\n    this.state.previousValue = this.state.value;\n    this.state.isEditing = true;\n    this.state.lifecycleState = CellLifecycleState.EDITING;\n\n    // Call on edit hook\n    if (this.columnConfig.hooks?.onEdit) {\n      this.columnConfig.hooks.onEdit(this.createEvent(this.state.value));\n    }\n\n    return true;\n  }\n\n  /**\n   * Save edited value\n   * @param newValue The new value from editor\n   */\n  saveEdit(newValue: T): boolean {\n    if (!this.state.isEditing) {\n      return false;\n    }\n\n    // Call before save hook\n    if (this.columnConfig.hooks?.beforeSave) {\n      this.columnConfig.hooks.beforeSave(this.createEvent(newValue, this.state.previousValue));\n    }\n\n    // Parse value if parser is provided\n    let parsedValue = newValue;\n    if (this.columnConfig.parser) {\n      try {\n        parsedValue = this.columnConfig.parser.parse(newValue);\n      } catch (error) {\n        this.state.error = `Failed to parse value: ${error}`;\n        return false;\n      }\n    }\n\n    // Validate\n    const previousValue = this.state.value;\n    this.state.value = parsedValue;\n    const validationResult = this.validate();\n\n    if (!validationResult.valid) {\n      this.state.value = previousValue; // Revert on validation failure\n      return false;\n    }\n\n    // Mark as dirty if value changed\n    this.state.isDirty = this.state.value !== this.state.originalValue;\n    this.state.isEditing = false;\n    this.state.lifecycleState = CellLifecycleState.DISPLAY;\n    this.state.lastModified = new Date();\n\n    // Save to history\n    this.saveToHistory();\n\n    // Call after save hook\n    if (this.columnConfig.hooks?.onSave) {\n      this.columnConfig.hooks.onSave(this.createEvent(parsedValue, previousValue));\n    }\n\n    // Call after edit hook\n    if (this.columnConfig.hooks?.afterEdit) {\n      this.columnConfig.hooks.afterEdit(this.createEvent(parsedValue));\n    }\n\n    return true;\n  }\n\n  /**\n   * Cancel edit and revert to previous value\n   */\n  cancelEdit(): void {\n    if (!this.state.isEditing) {\n      return;\n    }\n\n    // Revert to previous value\n    if (this.state.previousValue !== undefined) {\n      this.state.value = this.state.previousValue;\n    }\n\n    this.state.isEditing = false;\n    this.state.lifecycleState = CellLifecycleState.DISPLAY;\n    this.state.error = undefined;\n    this.state.errors = undefined;\n\n    // Call cancel hook\n    if (this.columnConfig.hooks?.onCancel) {\n      this.columnConfig.hooks.onCancel(this.createEvent(this.state.value));\n    }\n\n    // Call after edit hook\n    if (this.columnConfig.hooks?.afterEdit) {\n      this.columnConfig.hooks.afterEdit(this.createEvent(this.state.value));\n    }\n  }\n\n  /**\n   * Reset cell to original value\n   */\n  reset(): void {\n    if (this.state.originalValue !== undefined) {\n      this.state.value = this.state.originalValue;\n      this.state.isDirty = false;\n      this.state.error = undefined;\n      this.state.errors = undefined;\n      this.state.isEditing = false;\n      this.state.lifecycleState = CellLifecycleState.DISPLAY;\n    }\n  }\n\n  /**\n   * Check if cell can be edited\n   */\n  canEdit(): boolean {\n    return (\n      this.columnConfig.editable === true &&\n      this.columnConfig.editMode !== EditMode.NONE &&\n      canEdit(this.state)\n    );\n  }\n\n  /**\n   * Check if cell is valid\n   */\n  isValid(): boolean {\n    return isCellValid(this.state);\n  }\n\n  /**\n   * Check if cell is dirty (modified)\n   */\n  isDirty(): boolean {\n    return this.state.isDirty;\n  }\n\n  /**\n   * Check if cell is in edit mode\n   */\n  isEditing(): boolean {\n    return this.state.isEditing;\n  }\n\n  /**\n   * Set focus state on this cell\n   */\n  focus(): void {\n    this.state.isFocused = true;\n  }\n  \n  /**\n   * Remove focus from this cell\n   */\n  blur(): void {\n    this.state.isFocused = false;\n  }\n  \n  /**\n   * Check if this cell is focused\n   */\n  isFocused(): boolean {\n    return this.state.isFocused ?? false;\n  }\n\n  /**\n   * Get current cell state (Memento pattern)\n   */\n  getState(): CellState<T> {\n    return { ...this.state };\n  }\n\n  /**\n   * Restore cell state from snapshot (Memento pattern)\n   */\n  restoreState(state: CellState<T>): void {\n    this.state = { ...state };\n  }\n\n  /**\n   * Get column configuration (readonly access)\n   */\n  getColumnConfig(): Readonly<ColumnConfig<T>> {\n    return this.columnConfig;\n  }\n\n  /**\n   * Get row data context\n   */\n  getRowData(): any {\n    return this.rowData;\n  }\n\n  /**\n   * Get row index\n   */\n  getRowIndex(): number | undefined {\n    return this.rowIndex;\n  }\n\n  /**\n   * Set loading state\n   */\n  setLoading(isLoading: boolean): void {\n    this.state.isLoading = isLoading;\n  }\n\n  /**\n   * Set disabled state\n   */\n  setDisabled(isDisabled: boolean): void {\n    this.state.isDisabled = isDisabled;\n  }\n\n  /**\n   * Set readonly state\n   */\n  setReadonly(isReadonly: boolean): void {\n    this.state.isReadonly = isReadonly;\n  }\n\n  /**\n   * Save current state to history\n   */\n  private saveToHistory(): void {\n    // Remove any states after current position (for redo invalidation)\n    this.history = this.history.slice(0, this.historyIndex + 1);\n\n    // Add current state\n    this.history.push(createMemento(this.state));\n    this.historyIndex = this.history.length - 1;\n\n    // Limit history size\n    if (this.history.length > this.maxHistorySize) {\n      this.history.shift();\n      this.historyIndex--;\n    }\n  }\n\n  /**\n   * Undo last change\n   */\n  undo(): boolean {\n    if (this.historyIndex > 0) {\n      this.historyIndex--;\n      const memento = this.history[this.historyIndex];\n      this.state = restoreFromMemento(this.state, memento);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Redo last undone change\n   */\n  redo(): boolean {\n    if (this.historyIndex < this.history.length - 1) {\n      this.historyIndex++;\n      const memento = this.history[this.historyIndex];\n      this.state = restoreFromMemento(this.state, memento);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Check if undo is available\n   */\n  canUndo(): boolean {\n    return this.historyIndex > 0;\n  }\n\n  /**\n   * Check if redo is available\n   */\n  canRedo(): boolean {\n    return this.historyIndex < this.history.length - 1;\n  }\n\n  /**\n   * Create cell event for hooks\n   */\n  private createEvent(value: T, previousValue?: T): CellEvent<T> {\n    return {\n      value,\n      previousValue: previousValue ?? this.state.previousValue,\n      rowData: this.rowData,\n      columnKey: this.columnConfig.key,\n      rowIndex: this.rowIndex\n    };\n  }\n\n  /**\n   * Get cell metadata\n   */\n  getMetadata(key: string): any {\n    return this.state.metadata?.[key];\n  }\n\n  /**\n   * Set cell metadata\n   */\n  setMetadata(key: string, value: any): void {\n    if (!this.state.metadata) {\n      this.state.metadata = {};\n    }\n    this.state.metadata[key] = value;\n  }\n\n  /**\n   * Clear all metadata\n   */\n  clearMetadata(): void {\n    this.state.metadata = undefined;\n  }\n}\n\n"]}

package/esm2020/lib/renderer/models/row-validation-state.interface.mjs

@@ -0,0 +1,7 @@
+/**
+ * Row validation state interface
+ * Represents an INVALID row with accumulated cell errors
+ * Note: Valid rows are not stored - absence of a row state means the row is valid
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LXZhbGlkYXRpb24tc3RhdGUuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtdGFibGUvc3JjL2xpYi9yZW5kZXJlci9tb2RlbHMvcm93LXZhbGlkYXRpb24tc3RhdGUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJvdyB2YWxpZGF0aW9uIHN0YXRlIGludGVyZmFjZVxuICogUmVwcmVzZW50cyBhbiBJTlZBTElEIHJvdyB3aXRoIGFjY3VtdWxhdGVkIGNlbGwgZXJyb3JzXG4gKiBOb3RlOiBWYWxpZCByb3dzIGFyZSBub3Qgc3RvcmVkIC0gYWJzZW5jZSBvZiBhIHJvdyBzdGF0ZSBtZWFucyB0aGUgcm93IGlzIHZhbGlkXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBSb3dWYWxpZGF0aW9uU3RhdGUge1xuICAvKipcbiAgICogSW5kZXggb2YgdGhlIHJvdyBpbiB0aGUgdGFibGVcbiAgICovXG4gIHJvd0luZGV4OiBudW1iZXI7XG4gIFxuICAvKipcbiAgICogQWx3YXlzIGZhbHNlIGZvciBzdG9yZWQgc3RhdGVzIChvbmx5IGludmFsaWQgcm93cyBhcmUgc3RvcmVkKVxuICAgKi9cbiAgaXNWYWxpZDogZmFsc2U7XG4gIFxuICAvKipcbiAgICogTnVtYmVyIG9mIGludmFsaWQgY2VsbHMgaW4gdGhlIHJvd1xuICAgKi9cbiAgaW52YWxpZENlbGxDb3VudDogbnVtYmVyO1xuICBcbiAgLyoqXG4gICAqIE1hcCBvZiBjb2x1bW4ga2V5cyB0byB2YWxpZGF0aW9uIGVycm9yIG1lc3NhZ2VzXG4gICAqL1xuICBjZWxsRXJyb3JzOiBNYXA8c3RyaW5nLCBzdHJpbmc+O1xuICBcbiAgLyoqXG4gICAqIFRpbWVzdGFtcCBvZiB0aGUgbGFzdCB2YWxpZGF0aW9uXG4gICAqL1xuICBsYXN0VmFsaWRhdGVkOiBEYXRlO1xufVxuIl19

package/esm2020/lib/renderer/models/sheet-state.class.mjs

@@ -0,0 +1,90 @@
+/**
+ * SheetState - Reactive state management for sheet operations
+ * Wraps TableState and adds sheet-level state tracking
+ */
+import { BehaviorSubject } from 'rxjs';
+import { TableState } from './table-state.class';
+/**
+ * SheetState class - Manages sheet-level state and delegates table operations
+ */
+export class SheetState {
+    /**
+     * Constructor
+     * @param config Sheet state configuration
+     * @param columns Reference to columns array for table state
+     * @param tableStateConfig Optional table state configuration
+     */
+    constructor(config, columns, tableStateConfig) {
+        this.id = config.id;
+        this.name$ = new BehaviorSubject(config.name);
+        // Initialize table state
+        this.tableState = new TableState(columns, tableStateConfig);
+        // Initialize metadata
+        const now = new Date();
+        this._metadata$ = new BehaviorSubject({
+            createdAt: now,
+            lastModified: now,
+            lastAccessed: now
+        });
+        this.metadata$ = this._metadata$.asObservable();
+    }
+    /**
+     * Update sheet name
+     * @param name New sheet name
+     */
+    updateName(name) {
+        this.name$.next(name);
+        this.updateLastModified();
+    }
+    /**
+     * Get current sheet name
+     */
+    getName() {
+        return this.name$.value;
+    }
+    /**
+     * Get complete state snapshot
+     */
+    getSnapshot() {
+        return {
+            id: this.id,
+            name: this.name$.value,
+            tableStateSnapshot: this.tableState.getState(),
+            metadata: this._metadata$.value
+        };
+    }
+    /**
+     * Reset sheet state
+     */
+    reset() {
+        this.tableState.reset();
+        this.updateLastModified();
+    }
+    /**
+     * Update last accessed timestamp
+     */
+    updateLastAccessed() {
+        const currentMetadata = this._metadata$.value;
+        this._metadata$.next({
+            ...currentMetadata,
+            lastAccessed: new Date()
+        });
+    }
+    /**
+     * Update last modified timestamp
+     */
+    updateLastModified() {
+        const currentMetadata = this._metadata$.value;
+        this._metadata$.next({
+            ...currentMetadata,
+            lastModified: new Date()
+        });
+    }
+    /**
+     * Get current metadata
+     */
+    getMetadata() {
+        return this._metadata$.value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/renderer/models/sheet-state.interface.mjs

@@ -0,0 +1,5 @@
+/**
+ * Sheet state interfaces for state management
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hlZXQtc3RhdGUuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtdGFibGUvc3JjL2xpYi9yZW5kZXJlci9tb2RlbHMvc2hlZXQtc3RhdGUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTaGVldCBzdGF0ZSBpbnRlcmZhY2VzIGZvciBzdGF0ZSBtYW5hZ2VtZW50XG4gKi9cblxuaW1wb3J0IHsgVGFibGVTdGF0ZVNuYXBzaG90IH0gZnJvbSAnLi90YWJsZS10eXBlcyc7XG5cbi8qKlxuICogQ29uZmlndXJhdGlvbiBvcHRpb25zIGZvciBpbml0aWFsaXppbmcgU2hlZXRTdGF0ZVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNoZWV0U3RhdGVDb25maWcge1xuICAvKipcbiAgICogU2hlZXQgSURcbiAgICovXG4gIGlkOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIEluaXRpYWwgc2hlZXQgbmFtZVxuICAgKi9cbiAgbmFtZTogc3RyaW5nO1xufVxuXG4vKipcbiAqIFNoZWV0IG1ldGFkYXRhIHRyYWNraW5nXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2hlZXRNZXRhZGF0YSB7XG4gIC8qKlxuICAgKiBXaGVuIHRoZSBzaGVldCB3YXMgY3JlYXRlZFxuICAgKi9cbiAgY3JlYXRlZEF0OiBEYXRlO1xuXG4gIC8qKlxuICAgKiBXaGVuIHRoZSBzaGVldCB3YXMgbGFzdCBtb2RpZmllZFxuICAgKi9cbiAgbGFzdE1vZGlmaWVkOiBEYXRlO1xuXG4gIC8qKlxuICAgKiBXaGVuIHRoZSBzaGVldCB3YXMgbGFzdCBhY2Nlc3NlZFxuICAgKi9cbiAgbGFzdEFjY2Vzc2VkOiBEYXRlO1xufVxuXG4vKipcbiAqIENvbXBsZXRlIHNuYXBzaG90IG9mIHNoZWV0IHN0YXRlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2hlZXRTdGF0ZVNuYXBzaG90IHtcbiAgLyoqXG4gICAqIFNoZWV0IElEXG4gICAqL1xuICBpZDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBTaGVldCBuYW1lXG4gICAqL1xuICBuYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRhYmxlIHN0YXRlIHNuYXBzaG90XG4gICAqL1xuICB0YWJsZVN0YXRlU25hcHNob3Q6IFRhYmxlU3RhdGVTbmFwc2hvdDtcblxuICAvKipcbiAgICogU2hlZXQgbWV0YWRhdGFcbiAgICovXG4gIG1ldGFkYXRhOiBTaGVldE1ldGFkYXRhO1xufVxuXG4iXX0=