@ricsam/formula-engine 0.0.16 → 0.0.18

package/dist/cjs/core/managers/copy-manager.cjs

@@ -35,7 +35,9 @@ module.exports = __toCommonJS(exports_copy_manager);
 var import_parser = require("../../parser/parser.cjs");
 var import_formatter = require("../../parser/formatter.cjs");
 var import_ast_traverser = require("../ast-traverser.cjs");
+var import_utils = require("../utils.cjs");
 var import_range_utils = require("../utils/range-utils.cjs");
+var import_cell_mover = require("../cell-mover.cjs");
 
 class CopyManager {
   workbookManager;
@@ -46,30 +48,114 @@ class CopyManager {
     this.evaluationManager = evaluationManager;
     this.styleManager = styleManager;
   }
-  copyCells(source, target, options) {
+  normalizeInclude(include) {
+    if (!include || include === "all") {
+      return ["content", "style", "metadata"];
+    }
+    return include;
+  }
+  shouldInclude(options, part) {
+    const normalized = this.normalizeInclude(options.include);
+    return normalized.includes(part);
+  }
+  pasteCells(source, target, options) {
     if (source.length === 0) {
       return;
     }
+    if (options.cut === true) {
+      return this.cutCells(source, target, options);
+    } else {
+      return this.copyOnlyCells(source, target, options);
+    }
+  }
+  cutCells(source, target, options) {
+    const topLeft = this.findTopLeft(source);
+    const rowOffset = target.rowIndex - topLeft.rowIndex;
+    const colOffset = target.colIndex - topLeft.colIndex;
+    const snapshot = this.snapshotCellsWithStyles(source);
+    this.clearSourceCells(source);
+    if (this.shouldInclude(options, "style")) {
+      for (const cell of source) {
+        const cellRange = {
+          workbookName: cell.workbookName,
+          sheetName: cell.sheetName,
+          range: {
+            start: { col: cell.colIndex, row: cell.rowIndex },
+            end: {
+              col: { type: "number", value: cell.colIndex },
+              row: { type: "number", value: cell.rowIndex }
+            }
+          }
+        };
+        this.styleManager.clearCellStylesInRange(cellRange);
+      }
+    }
+    const movedCellsSet = new Set(source.map((c) => `${c.workbookName}:${c.sheetName}:${c.colIndex}:${c.rowIndex}`));
+    const movedCellsInfo = {
+      cellsSet: movedCellsSet,
+      workbookName: topLeft.workbookName,
+      sheetName: topLeft.sheetName,
+      rowOffset,
+      colOffset
+    };
+    this.workbookManager.updateFormulasExcluding(movedCellsSet, (formula) => import_cell_mover.updateReferencesForMovedCells(formula, movedCellsInfo));
+    for (let i = 0;i < snapshot.length; i++) {
+      const snap = snapshot[i];
+      const sourceCell = source[i];
+      const targetCell = {
+        workbookName: target.workbookName,
+        sheetName: target.sheetName,
+        colIndex: sourceCell.colIndex + colOffset,
+        rowIndex: sourceCell.rowIndex + rowOffset
+      };
+      if (this.shouldInclude(options, "content") && snap.content) {
+        let targetContent = snap.content;
+        if (typeof snap.content === "string" && snap.content.startsWith("=")) {
+          targetContent = this.adjustFormulaReferences(snap.content, {
+            colIndex: snap.address.colIndex,
+            rowIndex: snap.address.rowIndex
+          }, {
+            colIndex: targetCell.colIndex,
+            rowIndex: targetCell.rowIndex
+          });
+        }
+        this.workbookManager.setCellContent(targetCell, targetContent);
+      }
+      if (this.shouldInclude(options, "metadata")) {
+        if (snap.metadata) {
+          this.workbookManager.setCellMetadata(targetCell, {
+            ...snap.metadata
+          });
+        } else {
+          this.workbookManager.setCellMetadata(targetCell, undefined);
+        }
+      }
+      if (this.shouldInclude(options, "style")) {
+        this.applyStylesFromSnapshot(snap, targetCell);
+      }
+    }
+  }
+  copyOnlyCells(source, target, options) {
     const topLeft = this.findTopLeft(source);
     const rowOffset = target.rowIndex - topLeft.rowIndex;
     const colOffset = target.colIndex - topLeft.colIndex;
-    if (options.target !== "style") {
-      for (const sourceCell of source) {
+    const snapshot = this.snapshotCells(source);
+    if (this.shouldInclude(options, "content")) {
+      for (let i = 0;i < source.length; i++) {
+        const sourceCell = source[i];
+        const cellSnapshot = snapshot[i];
         const targetCell = {
           workbookName: target.workbookName,
           sheetName: target.sheetName,
           colIndex: sourceCell.colIndex + colOffset,
           rowIndex: sourceCell.rowIndex + rowOffset
         };
-        this.copyCellContent(sourceCell, targetCell, topLeft, options);
+        this.copyCellContentFromSnapshot(cellSnapshot, targetCell, topLeft, options);
       }
     }
-    if (options.target === "all" || options.target === "style") {
+    if (this.shouldInclude(options, "style")) {
       this.copyFormatting(source, topLeft, target, rowOffset, colOffset);
     }
-    if (options.cut) {
-      this.clearSourceCells(source);
-    }
   }
   findTopLeft(cells) {
     let minRow = Infinity;
@@ -84,6 +170,141 @@ class CopyManager {
     }
     return topLeftCell;
   }
+  snapshotCells(cells) {
+    return cells.map((cell) => {
+      const sheet = this.workbookManager.getSheet({
+        workbookName: cell.workbookName,
+        sheetName: cell.sheetName
+      });
+      const key = `${String.fromCharCode(65 + cell.colIndex)}${cell.rowIndex + 1}`;
+      const content = sheet?.content.get(key);
+      const metadata = this.workbookManager.getCellMetadata(cell);
+      return {
+        address: cell,
+        content,
+        metadata
+      };
+    });
+  }
+  snapshotCellsWithStyles(cells) {
+    const allCellStyles = this.styleManager.getAllCellStyles();
+    const allConditionalStyles = this.styleManager.getAllConditionalStyles();
+    return cells.map((cell) => {
+      const sheet = this.workbookManager.getSheet({
+        workbookName: cell.workbookName,
+        sheetName: cell.sheetName
+      });
+      const key = import_utils.getCellReference(cell);
+      const content = sheet?.content.get(key);
+      const metadata = this.workbookManager.getCellMetadata(cell);
+      const matchingCellStyles = allCellStyles.filter((style) => style.areas.some((area) => area.workbookName === cell.workbookName && area.sheetName === cell.sheetName && import_utils.isCellInRange(cell, area.range)));
+      const matchingConditionalStyles = allConditionalStyles.filter((style) => style.areas.some((area) => area.workbookName === cell.workbookName && area.sheetName === cell.sheetName && import_utils.isCellInRange(cell, area.range)));
+      return {
+        address: cell,
+        content,
+        metadata,
+        matchingCellStyles,
+        matchingConditionalStyles
+      };
+    });
+  }
+  applyStylesFromSnapshot(snapshot, targetCell) {
+    if (snapshot.matchingCellStyles) {
+      for (const style of snapshot.matchingCellStyles) {
+        const newStyle = {
+          areas: [
+            {
+              workbookName: targetCell.workbookName,
+              sheetName: targetCell.sheetName,
+              range: {
+                start: { col: targetCell.colIndex, row: targetCell.rowIndex },
+                end: {
+                  col: { type: "number", value: targetCell.colIndex },
+                  row: { type: "number", value: targetCell.rowIndex }
+                }
+              }
+            }
+          ],
+          style: style.style
+        };
+        this.styleManager.addCellStyle(newStyle);
+      }
+    }
+    if (snapshot.matchingConditionalStyles) {
+      for (const style of snapshot.matchingConditionalStyles) {
+        const newStyle = {
+          areas: [
+            {
+              workbookName: targetCell.workbookName,
+              sheetName: targetCell.sheetName,
+              range: {
+                start: { col: targetCell.colIndex, row: targetCell.rowIndex },
+                end: {
+                  col: { type: "number", value: targetCell.colIndex },
+                  row: { type: "number", value: targetCell.rowIndex }
+                }
+              }
+            }
+          ],
+          condition: style.condition
+        };
+        this.styleManager.addConditionalStyle(newStyle);
+      }
+    }
+  }
+  copyCellContentFromSnapshot(snapshot, targetCell, sourceTopLeft, options) {
+    if (!snapshot.content) {
+      return;
+    }
+    let targetContent;
+    const copyType = options.type ?? "formula";
+    if (copyType === "value") {
+      const evalResult = this.evaluationManager.getCellEvaluationResult(snapshot.address);
+      if (!evalResult || evalResult.type !== "value") {
+        targetContent = snapshot.content;
+      } else {
+        const result = evalResult.result;
+        if (result.type === "number") {
+          targetContent = result.value;
+        } else if (result.type === "string") {
+          targetContent = result.value;
+        } else if (result.type === "boolean") {
+          targetContent = result.value;
+        } else {
+          targetContent = snapshot.content;
+        }
+      }
+    } else {
+      if (typeof snapshot.content === "string" && snapshot.content.startsWith("=")) {
+        targetContent = this.adjustFormulaReferences(snapshot.content, {
+          colIndex: snapshot.address.colIndex,
+          rowIndex: snapshot.address.rowIndex
+        }, {
+          colIndex: targetCell.colIndex,
+          rowIndex: targetCell.rowIndex
+        });
+      } else {
+        targetContent = snapshot.content;
+      }
+    }
+    const targetSheet = this.workbookManager.getSheet({
+      workbookName: targetCell.workbookName,
+      sheetName: targetCell.sheetName
+    });
+    if (targetSheet) {
+      const targetKey = `${String.fromCharCode(65 + targetCell.colIndex)}${targetCell.rowIndex + 1}`;
+      targetSheet.content.set(targetKey, targetContent);
+    }
+    if (this.shouldInclude(options, "metadata")) {
+      if (snapshot.metadata) {
+        this.workbookManager.setCellMetadata(targetCell, {
+          ...snapshot.metadata
+        });
+      } else {
+        this.workbookManager.setCellMetadata(targetCell, undefined);
+      }
+    }
+  }
   copyCellContent(sourceCell, targetCell, sourceTopLeft, options) {
     const sheet = this.workbookManager.getSheet({
       workbookName: sourceCell.workbookName,
@@ -98,7 +319,8 @@ class CopyManager {
       return;
     }
     let targetContent;
-    if (options.type === "value") {
+    const copyType = options.type ?? "formula";
+    if (copyType === "value") {
       const evalResult = this.evaluationManager.getCellEvaluationResult(sourceCell);
       if (!evalResult || evalResult.type !== "value") {
         targetContent = cellContent;
@@ -135,6 +357,14 @@ class CopyManager {
       const targetKey = `${String.fromCharCode(65 + targetCell.colIndex)}${targetCell.rowIndex + 1}`;
       targetSheet.content.set(targetKey, targetContent);
     }
+    if (this.shouldInclude(options, "metadata")) {
+      const sourceMetadata = this.workbookManager.getCellMetadata(sourceCell);
+      if (sourceMetadata) {
+        this.workbookManager.setCellMetadata(targetCell, { ...sourceMetadata });
+      } else {
+        this.workbookManager.setCellMetadata(targetCell, undefined);
+      }
+    }
   }
   adjustFormulaReferences(formula, sourceAddress, targetAddress) {
     try {
@@ -192,34 +422,42 @@ class CopyManager {
     const allConditionalStyles = this.styleManager.getAllConditionalStyles();
     const allCellStyles = this.styleManager.getAllCellStyles();
     for (const style of allConditionalStyles) {
-      if (style.area.workbookName === sourceTopLeft.workbookName && style.area.sheetName === sourceTopLeft.sheetName) {
-        const intersection = import_range_utils.intersectRanges(style.area.range, sourceRange);
-        if (intersection) {
-          const newStyle = {
-            area: {
-              workbookName: target.workbookName,
-              sheetName: target.sheetName,
-              range: this.adjustRange(intersection, rowOffset, colOffset)
-            },
-            condition: style.condition
-          };
-          this.styleManager.addConditionalStyle(newStyle);
+      for (const area of style.areas) {
+        if (area.workbookName === sourceTopLeft.workbookName && area.sheetName === sourceTopLeft.sheetName) {
+          const intersection = import_range_utils.intersectRanges(area.range, sourceRange);
+          if (intersection) {
+            const newStyle = {
+              areas: [
+                {
+                  workbookName: target.workbookName,
+                  sheetName: target.sheetName,
+                  range: this.adjustRange(intersection, rowOffset, colOffset)
+                }
+              ],
+              condition: style.condition
+            };
+            this.styleManager.addConditionalStyle(newStyle);
+          }
         }
       }
     }
     for (const style of allCellStyles) {
-      if (style.area.workbookName === sourceTopLeft.workbookName && style.area.sheetName === sourceTopLeft.sheetName) {
-        const intersection = import_range_utils.intersectRanges(style.area.range, sourceRange);
-        if (intersection) {
-          const newStyle = {
-            area: {
-              workbookName: target.workbookName,
-              sheetName: target.sheetName,
-              range: this.adjustRange(intersection, rowOffset, colOffset)
-            },
-            style: style.style
-          };
-          this.styleManager.addCellStyle(newStyle);
+      for (const area of style.areas) {
+        if (area.workbookName === sourceTopLeft.workbookName && area.sheetName === sourceTopLeft.sheetName) {
+          const intersection = import_range_utils.intersectRanges(area.range, sourceRange);
+          if (intersection) {
+            const newStyle = {
+              areas: [
+                {
+                  workbookName: target.workbookName,
+                  sheetName: target.sheetName,
+                  range: this.adjustRange(intersection, rowOffset, colOffset)
+                }
+              ],
+              style: style.style
+            };
+            this.styleManager.addCellStyle(newStyle);
+          }
         }
       }
     }
@@ -257,22 +495,15 @@ class CopyManager {
   }
   clearSourceCells(cells) {
     for (const cell of cells) {
-      const sheet = this.workbookManager.getSheet({
-        workbookName: cell.workbookName,
-        sheetName: cell.sheetName
-      });
-      if (sheet) {
-        const key = `${String.fromCharCode(65 + cell.colIndex)}${cell.rowIndex + 1}`;
-        sheet.content.delete(key);
-      }
+      this.workbookManager.setCellContent(cell, "");
     }
   }
   fillAreas(seedRange, targetRanges, options) {
     for (const targetRange of targetRanges) {
       this.fillRangeWithSeed(seedRange, targetRange, {
-        copyContent: options.target !== "style",
-        copyStyles: options.target === "all" || options.target === "style",
-        contentType: options.type,
+        copyContent: this.shouldInclude(options, "content"),
+        copyStyles: this.shouldInclude(options, "style"),
+        contentType: options.type ?? "formula",
         adjustFormulas: true
       });
     }
@@ -308,7 +539,7 @@ class CopyManager {
             this.copyCellContentWithOffset(seedCell, targetCell, rowDelta, colDelta, {
               type: options.contentType,
               cut: false,
-              target: "content"
+              include: ["content"]
             });
           }
           if (options.copyStyles) {
@@ -346,7 +577,7 @@ class CopyManager {
             this.copyCellContentWithOffset(sourceCell, targetCell, 0, colDelta, {
               type: options.contentType,
               cut: false,
-              target: "content"
+              include: ["content"]
             });
           }
           if (options.copyStyles) {
@@ -419,7 +650,8 @@ class CopyManager {
       return;
     }
     let targetContent;
-    if (options.type === "value") {
+    const copyType = options.type ?? "formula";
+    if (copyType === "value") {
       const evalResult = this.evaluationManager.getCellEvaluationResult(sourceCell);
       if (!evalResult || evalResult.type !== "value") {
         targetContent = cellContent;
@@ -450,6 +682,14 @@ class CopyManager {
       const targetKey = `${String.fromCharCode(65 + targetCell.colIndex)}${targetCell.rowIndex + 1}`;
       targetSheet.content.set(targetKey, targetContent);
     }
+    if (this.shouldInclude(options, "metadata")) {
+      const sourceMetadata = this.workbookManager.getCellMetadata(sourceCell);
+      if (sourceMetadata) {
+        this.workbookManager.setCellMetadata(targetCell, { ...sourceMetadata });
+      } else {
+        this.workbookManager.setCellMetadata(targetCell, undefined);
+      }
+    }
   }
   adjustFormulaWithOffset(formula, rowDelta, colDelta) {
     try {
@@ -517,50 +757,64 @@ class CopyManager {
       }
     };
     for (const style of allConditionalStyles) {
-      if (style.area.workbookName === sourceCell.workbookName && style.area.sheetName === sourceCell.sheetName) {
-        const intersection = import_range_utils.intersectRanges(style.area.range, sourceCellRange);
-        if (intersection) {
-          const newStyle = {
-            area: {
-              workbookName: targetCell.workbookName,
-              sheetName: targetCell.sheetName,
-              range: {
-                start: { col: targetCell.colIndex, row: targetCell.rowIndex },
-                end: {
-                  col: { type: "number", value: targetCell.colIndex },
-                  row: { type: "number", value: targetCell.rowIndex }
+      for (const area of style.areas) {
+        if (area.workbookName === sourceCell.workbookName && area.sheetName === sourceCell.sheetName) {
+          const intersection = import_range_utils.intersectRanges(area.range, sourceCellRange);
+          if (intersection) {
+            const newStyle = {
+              areas: [
+                {
+                  workbookName: targetCell.workbookName,
+                  sheetName: targetCell.sheetName,
+                  range: {
+                    start: {
+                      col: targetCell.colIndex,
+                      row: targetCell.rowIndex
+                    },
+                    end: {
+                      col: { type: "number", value: targetCell.colIndex },
+                      row: { type: "number", value: targetCell.rowIndex }
+                    }
+                  }
                 }
-              }
-            },
-            condition: style.condition
-          };
-          this.styleManager.addConditionalStyle(newStyle);
+              ],
+              condition: style.condition
+            };
+            this.styleManager.addConditionalStyle(newStyle);
+          }
         }
       }
     }
     for (const style of allCellStyles) {
-      if (style.area.workbookName === sourceCell.workbookName && style.area.sheetName === sourceCell.sheetName) {
-        const intersection = import_range_utils.intersectRanges(style.area.range, sourceCellRange);
-        if (intersection) {
-          const newStyle = {
-            area: {
-              workbookName: targetCell.workbookName,
-              sheetName: targetCell.sheetName,
-              range: {
-                start: { col: targetCell.colIndex, row: targetCell.rowIndex },
-                end: {
-                  col: { type: "number", value: targetCell.colIndex },
-                  row: { type: "number", value: targetCell.rowIndex }
+      for (const area of style.areas) {
+        if (area.workbookName === sourceCell.workbookName && area.sheetName === sourceCell.sheetName) {
+          const intersection = import_range_utils.intersectRanges(area.range, sourceCellRange);
+          if (intersection) {
+            const newStyle = {
+              areas: [
+                {
+                  workbookName: targetCell.workbookName,
+                  sheetName: targetCell.sheetName,
+                  range: {
+                    start: {
+                      col: targetCell.colIndex,
+                      row: targetCell.rowIndex
+                    },
+                    end: {
+                      col: { type: "number", value: targetCell.colIndex },
+                      row: { type: "number", value: targetCell.rowIndex }
+                    }
+                  }
                 }
-              }
-            },
-            style: style.style
-          };
-          this.styleManager.addCellStyle(newStyle);
+              ],
+              style: style.style
+            };
+            this.styleManager.addCellStyle(newStyle);
+          }
         }
       }
     }
   }
 }
 
-//# debugId=9442C2DD8C5DC2E064756E2164756E21
+//# debugId=566F5D8EB2A3D66C64756E2164756E21