@mcpher/gas-fakes 2.3.10 → 2.3.11

package/package.json

@@ -40,7 +40,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.10",
+  "version": "2.3.11",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",

package/src/services/documentapp/elementhelpers.js

@@ -286,3 +286,30 @@ export const updateParagraphStyle = (element, paragraphStyle, fields) => {
   shadow.refresh();
   return element;
 };
+
+/**
+ * Updates the text style for a given element or range within it.
+ * @param {import('./fakeelement.js').FakeElement} element The element whose text style to update.
+ * @param {GoogleAppsScript.Document.TextStyle} textStyle The style object to apply.
+ * @param {string} fields The comma-separated string of field names to update.
+ * @param {object} [range] Optional specific range. Defaults to the element's range.
+ * @returns {import('./fakeelement.js').FakeElement} The element, for chaining.
+ */
+export const updateTextStyle = (element, textStyle, fields, range = null) => {
+  const shadow = element.shadowDocument;
+  const item = element.__elementMapItem;
+  const updateRange = range || {
+    startIndex: item.startIndex,
+    endIndex: item.endIndex,
+    segmentId: shadow.__segmentId,
+    tabId: shadow.__tabId,
+  };
+
+  const requests = [{
+    updateTextStyle: { range: updateRange, textStyle, fields },
+  }];
+
+  Docs.Documents.batchUpdate({ requests }, shadow.getId());
+  shadow.refresh();
+  return element;
+};

package/src/services/documentapp/fakeelement.js

@@ -96,6 +96,14 @@ export class FakeElement {
       });
     }
 
+  /**
+   * Gets the shadow document manager associated with this element's structure.
+   * @type {import('./shadowdocument.js').ShadowDocument | null}
+   */
+  get shadowDocument() {
+    return this.__shadowDocument;
+  }
+
   get __structure() {
     if (this.__isDetached) return null;
     return this.__shadowDocument.structure;

package/src/services/documentapp/fakeparagraph.js

@@ -4,6 +4,7 @@ import { Utils } from '../../support/utils.js';
 import { imageOptions } from './elementoptions.js';
 import { FakeContainerElement } from './fakecontainerelement.js';
 import { registerElement } from './elementRegistry.js';
+import { newFakeText } from './faketext.js';
 import { appendText, addPositionedImage, appendImage, insertImage } from './appenderhelpers.js';
 import { getText as getTextHelper, getAttributes as getAttributesHelper, updateParagraphStyle } from './elementhelpers.js';
 
@@ -32,6 +33,19 @@ export class FakeParagraph extends FakeContainerElement {
     return getTextHelper(this);
   }
 
+  /**
+   * Returns the contents of the paragraph as a Text element.
+   * @returns {GoogleAppsScript.Document.Text} The text element.
+   */
+  editAsText() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.editAsText');
+    if (nargs !== 0) matchThrow();
+    // In gas-fakes, we can return a FakeText that points to the same underlying item.
+    // The getText and updateTextStyle methods will work correctly because they
+    // handle both PARAGRAPH and TEXT items or ranges.
+    return newFakeText(this.__shadowDocument, this.__name);
+  }
+
   appendText(text) {
     const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.appendText');
     if (nargs !== 1) matchThrow();

package/src/services/documentapp/faketext.js

@@ -1,9 +1,15 @@
 import { Proxies } from '../../support/proxies.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
 import { FakeElement } from './fakeelement.js';
 import { registerElement } from './elementRegistry.js';
+import { getAttributes as getAttributesHelper, updateTextStyle, getText as getTextHelper } from './elementhelpers.js';
+
+const { is } = Utils;
 
 /**
  * A fake implementation of the Text class for DocumentApp.
+ * @implements {GoogleAppsScript.Document.Text}
  * @see https://developers.google.com/apps-script/reference/document/text
  */
 class FakeText extends FakeElement {
@@ -16,9 +22,173 @@ class FakeText extends FakeElement {
    * @returns {string} The text contents.
    */
   getText() {
-    const item = this.__elementMapItem;
-    // A Text element corresponds to a textRun in the API.
-    return item.textRun?.content || '';
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getText');
+    if (nargs !== 0) matchThrow();
+    return getTextHelper(this);
+  }
+
+  getAttributes() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getAttributes');
+    if (nargs !== 0) matchThrow();
+    return getAttributesHelper(this);
+  }
+
+  setAttributes(attributes) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setAttributes');
+    if (nargs !== 1 || !is.object(attributes)) matchThrow();
+
+    const textStyle = {};
+    const textFields = [];
+    const Attribute = DocumentApp.Attribute;
+
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+
+    for (const key in attributes) {
+      const value = attributes[key];
+      // Note: GAS allows null to clear some attributes, but let's handle the basics first.
+      switch (String(key)) {
+        case String(Attribute.BACKGROUND_COLOR): textStyle.backgroundColor = { color: { rgbColor: colorToRgb(value) } }; textFields.push('backgroundColor'); break;
+        case String(Attribute.BOLD): textStyle.bold = value; textFields.push('bold'); break;
+        case String(Attribute.FONT_FAMILY): textStyle.weightedFontFamily = { fontFamily: value }; textFields.push('weightedFontFamily'); break;
+        case String(Attribute.FONT_SIZE): textStyle.fontSize = { magnitude: value, unit: 'PT' }; textFields.push('fontSize'); break;
+        case String(Attribute.FOREGROUND_COLOR): textStyle.foregroundColor = { color: { rgbColor: colorToRgb(value) } }; textFields.push('foregroundColor'); break;
+        case String(Attribute.ITALIC): textStyle.italic = value; textFields.push('italic'); break;
+        case String(Attribute.LINK_URL): textStyle.link = { url: value }; textFields.push('link'); break;
+        case String(Attribute.STRIKETHROUGH): textStyle.strikethrough = value; textFields.push('strikethrough'); break;
+        case String(Attribute.UNDERLINE): textStyle.underline = value; textFields.push('underline'); break;
+      }
+    }
+
+    if (textFields.length === 0) return this;
+    return updateTextStyle(this, textStyle, textFields.join(','));
+  }
+
+  setBold(bold) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setBold');
+    if (nargs !== 1 || !is.boolean(bold)) matchThrow();
+    return updateTextStyle(this, { bold }, 'bold');
+  }
+
+  isBold() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isBold');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.BOLD];
+  }
+
+  setItalic(italic) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setItalic');
+    if (nargs !== 1 || !is.boolean(italic)) matchThrow();
+    return updateTextStyle(this, { italic }, 'italic');
+  }
+
+  isItalic() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isItalic');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.ITALIC];
+  }
+
+  setUnderline(underline) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setUnderline');
+    if (nargs !== 1 || !is.boolean(underline)) matchThrow();
+    return updateTextStyle(this, { underline }, 'underline');
+  }
+
+  isUnderline() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isUnderline');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.UNDERLINE];
+  }
+
+  setFontFamily(fontFamily) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setFontFamily');
+    if (nargs !== 1 || !is.string(fontFamily)) matchThrow();
+    return updateTextStyle(this, { weightedFontFamily: { fontFamily } }, 'weightedFontFamily');
+  }
+
+  getFontFamily() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getFontFamily');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FONT_FAMILY];
+  }
+
+  setFontSize(fontSize) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setFontSize');
+    if (nargs !== 1 || !is.number(fontSize)) matchThrow();
+    return updateTextStyle(this, { fontSize: { magnitude: fontSize, unit: 'PT' } }, 'fontSize');
+  }
+
+  getFontSize() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getFontSize');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FONT_SIZE];
+  }
+
+  setForegroundColor(color) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setForegroundColor');
+    if (nargs !== 1 || !is.string(color)) matchThrow();
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+    return updateTextStyle(this, { foregroundColor: { color: { rgbColor: colorToRgb(color) } } }, 'foregroundColor');
+  }
+
+  getForegroundColor() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getForegroundColor');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FOREGROUND_COLOR];
+  }
+
+  setBackgroundColor(color) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setBackgroundColor');
+    if (nargs !== 1 || !is.string(color)) matchThrow();
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+    return updateTextStyle(this, { backgroundColor: { color: { rgbColor: colorToRgb(color) } } }, 'backgroundColor');
+  }
+
+  getBackgroundColor() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getBackgroundColor');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.BACKGROUND_COLOR];
+  }
+
+  setLinkUrl(url) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setLinkUrl');
+    if (nargs !== 1 || (!is.string(url) && !is.null(url))) matchThrow();
+    return updateTextStyle(this, { link: { url: url } }, 'link');
+  }
+
+  getLinkUrl() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getLinkUrl');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.LINK_URL];
+  }
+
+  setStrikethrough(strikethrough) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setStrikethrough');
+    if (nargs !== 1 || !is.boolean(strikethrough)) matchThrow();
+    return updateTextStyle(this, { strikethrough }, 'strikethrough');
+  }
+
+  isStrikethrough() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isStrikethrough');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.STRIKETHROUGH];
   }
 
   toString() {
@@ -28,4 +198,4 @@ class FakeText extends FakeElement {
 
 export const newFakeText = (...args) => Proxies.guard(new FakeText(...args));
 
-registerElement('TEXT', newFakeText);
+registerElement('TEXT', newFakeText);