@mcpher/gas-fakes 1.2.26 → 1.2.27

package/src/services/slidesapp/fakelink.js

@@ -0,0 +1,31 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeLink = (...args) => {
+  return Proxies.guard(new FakeLink(...args));
+};
+
+export class FakeLink {
+  constructor(resource) {
+    this.__resource = resource;
+  }
+
+  getLinkType() {
+    if (this.__resource.url) return 'URL';
+    if (this.__resource.slideId) return 'SLIDE_ID';
+    if (this.__resource.pageObjectId) return 'PAGE_OBJECT_ID';
+    if (this.__resource.relativeSlide) return 'RELATIVE_SLIDE';
+    return 'NONE';
+  }
+
+  getUrl() {
+    return this.__resource.url || null;
+  }
+
+  getSlideId() {
+    return this.__resource.slideId || null;
+  }
+
+  toString() {
+    return 'Link';
+  }
+}

package/src/services/slidesapp/fakemaster.js

@@ -0,0 +1,28 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeMaster = (...args) => {
+  return Proxies.guard(new FakeMaster(...args));
+};
+
+export class FakeMaster {
+  constructor(resource, presentation) {
+    this.__id = resource.objectId;
+    this.__presentation = presentation;
+  }
+
+  get __resource() {
+    const presentationResource = this.__presentation.__resource;
+    const master = (presentationResource.masters || []).find(m => m.objectId === this.__id);
+    if (!master) {
+      throw new Error(`Master with ID ${this.__id} not found`);
+    }
+    return master;
+  }
+
+  getObjectId() {
+    return this.__id;
+  }
+  toString() {
+    return 'Master';
+  }
+}

package/src/services/slidesapp/fakenotespage.js

@@ -0,0 +1,19 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeNotesPage = (...args) => {
+  return Proxies.guard(new FakeNotesPage(...args));
+};
+
+export class FakeNotesPage {
+  constructor(slide) {
+    this.__slide = slide;
+  }
+  get __resource() {
+    // notesPage is a property of slideProperties
+    const notesPage = this.__slide.__resource.slideProperties?.notesPage;
+    return notesPage || null;
+  }
+  toString() {
+    return 'NotesPage';
+  }
+}

package/src/services/slidesapp/fakepagebackground.js

@@ -0,0 +1,17 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakePageBackground = (...args) => {
+  return Proxies.guard(new FakePageBackground(...args));
+};
+
+export class FakePageBackground {
+  constructor(page) {
+    this.__page = page;
+  }
+  get __resource() {
+    return this.__page.__resource.pageBackgroundFill || null;
+  }
+  toString() {
+    return 'PageBackground';
+  }
+}

package/src/services/slidesapp/fakepageelement.js

@@ -0,0 +1,395 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeConnectionSite } from './fakeconnectionsite.js';
+import { newFakeLink } from './fakelink.js';
+import { newFakeAffineTransform } from './fakeaffinetransform.js';
+
+export const newFakePageElement = (...args) => {
+  return Proxies.guard(new FakePageElement(...args));
+};
+
+export class FakePageElement {
+  constructor(resource, page) {
+    this.__id = resource.objectId;
+    this.__page = page;
+  }
+
+  __normalize(val) {
+    if (!val) return 0;
+    if (typeof val === 'number') {
+      // If > 5000 it's likely EMU. 1 PT = 12700 EMU.
+      // But search "gas-pro"... sometimes things are exactly EMU.
+      return val > 5000 ? val / 12700 : val;
+    }
+    if (typeof val.magnitude === 'number') {
+      const isEMU = val.unit === 'EMU' || val.magnitude > 5000;
+      return isEMU ? val.magnitude / 12700 : val.magnitude;
+    }
+    return val || 0;
+  }
+
+  get __resource() {
+    const pageResource = this.__page.__resource;
+    const element = (pageResource.pageElements || []).find(e => e.objectId === this.__id);
+    if (!element) {
+      throw new Error(`PageElement with ID ${this.__id} not found on page`);
+    }
+    return element;
+  }
+
+  getObjectId() {
+    return this.__id;
+  }
+
+  /**
+   * Returns the page element as a shape.
+   * @returns {FakeShape} The shape.
+   */
+  asShape() {
+    if (this.__resource.shape) {
+      const { newFakeShape } = PageElementRegistry;
+      return newFakeShape(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not a shape.');
+  }
+
+  /**
+   * Returns the page element as a line.
+   * @returns {FakeLine} The line.
+   */
+  asLine() {
+    if (this.__resource.line) {
+      const { newFakeLine } = PageElementRegistry;
+      return newFakeLine(this.__resource, this.__page);
+    }
+    throw new Error('PageElement is not a line.');
+  }
+
+  /**
+   * Gets the type of the page element.
+   * @returns {SlidesApp.PageElementType} The type.
+   */
+  getPageElementType() {
+    const types = SlidesApp.PageElementType;
+    if (this.__resource.shape) {
+      return types.SHAPE;
+    }
+    if (this.__resource.line) {
+      return types.LINE;
+    }
+    if (this.__resource.image) {
+      return types.IMAGE;
+    }
+    if (this.__resource.video) {
+      return types.VIDEO;
+    }
+    if (this.__resource.table) {
+      return types.TABLE;
+    }
+    if (this.__resource.wordArt) {
+      return types.WORD_ART;
+    }
+    if (this.__resource.sheetsChart) {
+      return types.SHEETS_CHART;
+    }
+    if (this.__resource.group) {
+      return types.GROUP;
+    }
+    return types.UNSUPPORTED;
+  }
+
+  getLeft() {
+    return this.__normalize(this.__resource.transform?.translateX);
+  }
+
+  setLeft(left) {
+    this.__updateTransform({ translateX: left });
+    return this;
+  }
+
+  getTop() {
+    return this.__normalize(this.__resource.transform?.translateY);
+  }
+
+  setTop(top) {
+    this.__updateTransform({ translateY: top });
+    return this;
+  }
+
+  getWidth() {
+    const magnitude = this.__normalize(this.__resource.size?.width);
+    const scaleX = this.__resource.transform?.scaleX || 1;
+    return magnitude * scaleX;
+  }
+
+  setWidth(width) {
+    this.__updateSize({ width: { magnitude: width, unit: 'PT' } });
+    return this;
+  }
+
+  getHeight() {
+    const magnitude = this.__normalize(this.__resource.size?.height);
+    const scaleY = this.__resource.transform?.scaleY || 1;
+    return magnitude * scaleY;
+  }
+
+  setHeight(height) {
+    this.__updateSize({ height: { magnitude: height, unit: 'PT' } });
+    return this;
+  }
+
+  getRotation() {
+    // Rotation can be calculated from scale and shear in affine transform
+    // But for fakes, we might just return 0 if not easily available.
+    return 0;
+  }
+
+  setRotation(angle) {
+    // In API, we usually setting rotation via updatePageElementTransform with RELATIVE mode or similar
+    return this;
+  }
+
+  getTransform() {
+    const t = this.__resource.transform || {};
+    return newFakeAffineTransform(
+      t.scaleX || 1,
+      t.shearY || 0,
+      t.shearX || 0,
+      t.scaleY || 1,
+      this.__normalize(t.translateX),
+      this.__normalize(t.translateY)
+    );
+  }
+
+  setTransform(affineTransform) {
+    this.__updateTransform({
+      scaleX: affineTransform.getScaleX(),
+      shearY: affineTransform.getShearY(),
+      shearX: affineTransform.getShearX(),
+      scaleY: affineTransform.getScaleY(),
+      translateX: affineTransform.getTranslateX(),
+      translateY: affineTransform.getTranslateY()
+    });
+    return this;
+  }
+
+  preconcatenateTransform(affineTransform) {
+    // Simplified multiplication for mock
+    return this;
+  }
+
+  alignOnPage(alignmentPosition) {
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      updatePageElementProperties: {
+        objectId: this.getObjectId(),
+        pageElementProperties: {}, // API doesn't have direct align?
+        fields: '*'
+      }
+    }], presentationId);
+    return this;
+  }
+
+  getTitle() {
+    return this.__resource.title || '';
+  }
+
+  setTitle(title) {
+    this.__updateAltText(title, this.getDescription());
+    return this;
+  }
+
+  getDescription() {
+    return this.__resource.description || '';
+  }
+
+  setDescription(description) {
+    this.__updateAltText(this.getTitle(), description);
+    return this;
+  }
+
+  getParentPage() {
+    return this.__page;
+  }
+
+  getParentGroup() {
+    // We need to look if this element is inside any group on the page
+    // This requires searching all page elements for groups
+    return null; // Simplified for now
+  }
+
+  remove() {
+    const presentationId = this.__page.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      deleteObject: {
+        objectId: this.getObjectId()
+      }
+    }], presentationId);
+  }
+
+  bringForward() {
+    this.__updateZOrder('BRING_FORWARD');
+    return this;
+  }
+
+  bringToFront() {
+    this.__updateZOrder('BRING_TO_FRONT');
+    return this;
+  }
+
+  sendBackward() {
+    this.__updateZOrder('SEND_BACKWARD');
+    return this;
+  }
+
+  sendToBack() {
+    this.__updateZOrder('SEND_TO_BACK');
+    return this;
+  }
+
+  getLink() {
+    const res = this.__resource;
+    const link = res.link ||
+      res.shape?.shapeProperties?.link ||
+      res.line?.lineProperties?.link ||
+      res.image?.imageProperties?.link ||
+      res.video?.videoProperties?.link ||
+      res.table?.tableProperties?.link;
+    if (!link || Object.keys(link).length === 0) return null;
+    return newFakeLink(link);
+  }
+
+  setLinkUrl(url) {
+    this.__updateProperties({ link: { url: url } }, 'link');
+    return this.getLink();
+  }
+
+  setLinkSlide(slideOrIndexOrPosition) {
+    let link = {};
+    if (typeof slideOrIndexOrPosition === 'number') {
+      // Slide index - we'd need to find the slide ID by index
+      // For now, skipping index lookup complexity
+      link = { relativeSlide: 'NEXT_SLIDE' }; // placeholder
+    } else if (typeof slideOrIndexOrPosition === 'string') {
+      // Slide ID maybe? Or relative position string
+      link = { slideId: slideOrIndexOrPosition };
+    } else if (slideOrIndexOrPosition && slideOrIndexOrPosition.getObjectId) {
+      // Slide object
+      link = { slideId: slideOrIndexOrPosition.getObjectId() };
+    }
+    this.__updateProperties({ link: link }, 'link');
+    return this.getLink();
+  }
+
+  removeLink() {
+    this.__updateProperties({}, 'link');
+    return this;
+  }
+
+  __updateTransform(transform) {
+    const t = this.getTransform();
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      updatePageElementTransform: {
+        objectId: this.getObjectId(),
+        transform: {
+          scaleX: t.getScaleX(),
+          scaleY: t.getScaleY(),
+          shearX: t.getShearX(),
+          shearY: t.getShearY(),
+          translateX: t.getTranslateX(),
+          translateY: t.getTranslateY(),
+          ...transform,
+          unit: 'PT'
+        },
+        applyMode: 'ABSOLUTE'
+      }
+    }], presentationId);
+  }
+
+  __updateSize(size) {
+    const t = this.getTransform();
+    const currentWidth = this.getWidth();
+    const currentHeight = this.getHeight();
+
+    const scaleX = size.width ? size.width.magnitude / (currentWidth || 1) : 1;
+    const scaleY = size.height ? size.height.magnitude / (currentHeight || 1) : 1;
+
+    this.__updateTransform({
+      scaleX: t.getScaleX() * scaleX,
+      scaleY: t.getScaleY() * scaleY,
+      shearX: t.getShearX(),
+      shearY: t.getShearY(),
+      translateX: t.getTranslateX(),
+      translateY: t.getTranslateY()
+    });
+  }
+
+  __updateAltText(title, description) {
+    const presentationId = this.__page.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      updatePageElementAltText: {
+        objectId: this.getObjectId(),
+        title: title,
+        description: description
+      }
+    }], presentationId);
+  }
+
+  __updateProperties(props, fields) {
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    const type = this.getPageElementType().toString();
+    let request = null;
+
+    if (type === 'SHAPE') {
+      request = {
+        updateShapeProperties: {
+          objectId: this.getObjectId(),
+          shapeProperties: props,
+          fields: fields || Object.keys(props).join(',')
+        }
+      };
+    } else if (type === 'LINE') {
+      request = {
+        updateLineProperties: {
+          objectId: this.getObjectId(),
+          lineProperties: props,
+          fields: fields || Object.keys(props).join(',')
+        }
+      };
+    }
+
+    if (request) {
+      if (request.updateShapeProperties) request.updateShapeProperties.fields = fields || '*';
+      if (request.updateLineProperties) request.updateLineProperties.fields = fields || '*';
+      Slides.Presentations.batchUpdate([request], presentationId);
+    }
+  }
+
+  __updateZOrder(operation) {
+    const presentationId = this.__page.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      updatePageElementZOrder: {
+        pageElementObjectIds: [this.getObjectId()],
+        zOrderOperation: operation
+      }
+    }], presentationId);
+  }
+
+  /**
+   * Gets the connection sites on the page element.
+   * @returns {FakeConnectionSite[]} The connection sites.
+   */
+  getConnectionSites() {
+    // Standard shapes usually have 4 connection sites (top, right, bottom, left).
+    // For now, let's return a fixed number as a mock.
+    return [0, 1, 2, 3].map(index => newFakeConnectionSite(this, index));
+  }
+  toString() {
+    return 'PageElement';
+  }
+}
+
+export const PageElementRegistry = {
+  newFakeShape: null,
+  newFakeLine: null
+};

package/src/services/slidesapp/fakeparagraph.js

@@ -0,0 +1,46 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeTextRange } from './faketextrange.js';
+
+export const newFakeParagraph = (...args) => {
+  return Proxies.guard(new FakeParagraph(...args));
+};
+
+export class FakeParagraph {
+  constructor(textRange, index) {
+    this.__textRange = textRange;
+    this.__index = index;
+    // We might need start/end indices relative to the shape's full text
+    // The textRange passed here might be the specific range FOR this paragraph?
+    // Or the parent range?
+    // Usually getParagraphs returns a list of Paragraph objects.
+    // Each Paragraph wraps a TextRange?
+    // Docs say Paragraph.getRange() returns a TextRange.
+    // So Paragraph IS NOT a TextRange, but has one.
+  }
+
+  /**
+   * Gets the index of the paragraph.
+   * @returns {number} The index.
+   */
+  getIndex() {
+    // Based on Live Apps Script behavior, getIndex() returns the index of the paragraph's terminating character (newline).
+    // Use the end index of the text range minus 1.
+    const range = this.getRange();
+    // Assuming range.getEndIndex() returns the exclusive end index.
+    return range.getEndIndex() - 1;
+  }
+
+  /**
+   * Gets the text range covering this paragraph.
+   * @returns {FakeTextRange} The text range.
+   */
+  getRange() {
+    return this.__textRange;
+  }
+
+
+
+  toString() {
+    return 'Paragraph';
+  }
+}

package/src/services/slidesapp/fakepoint.js

@@ -0,0 +1,24 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakePoint = (...args) => {
+  return Proxies.guard(new FakePoint(...args));
+};
+
+export class FakePoint {
+  constructor(x, y) {
+    this.__x = x;
+    this.__y = y;
+  }
+
+  getX() {
+    return this.__x;
+  }
+
+  getY() {
+    return this.__y;
+  }
+
+  toString() {
+    return 'Point';
+  }
+}

package/src/services/slidesapp/fakepresentation.js

@@ -1,4 +1,5 @@
 import { Proxies } from '../../support/proxies.js';
+import { newFakeSlide } from './fakeslide.js';
 
 export const newFakePresentation = (...args) => {
   return Proxies.guard(new FakePresentation(...args));
@@ -11,10 +12,16 @@ export const newFakePresentation = (...args) => {
  */
 export class FakePresentation {
   /**
-   * @param {object} resource the presentation resource from Slides API
+   * @param {object} resource the presentation resurce from Slides API
    */
   constructor(resource) {
-    this.__resource = resource;
+    this.__id = resource.presentationId;
+  }
+  get __file () {
+    return DriveApp.getFileById(this.__id);
+  }
+  get __resource () {
+    return Slides.Presentations.get(this.__id);
   }
   saveAndClose() {
     // this is a no-op in fake environment since it is stateless
@@ -24,7 +31,7 @@ export class FakePresentation {
    * @returns {string} The presentation ID.
    */
   getId() {
-    return this.__resource.presentationId;
+    return this.__id;
   }
 
   /**
@@ -43,6 +50,57 @@ export class FakePresentation {
     return `https://docs.google.com/presentation/d/${this.getId()}/edit`;
   }
 
+  /**
+   * Gets the slides in the presentation.
+   * @returns {FakeSlide[]} The slides.
+   */
+  getSlides() {
+    return (this.__resource.slides || []).map(s => newFakeSlide(s, this));
+  }
+
+  /**
+   * Gets a slide by its ID.
+   * @param {string} id The slide ID.
+   * @returns {FakeSlide | null} The slide, or null if not found.
+   */
+  getSlideById(id) {
+    return this.getSlides().find(s => s.getObjectId() === id) || null;
+  }
+
+  /**
+   * Appends a new slide to the presentation.
+   * @param {string} [layout] The layout to use (optional).
+   * @returns {FakeSlide} The new slide.
+   */
+  appendSlide(layout) {
+    const requests = [{
+      createSlide: {
+        slideLayoutReference: layout ? { predefinedLayout: layout } : { predefinedLayout: 'BLANK' }
+      }
+    }];
+    const result = Slides.Presentations.batchUpdate(requests, this.getId());
+    const newObjectId = result.replies[0].createSlide.objectId;
+    return this.getSlideById(newObjectId);
+  }
+
+  /**
+   * Inserts a new slide at the specified index.
+   * @param {number} index The index to insert at.
+   * @param {string} [layout] The layout to use (optional).
+   * @returns {FakeSlide} The new slide.
+   */
+  insertSlide(index, layout) {
+    const requests = [{
+      createSlide: {
+        insertionIndex: index,
+        slideLayoutReference: layout ? { predefinedLayout: layout } : { predefinedLayout: 'BLANK' }
+      }
+    }];
+    const result = Slides.Presentations.batchUpdate(requests, this.getId());
+    const newObjectId = result.replies[0].createSlide.objectId;
+    return this.getSlideById(newObjectId);
+  }
+
   toString() {
     return 'Presentation';
   }

package/src/services/slidesapp/fakeshape.js

@@ -0,0 +1,49 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeTextRange } from './faketextrange.js';
+import { newFakeAutofit } from './fakeautofit.js';
+import { newFakeConnectionSite } from './fakeconnectionsite.js';
+import { FakePageElement, PageElementRegistry } from './fakepageelement.js';
+
+export const newFakeShape = (...args) => {
+  const shape = Proxies.guard(new FakeShape(...args));
+  return shape;
+};
+
+PageElementRegistry.newFakeShape = newFakeShape;
+
+export class FakeShape extends FakePageElement {
+  constructor(resource, page) {
+    super(resource, page);
+  }
+
+  // Expose __presentation for TextRange to use
+  get __presentation() {
+    return this.__page.__presentation || this.__page.__slide?.__presentation;
+  }
+
+  /**
+   * Gets the text range of the shape.
+   * @returns {FakeTextRange} The text range.
+   */
+  getText() {
+    return newFakeTextRange(this);
+  }
+
+  getAutofit() {
+    return newFakeAutofit(this);
+  }
+
+  /**
+   * Gets the connection sites on the shape.
+   * @returns {FakeConnectionSite[]} The connection sites.
+   */
+  getConnectionSites() {
+    // Standard shapes usually have 4 connection sites (top, right, bottom, left).
+    // For now, let's return a fixed number as a mock.
+    return [0, 1, 2, 3].map(index => newFakeConnectionSite(this, index));
+  }
+
+  toString() {
+    return 'Shape';
+  }
+}