@mcpher/gas-fakes 1.2.26 → 1.2.27

package/package.json

@@ -34,7 +34,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.26",
+  "version": "1.2.27",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/src/cli/setup.js

@@ -302,8 +302,8 @@ export async function initializeConfiguration(options = {}) {
           existingConfig.LOG_DESTINATION
         ) > -1
           ? ["CONSOLE", "CLOUD", "BOTH", "NONE"].indexOf(
-              existingConfig.LOG_DESTINATION
-            )
+            existingConfig.LOG_DESTINATION
+          )
           : 0,
     },
     {
@@ -316,7 +316,7 @@ export async function initializeConfiguration(options = {}) {
       ],
       initial:
         ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE?.toUpperCase()) >
-        -1
+          -1
           ? ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE.toUpperCase())
           : 0,
     },
@@ -408,9 +408,9 @@ export async function initializeConfiguration(options = {}) {
 /**
  * Handles the 'auth' command to authenticate with Google Cloud.
  */
-export function authenticateUser() {
+export async function authenticateUser() {
   // First, check if gcloud CLI is available.
-  checkForGcloudCli();
+  await checkForGcloudCli();
 
   const rootDirectory = process.cwd();
   const envPath = path.join(rootDirectory, ".env");

package/src/cli/utils.js

@@ -1,6 +1,5 @@
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import { createRequire } from "node:module";
-
 const require = createRequire(import.meta.url);
 const pjson = require("../../package.json");
 
@@ -73,8 +72,7 @@ export async function checkForGcloudCli() {
 /**
  * Helper function to run a shell command sync (used in setup).
  */
-export async function runCommandSync(command) {
-  const { execSync } = await import("child_process");
+export function runCommandSync(command) {
   try {
     execSync(command, { stdio: "inherit" });
   } catch (error) {

package/src/services/enums/slidesenums.js

@@ -1,4 +1,4 @@
-import { newFakeGasenum} from "@mcpher/fake-gasenum";
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
 
 export const AlignmentPosition = newFakeGasenum([
   "CENTER",

package/src/services/formapp/fakechoiceitem.js

@@ -45,7 +45,7 @@ export class FakeChoiceItem extends newFakeFormItem().constructor {
 
     const updateRequest = Forms.newRequest().setUpdateItem({
       item: {
-        itemId: this.getId(),
+        itemId: this.__itemId,
         questionItem: {
           question: {
             choiceQuestion: choiceQuestion,

package/src/services/formapp/fakeform.js

@@ -13,7 +13,7 @@ import { newFakeListItem } from './fakelistitem.js';
 import { newFakePageBreakItem } from './fakepagebreakitem.js';
 import { newFakeTextItem } from './faketextitem.js';
 import { signatureArgs } from '../../support/helpers.js';
-import {Utils} from '../../support/utils.js';
+import { Utils } from '../../support/utils.js';
 const { is } = Utils
 export const newFakeForm = (...args) => {
   return Proxies.guard(new FakeForm(...args));
@@ -53,7 +53,7 @@ export class FakeForm {
     return this;
   }
 
-    
+
   saveAndClose() {
     // this is a no-op in fake environment since it is stateless
   }
@@ -298,6 +298,7 @@ export class FakeForm {
     if (!this.__resource.items) {
       return null;
     }
+    const hexId = Utils.toHex(id);
     const isKnownItem = (id, item) => {
       if (item.itemId === id) return true;
       if (item.questionItem?.question?.questionId === id) return true;
@@ -307,7 +308,7 @@ export class FakeForm {
       return found
     }
 
-    const itemResource = this.__resource.items.find((item) => isKnownItem(id, item));
+    const itemResource = this.__resource.items.find((item) => isKnownItem(hexId, item));
 
     if (!itemResource) {
       return null;

package/src/services/formapp/fakeformitem.js

@@ -114,8 +114,7 @@ export class FakeFormItem {
   }
 
   getId() {
-    // Live Apps Script returns IDs as decimal numbers, not the hex strings from the API.
-    return parseInt(this.__itemId, 16); // Convert to decimal
+    return Utils.fromHex(this.__itemId);
   }
 
   getIndex() {

package/src/services/formapp/fakeformresponse.js

@@ -1,5 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeItemResponse } from './fakeitemresponse.js';
+import { Utils } from '../../support/utils.js';
 
 export const newFakeFormResponse = (...args) => {
   return Proxies.guard(new FakeFormResponse(...args));
@@ -33,7 +34,7 @@ export class FakeFormResponse {
    * @returns {number} the unique hex ID converted to a decimal number
    */
   getId() {
-    return parseInt(this.__resource.responseId, 16);
+    return Utils.fromHex(this.__resource.responseId);
   }
 
   /**
@@ -59,7 +60,7 @@ export class FakeFormResponse {
     const groupedAnswers = new Map();
 
     for (const [questionId, answer] of Object.entries(this.__resource.answers)) {
-      const item = this.__form.getItemById(questionId);
+      const item = this.__form.getItemById(Utils.fromHex(questionId));
 
       if (item) {
         const itemId = item.getId(); // Use the unique item ID as the key.

package/src/services/formapp/fakelistitem.js

@@ -3,6 +3,7 @@ import { FakeFormItem } from './fakeformitem.js';
 import { newFakeChoice } from './fakechoice.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
+import { Utils } from '../../support/utils.js';
 
 export const newFakeListItem = (...args) => {
   return Proxies.guard(new FakeListItem(...args));
@@ -56,7 +57,7 @@ export class FakeListItem extends FakeFormItem {
       // Translate from API format back to Apps Script format.
       if (option.goToSectionId) {
         navType = 'GO_TO_PAGE';
-        pageId = option.goToSectionId;
+        pageId = Utils.fromHex(option.goToSectionId);
       } else if (option.goToAction) {
         switch (option.goToAction) {
           case 'NEXT_SECTION': navType = 'CONTINUE'; break;
@@ -85,7 +86,7 @@ export class FakeListItem extends FakeFormItem {
           case 'GO_TO_PAGE':
             // For navigating to a specific page, you ONLY set the goToSectionId.
             // The pageId is the itemId of the PageBreakItem.
-            option.goToSectionId = choice.__pageId;
+            option.goToSectionId = Utils.toHex(choice.__pageId);
             break;
           case 'CONTINUE':
             option.goToAction = 'NEXT_SECTION';

package/src/services/slidesapp/fakeaffinetransform.js

@@ -0,0 +1,55 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeAffineTransformBuilder } from './fakeaffinetransformbuilder.js';
+
+export const newFakeAffineTransform = (...args) => {
+  return Proxies.guard(new FakeAffineTransform(...args));
+};
+
+export class FakeAffineTransform {
+  constructor(scaleX, shearY, shearX, scaleY, translateX, translateY) {
+    this.__scaleX = scaleX;
+    this.__shearY = shearY;
+    this.__shearX = shearX;
+    this.__scaleY = scaleY;
+    this.__translateX = translateX;
+    this.__translateY = translateY;
+  }
+
+  getScaleX() {
+    return this.__scaleX;
+  }
+
+  getScaleY() {
+    return this.__scaleY;
+  }
+
+  getShearX() {
+    return this.__shearX;
+  }
+
+  getShearY() {
+    return this.__shearY;
+  }
+
+  getTranslateX() {
+    return this.__translateX;
+  }
+
+  getTranslateY() {
+    return this.__translateY;
+  }
+
+  toBuilder() {
+    return newFakeAffineTransformBuilder()
+      .setScaleX(this.__scaleX)
+      .setShearY(this.__shearY)
+      .setShearX(this.__shearX)
+      .setScaleY(this.__scaleY)
+      .setTranslateX(this.__translateX)
+      .setTranslateY(this.__translateY);
+  }
+
+  toString() {
+    return 'AffineTransform';
+  }
+}

package/src/services/slidesapp/fakeaffinetransformbuilder.js

@@ -0,0 +1,64 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeAffineTransform } from './fakeaffinetransform.js';
+
+export const newFakeAffineTransformBuilder = (...args) => {
+  return Proxies.guard(new FakeAffineTransformBuilder(...args));
+};
+
+export class FakeAffineTransformBuilder {
+  constructor() {
+    // Defaults? Documentation doesn't explicitly specify, but identity matrix is reasonable.
+    // scaleX=1, scaleY=1, others 0.
+    this.__scaleX = 1;
+    this.__shearY = 0;
+    this.__shearX = 0;
+    this.__scaleY = 1;
+    this.__translateX = 0;
+    this.__translateY = 0;
+  }
+
+  build() {
+    return newFakeAffineTransform(
+      this.__scaleX,
+      this.__shearY,
+      this.__shearX,
+      this.__scaleY,
+      this.__translateX,
+      this.__translateY
+    );
+  }
+
+  setScaleX(scaleX) {
+    this.__scaleX = scaleX;
+    return this;
+  }
+
+  setScaleY(scaleY) {
+    this.__scaleY = scaleY;
+    return this;
+  }
+
+  setShearX(shearX) {
+    this.__shearX = shearX;
+    return this;
+  }
+
+  setShearY(shearY) {
+    this.__shearY = shearY;
+    return this;
+  }
+
+  setTranslateX(translateX) {
+    this.__translateX = translateX;
+    return this;
+  }
+
+  setTranslateY(translateY) {
+    this.__translateY = translateY;
+    return this;
+  }
+
+  toString() {
+    return 'AffineTransformBuilder';
+  }
+}

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