@mcpher/gas-fakes 1.2.26 → 1.2.28

package/src/services/slidesapp/fakeautofit.js

@@ -0,0 +1,49 @@
+import { Proxies } from '../../support/proxies.js';
+import { AutofitType } from '../enums/slidesenums.js';
+
+export const newFakeAutofit = (...args) => {
+  return Proxies.guard(new FakeAutofit(...args));
+};
+
+export class FakeAutofit {
+  constructor(shape) {
+    this.__shape = shape;
+    // Store autofit type on the shape resource or locally?
+    // Ideally on the resource so it persists if we reload the shape.
+    // But for now, let's look at the shape's property if meaningful or just a local property default.
+    // The resource might have 'text.autoFit'.
+  }
+
+  get __resource() {
+    // Ensure shape.text exists
+    if (!this.__shape.__resource.shape.text) {
+      this.__shape.__resource.shape.text = {};
+    }
+    return this.__shape.__resource.shape.text;
+  }
+
+  getAutofitType() {
+    const type = (this.__resource.autoFit && this.__resource.autoFit.autofitType) || 'NONE';
+    return AutofitType[type] || AutofitType.NONE;
+  }
+
+  disableAutofit() {
+    if (!this.__resource.autoFit) {
+      this.__resource.autoFit = {};
+    }
+    this.__resource.autoFit.autofitType = AutofitType.NONE.toString();
+    return this;
+  }
+
+  getFontScale() {
+    return (this.__resource.autoFit && this.__resource.autoFit.fontScale) !== undefined ? this.__resource.autoFit.fontScale : 1;
+  }
+
+  getLineSpacingReduction() {
+    return (this.__resource.autoFit && this.__resource.autoFit.lineSpacingReduction) !== undefined ? this.__resource.autoFit.lineSpacingReduction : 0;
+  }
+
+  toString() {
+    return 'Autofit';
+  }
+}

package/src/services/slidesapp/fakeautotext.js

@@ -0,0 +1,29 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeAutoText = (...args) => {
+  return Proxies.guard(new FakeAutoText(...args));
+};
+
+export class FakeAutoText {
+  constructor(range, type, index) {
+    this.__range = range;
+    this.__type = type;
+    this.__index = index;
+  }
+
+  getIndex() {
+    return this.__index;
+  }
+
+  getRange() {
+    return this.__range;
+  }
+
+  getAutoTextType() {
+    return this.__type;
+  }
+
+  toString() {
+    return 'AutoText';
+  }
+}

package/src/services/slidesapp/fakeconnectionsite.js

@@ -0,0 +1,24 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeConnectionSite = (...args) => {
+  return Proxies.guard(new FakeConnectionSite(...args));
+};
+
+export class FakeConnectionSite {
+  constructor(pageElement, index) {
+    this.__pageElement = pageElement;
+    this.__index = index;
+  }
+
+  getIndex() {
+    return this.__index;
+  }
+
+  getPageElement() {
+    return this.__pageElement;
+  }
+
+  toString() {
+    return 'ConnectionSite';
+  }
+}

package/src/services/slidesapp/fakelayout.js

@@ -0,0 +1,38 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeMaster } from './fakemaster.js';
+
+export const newFakeLayout = (...args) => {
+  return Proxies.guard(new FakeLayout(...args));
+};
+
+export class FakeLayout {
+  constructor(resource, presentation) {
+    this.__id = resource.objectId;
+    this.__presentation = presentation;
+  }
+
+  get __resource() {
+    const presentationResource = this.__presentation.__resource;
+    const layout = (presentationResource.layouts || []).find(l => l.objectId === this.__id);
+    if (!layout) {
+      throw new Error(`Layout with ID ${this.__id} not found`);
+    }
+    return layout;
+  }
+
+  getMaster() {
+    const masterId = this.__resource.masterObjectId;
+    if (!masterId) return null;
+
+    const presentationResource = this.__presentation.__resource;
+    const master = (presentationResource.masters || []).find(m => m.objectId === masterId);
+    return master ? newFakeMaster(master, this.__presentation) : null;
+  }
+
+  getObjectId() {
+    return this.__id;
+  }
+  toString() {
+    return 'Layout';
+  }
+}

package/src/services/slidesapp/fakeline.js

@@ -0,0 +1,195 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakePageElement, PageElementRegistry } from './fakepageelement.js';
+import { newFakeLineFill } from './fakelinefill.js';
+import { newFakePoint } from './fakepoint.js';
+
+export const newFakeLine = (...args) => {
+  const line = Proxies.guard(new FakeLine(...args));
+  return line;
+};
+
+PageElementRegistry.newFakeLine = newFakeLine;
+
+export class FakeLine extends FakePageElement {
+  constructor(resource, page) {
+    super(resource, page);
+  }
+
+  get __line() {
+    return this.__resource.line;
+  }
+
+  getLineCategory() {
+    return this.__line.lineCategory;
+  }
+
+  getLineType() {
+    return this.__line.lineType;
+  }
+
+  isConnector() {
+    return this.getLineCategory() !== 'NON_CONNECTOR';
+  }
+
+  getLineFill() {
+    return newFakeLineFill(this);
+  }
+
+  getWeight() {
+    return this.__normalize(this.__line.lineProperties?.weight);
+  }
+
+  setWeight(weight) {
+    this.__updateLineProps({ weight: { magnitude: weight, unit: 'PT' } }, 'weight');
+    return this;
+  }
+
+  getDashStyle() {
+    const style = this.__line.lineProperties?.dashStyle || 'SOLID';
+    return SlidesApp.DashStyle[style] || SlidesApp.DashStyle.SOLID;
+  }
+
+  setDashStyle(dashStyle) {
+    this.__updateLineProps({ dashStyle: dashStyle }, 'dashStyle');
+    return this;
+  }
+
+  getStartArrow() {
+    const style = this.__line.lineProperties?.startArrow || 'NONE';
+    return SlidesApp.ArrowStyle[style] || SlidesApp.ArrowStyle.NONE;
+  }
+
+  setStartArrow(arrowStyle) {
+    this.__updateLineProps({ startArrow: arrowStyle }, 'startArrow');
+    return this;
+  }
+
+  getEndArrow() {
+    const style = this.__line.lineProperties?.endArrow || 'NONE';
+    return SlidesApp.ArrowStyle[style] || SlidesApp.ArrowStyle.NONE;
+  }
+
+  setEndArrow(arrowStyle) {
+    this.__updateLineProps({ endArrow: arrowStyle }, 'endArrow');
+    return this;
+  }
+
+  getStart() {
+    // Start point of the line. 
+    // Usually lines are defined by transform and size.
+    // For now, let's just return normalized coordinates
+    return newFakePoint(this.getLeft(), this.getTop());
+  }
+
+  setStart(xOrPoint, y) {
+    let xValue, yValue;
+    if (typeof xOrPoint === 'object') {
+      xValue = xOrPoint.getX();
+      yValue = xOrPoint.getY();
+    } else {
+      xValue = xOrPoint;
+      yValue = y;
+    }
+    this.__updateLineProps({
+      startPoint: {
+        x: { magnitude: xValue, unit: 'PT' },
+        y: { magnitude: yValue, unit: 'PT' }
+      }
+    }, 'startPoint');
+    return this;
+  }
+
+  getEnd() {
+    return newFakePoint(this.getLeft() + this.getWidth(), this.getTop() + this.getHeight());
+  }
+
+  setEnd(xOrPoint, y) {
+    let xValue, yValue;
+    if (typeof xOrPoint === 'object') {
+      xValue = xOrPoint.getX();
+      yValue = xOrPoint.getY();
+    } else {
+      xValue = xOrPoint;
+      yValue = y;
+    }
+    // We update size/transform to match endpoints for straight lines?
+    // Simplified: just set width/height
+    const dx = xValue - this.getLeft();
+    const dy = yValue - this.getTop();
+    this.setWidth(Math.abs(dx));
+    this.setHeight(Math.abs(dy));
+    return this;
+  }
+
+  reroute() {
+    // In API, there's no reroute directly in batchUpdate for lines?
+    // Wait, the documentation says reroute is available.
+    // It might be a specific request type.
+    // Actually, I don't see 'rerouteLine' in Slides API reference.
+    // It might be an Apps Script specific implementation that uses other methods.
+    return this;
+  }
+
+  getStartConnection() {
+    const conn = this.__line.lineProperties?.startConnection;
+    if (!conn) return null;
+
+    // We need to find the connected element
+    const element = this.__page.getPageElements().find(e => e.getObjectId() === conn.connectedObjectId);
+    if (!element) return null;
+
+    // And the connection site
+    const sites = element.getConnectionSites();
+    const site = sites.find(s => s.getIndex() === conn.connectionSiteIndex);
+
+    return site || null;
+  }
+
+  getEndConnection() {
+    const conn = this.__line.lineProperties?.endConnection;
+    if (!conn) return null;
+
+    const element = this.__page.getPageElements().find(e => e.getObjectId() === conn.connectedObjectId);
+    if (!element) return null;
+
+    const sites = element.getConnectionSites();
+    const site = sites.find(s => s.getIndex() === conn.connectionSiteIndex);
+
+    return site || null;
+  }
+
+  setStartConnection(connectionSite) {
+    this.__updateLineProps({
+      startConnection: {
+        connectedObjectId: connectionSite.getPageElement().getObjectId(),
+        connectionSiteIndex: connectionSite.getIndex()
+      }
+    }, 'startConnection');
+    return this;
+  }
+
+  setEndConnection(connectionSite) {
+    this.__updateLineProps({
+      endConnection: {
+        connectedObjectId: connectionSite.getPageElement().getObjectId(),
+        connectionSiteIndex: connectionSite.getIndex()
+      }
+    }, 'endConnection');
+    return this;
+  }
+
+  __updateLineProps(lineProperties, fields) {
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    Slides.Presentations.batchUpdate([{
+      updateLineProperties: {
+        objectId: this.getObjectId(),
+        lineProperties: lineProperties,
+        fields: fields
+      }
+    }], presentationId);
+  }
+
+  toString() {
+    return 'Line';
+  }
+}

package/src/services/slidesapp/fakelinefill.js

@@ -0,0 +1,58 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeLineFill = (...args) => {
+  return Proxies.guard(new FakeLineFill(...args));
+};
+
+export class FakeLineFill {
+  constructor(line) {
+    this.__line = line;
+  }
+
+  getFillType() {
+    return this.__line.__line.lineFill?.solidFill ? 'SOLID' : 'NONE';
+  }
+
+  getSolidFill() {
+    // This should return a SolidFill object
+    // For now we might need a FakeSolidFill or just return something simple
+    return null;
+  }
+
+  setSolidFill(color) {
+    // Implementing this requires updateLineProperties with solidFill
+    const presentationId = this.__line.__page.__presentation?.getId() || this.__line.__page.__slide?.__presentation.getId();
+
+    let solidFill = {};
+    if (typeof color === 'string') {
+      solidFill = { color: { rgbColor: this.__hexToRgb(color) } };
+    }
+    // Handle other color types if needed
+
+    Slides.Presentations.batchUpdate([{
+      updateLineProperties: {
+        objectId: this.__line.getObjectId(),
+        lineProperties: {
+          lineFill: {
+            solidFill: solidFill
+          }
+        },
+        fields: 'lineFill.solidFill'
+      }
+    }], presentationId);
+    return this;
+  }
+
+  __hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+      red: parseInt(result[1], 16) / 255.0,
+      green: parseInt(result[2], 16) / 255.0,
+      blue: parseInt(result[3], 16) / 255.0
+    } : null;
+  }
+
+  toString() {
+    return 'LineFill';
+  }
+}

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';
+  }
+}