@mcpher/gas-fakes 2.3.17 → 2.5.1

package/README.md

@@ -22,6 +22,16 @@ Collaborators should fork the repo and use the local versions of these files - s
 ## Usage
 Just as on Apps Script, everything is executed synchronously so you don't need to bother with handling Promises/async/await. Just write normal Apps Script code. Usually you would have an associated App Script project if that's your eventual target. Just like Apps Script, you need a manifest file (appsscript.json) so you can be sure that the correct scopes are authorized and asked for.
 
+### Local Web Development (`doGet` / `doPost`)
+You can develop and test Google Apps Script Web Apps and UI Add-ons entirely on your local machine using the built-in local web server. The `gas-fakes serve` command spins up a local HTTP endpoint that routes requests to your `doGet` or `doPost` functions, perfectly emulating the Apps Script environment.
+
+It features complete support for:
+- `HtmlService` templating (`<?!= include() ?>`).
+- Client-side RPC via `google.script.run`.
+- Visual UI emulation for Add-ons: Calling `SpreadsheetApp.getUi().showSidebar(html)` automatically frames your HTML output inside a visually accurate Workspace-style sidebar right in your browser!
+
+See the [Local Web Development Guide](notes/local-web-development.md) for full details.
+
 ### Natural Language Automation with `@gf_agent`
 With the introduction of the `gf_agent` skill for Gemini CLI and the built-in MCP server, you can now automate Google Workspace tasks using natural language. This specialized agent understands the full range of `gas-fakes` services and can generate and execute code locally based on your plain English prompts. Whether it's summarizing emails in a Google Doc or analyzing spreadsheet data, you can now do it directly from your terminal using plain English. See the [gf_agent documentation](gf_agent/README.md) for more details.
 
@@ -39,20 +49,7 @@ For details see [gas fakes cli](notes/gas-fakes-cli.md)
 
 ### Configuration
 
-Configuration for your local Node environment is handled via environment variables, typically stored in a `.env` file and managed by the `gas-fakes init` process.
-
-| Environment Variable | Default | Description |
-|---|---|---|
-| `GF_MANIFEST_PATH` | `./appsscript.json` | Path to the `appsscript.json` manifest file. |
-| `GF_CLASP_PATH` | `./.clasp.json` | Path to the `.clasp.json` file. |
-| `GF_SCRIPT_ID` | from clasp, or random | Discovered from `.clasp.json` or generated as a random UUID during `gas-fakes init`. Used for `ScriptApp.getScriptId()` and partitioning stores. |
-| `GF_DOCUMENT_ID` | `null` | A bound document ID for testing container-bound scripts. |
-| `GF_CACHE_PATH` | `/tmp/gas-fakes/cache` | Path for `CacheService` local file emulation. |
-| `GF_PROPERTIES_PATH` | `/tmp/gas-fakes/properties` | Path for `PropertiesService` local file emulation. |
-| `GF_PLATFORM_AUTH` | `google` | Comma-separated list of backends to initialize (`google`, `ksuite`, `msgraph`). |
-| `AUTH_TYPE` | `dwd` | Google auth type: `dwd` (Domain-Wide Delegation) or `adc` (Application Default Credentials). |
-| `LOG_DESTINATION` | `CONSOLE` | Logging destination: `CONSOLE`, `CLOUD`, `BOTH`, or `NONE`. |
-| `STORE_TYPE` | `FILE` | Internal storage type for properties/cache: `FILE` (local) or `UPSTASH` (Redis). |
+Configuration for your local Node environment is handled interactively by the `gas-fakes init` process, which manages the necessary environment variables in your `.env` file.
 
 ### Note on Consumer Accounts and ADC
 
@@ -123,21 +120,6 @@ console.log ('....example cloud log link for this session',Logger.__cloudLogLink
 
 It contains a cloud logging query that will display any logging done in this session - the filter is based on the scriptId (from the environment), the projectId and userId (from Auth), as well as the start and end time of the session. 
 
-#### A note on .env location
-
-You will have used the gas-fakes init command to create a .env file, containing the LOG_DESTINATION setting. You can change any of the settings in the .env file manually if you want to.
-
-If you want to set an initial LOG_DESTINATION using that .env file, you have to let gas-fakes know where to find it. Let's assume it's in the same folder as your main script. 
-```env
-node yourapp.js
-# or if your .env is somewhere else
-node --env-file pathtoenv yourapp.js
-```
-
-Alternatively, instead of putting it in an env file, you can export it in your shell environment. 
-```sh
-export LOG_DESTINATION="BOTH"
-```
 Finally, another approach is to set it dynamically at the beginning of your app.
 ```javascript
 Logger.__logDestination="BOTH"
@@ -168,14 +150,14 @@ There are a couple of syntactical differences between Node and Apps Script. Not
 // this required on Node but not on Apps Script
 if (ScriptApp.isFake) testFakes()
 ````
-For inspiration on pushing modified files to the IDE, see the togas.sh bash script I use for the test suite. There's also a complete push pull workflow available - see - [push test pull](notes/pull-test-push.md)
+For pushing modified files back to the Apps Script IDE, use the built-in `gas-fakes togas` CLI command which handles necessary module syntax transformations automatically.
 
 
 ## Help
 
 As I mentioned earlier, to take this further, I'm going to need a lot of help to extend the methods and services supported - so if you feel this would be useful to you, and would like to collaborate, please ping me on bruce@mcpher.com and we'll talk.
 
-## <img src="./pngs/logo.png" alt="gas-fakes logo" width="50" align="top"> Further Reading
+## <img src="../pngs/logo.png" alt="gas-fakes logo" width="50" align="top"> Further Reading
 
 ## Watch the gas-fakes intro video
 
@@ -187,6 +169,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 
 ## 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)
@@ -194,6 +177,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [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)
 - [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)
@@ -227,7 +211,6 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)
 - [named range identity](notes/named-range-identity.md)
 - [Workspace scopes with local authentication](notes/workspace_scopes.md)
-- [push test pull](notes/pull-test-push.md)
 - [sharing cache and properties between gas-fakes and live apps script](https://ramblings.mcpher.com/sharing-cache-and-properties-between-gas-fakes-and-live-apps-script/)
 - [gas-fakes-cli now has built in mcp server and gemini extension](https://ramblings.mcpher.com/gas-fakes-cli-now-has-built-in-mcp-server-and-gemini-extension/)
 - [gas-fakes CLI: Run apps script code directly from your terminal](https://ramblings.mcpher.com/gas-fakes-cli-run-apps-script-code-directly-from-your-terminal/)

package/package.json

@@ -5,7 +5,6 @@
   "dependencies": {
     "@azure/identity": "^4.13.1",
     "@mcpher/fake-gasenum": "^1.0.6",
-    "@mcpher/gas-fakes": "^2.3.9",
     "@mcpher/gas-flex-cache": "^1.1.5",
     "@microsoft/microsoft-graph-client": "^3.0.7",
     "@modelcontextprotocol/sdk": "^1.28.0",
@@ -40,7 +39,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.17",
+  "version": "2.5.1",
   "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

@@ -9,7 +9,9 @@ import {
   authenticateUser,
   enableGoogleAPIs,
 } from "./setup.js";
+import { startWebApp } from "./server.js";
 import { startMcpServer } from "./mcp.js";
+import { togas } from "./togas.js";
 import { Platforms, PlatformDefaults } from "../services/enums/platformenums.js";
 
 export async function main() {
@@ -26,7 +28,7 @@ export async function main() {
 
   // --- Main Execution Command ---
   program
-    .description("Execute a Google Apps Script file or string.")
+    .description("Execute a Google Apps Script file or string, or start the server.")
     .option("-f, --filename <string>", "Path to the Google Apps Script file.")
     .option(
       "-s, --script <string>",
@@ -87,7 +89,7 @@ export async function main() {
       if (!hasEnvFileFlag || !isDefaultEnv) {
         const envPath = path.resolve(process.cwd(), env);
         console.log(`...using env file in ${envPath}`);
-        dotenv.config({ path: envPath, quiet: true });
+        dotenv.config({ path: envPath, quiet: true, override: true });
       }
 
       const sandboxConfig = buildSandboxConfig(options);
@@ -175,6 +177,21 @@ export async function main() {
     .option("-t, --tools <string>", "Path to custom tools file.")
     .action(startMcpServer);
 
+  // --- Server Command ---
+  program
+    .command("serve [filename]")
+    .description("Starts a local web server to handle doGet and doPost requests.")
+    .option("-p, --port <number>", "Port for local web server (overrides .env).")
+    .option("-e, --env <path>", "Path to a custom .env file.", "./.env")
+    .option("-m, --main <string>", "The entry point function to execute on GET requests.", "doGet")
+    .action(async (filename, options) => {
+       if (!filename) {
+         console.error("error: missing required argument 'filename'");
+         process.exit(1);
+       }
+       await startWebApp({ ...options, filename });
+    });
+
   // --- JDBC Command ---
   program
     .command("jdbc")
@@ -193,6 +210,17 @@ export async function main() {
       }
     });
 
+  // --- Togas Command ---
+  program
+    .command("togas")
+    .description("Prepares and pushes local code to Google Apps Script using clasp.")
+    .option("-p, --pattern <string>", "Comma-separated glob patterns for files to include (default: *)")
+    .option("-t, --target <string>", "Target directory for clasp project (default: TOGAS_TARGET in .env)")
+    .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.")
+    .action(togas);
+
   program.showHelpAfterError("(add --help for additional information)");
 
   await program.parseAsync(process.argv);

package/src/cli/server.js

@@ -0,0 +1,32 @@
+import path from "path";
+import fs from "fs";
+import dotenv from "dotenv";
+import { startServer } from "../services/html/webapp.js";
+
+/**
+ * Starts a web server to handle doGet and doPost requests.
+ */
+export async function startWebApp(options = {}) {
+  const { filename, env, port, main: entryFunction } = options;
+
+  // Load environment variables
+  const envPath = path.resolve(process.cwd(), env || "./.env");
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath, quiet: true, override: true });
+  }
+
+  const serverPort = port || process.env.GF_SERVER_PORT || 8080;
+  let targetFilename = filename;
+  if (targetFilename && !targetFilename.endsWith('.js')) {
+      targetFilename += '.js';
+  }
+  const scriptPath = targetFilename ? path.resolve(process.cwd(), targetFilename) : null;
+
+  if (!scriptPath || !fs.existsSync(scriptPath)) {
+      console.error(`Error: GAS file not found: ${targetFilename}`);
+      process.exit(1);
+  }
+
+  console.log(`...starting web server for ${scriptPath} (default entrypoint: ${entryFunction})`);
+  startServer(serverPort, scriptPath, entryFunction);
+}

package/src/cli/setup.js

@@ -228,6 +228,30 @@ export async function initializeConfiguration(options = {}) {
       name: "GF_PROPERTIES_PATH",
       message: "Properties storage path",
       initial: existingConfig.GF_PROPERTIES_PATH || "/tmp/gas-fakes/properties",
+    },
+    {
+      type: "number",
+      name: "GF_SERVER_PORT",
+      message: "Port for local web server (doGet/doPost)",
+      initial: parseInt(existingConfig.GF_SERVER_PORT) || 8080,
+    },
+    {
+      type: "text",
+      name: "TOGAS_TARGET",
+      message: "Togas: Target directory for clasp project (e.g., ../testongas)",
+      initial: existingConfig.TOGAS_TARGET || "../testongas",
+    },
+    {
+      type: "text",
+      name: "TOGAS_SCRIPT_ID",
+      message: "Togas: Script ID for the target clasp project",
+      initial: existingConfig.TOGAS_SCRIPT_ID || existingConfig.GF_SCRIPT_ID || "",
+    },
+    {
+      type: "text",
+      name: "TOGAS_PATTERN",
+      message: "Togas: Comma-separated glob patterns for files to include (e.g. abc*,xyz*)",
+      initial: existingConfig.TOGAS_PATTERN || "*",
     }
   ];
 

package/src/cli/togas.js

@@ -0,0 +1,176 @@
+import fs from "fs";
+import path from "path";
+import prompts from "prompts";
+import { execSync } from "child_process";
+import dotenv from "dotenv";
+import { Utils } from "../support/utils.js";
+
+/**
+ * Prepares and pushes local code to Google Apps Script using clasp.
+ * @param {object} options Options object provided by commander.js.
+ */
+export async function togas(options) {
+  // 1. Load env
+  const envPath = path.resolve(process.cwd(), options.env || "./.env");
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath, quiet: true, override: true });
+  }
+
+  const target = options.target || process.env.TOGAS_TARGET;
+  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 || "./";
+
+  if (!target) {
+    console.error("Error: TOGAS_TARGET is not set. Please run 'gas-fakes init' or provide --target.");
+    process.exit(1);
+  }
+
+  const absoluteTarget = path.resolve(process.cwd(), target);
+  const absoluteSource = path.resolve(process.cwd(), source);
+
+  if (absoluteTarget === absoluteSource) {
+    console.error("Error: Target directory cannot be the same as the source directory.");
+    process.exit(1);
+  }
+
+  // 2. Prepare target
+  if (!fs.existsSync(absoluteTarget)) {
+    fs.mkdirSync(absoluteTarget, { recursive: true });
+  }
+
+  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
+    });
+
+    if (response.create) {
+        if (!scriptId) {
+             console.error("Error: No Script ID found. Please provide one with --scriptId or in .env.");
+             process.exit(1);
+        }
+        const claspConfig = { scriptId, rootDir: "./" };
+        fs.writeFileSync(claspJsonPath, JSON.stringify(claspConfig, null, 2));
+        console.log(`Created .clasp.json with scriptId: ${scriptId}`);
+    } else {
+      console.log("Operation cancelled.");
+      return;
+    }
+  } else {
+    // Check scriptId
+    try {
+        const claspConfig = JSON.parse(fs.readFileSync(claspJsonPath, "utf8"));
+        if (scriptId && claspConfig.scriptId !== scriptId) {
+            console.error(`Error: .clasp.json scriptId (${claspConfig.scriptId}) does not match configured scriptId (${scriptId}).`);
+            process.exit(1);
+        }
+    } catch (e) {
+        console.warn(`Warning: Failed to parse ${claspJsonPath}.`);
+    }
+  }
+
+  // 3. Copy files
+  console.log(`...scanning source: ${absoluteSource}`);
+  console.log(`...matching patterns: ${pattern}`);
+  
+  // Create an array of regexes for the comma-separated patterns
+  // We want to match the pattern explicitly ending in .js, .html, or .gs
+  const regexPatterns = pattern.split(',').map(p => p.trim()).filter(Boolean).map(p => {
+    // Escape regex characters except the * wildcard
+    const escapedPattern = p.split('*').map(s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*');
+    
+    // If the user provided an extension, use it, otherwise match our target extensions
+    if (p.endsWith('.js') || p.endsWith('.html') || p.endsWith('.gs')) {
+      return new RegExp("^" + escapedPattern + "$");
+    } else {
+      // Append the target extensions to the pattern
+      return new RegExp("^" + escapedPattern + "\\.(js|html|gs)$");
+    }
+  });
+  
+  const copiedFiles = [];
+  const specialFiles = ["appsscript.json"];
+
+  // Helper to walk directory recursively and efficiently
+  function walkSync(dir, relativeDir = "") {
+    const absoluteDir = path.join(dir, relativeDir);
+    
+    // Skip target directory if it's inside source
+    if (absoluteDir === absoluteTarget) return;
+    
+    const entries = fs.readdirSync(absoluteDir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const entryRelativePath = path.join(relativeDir, entry.name);
+      const entryAbsolutePath = path.join(dir, entryRelativePath);
+      
+      if (entry.isDirectory()) {
+        // Skip common ignored directories
+        if (entry.name === "node_modules" || entry.name === ".git" || entryAbsolutePath === absoluteTarget) {
+          continue;
+        }
+        walkSync(dir, entryRelativePath);
+      } else if (entry.isFile()) {
+        const fileName = entry.name;
+        const extension = path.extname(fileName).toLowerCase();
+        
+        // Handle special files
+        if (specialFiles.includes(entryRelativePath)) {
+          const destPath = path.join(absoluteTarget, entryRelativePath);
+          fs.mkdirSync(path.dirname(destPath), { recursive: true });
+          fs.copyFileSync(entryAbsolutePath, destPath);
+          if (extension === ".js" || extension === ".gs") copiedFiles.push(destPath);
+          continue;
+        }
+
+        // Match patterns for .js, .gs, .html
+        if ((extension === ".js" || extension === ".html" || extension === ".gs") && 
+            regexPatterns.some(regex => regex.test(fileName))) {
+            
+            const destPath = path.join(absoluteTarget, entryRelativePath);
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.copyFileSync(entryAbsolutePath, destPath);
+            if (extension === ".js" || extension === ".gs") copiedFiles.push(destPath);
+        }
+      }
+    }
+  }
+
+  walkSync(absoluteSource);
+
+  if (copiedFiles.length === 0) {
+    console.log("No files matched the patterns. Nothing to do.");
+    return;
+  }
+
+  // 4. Transform JS files
+  console.log(`...transforming ${copiedFiles.length} files for Apps Script compatibility`);
+  for (const filePath of copiedFiles) {
+    let content = fs.readFileSync(filePath, "utf8");
+    fs.writeFileSync(filePath, Utils.stripEsmKeywords(content));
+  }
+
+  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
+  });
+
+  if (response.push) {
+    console.log("Running clasp push...");
+    try {
+      execSync("clasp push", { cwd: absoluteTarget, stdio: "inherit" });
+      console.log("Push successful.");
+    } catch (err) {
+      console.error("Clasp push failed. Ensure you are logged in (clasp login) and the script exists.");
+    }
+  }
+}

package/src/index.js

@@ -29,4 +29,6 @@ import './services/mimetype/app.js'
 import './services/lock/app.js'
 import './services/libhandlerapp/app.js'
 import './services/jdbc/app.js'
+import './services/html/app.js'
+import './services/content/app.js'
 

package/src/services/common/fakeui.js

@@ -0,0 +1,45 @@
+/**
+ * @file Provides a fake implementation of the Ui class.
+ */
+import { Proxies } from '../../support/proxies.js';
+import { notYetImplemented } from '../../support/helpers.js';
+
+/**
+ * A fake implementation of the Ui class.
+ * @class FakeUi
+ * @implements {GoogleAppsScript.Base.Ui}
+ */
+class FakeUi {
+  createAddonMenu() {
+    return notYetImplemented('Ui.createAddonMenu');
+  }
+
+  createMenu(caption) {
+    return notYetImplemented('Ui.createMenu');
+  }
+
+  showSidebar(userInterface) {
+    // In live GAS, this returns void and pushes to the client UI.
+    // Locally, we set the dimensions to match a standard Sidebar (300px width).
+    if (userInterface && typeof userInterface.setWidth === 'function') {
+      userInterface.setWidth(300);
+      userInterface.__framingType = 'sidebar';
+    }
+    // We log it so the developer knows the UI interaction occurred.
+    console.log(`[gas-fakes] Ui.showSidebar triggered with Title: "${userInterface.getTitle ? userInterface.getTitle() : ''}"`);
+    return this;
+  }
+
+  showModalDialog(userInterface, title) {
+    // In live GAS, this returns void and pushes to the client UI.
+    // Locally, we set the title and apply standard dialog styling to the HtmlOutput.
+    if (userInterface && typeof userInterface.setTitle === 'function') {
+      userInterface.setTitle(title);
+      userInterface.__framingType = 'modal';
+    }
+    console.log(`[gas-fakes] Ui.showModalDialog triggered with Title: "${title}"`);
+    return this;
+  }
+}
+
+export const newFakeUi = (...args) => Proxies.guard(new FakeUi(...args));

package/src/services/content/app.js

@@ -0,0 +1,3 @@
+import { newFakeContentService } from "./contentservice.js";
+
+globalThis.ContentService = newFakeContentService();

package/src/services/content/contentservice.js

@@ -0,0 +1,14 @@
+import { FakeTextOutput } from "./textoutput.js";
+import { ContentEnums } from "../enums/contentenums.js";
+
+export class FakeContentService {
+  constructor() {
+    this.MimeType = ContentEnums.MimeType;
+  }
+
+  createTextOutput(content = "") {
+    return new FakeTextOutput(content);
+  }
+}
+
+export const newFakeContentService = () => new FakeContentService();

package/src/services/content/textoutput.js

@@ -0,0 +1,45 @@
+export class FakeTextOutput {
+  constructor(content = "") {
+    this._content = content;
+    this._mimeType = "text/plain";
+    this._fileName = null;
+    this.__isTextOutput = true;
+  }
+
+  append(content) {
+    this._content += content;
+    return this;
+  }
+
+  clear() {
+    this._content = null;
+    return this;
+  }
+
+  downloadAsFile(filename) {
+    this._fileName = filename;
+    return this;
+  }
+
+  getContent() {
+    return this._content;
+  }
+
+  getFileName() {
+    return this._fileName;
+  }
+
+  getMimeType() {
+    return this._mimeType;
+  }
+
+  setContent(content) {
+    this._content = content;
+    return this;
+  }
+
+  setMimeType(mimeType) {
+    this._mimeType = mimeType;
+    return this;
+  }
+}

package/src/services/documentapp/fakedocumentapp.js

@@ -3,7 +3,7 @@ import { newFakeDocument } from './fakedocument.js';
 
 import { signatureArgs } from '../../support/helpers.js';
 import is from '@sindresorhus/is';
-import { newFakeUi } from './fakeui.js';
+import { newFakeUi } from '../common/fakeui.js';
 import { Auth } from '../../support/auth.js';
 import * as Enums from '../enums/docsenums.js'
 import { defaultDocumentStyleRequests } from './elementblasters.js';

package/src/services/enums/contentenums.js

@@ -0,0 +1,15 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const ContentEnums = {
+  MimeType: newFakeGasenum([
+    "ATOM",
+    "CSV",
+    "ICAL",
+    "JAVASCRIPT",
+    "JSON",
+    "RSS",
+    "TEXT",
+    "VCARD",
+    "XML"
+  ])
+}

package/src/services/enums/htmlenums.js

@@ -0,0 +1,13 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const HtmlEnums = {
+  SandboxMode: newFakeGasenum([
+    "EMULATED",
+    "IFRAME",
+    "NATIVE"
+  ]),
+  XFrameOptionsMode: newFakeGasenum([
+    "ALLOWALL",
+    "DEFAULT"
+  ])
+}

package/src/services/enums/scriptenums.js

@@ -0,0 +1,6 @@
+export const ScriptEnums = {
+  AuthorizationStatus: {
+    REQUIRED: 'REQUIRED',
+    NOT_REQUIRED: 'NOT_REQUIRED'
+  }
+};

package/src/services/formapp/fakeformapp.js

@@ -1,6 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import * as Enums from '../enums/formsenums.js';
 import { newFakeForm } from './fakeform.js';
+import { newFakeUi } from '../common/fakeui.js';
 import { Auth } from '../../support/auth.js';
 import { Url } from '../../support/url.js';
 import { signatureArgs } from '../../support/helpers.js'
@@ -74,6 +75,10 @@ class FakeFormApp {
     return this.openById(id);
   }
 
+  getUi() {
+    return newFakeUi();
+  }
+
   /**
    * Opens the form with the specified ID.
    * @param {string} id The ID of the form to open.

package/src/services/html/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 { newFakeHtmlService as maker} from './htmlservice.js'
+let _app = null;
+_app = lazyLoaderApp(_app, 'HtmlService', maker)