@divyacon/piece-google-docs 0.0.0-stage → 0.1.0

package/src/lib/actions/get-document.action.ts

@@ -0,0 +1,37 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs } from '@googleapis/docs';
+import { readDocumentActionOutputSchema } from '../output-schemas';
+
+export const getDocument = createAction({
+  auth: googleDocsAuth,
+  name: 'get_document',
+  displayName: 'Get Document',
+  description: 'Get the full content and structure of a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Fetches the full content and structure of a Google Docs document by its ID — the raw document JSON including body elements and their character indices. Use when an agent needs the complete structure, e.g. to locate element indices before editing. For only the readable text use Get Document Plaintext; for just the body end index use Get Document End Index. Requires the document ID; read-only and idempotent.',
+    idempotent: true,
+  },
+  outputSchema: readDocumentActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to read (from the document URL or Search Documents).',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+    try {
+      const response = await docs.documents.get({ documentId });
+      return response.data;
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'read'));
+    }
+  },
+});

package/src/lib/actions/insert-image-in-table-cell.action.ts

@@ -0,0 +1,139 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertImageInTableCellActionOutputSchema } from '../output-schemas';
+
+export const insertImageInTableCell = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_image_in_table_cell',
+  displayName: 'Insert Image in Table Cell',
+  description: 'Insert an inline image into a specific table cell in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts an inline image at the start of a specific table cell in a Google Docs document. The action reads the document to resolve the correct character index for the target cell, then inserts the image from the given URI. Optionally accepts width and height in points. Requires the table start index (from Read Document — cannot be guessed). Not idempotent: each call inserts another image.',
+    idempotent: false,
+  },
+  outputSchema: insertImageInTableCellActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document containing the table.',
+      required: true,
+    }),
+    tableStartIndex: Property.Number({
+      displayName: 'Table Start Index',
+      description: 'Obtain the table start index from Read Document — cannot be guessed.',
+      required: true,
+    }),
+    rowIndex: Property.Number({
+      displayName: 'Row Index',
+      description: 'Zero-based row index of the target cell.',
+      required: true,
+    }),
+    columnIndex: Property.Number({
+      displayName: 'Column Index',
+      description: 'Zero-based column index of the target cell.',
+      required: true,
+    }),
+    uri: Property.ShortText({
+      displayName: 'Image URI',
+      description: 'Publicly accessible URL of the image to insert.',
+      required: true,
+    }),
+    width: Property.Number({
+      displayName: 'Width (points)',
+      description: 'Optional width of the image in points. If omitted, the image uses its natural size.',
+      required: false,
+    }),
+    height: Property.Number({
+      displayName: 'Height (points)',
+      description: 'Optional height of the image in points. If omitted, the image uses its natural size.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, tableStartIndex, rowIndex, columnIndex, uri, width, height } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    let cellContentIndex: number;
+    try {
+      const docResponse = await docs.documents.get({ documentId });
+      const content = docResponse.data.body?.content ?? [];
+
+      const tableElement = content.find(
+        (el) => el.table !== undefined && el.startIndex === tableStartIndex
+      );
+
+      if (!tableElement?.table) {
+        throw new Error(
+          `No table found at start index ${tableStartIndex}. Verify the table start index from Read Document.`
+        );
+      }
+
+      const tableRows = tableElement.table.tableRows ?? [];
+      const targetRow = tableRows[rowIndex];
+      if (!targetRow) {
+        throw new Error(`Row index ${rowIndex} is out of range — table has ${tableRows.length} row(s).`);
+      }
+
+      const targetCell = (targetRow.tableCells ?? [])[columnIndex];
+      if (!targetCell) {
+        throw new Error(
+          `Column index ${columnIndex} is out of range — row has ${(targetRow.tableCells ?? []).length} cell(s).`
+        );
+      }
+
+      const firstContent = (targetCell.content ?? [])[0];
+      if (firstContent?.startIndex === undefined || firstContent.startIndex === null) {
+        throw new Error('Could not resolve the content start index for the target cell.');
+      }
+
+      cellContentIndex = firstContent.startIndex;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('No table') ||
+          error instanceof Error && error.message.startsWith('Row index') ||
+          error instanceof Error && error.message.startsWith('Column index') ||
+          error instanceof Error && error.message.startsWith('Could not')) {
+        throw error;
+      }
+      throw new Error(docsCommon.formatError(error, 'read'));
+    }
+
+    const objectSize: docs_v1.Schema$Size | undefined =
+      width !== undefined || height !== undefined
+        ? {
+            width: width !== undefined ? { magnitude: width, unit: 'PT' } : undefined,
+            height: height !== undefined ? { magnitude: height, unit: 'PT' } : undefined,
+          }
+        : undefined;
+
+    const request: docs_v1.Schema$Request = {
+      insertInlineImage: {
+        uri,
+        location: { index: cellContentIndex },
+        ...(objectSize ? { objectSize } : {}),
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        tableStartIndex,
+        rowIndex,
+        columnIndex,
+        insertedAtIndex: cellContentIndex,
+        uri,
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert image into table cell in'));
+    }
+  },
+});

package/src/lib/actions/insert-inline-image.action.ts

@@ -0,0 +1,83 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertInlineImageActionOutputSchema } from '../output-schemas';
+
+export const insertInlineImage = createAction({
+	auth: googleDocsAuth,
+	name: 'insert_inline_image',
+	displayName: 'Insert Inline Image',
+	description: 'Insert an inline image into a Google Docs document at a position or at the end.',
+	audience: 'ai',
+	aiMetadata: {
+		description:
+			'Inserts an inline image from a publicly fetchable URI into a Google Docs document. If "index" is omitted the image is placed at the end of the document body; if "index" is provided it is inserted at that character index — obtain a valid index from Get Document End Index first (indices cannot be guessed). The URI must be publicly accessible by Google at call time. Not idempotent: each call inserts another copy of the image.',
+		idempotent: false,
+	},
+	outputSchema: insertInlineImageActionOutputSchema,
+	props: {
+		documentId: Property.ShortText({
+			displayName: 'Document ID',
+			description: 'The ID of the document to insert the image into.',
+			required: true,
+		}),
+		uri: Property.ShortText({
+			displayName: 'Image URI',
+			description: 'A publicly accessible URL of the image to insert. Google must be able to fetch this URL at the time of the call.',
+			required: true,
+		}),
+		index: Property.Number({
+			displayName: 'Index',
+			description:
+				'Character index at which to insert the image. Leave empty to insert at the end of the document. Obtain a valid index from Get Document End Index.',
+			required: false,
+		}),
+		widthPt: Property.Number({
+			displayName: 'Width (pt)',
+			description: 'Desired width of the image in points. Leave empty to use the image\'s natural size.',
+			required: false,
+		}),
+		heightPt: Property.Number({
+			displayName: 'Height (pt)',
+			description: 'Desired height of the image in points. Leave empty to use the image\'s natural size.',
+			required: false,
+		}),
+	},
+	async run(context) {
+		const { documentId, uri, index, widthPt, heightPt } = context.propsValue;
+		const authClient = await createGoogleClient(context.auth);
+		const docs = googleDocs({ version: 'v1', auth: authClient });
+
+		const objectSize: docs_v1.Schema$Size | undefined =
+			widthPt !== undefined && widthPt !== null && heightPt !== undefined && heightPt !== null
+				? {
+						width: { magnitude: widthPt, unit: 'PT' },
+						height: { magnitude: heightPt, unit: 'PT' },
+					}
+				: undefined;
+
+		const location: docs_v1.Schema$InsertInlineImageRequest =
+			index === undefined || index === null
+				? { uri, endOfSegmentLocation: {}, ...(objectSize ? { objectSize } : {}) }
+				: { uri, location: { index }, ...(objectSize ? { objectSize } : {}) };
+
+		const request: docs_v1.Schema$Request = { insertInlineImage: location };
+
+		try {
+			const response = await docs.documents.batchUpdate({
+				documentId,
+				requestBody: { requests: [request] },
+			});
+			const insertedObjectId = response.data.replies?.[0]?.insertInlineImage?.objectId ?? null;
+			return {
+				success: true,
+				documentId,
+				insertedObjectId,
+				mode: index === undefined || index === null ? 'append' : 'insert_at_index',
+			};
+		} catch (error) {
+			throw new Error(docsCommon.formatError(error, 'insert inline image into'));
+		}
+	},
+});

package/src/lib/actions/insert-page-break.action.ts

@@ -0,0 +1,56 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertPageBreakActionOutputSchema } from '../output-schemas';
+
+export const insertPageBreak = createAction({
+	auth: googleDocsAuth,
+	name: 'insert_page_break',
+	displayName: 'Insert Page Break',
+	description: 'Insert a page break into a Google Docs document at a position or at the end.',
+	audience: 'ai',
+	aiMetadata: {
+		description:
+			'Inserts a page break into a Google Docs document. If "index" is omitted the page break is appended at the end of the document body; if "index" is provided it is inserted at that character index — obtain a valid index from Get Document End Index first (indices cannot be guessed and must fall inside an existing paragraph). Not idempotent: each call inserts another page break.',
+		idempotent: false,
+	},
+	outputSchema: insertPageBreakActionOutputSchema,
+	props: {
+		documentId: Property.ShortText({
+			displayName: 'Document ID',
+			description: 'The ID of the document to insert the page break into.',
+			required: true,
+		}),
+		index: Property.Number({
+			displayName: 'Index',
+			description:
+				'Character index at which to insert the page break. Leave empty to insert at the end of the document. Obtain a valid index from Get Document End Index.',
+			required: false,
+		}),
+	},
+	async run(context) {
+		const { documentId, index } = context.propsValue;
+		const authClient = await createGoogleClient(context.auth);
+		const docs = googleDocs({ version: 'v1', auth: authClient });
+
+		const request: docs_v1.Schema$Request =
+			index === undefined || index === null
+				? { insertPageBreak: { endOfSegmentLocation: {} } }
+				: { insertPageBreak: { location: { index } } };
+
+		try {
+			await docs.documents.batchUpdate({
+				documentId,
+				requestBody: { requests: [request] },
+			});
+			return {
+				success: true,
+				documentId,
+				mode: index === undefined || index === null ? 'append' : 'insert_at_index',
+			};
+		} catch (error) {
+			throw new Error(docsCommon.formatError(error, 'insert page break into'));
+		}
+	},
+});

package/src/lib/actions/insert-table-column.action.ts

@@ -0,0 +1,80 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertTableColumnActionOutputSchema } from '../output-schemas';
+
+export const insertTableColumn = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_table_column',
+  displayName: 'Insert Table Column',
+  description: 'Insert a column into an existing table in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts a new column into an existing table in a Google Docs document. The column is inserted to the left or right of the cell identified by rowIndex and columnIndex. Use "insertRight" to control the insertion side. Not idempotent: each call inserts another column.',
+    idempotent: false,
+  },
+  outputSchema: insertTableColumnActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document containing the table.',
+      required: true,
+    }),
+    tableStartIndex: Property.Number({
+      displayName: 'Table Start Index',
+      description: 'Obtain the table start index from Read Document — cannot be guessed.',
+      required: true,
+    }),
+    rowIndex: Property.Number({
+      displayName: 'Row Index',
+      description: 'Zero-based row index of the reference cell used to identify the column.',
+      required: true,
+    }),
+    columnIndex: Property.Number({
+      displayName: 'Column Index',
+      description: 'Zero-based column index of the reference cell.',
+      required: true,
+    }),
+    insertRight: Property.Checkbox({
+      displayName: 'Insert to the Right',
+      description: 'If true, the new column is inserted to the right of the reference cell; if false, to the left.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, tableStartIndex, rowIndex, columnIndex, insertRight } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      insertTableColumn: {
+        tableCellLocation: {
+          tableStartLocation: { index: tableStartIndex },
+          rowIndex,
+          columnIndex,
+        },
+        insertRight: insertRight ?? false,
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        tableStartIndex,
+        rowIndex,
+        columnIndex,
+        insertRight: insertRight ?? false,
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert table column into'));
+    }
+  },
+});

package/src/lib/actions/insert-table-row.action.ts

@@ -0,0 +1,80 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertTableRowActionOutputSchema } from '../output-schemas';
+
+export const insertTableRow = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_table_row',
+  displayName: 'Insert Table Row',
+  description: 'Insert a row into an existing table in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts a new row into an existing table in a Google Docs document. The row is inserted above or below the cell identified by rowIndex and columnIndex. Use "insertBelow" to control the insertion side. Not idempotent: each call inserts another row.',
+    idempotent: false,
+  },
+  outputSchema: insertTableRowActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document containing the table.',
+      required: true,
+    }),
+    tableStartIndex: Property.Number({
+      displayName: 'Table Start Index',
+      description: 'Obtain the table start index from Read Document — cannot be guessed.',
+      required: true,
+    }),
+    rowIndex: Property.Number({
+      displayName: 'Row Index',
+      description: 'Zero-based row index of the reference cell used to identify the row.',
+      required: true,
+    }),
+    columnIndex: Property.Number({
+      displayName: 'Column Index',
+      description: 'Zero-based column index of the reference cell.',
+      required: true,
+    }),
+    insertBelow: Property.Checkbox({
+      displayName: 'Insert Below',
+      description: 'If true, the new row is inserted below the reference cell; if false, above.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, tableStartIndex, rowIndex, columnIndex, insertBelow } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      insertTableRow: {
+        tableCellLocation: {
+          tableStartLocation: { index: tableStartIndex },
+          rowIndex,
+          columnIndex,
+        },
+        insertBelow: insertBelow ?? false,
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        tableStartIndex,
+        rowIndex,
+        columnIndex,
+        insertBelow: insertBelow ?? false,
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert table row into'));
+    }
+  },
+});

package/src/lib/actions/insert-table.action.ts

@@ -0,0 +1,68 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertTableActionOutputSchema } from '../output-schemas';
+
+export const insertTable = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_table',
+  displayName: 'Insert Table',
+  description: 'Insert a new table into a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts a new table with the specified number of rows and columns into a Google Docs document. If "index" is omitted the table is inserted at the end of the document body; if provided the table is inserted at that character index — obtain a valid index from Get Document End Index first. Not idempotent: each call inserts another table.',
+    idempotent: false,
+  },
+  outputSchema: insertTableActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to insert the table into.',
+      required: true,
+    }),
+    rows: Property.Number({
+      displayName: 'Rows',
+      description: 'Number of rows in the new table.',
+      required: true,
+    }),
+    columns: Property.Number({
+      displayName: 'Columns',
+      description: 'Number of columns in the new table.',
+      required: true,
+    }),
+    index: Property.Number({
+      displayName: 'Index',
+      description:
+        'Character index at which to insert the table. Leave empty to append at the end of the document. Obtain a valid index from Get Document End Index.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, rows, columns, index } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request =
+      index === undefined || index === null
+        ? { insertTable: { rows, columns, endOfSegmentLocation: {} } }
+        : { insertTable: { rows, columns, location: { index } } };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        rows,
+        columns,
+        mode: index === undefined || index === null ? 'append' : 'insert_at_index',
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert table into'));
+    }
+  },
+});

package/src/lib/actions/insert-text-in-table-cell.action.ts

@@ -0,0 +1,120 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertTextInTableCellActionOutputSchema } from '../output-schemas';
+
+export const insertTextInTableCell = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_text_in_table_cell',
+  displayName: 'Insert Text in Table Cell',
+  description: 'Insert text into a specific table cell in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts text at the start of a specific table cell in a Google Docs document. The action reads the document to resolve the correct character index for the target cell, then inserts text there. Requires the table start index (from Read Document — cannot be guessed), plus the zero-based row and column index of the target cell. Not idempotent: each call inserts the text again.',
+    idempotent: false,
+  },
+  outputSchema: insertTextInTableCellActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document containing the table.',
+      required: true,
+    }),
+    tableStartIndex: Property.Number({
+      displayName: 'Table Start Index',
+      description: 'Obtain the table start index from Read Document — cannot be guessed.',
+      required: true,
+    }),
+    rowIndex: Property.Number({
+      displayName: 'Row Index',
+      description: 'Zero-based row index of the target cell.',
+      required: true,
+    }),
+    columnIndex: Property.Number({
+      displayName: 'Column Index',
+      description: 'Zero-based column index of the target cell.',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Text',
+      description: 'The text to insert into the table cell.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, tableStartIndex, rowIndex, columnIndex, text } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    let cellContentIndex: number;
+    try {
+      const docResponse = await docs.documents.get({ documentId });
+      const content = docResponse.data.body?.content ?? [];
+
+      const tableElement = content.find(
+        (el) => el.table !== undefined && el.startIndex === tableStartIndex
+      );
+
+      if (!tableElement?.table) {
+        throw new Error(
+          `No table found at start index ${tableStartIndex}. Verify the table start index from Read Document.`
+        );
+      }
+
+      const tableRows = tableElement.table.tableRows ?? [];
+      const targetRow = tableRows[rowIndex];
+      if (!targetRow) {
+        throw new Error(`Row index ${rowIndex} is out of range — table has ${tableRows.length} row(s).`);
+      }
+
+      const targetCell = (targetRow.tableCells ?? [])[columnIndex];
+      if (!targetCell) {
+        throw new Error(
+          `Column index ${columnIndex} is out of range — row has ${(targetRow.tableCells ?? []).length} cell(s).`
+        );
+      }
+
+      const firstContent = (targetCell.content ?? [])[0];
+      if (firstContent?.startIndex === undefined || firstContent.startIndex === null) {
+        throw new Error('Could not resolve the content start index for the target cell.');
+      }
+
+      cellContentIndex = firstContent.startIndex;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('No table') ||
+          error instanceof Error && error.message.startsWith('Row index') ||
+          error instanceof Error && error.message.startsWith('Column index') ||
+          error instanceof Error && error.message.startsWith('Could not')) {
+        throw error;
+      }
+      throw new Error(docsCommon.formatError(error, 'read'));
+    }
+
+    const request: docs_v1.Schema$Request = {
+      insertText: {
+        text,
+        location: { index: cellContentIndex },
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        tableStartIndex,
+        rowIndex,
+        columnIndex,
+        insertedAtIndex: cellContentIndex,
+        insertedCharacters: text.length,
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert text into table cell in'));
+    }
+  },
+});