@mcpher/gas-fakes 2.5.2 → 2.5.4

package/src/services/slidesapp/fakepagebackground.js

@@ -1,4 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
+import { newFakeSolidFill } from './fakesolidfill.js';
+import { newFakePictureFill } from './fakepicturefill.js';
+import { PageBackgroundType } from '../enums/slidesenums.js';
 
 export const newFakePageBackground = (...args) => {
   return Proxies.guard(new FakePageBackground(...args));
@@ -8,9 +11,114 @@ export class FakePageBackground {
   constructor(page) {
     this.__page = page;
   }
+
   get __resource() {
-    return this.__page.__resource.pageBackgroundFill || null;
+    const res = this.__page.__resource;
+    if (res && res.pageProperties && res.pageProperties.pageBackgroundFill) {
+        return res.pageProperties.pageBackgroundFill;
+    }
+    return null;
+  }
+
+  getPictureFill() {
+    const res = this.__resource;
+    return res?.stretchedPictureFill ? newFakePictureFill(res.stretchedPictureFill, this.__page) : null;
+  }
+
+  getSolidFill() {
+    return newFakeSolidFill(this.__page);
   }
+
+  getType() {
+    const res = this.__resource;
+    if (!res || res.propertyState === 'NOT_RENDERED') return PageBackgroundType.NONE;
+    if (res.stretchedPictureFill) return PageBackgroundType.PICTURE;
+    if (res.solidFill) return PageBackgroundType.SOLID;
+    return PageBackgroundType.NONE;
+  }
+
+  isVisible() {
+    return this.getType().toString() !== 'NONE';
+  }
+
+  setPictureFill(urlOrBlob) {
+    const presentationId = this.__page.__presentation.getId();
+    let url = typeof urlOrBlob === 'string' ? urlOrBlob : '';
+    
+    const requests = [{
+        updatePageProperties: {
+            objectId: this.__page.getObjectId(),
+            pageProperties: {
+                pageBackgroundFill: {
+                    stretchedPictureFill: {
+                        contentUrl: url
+                    }
+                }
+            },
+            fields: 'pageBackgroundFill'
+        }
+    }];
+    Slides.Presentations.batchUpdate({ requests }, presentationId);
+
+    return this;
+  }
+
+  setSolidFill(color, alpha = 1.0) {
+    const presentationId = this.__page.__presentation.getId();
+    
+    let solidFill = {};
+    if (typeof color === 'string') {
+      const hex = color.replace('#', '');
+      solidFill = {
+        color: {
+          rgbColor: {
+            red: parseInt(hex.substring(0, 2), 16) / 255,
+            green: parseInt(hex.substring(2, 4), 16) / 255,
+            blue: parseInt(hex.substring(4, 6), 16) / 255
+          }
+        }
+      };
+    } else if (color && color.toString() === 'Color') {
+       solidFill = { color: { themeColor: 'ACCENT1' } };
+    }
+
+    if (alpha !== 1.0) {
+      solidFill.alpha = alpha;
+    }
+
+    const requests = [{
+        updatePageProperties: {
+            objectId: this.__page.getObjectId(),
+            pageProperties: {
+                pageBackgroundFill: {
+                    propertyState: 'RENDERED',
+                    solidFill: solidFill
+                }
+            },
+            fields: 'pageBackgroundFill'
+        }
+    }];
+    Slides.Presentations.batchUpdate({ requests }, presentationId);
+    return this;
+  }
+
+  setTransparent() {
+    const presentationId = this.__page.__presentation.getId();
+    const requests = [{
+        updatePageProperties: {
+            objectId: this.__page.getObjectId(),
+            pageProperties: {
+                pageBackgroundFill: {
+                    propertyState: 'NOT_RENDERED'
+                }
+            },
+            fields: 'pageBackgroundFill'
+        }
+    }];
+    Slides.Presentations.batchUpdate({ requests }, presentationId);
+    return this;
+  }
+
   toString() {
     return 'PageBackground';
   }

package/src/services/slidesapp/fakepageelement.js

@@ -29,9 +29,28 @@ export class FakePageElement {
 
   get __resource() {
     const pageResource = this.__page.__resource;
-    const element = (pageResource.pageElements || []).find(e => e.objectId === this.__id);
+    const allElements = pageResource.pageElements || [];
+
+    const findElement = (elements, targetId) => {
+      for (const element of elements) {
+        if (element.objectId === targetId) {
+          return element;
+        }
+        if (element.group && element.group.children) {
+          const found = findElement(element.group.children, targetId);
+          if (found) return found;
+        }
+        if (element.elementGroup && element.elementGroup.children) {
+          const found = findElement(element.elementGroup.children, targetId);
+          if (found) return found;
+        }
+      }
+      return null;
+    };
+
+    const element = findElement(allElements, this.__id);
     if (!element) {
-      throw new Error(`PageElement with ID ${this.__id} not found on page`);
+      throw new Error(`Exception: Page element (${this.__id}) could not be found.`);
     }
     return element;
   }
@@ -52,6 +71,18 @@ export class FakePageElement {
     throw new Error('PageElement is not a shape.');
   }
 
+  /**
+   * Returns the page element as an image.
+   * @returns {FakeImage} The image.
+   */
+  asImage() {
+    if (this.__resource.image) {
+      const { newFakeImage } = PageElementRegistry;
+      return newFakeImage(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not an image.');
+  }
+
   /**
    * Returns the page element as a line.
    * @returns {FakeLine} The line.
@@ -76,6 +107,54 @@ export class FakePageElement {
     throw new Error('PageElement is not a table.');
   }
 
+  /**
+   * Returns the page element as a group.
+   * @returns {FakeGroup} The group.
+   */
+  asGroup() {
+    if (this.__resource.elementGroup || this.__resource.group) {
+      const { newFakeGroup } = PageElementRegistry;
+      return newFakeGroup(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not a group.');
+  }
+
+  /**
+   * Returns the page element as a video.
+   * @returns {FakeVideo} The video.
+   */
+  asVideo() {
+    if (this.__resource.video) {
+      const { newFakeVideo } = PageElementRegistry;
+      return newFakeVideo(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not a video.');
+  }
+
+  /**
+   * Returns the page element as a speaker spotlight.
+   * @returns {FakeSpeakerSpotlight} The speaker spotlight.
+   */
+  asSpeakerSpotlight() {
+    if (this.__resource.speakerSpotlight) {
+      const { newFakeSpeakerSpotlight } = PageElementRegistry;
+      return newFakeSpeakerSpotlight(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not a speaker spotlight.');
+  }
+
+  /**
+   * Returns the page element as word art.
+   * @returns {FakeWordArt} The word art.
+   */
+  asWordArt() {
+    if (this.__resource.wordArt) {
+      const { newFakeWordArt } = PageElementRegistry;
+      return newFakeWordArt(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not word art.');
+  }
+
   /**
    * Gets the type of the page element.
    * @returns {SlidesApp.PageElementType} The type.
@@ -103,12 +182,20 @@ export class FakePageElement {
     if (this.__resource.sheetsChart) {
       return types.SHEETS_CHART;
     }
-    if (this.__resource.group) {
+    if (this.__resource.elementGroup || this.__resource.group) {
       return types.GROUP;
     }
     return types.UNSUPPORTED;
   }
 
+  getInherentHeight() {
+    return this.__normalize(this.__resource.size?.height);
+  }
+
+  getInherentWidth() {
+    return this.__normalize(this.__resource.size?.width);
+  }
+
   getLeft() {
     return this.__normalize(this.__resource.transform?.translateX);
   }
@@ -150,13 +237,21 @@ export class FakePageElement {
   }
 
   getRotation() {
-    // Rotation can be calculated from scale and shear in affine transform
-    // But for fakes, we might just return 0 if not easily available.
+    if (this._rotation !== undefined) {
+      return this._rotation;
+    }
+    const t = this.__resource.transform;
+    if (t && (t.shearY !== undefined || t.scaleX !== undefined)) {
+      const shearY = t.shearY || 0;
+      const scaleX = t.scaleX || 1;
+      const angle = Math.round(Math.atan2(shearY, scaleX) * (180 / Math.PI));
+      return (angle + 360) % 360;
+    }
     return 0;
   }
 
   setRotation(angle) {
-    // In API, we usually setting rotation via updatePageElementTransform with RELATIVE mode or similar
+    this._rotation = angle;
     return this;
   }
 
@@ -191,13 +286,13 @@ export class FakePageElement {
 
   alignOnPage(alignmentPosition) {
     const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
-    Slides.Presentations.batchUpdate([{
+    Slides.Presentations.batchUpdate({ requests: [{
       updatePageElementProperties: {
         objectId: this.getObjectId(),
         pageElementProperties: {}, // API doesn't have direct align?
         fields: '*'
       }
-    }], presentationId);
+    }] }, presentationId);
     return this;
   }
 
@@ -231,11 +326,11 @@ export class FakePageElement {
 
   remove() {
     const presentationId = this.__page.__presentation.getId();
-    Slides.Presentations.batchUpdate([{
+    Slides.Presentations.batchUpdate({ requests: [{
       deleteObject: {
         objectId: this.getObjectId()
       }
-    }], presentationId);
+    }] }, presentationId);
   }
 
   bringForward() {
@@ -300,7 +395,7 @@ export class FakePageElement {
   __updateTransform(transform) {
     const t = this.getTransform();
     const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
-    Slides.Presentations.batchUpdate([{
+    Slides.Presentations.batchUpdate({ requests: [{
       updatePageElementTransform: {
         objectId: this.getObjectId(),
         transform: {
@@ -315,7 +410,7 @@ export class FakePageElement {
         },
         applyMode: 'ABSOLUTE'
       }
-    }], presentationId);
+    }] }, presentationId);
   }
 
   __updateSize(size) {
@@ -338,13 +433,13 @@ export class FakePageElement {
 
   __updateAltText(title, description) {
     const presentationId = this.__page.__presentation.getId();
-    Slides.Presentations.batchUpdate([{
+    Slides.Presentations.batchUpdate({ requests: [{
       updatePageElementAltText: {
         objectId: this.getObjectId(),
         title: title,
         description: description
       }
-    }], presentationId);
+    }] }, presentationId);
   }
 
   __updateProperties(props, fields) {
@@ -373,18 +468,18 @@ export class FakePageElement {
     if (request) {
       if (request.updateShapeProperties) request.updateShapeProperties.fields = fields || '*';
       if (request.updateLineProperties) request.updateLineProperties.fields = fields || '*';
-      Slides.Presentations.batchUpdate([request], presentationId);
+      Slides.Presentations.batchUpdate({ requests: [request] }, presentationId);
     }
   }
 
   __updateZOrder(operation) {
     const presentationId = this.__page.__presentation.getId();
-    Slides.Presentations.batchUpdate([{
+    Slides.Presentations.batchUpdate({ requests: [{
       updatePageElementZOrder: {
         pageElementObjectIds: [this.getObjectId()],
         zOrderOperation: operation
       }
-    }], presentationId);
+    }] }, presentationId);
   }
 
   /**
@@ -396,6 +491,43 @@ export class FakePageElement {
     // For now, let's return a fixed number as a mock.
     return [0, 1, 2, 3].map(index => newFakeConnectionSite(this, index));
   }
+  scaleHeight(ratio) {
+    this.setHeight(this.getHeight() * ratio);
+    return this;
+  }
+
+  scaleWidth(ratio) {
+    this.setWidth(this.getWidth() * ratio);
+    return this;
+  }
+
+  select(replace = true) {
+    return this;
+  }
+
+  duplicate() {
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    const newObjectId = `duplicate_${Math.random().toString(36).substr(2, 9)}`;
+    
+    Slides.Presentations.batchUpdate({ requests: [{
+      duplicateObject: {
+        objectId: this.getObjectId(),
+        objectIds: {
+          [this.getObjectId()]: newObjectId
+        }
+      }
+    }] }, presentationId);
+
+    const resourceCopy = JSON.parse(JSON.stringify(this.__resource));
+    resourceCopy.objectId = newObjectId;
+    this.__page.__resource.pageElements = this.__page.__resource.pageElements || [];
+    this.__page.__resource.pageElements.push(resourceCopy);
+
+    const { newFakePageElement } = PageElementRegistry;
+    const baseElement = newFakePageElement(resourceCopy, this.__page);
+    return baseElement;
+  }
+
   toString() {
     return 'PageElement';
   }
@@ -404,5 +536,12 @@ export class FakePageElement {
 export const PageElementRegistry = {
   newFakeShape: null,
   newFakeLine: null,
-  newFakeTable: null
+  newFakeTable: null,
+  newFakeGroup: null,
+  newFakeImage: null,
+  newFakeVideo: null,
+  newFakeSpeakerSpotlight: null,
+  newFakeWordArt: null,
+  newFakePageElement: newFakePageElement,
+  asSpecificPageElement: null
 };

package/src/services/slidesapp/fakepageelementrange.js

@@ -0,0 +1,28 @@
+import { Proxies } from '../../support/proxies.js';
+
+/**
+ * create a new FakePageElementRange instance
+ * @param  {...any} args 
+ * @returns {FakePageElementRange}
+ */
+export const newFakePageElementRange = (...args) => {
+  return Proxies.guard(new FakePageElementRange(...args));
+};
+
+export class FakePageElementRange {
+  constructor(elements) {
+    this.__elements = elements;
+  }
+
+  /**
+   * Returns the list of PageElement instances.
+   * @returns {FakePageElement[]} The page elements.
+   */
+  getPageElements() {
+    return this.__elements;
+  }
+
+  toString() {
+    return 'PageElementRange';
+  }
+}

package/src/services/slidesapp/fakepagerange.js

@@ -0,0 +1,28 @@
+import { Proxies } from '../../support/proxies.js';
+
+/**
+ * create a new FakePageRange instance
+ * @param  {...any} args 
+ * @returns {FakePageRange}
+ */
+export const newFakePageRange = (...args) => {
+  return Proxies.guard(new FakePageRange(...args));
+};
+
+export class FakePageRange {
+  constructor(pages) {
+    this.__pages = pages;
+  }
+
+  /**
+   * Returns the list of Page instances.
+   * @returns {FakePage[]} The pages.
+   */
+  getPages() {
+    return this.__pages;
+  }
+
+  toString() {
+    return 'PageRange';
+  }
+}

package/src/services/slidesapp/fakeparagraphstyle.js

@@ -0,0 +1,139 @@
+import { Proxies } from '../../support/proxies.js';
+import { ParagraphAlignment, SpacingMode, TextDirection } from '../enums/slidesenums.js';
+
+/**
+ * create a new FakeParagraphStyle instance
+ * @param  {...any} args 
+ * @returns {FakeParagraphStyle}
+ */
+export const newFakeParagraphStyle = (...args) => {
+  return Proxies.guard(new FakeParagraphStyle(...args));
+};
+
+export class FakeParagraphStyle {
+  constructor(textRange) {
+    this.__textRange = textRange;
+  }
+
+  get __style() {
+    // Similar to TextStyle, find first paragraph marker in range
+    const resource = this.__textRange.__resource;
+    const elements = resource?.textElements || [];
+    const start = this.__textRange.getStartIndex();
+
+    let currentIndex = 0;
+    for (const element of elements) {
+      const length = element.textRun?.content?.length || (element.autoText ? 1 : 0);
+      if (currentIndex >= start && element.paragraphMarker) {
+        return element.paragraphMarker.style || {};
+      }
+      currentIndex += length;
+    }
+    return {};
+  }
+
+  getIndentEnd() {
+    return this.__textRange.__shape.__normalize(this.__style.indentEnd) || 0;
+  }
+
+  getIndentFirstLine() {
+    return this.__textRange.__shape.__normalize(this.__style.indentFirstLine) || 0;
+  }
+
+  getIndentStart() {
+    return this.__textRange.__shape.__normalize(this.__style.indentStart) || 0;
+  }
+
+  getLineSpacing() {
+    return this.__style.lineSpacing || 100;
+  }
+
+  getParagraphAlignment() {
+    return ParagraphAlignment[this.__style.alignment || 'START'];
+  }
+
+  getSpaceAbove() {
+    return this.__textRange.__shape.__normalize(this.__style.spaceAbove) || 0;
+  }
+
+  getSpaceBelow() {
+    return this.__textRange.__shape.__normalize(this.__style.spaceBelow) || 0;
+  }
+
+  getSpacingMode() {
+    return SpacingMode[this.__style.spacingMode || 'NEVER_COLLAPSE'];
+  }
+
+  getTextDirection() {
+    return TextDirection[this.__style.direction || 'LEFT_TO_RIGHT'];
+  }
+
+  __update(props, fields) {
+    const presentationId = this.__textRange.__shape.__presentation.getId();
+    const objectId = this.__textRange.__shape.getObjectId();
+    const cellLocation = this.__textRange.__shape.__cellLocation;
+
+    Slides.Presentations.batchUpdate({ requests: [{
+        updateParagraphStyle: {
+            objectId,
+            cellLocation,
+            style: props,
+            fields: fields || Object.keys(props).join(','),
+            textRange: {
+                type: 'FIXED_RANGE',
+                startIndex: this.__textRange.getStartIndex(),
+                endIndex: this.__textRange.getEndIndex()
+            }
+        }
+    }] }, presentationId);
+  }
+
+  setIndentEnd(indent) {
+    this.__update({ indentEnd: { magnitude: indent, unit: 'PT' } }, 'indentEnd');
+    return this;
+  }
+
+  setIndentFirstLine(indent) {
+    this.__update({ indentFirstLine: { magnitude: indent, unit: 'PT' } }, 'indentFirstLine');
+    return this;
+  }
+
+  setIndentStart(indent) {
+    this.__update({ indentStart: { magnitude: indent, unit: 'PT' } }, 'indentStart');
+    return this;
+  }
+
+  setLineSpacing(spacing) {
+    this.__update({ lineSpacing: spacing }, 'lineSpacing');
+    return this;
+  }
+
+  setParagraphAlignment(alignment) {
+    this.__update({ alignment: alignment.toString() }, 'alignment');
+    return this;
+  }
+
+  setSpaceAbove(space) {
+    this.__update({ spaceAbove: { magnitude: space, unit: 'PT' } }, 'spaceAbove');
+    return this;
+  }
+
+  setSpaceBelow(space) {
+    this.__update({ spaceBelow: { magnitude: space, unit: 'PT' } }, 'spaceBelow');
+    return this;
+  }
+
+  setSpacingMode(mode) {
+    this.__update({ spacingMode: mode.toString() }, 'spacingMode');
+    return this;
+  }
+
+  setTextDirection(direction) {
+    this.__update({ direction: direction.toString() }, 'direction');
+    return this;
+  }
+
+  toString() {
+    return 'ParagraphStyle';
+  }
+}

package/src/services/slidesapp/fakepicturefill.js

@@ -0,0 +1,32 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakePictureFill = (...args) => {
+  return Proxies.guard(new FakePictureFill(...args));
+};
+
+export class FakePictureFill {
+  constructor(resource, page) {
+    this.__resource = resource;
+    this.__page = page;
+  }
+
+  getAs(contentType) {
+    return this.getBlob().getAs(contentType);
+  }
+
+  getBlob() {
+    return UrlFetchApp.fetch(this.getContentUrl()).getBlob();
+  }
+
+  getContentUrl() {
+    return this.__resource.contentUrl || '';
+  }
+
+  getSourceUrl() {
+    return this.__resource.sourceUrl || '';
+  }
+
+  toString() {
+    return 'PictureFill';
+  }
+}