@mcpher/gas-fakes 1.0.19 → 1.0.21

package/src/services/documentapp/fakelistitem.js

@@ -2,13 +2,13 @@
  * @file Provides a fake implementation of the ListItem class.
  */
 import { Proxies } from '../../support/proxies.js';
-import { FakeContainerElement } from './fakecontainerelement.js';
+import { FakeParagraph } from './fakeparagraph.js';
 import { registerElement } from './elementRegistry.js';
-import { getText, updateParagraphStyle, getAttributes as getAttributesHelper } from './elementhelpers.js';
-import { appendText } from './appenderhelpers.js';
+import { getText, updateParagraphStyle, getAttributes as getAttributesHelper, findItem } from './elementhelpers.js';
+import { appendText, insertImage } from './appenderhelpers.js';
 import { notYetImplemented, signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
-const { is } = Utils;
+const { is, lobify } = Utils;
 
 /**
  * Creates a new proxied FakeListItem instance.
@@ -22,11 +22,11 @@ export const newFakeListItem = (...args) => {
 /**
  * A fake implementation of the ListItem class for DocumentApp.
  * @class FakeListItem
- * @extends {FakeContainerElement}
+ * @extends {FakeParagraph}
  * @implements {GoogleAppsScript.Document.ListItem}
  * @see https://developers.google.com/apps-script/reference/document/list-item
  */
-export class FakeListItem extends FakeContainerElement {
+export class FakeListItem extends FakeParagraph {
   /**
    * @param {import('./shadowdocument.js').ShadowDocument} shadowDocument The shadow document manager.
    * @param {string|object} nameOrItem The name of the element or the element's API resource.
@@ -36,25 +36,6 @@ export class FakeListItem extends FakeContainerElement {
     super(shadowDocument, nameOrItem);
   }
 
-  /**
-   * Gets the text content of the list item, flattening all child text elements.
-   * @returns {string} The text content.
-   * @see https://developers.google.com/apps-script/reference/document/list-item#getText()
-   */
-  getText() {
-    return getText(this);
-  }
-
-  /**
-   * Appends text to the list item.
-   * @param {string|GoogleAppsScript.Document.Text} textOrTextElement The text to append.
-   * @returns {GoogleAppsScript.Document.ListItem} The list item, for chaining.
-   */
-  appendText(textOrTextElement) {
-    appendText(this, textOrTextElement);
-    return this;
-  }
-
   /**
    * Gets a copy of the element's attributes.
    * @returns {object} The attributes.
@@ -77,12 +58,12 @@ export class FakeListItem extends FakeContainerElement {
     const nestingLevel = this.getNestingLevel();
     // The shadowDocument is only available on attached elements.
     if (this.__isDetached) return null;
-    const docResource = this.shadowDocument.resource;    
+    const docResource = this.shadowDocument.resource;
     // The lists can be at the top level or inside the first tab.
-    const {lists} = this.shadowDocument.__unpackDocumentTab(docResource);
+    const { lists } = this.shadowDocument.__unpackDocumentTab(docResource);
     // Find the list by ID.
     const list = lists?.[listId];
-    if (!list) return null;    
+    if (!list) return null;
 
     const levelProps = list.listProperties?.nestingLevels?.[nestingLevel];
     // For a default list, the API might not return explicit level properties.
@@ -198,6 +179,107 @@ export class FakeListItem extends FakeContainerElement {
     return this;
   }
 
+  getAlignment() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getAlignment');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.HORIZONTAL_ALIGNMENT];
+  }
+
+  setAlignment(alignment) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setAlignment');
+    if (nargs !== 1) matchThrow();
+
+    const alignmentMap = {
+      [DocumentApp.HorizontalAlignment.LEFT]: 'START',
+      [DocumentApp.HorizontalAlignment.CENTER]: 'CENTER',
+      [DocumentApp.HorizontalAlignment.RIGHT]: 'END',
+      [DocumentApp.HorizontalAlignment.JUSTIFIED]: 'JUSTIFY',
+    };
+
+    const apiAlignment = alignmentMap[alignment];
+    if (!apiAlignment) {
+      throw new Error(`Invalid argument: ${alignment}`);
+    }
+
+    return updateParagraphStyle(this, { alignment: apiAlignment }, 'alignment');
+  }
+
+  getIndentEnd() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getIndentEnd');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_END];
+  }
+
+  setIndentEnd(indentEnd) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setIndentEnd');
+    if (nargs !== 1 || !is.number(indentEnd)) matchThrow();
+    return updateParagraphStyle(this, { indentEnd: { magnitude: indentEnd, unit: 'PT' } }, 'indentEnd');
+  }
+
+  getIndentFirstLine() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getIndentFirstLine');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_FIRST_LINE];
+  }
+
+  getIndentStart() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getIndentStart');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_START];
+  }
+
+  getLineSpacing() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getLineSpacing');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.LINE_SPACING];
+  }
+
+  setLineSpacing(multiplier) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setLineSpacing');
+    if (nargs !== 1 || !is.number(multiplier)) matchThrow();
+    return updateParagraphStyle(this, { lineSpacing: multiplier * 100 }, 'lineSpacing');
+  }
+
+  getSpacingAfter() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getSpacingAfter');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.SPACING_AFTER];
+  }
+
+  setSpacingAfter(spacingAfter) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setSpacingAfter');
+    if (nargs !== 1 || !is.number(spacingAfter)) matchThrow();
+    return updateParagraphStyle(this, { spaceBelow: { magnitude: spacingAfter, unit: 'PT' } }, 'spaceBelow');
+  }
+
+  getSpacingBefore() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.getSpacingBefore');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.SPACING_BEFORE];
+  }
+
+  setSpacingBefore(spacingBefore) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setSpacingBefore');
+    if (nargs !== 1 || !is.number(spacingBefore)) matchThrow();
+    return updateParagraphStyle(this, { spaceAbove: { magnitude: spacingBefore, unit: 'PT' } }, 'spaceAbove');
+  }
+
+  isLeftToRight() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.isLeftToRight');
+    if (nargs !== 0) matchThrow();
+    // The getAttributes helper will return true/false/null.
+    const ltr = this.getAttributes()[DocumentApp.Attribute.LEFT_TO_RIGHT];
+    // Default to true if null, which matches live behavior for new paragraphs.
+    return ltr === null ? true : ltr;
+  }
+
+  setLeftToRight(leftToRight) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setLeftToRight');
+    if (nargs !== 1 || !is.boolean(leftToRight)) matchThrow();
+    const direction = leftToRight ? 'LEFT_TO_RIGHT' : 'RIGHT_TO_LEFT';
+    return updateParagraphStyle(this, { direction }, 'direction');
+  }
+
 
   /**
    * Sets the glyph type of the list item.
@@ -236,6 +318,73 @@ export class FakeListItem extends FakeContainerElement {
     return updateParagraphStyle(this, { indentStart: { magnitude: indentStart, unit: 'PT' } }, 'indentStart');
   }
 
+  clear() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.clear');
+    if (nargs !== 0) matchThrow();
+
+    const item = this.__elementMapItem;
+    const requests = [];
+
+    // Find the named range associated with this element to protect it.
+    const nr = this.shadowDocument.getNamedRange(item.__name);
+    if (!nr) {
+      throw new Error(`Internal error: Could not find named range for element ${item.__name}`);
+    }
+
+    // Delete the content, but not the final newline that defines the paragraph.
+    if (item.endIndex - 1 > item.startIndex) {
+      requests.push({
+        deleteContentRange: {
+          range: { startIndex: item.startIndex, endIndex: item.endIndex - 1, segmentId: this.__segmentId }
+        }
+      });
+
+      // Protect the named range by deleting the old one and recreating it with the same name but the new, smaller range.
+      requests.push({ deleteNamedRange: { namedRangeId: nr.namedRangeId } });
+      requests.push({
+        createNamedRange: { name: nr.name, range: { startIndex: item.startIndex, endIndex: item.startIndex + 1, segmentId: this.__segmentId } },
+      });
+
+      Docs.Documents.batchUpdate({ requests }, this.shadowDocument.getId());
+      this.shadowDocument.refresh();
+    }
+    return this;
+  }
+
+  setText(text) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.setText');
+    if (nargs !== 1 || !is.string(text)) matchThrow();
+
+    const item = this.__elementMapItem;
+    const requests = [];
+
+    // Find the named range associated with this element to protect it.
+    const nr = this.shadowDocument.getNamedRange(item.__name);
+    if (!nr) {
+      throw new Error(`Internal error: Could not find named range for element ${item.__name}`);
+    }
+
+    if (item.endIndex - 1 > item.startIndex) {
+      requests.push({ deleteContentRange: { range: { startIndex: item.startIndex, endIndex: item.endIndex - 1, segmentId: this.__segmentId } } });
+    }
+    if (text) {
+      requests.push({ insertText: { location: { index: item.startIndex, segmentId: this.__segmentId }, text } });
+    }
+
+    // As you correctly pointed out, we must protect the named range.
+    // Delete the old one and recreate it with the same name but the new, updated range.
+    requests.push({ deleteNamedRange: { namedRangeId: nr.namedRangeId } });
+    requests.push({
+      createNamedRange: {
+        name: nr.name,
+        range: { startIndex: item.startIndex, endIndex: item.startIndex + (text ? text.length : 0) + 1, segmentId: this.__segmentId },
+      },
+    });
+ 
+    Docs.Documents.batchUpdate({ requests }, this.shadowDocument.getId());
+    this.shadowDocument.refresh();
+  }
+
   /**
    * Sets the nesting level of the list item.
    * @param {number} nestingLevel The new nesting level, starting from 0.

package/src/services/documentapp/fakeparagraph.js

@@ -1,17 +1,18 @@
 import { Proxies } from '../../support/proxies.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
+import { imageOptions } from './elementoptions.js';
 import { FakeContainerElement } from './fakecontainerelement.js';
 import { registerElement } from './elementRegistry.js';
 import { appendText, addPositionedImage, appendImage, insertImage } from './appenderhelpers.js';
-import { getText as getTextHelper, getAttributes as getAttributesHelper } from './elementhelpers.js';
+import { getText as getTextHelper, getAttributes as getAttributesHelper, updateParagraphStyle } from './elementhelpers.js';
 
 const { is } = Utils;
 
 /**
  * @implements {GoogleAppsScript.Document.Paragraph}
  */
-class FakeParagraph extends FakeContainerElement {
+export class FakeParagraph extends FakeContainerElement {
   constructor(shadowDocument, name) {
     const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph');
     // An attached element has a shadowDocument and a string name (its ID).
@@ -52,15 +53,32 @@ class FakeParagraph extends FakeContainerElement {
   appendInlineImage(image) {
     const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.appendInlineImage');
     if (nargs !== 1) matchThrow();
-    // This uses the generic appendImage helper, which is designed to handle insertions into paragraphs.
-    return appendImage(this, image);
+
+    // The generic appendImage helper creates a new paragraph. We need to insert into the existing one.
+    // We can use the insertImage helper, which inserts at a specific child index.
+    return this.insertInlineImage(this.getNumChildren(), image);
   }
 
   insertInlineImage(childIndex, image) {
     const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.insertInlineImage');
     if (nargs !== 2) matchThrow();
-    // This uses the generic insertImage helper.
-    return insertImage(this, childIndex, image);
+
+    // The generic insertImage helper is for top-level containers. We need a specific implementation.
+    const children = [];
+    for (let i = 0; i < this.getNumChildren(); i++) {
+      children.push(this.getChild(i));
+    }
+
+    if (childIndex < 0 || childIndex > children.length) {
+      throw new Error(`Child index (${childIndex}) must be less than or equal to the number of child elements (${children.length}).`);
+    }
+
+    // Determine the character index for insertion.
+    const insertIndex = (childIndex === children.length)
+      ? this.__elementMapItem.endIndex - 1 // Append before the final newline
+      : children[childIndex].__elementMapItem.startIndex; // Insert before the specified child
+
+    return this.__insertImageAtIndex(image, insertIndex);
   }
 
   setHeading(heading) {
@@ -131,12 +149,181 @@ class FakeParagraph extends FakeContainerElement {
     return apiToEnumMap[namedStyleType] || DocumentApp.ParagraphHeading.NORMAL;
   }
 
+  getAlignment() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getAlignment');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.HORIZONTAL_ALIGNMENT];
+  }
+
+  setAlignment(alignment) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setAlignment');
+    if (nargs !== 1) matchThrow();
+
+    const alignmentMap = {
+      [DocumentApp.HorizontalAlignment.LEFT]: 'START',
+      [DocumentApp.HorizontalAlignment.CENTER]: 'CENTER',
+      [DocumentApp.HorizontalAlignment.RIGHT]: 'END',
+      [DocumentApp.HorizontalAlignment.JUSTIFIED]: 'JUSTIFY',
+    };
+
+    const apiAlignment = alignmentMap[alignment];
+    if (!apiAlignment) {
+      throw new Error(`Invalid argument: ${alignment}`);
+    }
+
+    return updateParagraphStyle(this, { alignment: apiAlignment }, 'alignment');
+  }
+
+  getIndentEnd() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getIndentEnd');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_END];
+  }
+
+  setIndentEnd(indentEnd) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setIndentEnd');
+    if (nargs !== 1 || !is.number(indentEnd)) matchThrow();
+    return updateParagraphStyle(this, { indentEnd: { magnitude: indentEnd, unit: 'PT' } }, 'indentEnd');
+  }
+
+  getIndentFirstLine() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getIndentFirstLine');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_FIRST_LINE];
+  }
+
+  setIndentFirstLine(indentFirstLine) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setIndentFirstLine');
+    if (nargs !== 1 || !is.number(indentFirstLine)) matchThrow();
+    return updateParagraphStyle(this, { indentFirstLine: { magnitude: indentFirstLine, unit: 'PT' } }, 'indentFirstLine');
+  }
+
+  getIndentStart() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getIndentStart');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.INDENT_START];
+  }
+
+  setIndentStart(indentStart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setIndentStart');
+    if (nargs !== 1 || !is.number(indentStart)) matchThrow();
+    return updateParagraphStyle(this, { indentStart: { magnitude: indentStart, unit: 'PT' } }, 'indentStart');
+  }
+
+  getLineSpacing() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getLineSpacing');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.LINE_SPACING];
+  }
+
+  setLineSpacing(multiplier) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setLineSpacing');
+    if (nargs !== 1 || !is.number(multiplier)) matchThrow();
+    return updateParagraphStyle(this, { lineSpacing: multiplier * 100 }, 'lineSpacing');
+  }
+
+  getSpacingAfter() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getSpacingAfter');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.SPACING_AFTER];
+  }
+
+  setSpacingAfter(spacingAfter) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setSpacingAfter');
+    if (nargs !== 1 || !is.number(spacingAfter)) matchThrow();
+    return updateParagraphStyle(this, { spaceBelow: { magnitude: spacingAfter, unit: 'PT' } }, 'spaceBelow');
+  }
+
+  getSpacingBefore() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.getSpacingBefore');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.SPACING_BEFORE];
+  }
+
+  setSpacingBefore(spacingBefore) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setSpacingBefore');
+    if (nargs !== 1 || !is.number(spacingBefore)) matchThrow();
+    return updateParagraphStyle(this, { spaceAbove: { magnitude: spacingBefore, unit: 'PT' } }, 'spaceAbove');
+  }
+
+  isLeftToRight() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.isLeftToRight');
+    if (nargs !== 0) matchThrow();
+    // The getAttributes helper will return true/false/null.
+    const ltr = this.getAttributes()[DocumentApp.Attribute.LEFT_TO_RIGHT];
+    // Default to true if null, which matches live behavior for new paragraphs.
+    return ltr === null ? true : ltr;
+  }
+
+  setLeftToRight(leftToRight) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.setLeftToRight');
+    if (nargs !== 1 || !is.boolean(leftToRight)) matchThrow();
+    const direction = leftToRight ? 'LEFT_TO_RIGHT' : 'RIGHT_TO_LEFT';
+    return updateParagraphStyle(this, { direction }, 'direction');
+  }
+
   toString() {
     return 'Paragraph';
   }
+
+  /**
+   * Helper to insert an image at a specific character index.
+   * @param {GoogleAppsScript.Base.BlobSource} image The image to insert.
+   * @param {number} index The character index.
+   * @returns {GoogleAppsScript.Document.InlineImage} The new image.
+   * @private
+   */
+  __insertImageAtIndex(image, index) {
+    // As you correctly pointed out, we must protect the named range of the parent paragraph.
+    const item = this.__elementMapItem;
+    const nr = this.shadowDocument.getNamedRange(item.__name);
+    if (!nr) {
+      throw new Error(`Internal error: Could not find named range for element ${item.__name}`);
+    }
+    // This is a simplified and corrected version of the logic in imageOptions.getMainRequest.
+    // It directly creates the insertInlineImage request without the complex logic
+    // for adding new paragraphs, which was causing the empty request array.
+    const { uri, size, cleanup } = imageOptions.__getImageUriAndSize(image);
+
+    const requests = [{
+      insertInlineImage: {
+        uri,
+        location: { index, segmentId: this.__segmentId },
+        objectSize: size,
+      },
+    }];
+
+    // Add the protection requests to the batch update.
+    // This tells the API to preserve the identity of the paragraph being modified.
+    requests.push({ deleteNamedRange: { namedRangeId: nr.namedRangeId } });
+    requests.push({
+      createNamedRange: {
+        name: nr.name,
+        // The new range will be expanded by 1 character for the inserted image.
+        range: { startIndex: item.startIndex, endIndex: item.endIndex + 1, segmentId: this.__segmentId },
+      },
+    });
+    try {
+      Docs.Documents.batchUpdate({ requests }, this.shadowDocument.getId());
+      this.shadowDocument.refresh();
+      // After refresh, find the newly created image element to return it.
+      // This is a simplification; a more robust solution would find the image
+      // based on its new objectId from the batchUpdate response.
+      const children = [];
+      for (let i = 0; i < this.getNumChildren(); i++) {
+        children.push(this.getChild(i));
+      }
+      // The source 'image' can be a Blob or a detached InlineImage.
+      // We need to get the name from the underlying blob in either case.
+      const sourceImageName = image.getName ? image.getName() : image.getBlob().getName();
+      return children.find(c => c.getType() === DocumentApp.ElementType.INLINE_IMAGE && c.getBlob().getName() === sourceImageName);
+    } finally {
+      if (cleanup) cleanup();
+    }
+  }
 }
 
 export const newFakeParagraph = (...args) => Proxies.guard(new FakeParagraph(...args));
 
 registerElement('PARAGRAPH', newFakeParagraph);
-registerElement('LIST_ITEM', newFakeParagraph); // ListItems are also paragraphs
+registerElement('LIST_ITEM', newFakeParagraph); // ListItems are also paragraphs

package/src/services/documentapp/faketable.js

@@ -5,6 +5,7 @@
 import { Proxies } from '../../support/proxies.js';
 import { FakeContainerElement } from './fakecontainerelement.js';
 import { registerElement } from './elementRegistry.js';
+import { newFakeElement } from './fakeelement.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils;
@@ -45,6 +46,21 @@ export class FakeTable extends FakeContainerElement {
     return this.getChild(rowIndex);
   }
   
+  /**
+   * Gets the text content of the table.
+   * @returns {string} The text content.
+   * @see https://developers.google.com/apps-script/reference/document/table#getText()
+   */
+  getText() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Table.getText');
+    if (nargs !== 0) matchThrow();
+    // Live behavior: A Table's text is the concatenation of its non-empty rows' text, separated by newlines.
+    return this.__children
+      .map(childTwig => newFakeElement(this.shadowDocument, childTwig.name).__cast().getText())
+      .filter(text => text.length > 0) // Ignore empty rows
+      .join('\n');
+  }
+
   getValues() {
     return Array.from({ length: this.getNumRows() }, (_, r) => {
       const row = this.getRow(r);

package/src/services/documentapp/faketablerow.js

@@ -2,6 +2,8 @@
  * @file Provides a fake implementation of the TableRow class.
  */
 import { registerElement } from './elementRegistry.js';
+import { newFakeElement } from './fakeelement.js';
+import { signatureArgs } from '../../support/helpers.js';
 import { Proxies } from '../../support/proxies.js';
 import { FakeContainerElement } from './fakecontainerelement.js';
 
@@ -35,6 +37,19 @@ export class FakeTableRow extends FakeContainerElement {
   getNumCells() {
     return this.getNumChildren();
   }
+
+  /**
+   * Gets the text content of the table row.
+   * @returns {string} The text content.
+   */
+  getText() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'TableRow.getText');
+    if (nargs !== 0) matchThrow();
+    // Live Apps Script joins cell text with a newline character.
+    return this.__children      
+      .map(childTwig => newFakeElement(this.shadowDocument, childTwig.name).__cast().getText())
+      .join('\n');
+  }
 }
 
 /**

package/src/services/documentapp/nrhelpers.js

@@ -55,6 +55,7 @@ const addNrRequest = (type, element, addRequests, segmentId) => {
 };
 
 // either finds a matching named range, or adds it to the creation queue
+
 export const findOrCreateNamedRangeName = (element, type, currentNr, addRequests, segmentId) => {
   const { endIndex, startIndex } = element;
   const prefix = makeNrPrefix(type, segmentId);

package/src/services/documentapp/shadowdocument.js

@@ -320,6 +320,16 @@ class ShadowDocument {
     return null;
   }
 
+  get namedRanges () {
+    return this.__unpackDocumentTab(this.resource).documentTab.namedRanges || {}
+  }
+
+  getNamedRange (name) {
+    const nrs = this.namedRanges
+    if (!nrs) return null
+    return nrs[name]?.namedRanges?.[0] || null
+  }
+
   /**
    * Gets all footnotes in the document.
    * @returns {FakeFootnote[]} An array of footnotes.

package/src/services/driveapp/app.js

@@ -1,32 +1,10 @@
-// fake Apps Script DriveApp
 /**
- * the idea here is to create a global entry for the singleton 
- * before we actually have everything we need to create it. 
- * We do this by using a proxy, intercepting calls to the 
- * initial sigleton and diverting them to a completed one
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-import { newFakeDriveApp } from './fakedrive.js'
-import { Proxies } from '../../support/proxies.js'
 
-// This will eventually hold a proxy for DriveApp
-let _app = null
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeDriveApp as maker } from './fakedrive.js'
 
-/**
- * adds to global space to mimic Apps Script behavior
- */
-const name = "DriveApp"
-if (typeof globalThis[name] === typeof undefined) {
-
-  const getApp = () => {
-    // if it hasne been intialized yet then do that
-    if (!_app) {
-      console.log('...activating proxy for', name)
-      _app = newFakeDriveApp()
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
-
-  Proxies.registerProxy(name, getApp)
-
-}
+let _app = null;
+_app = lazyLoaderApp(_app, 'DriveApp', maker)

package/src/services/enums/gmailenums.js

@@ -0,0 +1,8 @@
+	export const LabelType = newFakeGasenum([
+  "INBOX",
+  "SPAM",
+  "TRASH",
+  "STARRED",
+  "CHAT",
+  "PRIORITY_INBOX"
+])

package/src/services/formapp/app.js

@@ -1,44 +1,9 @@
 /**
- * the idea here is to create a global entry for the singleton
- * before we actually have everything we need to create it.
- * We do this by using a proxy, intercepting calls to the
- * initial singleton and diverting them to a completed one
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-import { newFakeFormApp } from './fakeformapp.js';
-import { Proxies } from '../../support/proxies.js';
+import { newFakeFormApp as maker} from './fakeformapp.js';
+import { lazyLoaderApp } from '../common/lazyloader.js'
 
 let _app = null;
-
-const name = 'FormApp';
-const serviceName = 'FormApp';
-
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    if (!_app) {
-      const realApp = newFakeFormApp();
-
-      _app = new Proxy(realApp, {
-        get(target, prop, receiver) {
-          if (prop === 'toString') {
-            return () => name;
-          }
-
-          const serviceBehavior = ScriptApp.__behavior.sandboxService[serviceName];
-
-          if (!serviceBehavior.enabled) {
-            throw new Error(`${name} service is disabled by sandbox settings.`);
-          }
-
-          const allowedMethods = serviceBehavior.methods;
-          if (allowedMethods && typeof target[prop] === 'function' && !allowedMethods.includes(prop)) {
-            throw new Error(`Method ${name}.${prop} is not allowed by sandbox settings.`);
-          }
-
-          return Reflect.get(target, prop, receiver);
-        },
-      });
-    }
-    return _app;
-  };
-  Proxies.registerProxy(name, getApp);
-}
+_app = lazyLoaderApp(_app, 'FormApp', maker)