@mcpher/gas-fakes 2.5.2 → 2.5.3

package/README.md

@@ -167,17 +167,24 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 
 [![Use natural language with gf_agent](./pngs/gfagent.png)](https://youtu.be/lujByoX71HU)
 
+## Watch the local webapps and addons development video
+
+[![Local Apps Script Webapp and UI Emulation with gas-fakes](./pngs/srv.jpg)](https://youtu.be/vH9wl7QloZ4)
+
 ## Read more docs
 
 - [release notes](versionnotes/)
 - [gas fakes intro video](https://youtu.be/oEjpIrkYpEM)
 - [getting started](GETTING_STARTED.md) - how to handle authentication for Workspace scopes.
 - [readme](README.md)
+- [apps script parity](notes/parity.md)
 - [Natural Language Automation with Gemini Skills & MCP Server](notes/gemini-skills-mcp.md) - new skills-based agent approach.
 - [Add agent skills to gf_agent](https://ramblings.mcpher.com/add-skills-gf_agent/)
 - [gf_agent documentation](../gf_agent/README.md) - instructions for the Gemini CLI automation agent and MCP server.
 - [gas fakes cli](notes/gas-fakes-cli.md)
--[local add-on and webapp development with gas-fakes](notes/local-web-development.md)
+- [local add-on and webapp development with gas-fakes](notes/local-web-development.md)
+- [Bringing the webapp home](https://ramblings.mcpher.com/local-apps-script-webapp-and-ui-emulation/)
+- [Local development example code](https://github.com/brucemcpherson/gf-serve)
 - [github actions using adc](https://github.com/brucemcpherson/gas-fakes-actions-adc)
 - [github actions using dwd and wif](https://github.com/brucemcpherson/gas-fakes-actions-dwd)
 - [ksuite as a back end](notes/ksuite_poc.md)

package/package.json

@@ -39,7 +39,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "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/cli/app.js

@@ -219,6 +219,7 @@ export async function main() {
     .option("-s, --source <string>", "Source directory (default: ./ )")
     .option("-e, --env <path>", "Path to a custom .env file.", "./.env")
     .option("--scriptId <string>", "Script ID for the target clasp project.")
+    .option("-q, --quiet", "Automatically accept all prompts.")
     .action(togas);
 
   program.showHelpAfterError("(add --help for additional information)");

package/src/cli/togas.js

@@ -20,6 +20,7 @@ export async function togas(options) {
   const scriptId = options.scriptId || process.env.TOGAS_SCRIPT_ID || process.env.GF_SCRIPT_ID;
   const pattern = options.pattern || process.env.TOGAS_PATTERN || "*";
   const source = options.source || "./";
+  const autoAccept = !!options.quiet;
 
   if (!target) {
     console.error("Error: TOGAS_TARGET is not set. Please run 'gas-fakes init' or provide --target.");
@@ -41,14 +42,18 @@ export async function togas(options) {
 
   const claspJsonPath = path.join(absoluteTarget, ".clasp.json");
   if (!fs.existsSync(claspJsonPath)) {
-    const response = await prompts({
-      type: "confirm",
-      name: "create",
-      message: `No .clasp.json found in ${target}. Create one?`,
-      initial: true
-    });
+    let create = autoAccept;
+    if (!create) {
+      const response = await prompts({
+        type: "confirm",
+        name: "create",
+        message: `No .clasp.json found in ${target}. Create one?`,
+        initial: true
+      });
+      create = response.create;
+    }
 
-    if (response.create) {
+    if (create) {
         if (!scriptId) {
              console.error("Error: No Script ID found. Please provide one with --scriptId or in .env.");
              process.exit(1);
@@ -157,14 +162,18 @@ export async function togas(options) {
   console.log(`Ready for clasp push in ${target}.`);
 
   // 5. Clasp push
-  const response = await prompts({
-    type: "confirm",
-    name: "push",
-    message: "Push to Apps Script using clasp now?",
-    initial: true
-  });
+  let push = autoAccept;
+  if (!push) {
+    const response = await prompts({
+      type: "confirm",
+      name: "push",
+      message: "Push to Apps Script using clasp now?",
+      initial: true
+    });
+    push = response.push;
+  }
 
-  if (response.push) {
+  if (push) {
     console.log("Running clasp push...");
     try {
       execSync("clasp push", { cwd: absoluteTarget, stdio: "inherit" });

package/src/index.js

@@ -11,6 +11,7 @@ import './services/gmailapp/app.js'
 import './services/calendarapp/app.js'
 import './services/chartsapp/app.js'
 import './services/session/app.js'
+import './services/base/app.js'
 import './services/advdrive/app.js'
 import './services/advsheets/app.js'
 import './services/advdocs/app.js'

package/src/services/advslides/fakeadvslides.js

@@ -16,15 +16,15 @@ class FakeAdvSlidesPresentations extends FakeAdvResource {
   // Override 'get' to use the caching-enabled function fxSlidesGet.
   get(presentationId, options) {
     ScriptApp.__behavior.isAccessible(presentationId, 'Slides', 'read');
-    const { response, data } = this._call('get', { presentationId, ...options }, Syncit.fxSlidesGet);
+    const { response, data } = this._call('get', { presentationId, ...options }, {}, null, Syncit.fxSlidesGet);
     gError(response, 'slides.presentations', 'get');
     return data;    
   }
 
   // Signature matches Apps Script advanced service.
   create(presentation) {
-    // The underlying API wants the resource in a 'resource' property.
-    const result = this._call('create', { resource: presentation });
+    // The underlying API wants the resource in a 'requestBody' property for Node.js.
+    const result = this._call('create', { requestBody: presentation });
     if (result.data) {
       this.slides.__addAllowed(result.data.presentationId);
     }
@@ -32,12 +32,18 @@ class FakeAdvSlidesPresentations extends FakeAdvResource {
   }
 
   // Signature matches Apps Script advanced service.
-  batchUpdate(requests, presentationId) {
+  // Robustly handle both resource object and raw requests array.
+  batchUpdate(resource, presentationId) {
     // for slides, any batch update is a write
     ScriptApp.__behavior.isAccessible(presentationId, 'Slides', 'write');
+    
+    const requestBody = Array.isArray(resource) 
+      ? { requests: resource } 
+      : resource;
+
     const result = this._call('batchUpdate', {
       presentationId,
-      resource: { requests },
+      requestBody,
     });
     gError(result.response, 'slides.presentations', 'batchUpdate');
 

package/src/services/base/app.js

@@ -0,0 +1,9 @@
+/**
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
+ */
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeBase as maker } from './fakebase.js';
+
+let _app = null;
+_app = lazyLoaderApp(_app, 'Base', maker);

package/src/services/base/fakebase.js

@@ -0,0 +1,28 @@
+import { Proxies } from '../../support/proxies.js';
+import * as BaseEnums from '../enums/baseenums.js';
+import { newFakeMimeType } from '../mimetype/fakemimetype.js';
+
+/**
+ * @class FakeBase
+ * @description The Base service in Google Apps Script.
+ * @see https://developers.google.com/apps-script/reference/base
+ */
+export class FakeBase {
+  constructor() {
+    this.Button = BaseEnums.Button;
+    this.ButtonSet = BaseEnums.ButtonSet;
+    this.ColorType = BaseEnums.ColorType;
+    this.MimeType = newFakeMimeType();
+    this.Month = BaseEnums.Month;
+    this.Weekday = BaseEnums.Weekday;
+  }
+
+  toString() {
+    return 'Base';
+  }
+}
+
+/**
+ * @returns {FakeBase}
+ */
+export const newFakeBase = () => Proxies.guard(new FakeBase());

package/src/services/common/fakeadvresource.js

@@ -14,7 +14,7 @@ export class FakeAdvResource {
     this.__syncitMethod = syncitMethod; // e.g., Syncit.fxDocs or Syncit.fxSheets
   }
 
-  _call(method, params, options, subProp = null) {
+  _call(method, params, options, subProp = null, syncMethodOverride = null) {
     const pack = {
       prop: this.__serviceName,
       subProp,
@@ -22,7 +22,8 @@ export class FakeAdvResource {
       params,
       options
     };
-    const result = this.__syncitMethod(pack);
+    const syncMethod = syncMethodOverride || this.__syncitMethod;
+    const result = syncMethod(pack);
     if (!result || !result.response) {
       // Simulate an error response if the worker didn't provide one.
       return {

package/src/services/enums/baseenums.js

@@ -0,0 +1,47 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const Button = newFakeGasenum([
+  "CANCEL",
+  "CLOSE",
+  "NO",
+  "OK",
+  "YES"
+])
+
+export const ButtonSet = newFakeGasenum([
+  "OK",
+  "OK_CANCEL",
+  "YES_NO",
+  "YES_NO_CANCEL"
+])
+
+export const ColorType = newFakeGasenum([
+  "RGB",
+  "THEME",
+  "UNSUPPORTED"
+])
+
+export const Month = newFakeGasenum([
+  "JANUARY",
+  "FEBRUARY",
+  "MARCH",
+  "APRIL",
+  "MAY",
+  "JUNE",
+  "JULY",
+  "AUGUST",
+  "SEPTEMBER",
+  "OCTOBER",
+  "NOVEMBER",
+  "DECEMBER"
+])
+
+export const Weekday = newFakeGasenum([
+  "SUNDAY",
+  "MONDAY",
+  "TUESDAY",
+  "WEDNESDAY",
+  "THURSDAY",
+  "FRIDAY",
+  "SATURDAY"
+])

package/src/services/enums/slidesenums.js

@@ -142,7 +142,9 @@ export const PageType = newFakeGasenum([
   "UNSUPPORTED",
   "SLIDE",
   "LAYOUT",
-  "MASTER"
+  "MASTER",
+  "NOTES_MASTER",
+  "NOTES_PAGE"
 ])
 export const ParagraphAlignment = newFakeGasenum([
   "UNSUPPORTED",

package/src/services/html/serverworker.js

@@ -60,7 +60,7 @@ export class ServerWorkerContext {
         mainScriptPath: globalThis.__gasFakesMainScriptPath || this._mainScriptPath,
         controlBuf: this._controlBuf,
         dataBuf: this._dataBuf,
-        env: process.env // Pass current environment
+        env: { ...process.env, GAS_FAKES_WORKER: 'true' } // Pass current environment and mark as worker
       },
       stdout: true,
       stderr: true

package/src/services/slidesapp/app.js

@@ -5,5 +5,10 @@
 
 import { lazyLoaderApp } from '../common/lazyloader.js'
 import { newFakeSlidesApp as maker} from './fakeslidesapp.js';
+import './pageelementfactory.js';
+export { newFakePageElementRange } from './fakepageelementrange.js';
+export { newFakePageRange } from './fakepagerange.js';
+export { newFakeTableCellRange } from './faketablecellrange.js';
+export { newFakeTableColumn } from './faketablecolumn.js';
 let _app = null;
 _app = lazyLoaderApp(_app, 'SlidesApp', maker)

package/src/services/slidesapp/fakeautofit.js

@@ -39,7 +39,7 @@ export class FakeAutofit {
       }
     }];
 
-    Slides.Presentations.batchUpdate(requests, presentationId);
+    Slides.Presentations.batchUpdate({ requests }, presentationId);
     return this;
   }
 

package/src/services/slidesapp/fakeborder.js

@@ -0,0 +1,106 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeLineFill } from './fakelinefill.js';
+
+/**
+ * Represents the Border properties of a Slides element.
+ * Emulates the Slides API resource structure.
+ */
+export const newFakeBorder = (...args) => {
+  return Proxies.guard(new FakeBorder(...args));
+};
+
+export class FakeBorder {
+  /**
+   * @param {FakePageElement} parent - The element this border belongs to.
+   */
+  constructor(parent) {
+    this._parent = parent;
+  }
+
+  get __resource() {
+    // Border properties are typically in imageProperties.outline or shapeProperties.outline
+    const res = this._parent.__resource;
+    return res.image?.imageProperties?.outline || res.shape?.shapeProperties?.outline;
+  }
+
+  getLineFill() {
+    return newFakeLineFill(this._parent);
+  }
+
+  isVisible() {
+    const weight = this.getWeight();
+    return weight !== null && weight > 0;
+  }
+
+  setDashStyle(style) {
+    this.__update({ dashStyle: style.toString() }, 'dashStyle');
+    return this;
+  }
+
+  setTransparent() {
+    this.__update({ propertyState: 'NOT_RENDERED' }, 'propertyState');
+    return this;
+  }
+
+  setWeight(weight) {
+    this.__update({ weight: { magnitude: weight, unit: 'PT' }, propertyState: 'RENDERED' }, 'weight,propertyState');
+    return this;
+  }
+
+  __update(props, fields) {
+    const presentationId = this._parent.__presentation?.getId() || this._parent.__page?.__presentation?.getId();
+    const type = this._parent.getPageElementType().toString();
+    const objectId = this._parent.getObjectId();
+
+    let request = null;
+    if (type === 'SHAPE') {
+      request = {
+        updateShapeProperties: {
+          objectId,
+          shapeProperties: { outline: props },
+          fields: fields ? fields.split(',').map(f => `outline.${f}`).join(',') : 'outline'
+        }
+      };
+    } else if (type === 'IMAGE') {
+        request = {
+            updateImageProperties: {
+              objectId,
+              imageProperties: { outline: props },
+              fields: fields ? fields.split(',').map(f => `outline.${f}`).join(',') : 'outline'
+            }
+          };
+    }
+
+    if (request) {
+      Slides.Presentations.batchUpdate({ requests: [request] }, presentationId);
+    }
+  }
+
+  /**
+   * Retrieves the weight of the border in Points (PT).
+   * @returns {number | null} The border weight in PT, or null if not defined/rendered.
+   */
+  getWeight() {
+    const outline = this.__resource;
+    if (!outline || outline.propertyState === 'NOT_RENDERED' || outline.weight === undefined) {
+      return null;
+    }
+    return this._parent.__normalize(outline.weight);
+  }
+
+  /**
+   * Gets the DashStyle of the border.
+   * @returns {string} The dash style.
+   */
+  getDashStyle() {
+    const outline = this.__resource;
+    if (!outline || outline.propertyState === 'NOT_RENDERED' || !outline.dashStyle) {
+      return 'SOLID';
+    }
+    return outline.dashStyle;
+  }
+
+  toString() {
+    return 'Border';
+  }
+}

package/src/services/slidesapp/fakecolorscheme.js

@@ -150,7 +150,7 @@ export class FakeColorScheme {
       }
     }];
 
-    Slides.Presentations.batchUpdate(requests, presentationId);
+    Slides.Presentations.batchUpdate({ requests }, presentationId);
     return this;
   }
 

package/src/services/slidesapp/fakefill.js

@@ -0,0 +1,216 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeSolidFill } from './fakesolidfill.js';
+import { FillType } from '../enums/slidesenums.js';
+
+export const newFakeFill = (...args) => {
+  return Proxies.guard(new FakeFill(...args));
+};
+
+export class FakeFill {
+  constructor(element) {
+    this.__element = element;
+  }
+
+  get __fill() {
+    if (this.__element.__resource.shape) {
+      return this.__element.__resource.shape.shapeProperties?.shapeBackgroundFill || {};
+    }
+    if (this.__element.__resource.tableCellProperties) {
+      return this.__element.__resource.tableCellProperties.tableCellBackgroundFill || {};
+    }
+    return this.__element.__resource.pageProperties?.pageBackgroundFill || {};
+  }
+
+  getType() {
+    const fill = this.__fill;
+    if (fill.solidFill && fill.propertyState !== 'NOT_RENDERED') {
+      return FillType.SOLID;
+    }
+    return FillType.NONE;
+  }
+
+  isVisible() {
+    return this.getType().toString() !== 'NONE';
+  }
+
+  getSolidFill() {
+    if (this.getType().toString() !== 'SOLID') {
+      return null;
+    }
+    return newFakeSolidFill(this);
+  }
+
+  setSolidFill(...args) {
+    let rgbColor = null;
+    let themeColor = null;
+    let alpha = 1.0;
+
+    if (args.length >= 3) {
+      const r = args[0] / 255;
+      const g = args[1] / 255;
+      const b = args[2] / 255;
+      rgbColor = { red: r, green: g, blue: b };
+      if (args.length === 4) {
+        alpha = args[3];
+      }
+    } else if (args.length > 0) {
+      const colorArg = args[0];
+      if (args.length === 2) {
+        alpha = args[1];
+      }
+
+      if (typeof colorArg === 'string') {
+        if (colorArg.startsWith('#') || colorArg.length === 6 || colorArg.length === 3) {
+          const hex = colorArg.startsWith('#') ? colorArg : '#' + colorArg;
+          const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+          if (result) {
+            rgbColor = {
+              red: parseInt(result[1], 16) / 255.0,
+              green: parseInt(result[2], 16) / 255.0,
+              blue: parseInt(result[3], 16) / 255.0
+            };
+          }
+        } else {
+          themeColor = colorArg.toString();
+        }
+      } else if (colorArg && typeof colorArg.getColorType === 'function') {
+        if (colorArg.getColorType().toString() === 'RGB') {
+          const rgb = colorArg.asRgbColor();
+          rgbColor = {
+            red: rgb.getRed() / 255,
+            green: rgb.getGreen() / 255,
+            blue: rgb.getBlue() / 255
+          };
+        } else if (colorArg.getColorType().toString() === 'THEME') {
+          themeColor = colorArg.asThemeColor().getThemeColorType().toString();
+        }
+      } else if (colorArg && colorArg.toString) {
+        themeColor = colorArg.toString();
+      }
+    }
+
+    const solidFill = {
+      color: {}
+    };
+    if (rgbColor) {
+      solidFill.color.rgbColor = rgbColor;
+    } else if (themeColor) {
+      solidFill.color.themeColor = themeColor;
+    }
+    if (alpha !== 1.0) {
+      solidFill.alpha = alpha;
+    }
+
+    const presentationId = this.__element.__presentation?.getId() || this.__element.__page?.__presentation?.getId() || this.__element.__table?.__presentation?.getId();
+    if (this.__element.__resource.shape) {
+      Slides.Presentations.batchUpdate({ requests: [{
+        updateShapeProperties: {
+          objectId: this.__element.getObjectId(),
+          shapeProperties: {
+            shapeBackgroundFill: {
+              propertyState: 'RENDERED',
+              solidFill: solidFill
+            }
+          },
+          fields: 'shapeBackgroundFill'
+        }
+      }] }, presentationId);
+
+    } else if (this.__element.__resource.tableCellProperties) {
+        Slides.Presentations.batchUpdate({ requests: [{
+          updateTableCellProperties: {
+            objectId: this.__element.getObjectId(),
+            tableCellProperties: {
+              tableCellBackgroundFill: {
+                propertyState: 'RENDERED',
+                solidFill: solidFill
+              }
+            },
+            fields: 'tableCellBackgroundFill',
+            tableRange: {
+              location: {
+                rowIndex: this.__element.getRowIndex(),
+                columnIndex: this.__element.getColumnIndex()
+              },
+              rowSpan: 1,
+              columnSpan: 1
+            }
+          }
+        }] }, presentationId);
+
+    } else {
+      Slides.Presentations.batchUpdate({ requests: [{
+        updatePageProperties: {
+          objectId: this.__element.getObjectId(),
+          pageProperties: {
+            pageBackgroundFill: {
+              propertyState: 'RENDERED',
+              solidFill: solidFill
+            }
+          },
+          fields: 'pageBackgroundFill'
+        }
+      }] }, presentationId);
+
+    }
+
+    return this;
+  }
+
+  setTransparent() {
+    const presentationId = this.__element.__presentation?.getId() || this.__element.__page?.__presentation?.getId() || this.__element.__table?.__presentation?.getId();
+    if (this.__element.__resource.shape) {
+      Slides.Presentations.batchUpdate({ requests: [{
+        updateShapeProperties: {
+          objectId: this.__element.getObjectId(),
+          shapeProperties: {
+            shapeBackgroundFill: {
+              propertyState: 'NOT_RENDERED'
+            }
+          },
+          fields: 'shapeBackgroundFill'
+        }
+      }] }, presentationId);
+
+    } else if (this.__element.__resource.tableCellProperties) {
+        Slides.Presentations.batchUpdate({ requests: [{
+          updateTableCellProperties: {
+            objectId: this.__element.getObjectId(),
+            tableCellProperties: {
+              tableCellBackgroundFill: {
+                propertyState: 'NOT_RENDERED'
+              }
+            },
+            fields: 'tableCellBackgroundFill',
+            tableRange: {
+                location: {
+                  rowIndex: this.__element.getRowIndex(),
+                  columnIndex: this.__element.getColumnIndex()
+                },
+                rowSpan: 1,
+                columnSpan: 1
+              }
+          }
+        }] }, presentationId);
+
+    } else {
+      Slides.Presentations.batchUpdate({ requests: [{
+        updatePageProperties: {
+          objectId: this.__element.getObjectId(),
+          pageProperties: {
+            pageBackgroundFill: {
+              propertyState: 'NOT_RENDERED'
+            }
+          },
+          fields: 'pageBackgroundFill'
+        }
+      }] }, presentationId);
+
+    }
+    return this;
+  }
+
+  toString() {
+    return 'Fill';
+  }
+}

package/src/services/slidesapp/fakegroup.js

@@ -0,0 +1,35 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakePageElement, PageElementRegistry } from './fakepageelement.js';
+
+export const newFakeGroup = (...args) => {
+  return Proxies.guard(new FakeGroup(...args));
+};
+
+PageElementRegistry.newFakeGroup = newFakeGroup;
+
+export class FakeGroup extends FakePageElement {
+  constructor(resource, page) {
+    super(resource, page);
+  }
+
+  getChildren() {
+    const children = this.__resource.elementGroup?.children || this.__resource.group?.children || [];
+    const { newFakePageElement } = PageElementRegistry;
+    return children.map(childResource => {
+      return newFakePageElement(childResource, this.__page);
+    });
+  }
+
+  ungroup() {
+    const presentationId = this.__page.__presentation?.getId() || this.__page.__slide?.__presentation.getId();
+    Slides.Presentations.batchUpdate({ requests: [{
+      ungroupObjects: {
+        objectIds: [this.getObjectId()]
+      }
+    }] }, presentationId);
+  }
+
+  toString() {
+    return 'Group';
+  }
+}