@mcpher/gas-fakes 2.5.2 → 2.5.4

package/src/services/slidesapp/faketable.js

@@ -1,6 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import { FakePageElement, PageElementRegistry } from './fakepageelement.js';
 import { newFakeTableRow } from './faketablerow.js';
+import { newFakeTableColumn } from './faketablecolumn.js';
 
 export const newFakeTable = (...args) => {
   return Proxies.guard(new FakeTable(...args));
@@ -18,13 +19,41 @@ export class FakeTable extends FakePageElement {
   }
 
   /**
-   * Gets the rows in the table.
-   * @returns {FakeTableRow[]} The rows.
+   * Appends a new column to the right of the last column of the table.
+   * @returns {FakeTableColumn} The new appended column.
    */
-  getRows() {
-    return (this.__resource.table?.tableRows || []).map((_, index) =>
-      newFakeTableRow(this, index)
-    );
+  appendColumn() {
+    return this.insertColumn(this.getNumColumns());
+  }
+
+  /**
+   * Appends a new row below the last row of the table.
+   * @returns {FakeTableRow} The new appended row.
+   */
+  appendRow() {
+    return this.insertRow(this.getNumRows());
+  }
+
+  /**
+   * Gets a column by its index.
+   * @param {number} index The column index.
+   * @returns {FakeTableColumn} The column.
+   */
+  getColumn(index) {
+    if (index < 0 || index >= this.getNumColumns()) {
+      throw new Error(`Column index ${index} out of bounds`);
+    }
+    return newFakeTableColumn(this, index);
+  }
+
+  /**
+   * Gets a cell by its row and column index.
+   * @param {number} rowIndex The row index.
+   * @param {number} colIndex The column index.
+   * @returns {FakeTableCell} The cell.
+   */
+  getCell(rowIndex, colIndex) {
+    return this.getRow(rowIndex).getCell(colIndex);
   }
 
   /**
@@ -33,11 +62,10 @@ export class FakeTable extends FakePageElement {
    * @returns {FakeTableRow} The row.
    */
   getRow(index) {
-    const rows = this.getRows();
-    if (index < 0 || index >= rows.length) {
+    if (index < 0 || index >= this.getNumRows()) {
       throw new Error(`Row index ${index} out of bounds`);
     }
-    return rows[index];
+    return newFakeTableRow(this, index);
   }
 
   /**
@@ -57,6 +85,24 @@ export class FakeTable extends FakePageElement {
     return rows.length > 0 ? (rows[0].tableCells || []).length : 0;
   }
 
+  /**
+   * Inserts a new column at the specified index of the table.
+   * @param {number} index The index.
+   * @returns {FakeTableColumn} The new column.
+   */
+  insertColumn(index) {
+    throw new Error('Table.insertColumn() not yet implemented');
+  }
+
+  /**
+   * Inserts a new row at the specified index of the table.
+   * @param {number} index The index.
+   * @returns {FakeTableRow} The new row.
+   */
+  insertRow(index) {
+    throw new Error('Table.insertRow() not yet implemented');
+  }
+
   toString() {
     return 'Table';
   }

package/src/services/slidesapp/faketablecell.js

@@ -1,5 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeTextRange } from './faketextrange.js';
+import { newFakeFill } from './fakefill.js';
+import { ContentAlignment, CellMergeState } from '../enums/slidesenums.js';
 
 export const newFakeTableCell = (...args) => {
   return Proxies.guard(new FakeTableCell(...args));
@@ -12,30 +14,157 @@ export class FakeTableCell {
     this.__colIndex = colIndex;
   }
 
+  /**
+   * Returns the unique ID for this object.
+   * @returns {string} The ID.
+   */
+  getObjectId() {
+    return this.__table.getObjectId();
+  }
+
   get __resource() {
     return this.__table.__resource.table?.tableRows?.[this.__rowIndex]?.tableCells?.[this.__colIndex];
   }
 
+  /**
+   * Returns the 0-based column index of the table cell.
+   * @returns {number} The column index.
+   */
+  getColumnIndex() {
+    return this.__colIndex;
+  }
+
+  /**
+   * Returns the column span of the table cell.
+   * @returns {number} The column span.
+   */
+  getColumnSpan() {
+    return this.__resource?.columnSpan || 1;
+  }
+
+  /**
+   * Returns the ContentAlignment of the text in the table cell.
+   * @returns {ContentAlignment} The content alignment.
+   */
+  getContentAlignment() {
+    const alignment = this.__resource?.tableCellProperties?.contentAlignment;
+    return ContentAlignment[alignment || 'TOP'];
+  }
+
+  /**
+   * Returns the fill of the table cell.
+   * @returns {FakeFill} The fill.
+   */
+  getFill() {
+    return newFakeFill(this);
+  }
+
+  /**
+   * Returns the head cell of this table cell.
+   * @returns {FakeTableCell | null} The head cell or null.
+   */
+  getHeadCell() {
+    // Basic implementation: if this is merged, find its head.
+    // For now, return null as we don't have full merge tracking.
+    return null;
+  }
+
+  /**
+   * Returns the merge state of the table cell.
+   * @returns {CellMergeState} The merge state.
+   */
+  getMergeState() {
+    const rowSpan = this.getRowSpan();
+    const colSpan = this.getColumnSpan();
+    if (rowSpan > 1 || colSpan > 1) {
+      return CellMergeState.HEAD;
+    }
+    // TODO: Detect MERGED state if we can find the head.
+    return CellMergeState.NORMAL;
+  }
+
+  /**
+   * Returns the table column containing the current cell.
+   * @returns {FakeTableColumn} The column.
+   */
+  getParentColumn() {
+    return this.__table.getColumn(this.__colIndex);
+  }
+
+  /**
+   * Returns the table row containing the current cell.
+   * @returns {FakeTableRow} The row.
+   */
+  getParentRow() {
+    return this.__table.getRow(this.__rowIndex);
+  }
+
+  /**
+   * Returns the table containing the current cell.
+   * @returns {FakeTable} The table.
+   */
+  getParentTable() {
+    return this.__table;
+  }
+
+  /**
+   * Returns the 0-based row index of the table cell.
+   * @returns {number} The row index.
+   */
+  getRowIndex() {
+    return this.__rowIndex;
+  }
+
+  /**
+   * Returns the row span of the table cell.
+   * @returns {number} The row span.
+   */
+  getRowSpan() {
+    return this.__resource?.rowSpan || 1;
+  }
+
+  /**
+   * Sets the ContentAlignment of the text in the table cell.
+   * @param {ContentAlignment} alignment The alignment.
+   * @returns {FakeTableCell} This cell.
+   */
+  setContentAlignment(alignment) {
+    const presentationId = this.__table.__presentation.getId();
+    Slides.Presentations.batchUpdate({ requests: [{
+      updateTableCellProperties: {
+        objectId: this.__table.getObjectId(),
+        tableCellProperties: {
+          contentAlignment: alignment.toString()
+        },
+        fields: 'contentAlignment',
+        tableRange: {
+          location: {
+            rowIndex: this.__rowIndex,
+            columnIndex: this.__colIndex
+          },
+          rowSpan: 1,
+          columnSpan: 1
+        }
+      }
+    }] }, presentationId);
+    return this;
+  }
+
   /**
    * Gets the text in the cell.
    * @returns {FakeTextRange} The text range.
    */
   getText() {
-    // FakeTableCell in Slides API doesn't have a direct shape resource to pass to TextRange?
-    // Actually, TableCell has text property in Slides API.
-    // Wait, let's check Slides API TableCell resource.
-    // It has `text` field of type `TextContent`.
-    // FakeTextRange expects a `shape` with `__resource.shape.text`.
-    // We might need to adapt FakeTextRange or mock a shape-like object.
-
-    // Let's create a proxy for shape so FakeTextRange can work.
     const mockShape = {
       getObjectId: () => this.__table.getObjectId(),
-      __resource: {
-        shape: {
-          text: this.__resource?.text || { textElements: [] }
-        }
+      get __resource() {
+        return {
+          shape: {
+            text: this.__target.__resource?.text || { textElements: [] }
+          }
+        };
       },
+      __target: this,
       __cellLocation: {
         rowIndex: this.__rowIndex,
         columnIndex: this.__colIndex

package/src/services/slidesapp/faketablecellrange.js

@@ -0,0 +1,28 @@
+import { Proxies } from '../../support/proxies.js';
+
+/**
+ * create a new FakeTableCellRange instance
+ * @param  {...any} args 
+ * @returns {FakeTableCellRange}
+ */
+export const newFakeTableCellRange = (...args) => {
+  return Proxies.guard(new FakeTableCellRange(...args));
+};
+
+export class FakeTableCellRange {
+  constructor(cells) {
+    this.__cells = cells;
+  }
+
+  /**
+   * Returns the list of TableCell instances.
+   * @returns {FakeTableCell[]} The cells.
+   */
+  getTableCells() {
+    return this.__cells;
+  }
+
+  toString() {
+    return 'TableCellRange';
+  }
+}

package/src/services/slidesapp/faketablecolumn.js

@@ -0,0 +1,72 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeTableCell } from './faketablecell.js';
+
+/**
+ * create a new FakeTableColumn instance
+ * @param  {...any} args 
+ * @returns {FakeTableColumn}
+ */
+export const newFakeTableColumn = (...args) => {
+  return Proxies.guard(new FakeTableColumn(...args));
+};
+
+export class FakeTableColumn {
+  constructor(table, colIndex) {
+    this.__table = table;
+    this.__colIndex = colIndex;
+  }
+
+  /**
+   * Gets a cell by its index.
+   * @param {number} index The row index.
+   * @returns {FakeTableCell} The cell.
+   */
+  getCell(index) {
+    return newFakeTableCell(this.__table, index, this.__colIndex);
+  }
+
+  /**
+   * Gets the 0-based index of the column.
+   * @returns {number} The index.
+   */
+  getIndex() {
+    return this.__colIndex;
+  }
+
+  /**
+   * Gets the number of cells in this column.
+   * @returns {number} The number of cells.
+   */
+  getNumCells() {
+    return this.__table.getNumRows();
+  }
+
+  /**
+   * Gets the table containing the current column.
+   * @returns {FakeTable} The parent table.
+   */
+  getParentTable() {
+    return this.__table;
+  }
+
+  /**
+   * Gets the width of the column in points.
+   * @returns {number} The width.
+   */
+  getWidth() {
+    const tableResource = this.__table.__resource.table;
+    const colProperties = tableResource?.tableColumns?.[this.__colIndex];
+    return this.__table.__normalize(colProperties?.columnWidth);
+  }
+
+  /**
+   * Removes the table column.
+   */
+  remove() {
+    throw new Error('TableColumn.remove() not yet implemented');
+  }
+
+  toString() {
+    return 'TableColumn';
+  }
+}

package/src/services/slidesapp/faketablerow.js

@@ -38,6 +38,22 @@ export class FakeTableRow {
     return cells[index];
   }
 
+  /**
+   * Returns the 0-based index of the row.
+   * @returns {number} The index.
+   */
+  getIndex() {
+    return this.__rowIndex;
+  }
+
+  /**
+   * Returns the minimum height of the row in points.
+   * @returns {number} The minimum height.
+   */
+  getMinimumHeight() {
+    return this.__table.__normalize(this.__resource?.rowHeight);
+  }
+
   /**
    * Gets the number of cells in the row.
    * @returns {number} The number of cells.
@@ -46,6 +62,21 @@ export class FakeTableRow {
     return (this.__resource?.tableCells || []).length;
   }
 
+  /**
+   * Returns the table containing the current row.
+   * @returns {FakeTable} The parent table.
+   */
+  getParentTable() {
+    return this.__table;
+  }
+
+  /**
+   * Removes the table row.
+   */
+  remove() {
+    throw new Error('TableRow.remove() not yet implemented');
+  }
+
   toString() {
     return 'TableRow';
   }