@mcpher/gas-fakes 2.3.17 → 2.5.1

package/src/services/html/webapp.js

@@ -0,0 +1,266 @@
+import http from 'http';
+import { ServerWorkerContext } from './serverworker.js';
+
+const CLIENT_POLYFILL = `
+<link rel="stylesheet" href="https://ssl.gstatic.com/docs/script/css/add-ons1.css">
+<script>
+  window.google = window.google || {};
+  window.google.script = window.google.script || {};
+  window.google.script.run = (function() {
+    function RunProxy(handlers) {
+      this._sh = handlers ? handlers._sh : null;
+      this._fh = handlers ? handlers._fh : null;
+      this._uo = handlers ? handlers._uo : null;
+
+      return new Proxy(this, {
+        get: (target, prop) => {
+          if (prop === 'withSuccessHandler') return (h) => new RunProxy({ ...target, _sh: h });
+          if (prop === 'withFailureHandler') return (h) => new RunProxy({ ...target, _fh: h });
+          if (prop === 'withUserObject') return (o) => new RunProxy({ ...target, _uo: o });
+          
+          return (...args) => {
+            let hasError = false;
+            let errorMsg = '';
+            
+            // Validate arguments according to Google Apps Script rules
+            const validateArg = (arg) => {
+              if (arg === undefined) {
+                hasError = true;
+                errorMsg = 'google.script.run cannot process undefined arguments.';
+              } else if (typeof arg === 'function') {
+                hasError = true;
+                errorMsg = 'google.script.run cannot process function arguments.';
+              } else if (typeof Element !== 'undefined' && arg instanceof Element) {
+                hasError = true;
+                errorMsg = 'google.script.run cannot process DOM element arguments.';
+              } else if (arg === window) {
+                hasError = true;
+                errorMsg = 'google.script.run cannot process window object arguments.';
+              } else if (arg !== null && typeof arg === 'object') {
+                // deep validation could go here, but shallow is usually enough for the common mistakes
+              }
+            };
+            args.forEach(validateArg);
+
+            if (hasError) {
+              if (target._fh) {
+                setTimeout(() => target._fh(new Error(errorMsg), target._uo), 0);
+              }
+              return;
+            }
+
+            fetch(window.location.origin + '/__gas_rpc', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ funcName: prop, args: args })
+            })
+            .then(r => r.json())
+            .then(data => {
+              if (data.error) {
+                if (target._fh) target._fh(new Error(data.error), target._uo);
+              } else {
+                if (target._sh) target._sh(data.result, target._uo);
+              }
+            })
+            .catch(err => {
+              if (target._fh) target._fh(err, target._uo);
+            });
+          };
+        }
+      });
+    }
+    return new RunProxy();
+  })();
+  window.google.script.host = {
+    close: function() { 
+      if (window.top && window.top !== window) {
+        window.top.postMessage({ type: 'gas-fakes-close' }, '*');
+      } else {
+        document.body.innerHTML = '<h3 style="font-family: sans-serif; text-align: center; margin-top: 50px;">Dialog Closed. You may close this tab.</h3>';
+      }
+    },
+    origin: window.location.origin,
+    setHeight: function(h) { console.log('gas-fakes: Host setHeight called with', h); },
+    setWidth: function(w) { console.log('gas-fakes: Host setWidth called with', w); }
+  };
+//# sourceURL=gas-fakes:///polyfill.js
+</script>
+`;
+
+export function startServer(port = 3000, scriptPath = null, entryFunction = 'doGet') {
+  const server = http.createServer((req, res) => {
+    if (req.method === 'GET' && req.url.startsWith('/')) {
+      // 1. Serve GET request
+      try {
+        const ctx = new ServerWorkerContext(scriptPath);
+        // Emulate the event object passed to doGet
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const params = Object.fromEntries(url.searchParams.entries());
+        const getEvent = { 
+            parameter: params, 
+            parameters: Object.fromEntries([...url.searchParams.keys()].map(k => [k, url.searchParams.getAll(k)])), 
+            queryString: url.search.substring(1), 
+            contextPath: '', 
+            contentLength: 0 
+        };
+        const funcToRun = params.main || entryFunction || 'doGet';
+        const result = ctx.runFunction(funcToRun, [getEvent]);
+        
+        if (result && result.__isHtmlOutput) {
+           let html = result.content;
+           // Inject polyfill
+           if (html.toLowerCase().includes('</head>')) {
+               html = html.replace(/<\/head>/i, CLIENT_POLYFILL + '</head>');
+           } else {
+               html = CLIENT_POLYFILL + html;
+           }
+
+           if (result.__framingType === 'modal' || result.__framingType === 'sidebar') {
+               const isSidebar = result.__framingType === 'sidebar';
+               const widthStr = isSidebar ? '300px' : '600px';
+               const heightStr = isSidebar ? '100vh' : '450px';
+               const safeTitle = (result.title || 'gas-fakes Dialog').replace(/"/g, '&quot;');
+               
+               const modalCss = `
+                   body { background-color: rgba(0,0,0,0.6); margin: 0; display: flex; align-items: center; justify-content: center; height: 100vh; font-family: 'Google Sans', Roboto, Arial, sans-serif; overflow: hidden; }
+                   .dialog { width: ${widthStr}; height: ${heightStr}; background: #fff; border-radius: 8px; box-shadow: 0 24px 38px 3px rgba(0,0,0,0.14), 0 9px 46px 8px rgba(0,0,0,0.12), 0 11px 15px -7px rgba(0,0,0,0.2); display: flex; flex-direction: column; overflow: hidden; }
+                   .dialog-header { display: flex; justify-content: space-between; align-items: center; padding: 20px 24px 14px 24px; border-bottom: 1px solid transparent; }
+                   .dialog-title { font-size: 22px; color: #202124; margin: 0; line-height: 28px; font-weight: 400; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+                   .dialog-close { background: none; border: none; font-size: 20px; color: #5f6368; cursor: pointer; padding: 0; line-height: 1; }
+                   .dialog-close:hover { color: #202124; }
+                   .dialog-content { padding: 0; flex-grow: 1; display: flex; border: none; }
+                   iframe { border: none; width: 100%; height: 100%; background: #fff; }
+               `;
+
+               const sidebarCss = `
+                   body { background-color: transparent; margin: 0; display: flex; justify-content: flex-end; height: 100vh; font-family: 'Google Sans', Roboto, Arial, sans-serif; overflow: hidden; pointer-events: none; }
+                   .dialog { width: ${widthStr}; height: ${heightStr}; background: #fff; box-shadow: -1px 0 4px rgba(0,0,0,0.2); display: flex; flex-direction: column; pointer-events: auto; border-left: 1px solid #dadce0; }
+                   .dialog-header { display: flex; justify-content: space-between; align-items: center; padding: 16px; border-bottom: 1px solid #dadce0; }
+                   .dialog-title { font-size: 16px; color: #202124; margin: 0; font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+                   .dialog-close { background: none; border: none; font-size: 20px; color: #5f6368; cursor: pointer; padding: 0; line-height: 1; }
+                   .dialog-close:hover { color: #202124; }
+                   .dialog-content { flex-grow: 1; display: flex; border: none; }
+                   iframe { border: none; width: 100%; height: 100%; background: #fff; }
+               `;
+
+               const css = isSidebar ? sidebarCss : modalCss;
+               
+               // We encode the HTML so we can safely inject it into the iframe using document.write
+               const encodedHtml = encodeURIComponent(html);
+
+               html = `
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>${safeTitle}</title>
+    <style>${css}</style>
+  </head>
+  <body>
+    <div class="dialog">
+      <div class="dialog-header">
+        <h2 class="dialog-title">${safeTitle}</h2>
+        <button class="dialog-close" aria-label="Close" onclick="closeDialog()">x</button>
+      </div>
+      <div class="dialog-content">
+        <iframe id="gas-fakes-frame"></iframe>
+      </div>
+    </div>
+    <script>
+      // Handle programmatic closures from google.script.host.close()
+      window.addEventListener('message', function(e) {
+        if (e.data && e.data.type === 'gas-fakes-close') {
+           document.body.innerHTML = '<h3 style="font-family: sans-serif; text-align: center; margin-top: 50px;">Dialog Closed. You may close this tab.</h3>';
+        }
+      });
+      // Handle the 'X' button
+      function closeDialog() {
+         document.body.innerHTML = '<h3 style="font-family: sans-serif; text-align: center; margin-top: 50px;">Dialog Closed. You may close this tab.</h3>';
+      }
+
+      const iframe = document.getElementById('gas-fakes-frame');
+      iframe.contentWindow.document.open();
+      iframe.contentWindow.document.write(decodeURIComponent("${encodedHtml}"));
+      iframe.contentWindow.document.close();
+    </script>
+  </body>
+  </html>`;
+         }
+
+         res.writeHead(200, { 'Content-Type': 'text/html' });           res.end(html);
+        } else if (result && result.__isTextOutput) {
+           res.writeHead(200, { 'Content-Type': result.mimeType || 'text/plain' });
+           res.end(result.content);
+        } else {
+           res.writeHead(200, { 'Content-Type': 'text/plain' });
+           res.end(typeof result === 'string' ? result : JSON.stringify(result));
+        }
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end("Error executing " + entryFunction + ": " + err.message);
+      }
+    } else if (req.method === 'POST' && req.url === '/__gas_rpc') {
+      // 2. Handle google.script.run RPC requests
+      let body = '';
+      req.on('data', chunk => body += chunk.toString());
+      req.on('end', () => {
+         try {
+            const payload = JSON.parse(body);
+            const ctx = new ServerWorkerContext(scriptPath);
+            // Execute the requested function statelessly
+            const result = ctx.runFunction(payload.funcName, payload.args);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ result }));
+         } catch (err) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+         }
+      });
+    } else if (req.method === 'POST' && req.url === '/') {
+      // 3. Serve doPost
+      let body = '';
+      req.on('data', chunk => body += chunk.toString());
+      req.on('end', () => {
+        try {
+          const ctx = new ServerWorkerContext(scriptPath);
+          const doPostEvent = { 
+            postData: { 
+              contents: body, 
+              type: req.headers['content-type'] 
+            }, 
+            parameter: {}, 
+            parameters: {}, 
+            queryString: '', 
+            contextPath: '', 
+            contentLength: body.length 
+          };
+          const result = ctx.runFunction('doPost', [doPostEvent]);
+          
+          if (result && result.__isHtmlOutput) {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(result.content);
+          } else if (result && result.__isTextOutput) {
+            res.writeHead(200, { 'Content-Type': result.mimeType || 'text/plain' });
+            res.end(result.content);
+          } else {
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end(typeof result === 'string' ? result : JSON.stringify(result));
+          }
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'text/plain' });
+          res.end("Error executing doPost: " + err.message);
+        }
+      });
+    } else {
+      res.writeHead(404);
+      res.end('Not found');
+    }
+  });
+
+  server.listen(port, () => {
+    console.log('\n=================================================');
+    console.log('🚀 gas-fakes Web App running at: http://localhost:' + port);
+    console.log('=================================================\n');
+  });
+  
+  return server;
+}

package/src/services/html/worker.js

@@ -0,0 +1,63 @@
+import { parentPort, workerData } from 'worker_threads';
+import fs from 'fs';
+import path from 'path';
+import { runInThisContext } from 'vm';
+import { Utils as GasFakesUtils } from '../../support/utils.js';
+
+// Initialize the gas-fakes environment in this worker isolate
+import '../../index.js';
+
+// The worker is spawned with the path to the main script
+const { mainScriptPath, funcName, args, isTemplate, templateString } = workerData;
+
+async function run() {
+  try {
+    const projectDir = path.dirname(mainScriptPath);
+    
+    // Simulate Apps Script's global execution model:
+    // Read all .js and .gs files in the directory and evaluate them in this global context.
+    const files = fs.readdirSync(projectDir);
+    const scriptFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.gs'));
+    
+    // Sort files to ensure deterministic execution (like clasp does)
+    scriptFiles.sort();
+
+    for (const file of scriptFiles) {
+      const fullPath = path.join(projectDir, file);
+      const content = fs.readFileSync(fullPath, 'utf8');
+      
+      // Strip ESM keywords to allow evaluation in the raw VM context
+      const strippedContent = GasFakesUtils.stripEsmKeywords(content);
+      
+      try {
+        // runInThisContext executes the code globally within the current V8 isolate
+        runInThisContext(strippedContent, { filename: fullPath });
+      } catch (e) {
+        console.error(`gas-fakes Error parsing ${file}: ${e.message}`);
+      }
+    }
+
+    if (isTemplate) {
+        parentPort.postMessage({ result: "Template evaluation not yet implemented in worker" });
+        return;
+    }
+
+    const func = globalThis[funcName];
+
+    if (typeof func !== 'function') {
+      throw new Error(`google.script.run: function "${funcName}" is not defined on the server.`);
+    }
+
+    // Apps Script functions can be async, so we await
+    const result = await func(...args);
+    
+    // Apps Script parameters/returns are JSON serialized
+    const serializedResult = typeof result === 'undefined' ? undefined : JSON.parse(JSON.stringify(result));
+    
+    parentPort.postMessage({ result: serializedResult });
+  } catch (error) {
+    parentPort.postMessage({ error: { message: error.message, stack: error.stack } });
+  }
+}
+
+run();

package/src/services/libhandlerapp/fakelibrary.js

@@ -60,7 +60,7 @@ class FakeLibrary {
   }
 
   get combinedJs() {
-    return this.libContent.files.filter((f) => f.type === 'server_js').map((f) => `////-- ${f.name} --\n${f.source}`).join(`\n\n`)
+    return this.libContent.files.filter((f) => f.type === 'server_js').map((f) => `////-- ${f.name} --\n${f.source}\n;`).join(`\n\n`)
   }
 
   get content() {
@@ -90,7 +90,7 @@ class FakeLibrary {
     const functions = makeExports(ast, 'FunctionDeclaration', (f) => f.id.name)
     const variables = makeExports(ast, 'VariableDeclaration', (f) => f.declarations[0].id.name)
     const classes = makeExports(ast, 'ClassDeclaration', (f) => f.id.name)
-    const exports = [...functions, ...variables, ...classes];
+    const exports = [...functions, ...variables, ...classes].filter(Boolean);
     return `${this.combinedJs};\nreturn { ${exports.join(', ')} };`;
   }
 

package/src/services/scriptapp/app.js

@@ -6,8 +6,12 @@ import { Syncit } from '../../support/syncit.js'
 import { Auth } from '../../support/auth.js'
 import { Proxies } from '../../support/proxies.js'
 import { newFakeBehavior } from './behavior.js'
+import { newFakeAuthorizationInfo } from './fakeauthorizationinfo.js'
+import { ScriptEnums } from '../enums/scriptenums.js'
 import { newCacheDropin } from '@mcpher/gas-flex-cache'
 import { slogger } from "../../support/slogger.js";
+import fs from 'fs';
+import path from 'path';
 
 // This will eventually hold a proxy for ScriptApp
 let _app = null
@@ -155,6 +159,41 @@ if (typeof globalThis[name] === typeof undefined) {
       _app = {
         getOAuthToken,
         __getSourceOAuthToken: getSourceOAuthToken,
+        getResource: (filename) => {
+          let mainScriptPath = process.argv[1];
+          if (globalThis.__gasFakesMainScriptPath) {
+              mainScriptPath = globalThis.__gasFakesMainScriptPath;
+          }
+          if (!mainScriptPath || mainScriptPath.endsWith('node')) {
+              throw new Error("Could not determine project root for getResource. Ensure process.argv[1] is set or __gasFakesMainScriptPath is defined.");
+          }
+          
+          const projectDir = path.dirname(mainScriptPath);
+          let fullPath = path.resolve(projectDir, filename);
+
+          if (!fs.existsSync(fullPath)) {
+            // Apps Script allows omitting the extension. Try common ones.
+            const exts = ['.js', '.gs', '.html'];
+            let found = false;
+            for (const ext of exts) {
+                if (fs.existsSync(fullPath + ext)) {
+                    fullPath += ext;
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+               throw new Error(`File not found: ${fullPath}`);
+            }
+          }
+          const content = fs.readFileSync(fullPath, 'utf8');
+          // We can't import Utilities easily here without circular deps or breaking the proxy
+          // But we can just use the global Utilities object assuming it's loaded.
+          if (!globalThis.Utilities) {
+             throw new Error("Utilities service not loaded, cannot create Blob for getResource.");
+          }
+          return globalThis.Utilities.newBlob(content, "text/plain", filename);
+        },
         requireAllScopes,
         requireScopes,
         getScriptId: () => {
@@ -198,6 +237,11 @@ if (typeof globalThis[name] === typeof undefined) {
         AuthMode: {
           FULL: 'FULL'
         },
+        AuthorizationStatus: ScriptEnums.AuthorizationStatus,
+        getAuthorizationInfo: (authMode) => {
+          ensureInit();
+          return newFakeAuthorizationInfo(authMode);
+        },
         // __behavior added below to break recursion
         __newCacheDropin: newCacheDropin,
         __proxies: Proxies,

package/src/services/scriptapp/fakeauthorizationinfo.js

@@ -0,0 +1,22 @@
+import { ScriptEnums } from '../enums/scriptenums.js';
+
+export class FakeAuthorizationInfo {
+  constructor(authMode) {
+    this._authMode = authMode;
+  }
+
+  getAuthorizationStatus() {
+    // gas-fakes always handles auth out-of-band via CLI, 
+    // so during script execution, we assume auth is not required.
+    return ScriptEnums.AuthorizationStatus.NOT_REQUIRED;
+  }
+
+  getAuthorizationUrl() {
+    // Return null since we don't require inline authorization
+    return null;
+  }
+}
+
+export const newFakeAuthorizationInfo = (authMode) => {
+  return new FakeAuthorizationInfo(authMode);
+};

package/src/services/slidesapp/fakeslidesapp.js

@@ -1,5 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeAffineTransformBuilder } from './fakeaffinetransformbuilder.js';
+import { newFakeUi } from '../common/fakeui.js';
 import * as Enums from '../enums/slidesenums.js';
 import { newFakePresentation } from './fakepresentation.js';
 import { Auth } from '../../support/auth.js';
@@ -85,6 +86,10 @@ class FakeSlidesApp {
     return this.openById(id);
   }
 
+  getUi() {
+    return newFakeUi();
+  }
+
   /**
    * Opens the presentation with the specified ID.
    * @param {string} id The ID of the presentation to open.

package/src/services/spreadsheetapp/fakebooleancondition.js

@@ -83,8 +83,20 @@ export class FakeBooleanCondition {
     if (!this.__apiCondition.values) return [];
     
     // API condition values are typically { userEnteredValue: 'string' } or { relativeDate: 'TODAY' }
+    const type = this.getCriteriaType()?.toString() || '';
+    const isNumberType = type.startsWith('NUMBER_');
+    const isDateType = type.startsWith('DATE_') && !type.endsWith('_RELATIVE');
+
     return this.__apiCondition.values.map(v => {
-      if (v.userEnteredValue !== undefined) return v.userEnteredValue;
+      if (v.userEnteredValue !== undefined) {
+        if (isNumberType && !isNaN(v.userEnteredValue) && v.userEnteredValue !== '') {
+          return Number(v.userEnteredValue);
+        }
+        if (isDateType && !isNaN(Date.parse(v.userEnteredValue))) {
+          return new Date(v.userEnteredValue);
+        }
+        return v.userEnteredValue;
+      }
       // In Apps Script, RelativeDate enum values are typically returned as strings matching the enum
       if (v.relativeDate !== undefined) return SpreadsheetApp.RelativeDate[v.relativeDate] || v.relativeDate; 
       return null;
@@ -114,6 +126,6 @@ export class FakeBooleanCondition {
   }
 
   toString() {
-    return 'BooleanCondition';
+    return 'ConditionalFormatBooleanCondition';
   }
 }

package/src/services/spreadsheetapp/fakeembeddedchartbuilder.js

@@ -59,15 +59,40 @@ export class FakeEmbeddedChartBuilder {
     if (nargs !== 1) matchThrow();
 
     const gridRange = makeSheetsGridRange(range);
+    const startCol = gridRange.startColumnIndex || 0;
+    const endCol = gridRange.endColumnIndex || startCol + 1;
+    const numCols = endCol - startCol;
 
-    if (this.__apiChart.spec.basicChart.domains.length === 0) {
+    // If it's a multi-column range, live GAS splits the first column as domain 
+    // and the rest as series (unless it's already got a domain)
+    if (numCols > 1 && this.__apiChart.spec.basicChart.domains.length === 0) {
+      // First column is domain
+      const domainRange = JSON.parse(JSON.stringify(gridRange));
+      domainRange.endColumnIndex = startCol + 1;
       this.__apiChart.spec.basicChart.domains.push({
-        domain: { sourceRange: { sources: [gridRange] } },
+        domain: { sourceRange: { sources: [domainRange] } },
       });
+
+      // Rest are series
+      for (let i = 1; i < numCols; i++) {
+        const seriesRange = JSON.parse(JSON.stringify(gridRange));
+        seriesRange.startColumnIndex = startCol + i;
+        seriesRange.endColumnIndex = startCol + i + 1;
+        this.__apiChart.spec.basicChart.series.push({
+          series: { sourceRange: { sources: [seriesRange] } },
+        });
+      }
     } else {
-      this.__apiChart.spec.basicChart.series.push({
-        series: { sourceRange: { sources: [gridRange] } },
-      });
+      // Standard behavior
+      if (this.__apiChart.spec.basicChart.domains.length === 0) {
+        this.__apiChart.spec.basicChart.domains.push({
+          domain: { sourceRange: { sources: [gridRange] } },
+        });
+      } else {
+        this.__apiChart.spec.basicChart.series.push({
+          series: { sourceRange: { sources: [gridRange] } },
+        });
+      }
     }
     return this;
   }

package/src/services/spreadsheetapp/fakegradientcondition.js

@@ -66,6 +66,6 @@ export class FakeGradientCondition {
   }
 
   toString() {
-    return 'GradientCondition';
+    return 'ConditionalFormatGradientCondition';
   }
 }

package/src/services/spreadsheetapp/fakeovergridimage.js

@@ -44,4 +44,29 @@ export class FakeOverGridImage {
   getHeight() {
     return this.object.height;
   }
+
+  setHeight(height) {
+    this.object.height = height;
+    return this;
+  }
+
+  setWidth(width) {
+    this.object.width = width;
+    return this;
+  }
+
+  setAltTextTitle(title) {
+    this.object.altTextTitle = title;
+    return this;
+  }
+
+  setAltTextDescription(description) {
+    this.object.altTextDescription = description;
+    return this;
+  }
+
+  deleteOverlaidDrawing() {
+    // No-op for now as it's a mock
+    return this;
+  }
 }

package/src/services/spreadsheetapp/fakesheet.js

@@ -38,7 +38,6 @@ export class FakeSheet {
 
     const props = [
       // "getImages",
-      "insertImage",
       "removeImage",
       // "getNamedRanges",
       // "getRangeByName", // <--- This is a method for Class Spreadsheet.
@@ -1184,6 +1183,29 @@ export class FakeSheet {
     return [];
   }
 
+  insertImage(blobSourceOrUrl, column, row, offsetX, offsetY) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.insertImage");
+    if (nargs < 3 || nargs > 5) matchThrow();
+
+    // Warn about API limitations
+    console.warn(
+      "Sheet.insertImage: Floating images are not supported via the Google Sheets REST API v4. This is a local mock."
+    );
+
+    const obj = {
+      row: row - 1,
+      col: column - 1,
+      anchorCellXOffset: offsetX || 0,
+      anchorCellYOffset: offsetY || 0,
+      width: 100, // Default width
+      height: 100, // Default height
+      blob: typeof blobSourceOrUrl === "string" ? null : blobSourceOrUrl,
+      url: typeof blobSourceOrUrl === "string" ? blobSourceOrUrl : null,
+    };
+
+    return newFakeOverGridImage(this, obj);
+  }
+
   getImages() {
     const url = `https://docs.google.com/spreadsheets/export?exportFormat=xlsx&id=${this.__parent.__meta.spreadsheetId}`;
     const res = UrlFetchApp.fetch(url, {