@mcpher/gas-fakes 1.0.21 → 1.0.22

package/README.md

@@ -120,7 +120,7 @@ When logging to the cloud, entries are sent to the `gas-fakes/console_logs` log
 
 #### Dynamic Control
 
-You can change the logging destination at any time during runtime using the `Logger.__setLogDestination()` method. This is especially useful for testing or for applications that need to change their logging behavior dynamically.
+You can change the logging destination at any time during runtime by setting the `Logger.__logDestination` property. This is especially useful for testing or for applications that need to change their logging behavior dynamically.
 
 The method accepts one of the following string values: `'CONSOLE'`, `'CLOUD'`, `'BOTH'`, or `'NONE'`.
 
@@ -137,13 +137,26 @@ To change the destination during runtime in your script:
 Logger.log('This goes to console and cloud');
 
 // Switch to only logging to the console
-Logger.__setLogDestination('CONSOLE');
+Logger.__logDestination='CONSOLE';
 Logger.log('This now only goes to the console');
 
 // Disable logging completely
-Logger.__setLogDestination('NONE');
+Logger.__logDestination='NONE';
 Logger.log('This goes nowhere');
 ```
+
+#### Link to Cloud log for this run
+
+If you have used Logging to cloud, you can get a link to the log data like this. 
+
+```javascript
+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 gasfakes.json), the projectId and userId (from Auth), as well as the start and end time of the session. 
+
+
+
 ### Pushing files to GAS
 
 There are a couple of syntactical differences between Node and Apps Script. Not in the body of the code but in how the IDE executes. The 2 main ones are

package/gprompts/gas-inventory.js

@@ -3,90 +3,94 @@ import * as cheerio from 'cheerio';
 import fs from 'fs/promises';
 import { URL } from 'url';
 
-const baseUrl = "https://developers.google.com/apps-script/reference/"
+const baseUrl = "https://developers.google.com/apps-script/reference/script/"
 const outputFile = './gas-inventory.json';
 
 const visited = new Map();
 const queue = [baseUrl]
 
+// the urls are kebab cased
 const kebabCamel = (s) => {
   return s.replace(/([-][a-z])/ig, ($1) => {
     return $1.toUpperCase()
       .replace('-', '')
   });
 };
-async function scrape() {
-  const inventory = {};
 
-  while (queue.length > 0) {
-    const url = queue.shift();
-    console.log(`Scraping ${url}`);
-    const response = await got(url);
-    const $ = cheerio.load(response.body);
-    const serviceName = $('h1').text().split('\n').map(f=>f.replace(/^\s+/,'').trim()).filter (f=>f)[0];
-    console.log ('...starting service name',serviceName)
-    inventory[serviceName] = {
-      name: serviceName,
-      link: url,
-      classes: {},
-    };
+function debugPageStructure($) {
+  console.log('=== PAGE STRUCTURE DEBUG ===');
 
-    $('a').each((i, el) => {
-      const href = $(el).attr('href');
-      if (href && href.startsWith('/apps-script/reference')) {
-        const absoluteUrl = new URL(href, url).href;
-        const parentUrl = absoluteUrl.replace (/#.*/, '')
-        const method = kebabCamel(absoluteUrl.match(/#(.*)/) || ['', ''][1])
-        if (!visited.has(parentUrl)) {
-          console.log ('...adding to queue',parentUrl)
-          queue.push(parentUrl);
-          visited.set(parentUrl, {
-            url: parentUrl,
-            methods: new Map ()
-          });
-        }
-        if (method) {
-          visited.get(parentUrl).methods.set(absoluteUrl, {
-            url: absoluteUrl,
-            method
-          })
-        }
-      }
-    });
+  // Check if main elements exist
+  console.log('#main-content exists:', $('#main-content').length > 0);
+  console.log('devsite-content exists:', $('devsite-content').length > 0);
+  console.log('article exists:', $('article').length > 0);
+  console.log('h1 elements:', $('h1').length);
 
-    // Extract classes and methods
-    $('h2').each((i, el) => {
-      const className = $(el).text().trim();
-      if (className) {
-        console.log ('...found class',className,'for service',serviceName)
-        inventory[serviceName].classes[className] = {
-          methods: {},
-          properties: {},
-        };
-
-        // Find the table of methods for the current class
-        const methodsTable = $(el).nextAll('table').first();
-        methodsTable.find('tbody tr').each((j, row) => {
-          const methodName = $(row).find('td').eq(1).text().trim();
-          const methodLink = $(row).find('td').eq(1).find('a').attr('href');
-          const returnType = $(row).find('td').eq(0).text().trim();
+  // Show all h1 texts
+  $('h1').each((i, el) => {
+    console.log(`H1[${i}]:`, $(el).text().trim());
+  });
 
-          if (methodName) {
-            inventory[serviceName].classes[className].methods[methodName] = {
-              link: methodLink ? new URL(methodLink, url).href : '',
-              returns: {
-                type: returnType,
-                link: '' // to be extracted later
-              }
-            };
-          }
-        });
-      }
+  // Show structure of main-content
+  const mainContent = $('#main-content');
+  if (mainContent.length > 0) {
+    console.log('Main-content children:', mainContent.children().length);
+    mainContent.children().each((i, el) => {
+      console.log(`Child ${i}:`, el.tagName, $(el).attr('class') || $(el).attr('id'));
     });
   }
+}
 
-  await fs.writeFile(outputFile, JSON.stringify(inventory, null, 2));
-  console.log(`Inventory saved to ${outputFile}`);
+
+const getNextCheer = async (u) => {
+  console.log(`Scraping ${u}`);
+  const response = await got(u);
+  return cheerio.load(response.body);
 }
 
-scrape().catch(console.error);
+const getHrefs = ($) => {
+  return $('a').map((i, el) => {
+    const r = $(el).attr('href');
+    if (r) {
+      const absolute = new URL(r, baseUrl).href;
+      // skip references to elsewhere and blank anchors
+      if (absolute.startsWith(baseUrl) && !absolute.endsWith('#')) return absolute;
+    }
+  }).get();
+}
+
+
+const s2 = async () => {
+  const umap = new Map();
+  const uset = new Set()
+  while (queue.length) {
+
+    const url = queue.shift();
+    console.log('working on url', url)
+    const $ = await getNextCheer(url);
+    debugPageStructure($);
+
+    // get all the hrefs
+    getHrefs($).forEach(f => {
+      // so a url could have an anchor for a method so we need to strip that out
+      const u = new URL(f);
+      const method = u.hash.substring(1);
+      const classUrl = u.origin + '/' + u.pathname
+      const methodUrl = u.href
+      if (!umap.has(classUrl)) {
+        umap.set(classUrl, {
+          parents: new Map(),
+          classUrl,
+          methods: new Map()
+        })
+        console.log ('pushing', classUrl)
+        queue.push (classUrl)
+      }
+      const ob = umap.get(classUrl)
+      ob.methods.set(method, { method, methodUrl })
+      ob.parents.set(url, { url })
+      console.log('adding', f)
+    })
+  }
+}
+s2().catch(console.error)

package/package.json

@@ -5,9 +5,9 @@
   "dependencies": {
     "@google-cloud/logging": "^11.2.1",
     "@mcpher/fake-gasenum": "^1.0.2",
-    "@mcpher/unit": "^1.1.11",
     "@sindresorhus/is": "^7.0.1",
     "archiver": "^7.0.1",
+    "exceljs": "^4.4.0",
     "fast-json-stable-stringify": "^2.1.0",
     "get-stream": "^9.0.1",
     "googleapis": "^157.0.0",
@@ -17,6 +17,7 @@
     "keyv": "^5.5.0",
     "keyv-file": "^5.1.3",
     "mime": "^4.0.7",
+    "sinon": "^21.0.0",
     "sleep-synchronously": "^2.0.0",
     "subsume": "^4.0.0",
     "to-readable-stream": "^4.0.0",
@@ -64,7 +65,7 @@
     "pub": "cp mainlocal.js main.js && npm publish --access public"
   },
   "name": "@mcpher/gas-fakes",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/src/services/logger/fakelogger.js

@@ -23,6 +23,12 @@ export class FakeLogger {
      * @type {string}
      */
     this.__destination = (process.env.LOG_DESTINATION || 'CONSOLE').toUpperCase();
+    this.__startedLoggingAt = new Date()
+    this.__cloudLogLink = 'No cloud logging enabled - use Logger.__logDestination = "CLOUD" or "BOTH" to enable'
+
+    if (['CLOUD','BOTH'].includes(this.__destination)) {
+      writeToCloudOrConsole("...Initializing cloud logging", this)
+    }
   }
 
   /**
@@ -58,6 +64,7 @@ export class FakeLogger {
     const message = format(formatOrData, ...values);
     this.__log.push(message);
 
+
     // Pass the destination and instance context to the writer function.
     writeToCloudOrConsole(message, this);
 
@@ -83,6 +90,12 @@ export class FakeLogger {
     }
     return this;
   }
+
+  // to allow code compatibility without error on apps script, we should use the setter since it'll be undefined on Apps live Script
+  set __logDestination (destination) {
+    return this.__setLogDestination(destination);
+  }
+
 }
 
 /**
@@ -96,21 +109,23 @@ export const newFakeLogger = (...args) => Proxies.guard(new FakeLogger(...args))
  * @private
  * @param {FakeLogger} loggerInstance The logger instance, to access its destination.
  */
-const writeToCloudOrConsole =  (message, loggerInstance) => {
+const writeToCloudOrConsole = (message, loggerInstance) => {
   const logDestination = loggerInstance.__destination;
   const useConsoleLogging = logDestination === 'CONSOLE' || logDestination === 'BOTH';
   const useCloudLogging = logDestination === 'CLOUD' || logDestination === 'BOTH';
+  const logName = 'gas-fakes/console_logs';
+  const projectId = ScriptApp.__projectId;
+  const scriptId = ScriptApp.getScriptId();
+  const userId = ScriptApp.__userId;
 
   // Lazy-initialize the cloud logger if needed.
   const initializeCloudLogging = () => {
     if (cloudLog) return; // Already initialized.
     try {
-      const projectId = ScriptApp.__projectId;
       if (!projectId) {
         throw new Error('Could not determine Google Cloud Project ID for logging.');
       }
       const logging = new Logging({ projectId });
-      const logName = 'gas-fakes/console_logs';
       cloudLog = logging.log(logName);
       console.info(`gas-fakes: Cloud Logging is enabled, writing to log "${logName}".`);
     } catch (err) {
@@ -145,8 +160,8 @@ const writeToCloudOrConsole =  (message, loggerInstance) => {
       // not running on a specific GCP compute service.
       resource: { type: 'global' },
       labels: {
-        'gas-fakes-scriptId': ScriptApp.getScriptId(),
-        'gas-fakes-userId': ScriptApp.__userId,
+        'gas-fakes-scriptId': scriptId,
+        'gas-fakes-userId': userId,
       },
       jsonPayload: { message: message },
       severity: 'INFO',
@@ -156,7 +171,36 @@ const writeToCloudOrConsole =  (message, loggerInstance) => {
     // his allows us to catch errors, such as a disabled API or permission issues.
     // however we are firing and forgetting so an error might appear later on in execution
     if (cloudLog) {
-      cloudLog.write(cloudLog.entry(metadata)).catch(err=> console.error('gas-fakes: Failed to write to Cloud Logging.', err.message))
+      // filter on user/script/priject and run times
+      // we'll extend the end date filter to a little more than now
+      const aLittleMore = 7 * 1000
+      const endDate = new Date(new Date().getTime() + aLittleMore)
+      const startDate = loggerInstance.__startedLoggingAt
+
+      const base = `https://console.cloud.google.com/logs/query;`
+
+      // B. Build the RAW LQL Filter String (NO "query=" prefix here)
+      const lqlParts = [
+        // LogName filter
+        `logName="projects/${projectId}/logs/${logName.replace('/', '%2F')}"`,
+        // Labels filter
+        ...Object.keys(metadata.labels).map(k => `jsonPayload.labels.${k}="${metadata.labels[k]}"`),
+        // Date filter (recommended for query stability)
+        `timestamp>="${startDate.toISOString()}"`,
+        `timestamp<="${endDate.toISOString()}"`
+      ];
+      const fullLQLQuery = lqlParts.join(' AND ');
+
+      // C. Encode ONLY the filter content, then prepend the literal 'query='
+      const encodedQueryParam = `query=${encodeURIComponent(fullLQLQuery)}`;
+
+      // D. Create the timeRange parameter (correct casing)
+      const timeRangeParam = `;timeRange=${startDate.getTime()}/${endDate.getTime()}`;
+
+      // E. Assemble the final URL
+      loggerInstance.__cloudLogLink = base + encodedQueryParam + `?project=${projectId}`;
+      // fire and forget
+      cloudLog.write(cloudLog.entry(metadata)).catch(err => console.error('gas-fakes: Failed to write to Cloud Logging.', err.message))
     }
   }
-};
+};

package/src/services/spreadsheetapp/fakeovergridimage.js

@@ -0,0 +1,47 @@
+import { Proxies } from "../../support/proxies.js";
+
+/**
+ * create a new FakeOverGridImage instance
+ * @param  {...any} args
+ * @returns {FakeOverGridImage}
+ */
+export const newFakeOverGridImage = (...args) => {
+  return Proxies.guard(new FakeOverGridImage(...args));
+};
+
+/**
+ * basic fake FakeOverGridImage
+ * @class FakeOverGridImage
+ */
+export class FakeOverGridImage {
+  /**
+   * @constructor
+   * @param {Sheet} sheet
+   * @param {Object} obj
+   * @returns {FakeOverGridImage}
+   */
+  constructor(sheet, obj) {
+    this.sheet = sheet;
+    this.object = obj;
+  }
+
+  getAnchorCell() {
+    return this.sheet.getRange(this.object.row + 1, this.object.col + 1);
+  }
+
+  getAnchorCellXOffset() {
+    return this.object.anchorCellXOffset;
+  }
+
+  getAnchorCellYOffset() {
+    return this.object.anchorCellYOffset;
+  }
+
+  getWidth() {
+    return this.object.width;
+  }
+
+  getHeight() {
+    return this.object.height;
+  }
+}

package/src/services/spreadsheetapp/fakesheet.js

@@ -13,6 +13,10 @@ import { FakeTextFinder, newFakeTextFinder } from "./faketextfinder.js";
 
 import { newFakeNamedRange } from "./fakenamedrange.js";
 import { newFakeProtection } from "./fakeprotection.js";
+import { newFakeOverGridImage } from "./fakeovergridimage.js";
+
+import { Syncit } from "../../support/syncit.js";
+// import ExcelJS from "exceljs"; // When test_getImages() is used, use this.
 
 const { is, isEnum } = Utils;
 
@@ -35,7 +39,7 @@ export class FakeSheet {
       "insertChart",
       "removeChart",
       "updateChart",
-      "getImages",
+      // "getImages",
       "insertImage",
       "removeImage",
       // "getNamedRanges",
@@ -1063,6 +1067,30 @@ export class FakeSheet {
     return [];
   }
 
+  // This function is used for testing getImages without a worker.
+  // async test_getImages() {
+  //   const url = `https://docs.google.com/spreadsheets/export?exportFormat=xlsx&id=${
+  //     this.__parent.__meta.spreadsheetId
+  //   }&access_token=${ScriptApp.getOAuthToken()}`;
+  //   const res = UrlFetchApp.fetch(url);
+  //   const buf = new Uint8Array(res.getBlob()._data).buffer;
+  //   const workbook = new ExcelJS.Workbook();
+  //   await workbook.xlsx.load(buf);
+  //   const worksheet = workbook.worksheets[this.getIndex() - 1];
+  //   const images = worksheet.getImages();
+  //   console.log(images);
+  // }
+
+  getImages() {
+    const url = `https://docs.google.com/spreadsheets/export?exportFormat=xlsx&id=${
+      this.__parent.__meta.spreadsheetId
+    }&access_token=${ScriptApp.getOAuthToken()}`;
+    const idx = this.getIndex() - 1;
+    const ar = Syncit.fxGetImagesFromXlsx({ url, idx });
+    const sheet = this;
+    return ar.map((e) => newFakeOverGridImage(sheet, e));
+  }
+
   __batchUpdate({ spreadsheetId, requests }) {
     return Sheets.Spreadsheets.batchUpdate({ requests }, spreadsheetId);
   }

package/src/support/sxxlsx.js

@@ -0,0 +1,41 @@
+import got from "got";
+import ExcelJS from "exceljs";
+
+async function __getWorkbook(url) {
+  const res = await got(url, { responseType: "buffer" });
+  let buf;
+  if (res.rawBody && Buffer.isBuffer(res.rawBody)) {
+    buf = res.rawBody;
+  } else if (res.body && Buffer.isBuffer(res.body)) {
+    buf = res.body;
+  } else {
+    throw new Error(res);
+  }
+  const workbook = new ExcelJS.Workbook();
+  await workbook.xlsx.load(buf);
+  return workbook;
+}
+
+export const sxGetImagesFromXlsx = async (_, { url, idx }) => {
+  const workbook = await __getWorkbook(url);
+  const worksheet = workbook.worksheets[idx];
+  const ar = worksheet.getImages().reduce((arr, image) => {
+    const imageId = image.imageId;
+    if (image.range.tl.nativeColOff != 0 && image.range.tl.nativeRowOff != 0) {
+      const col = image.range.tl.nativeCol;
+      const row = image.range.tl.nativeRow;
+      const { width, height } = image.range.ext;
+      arr.push({
+        imageId,
+        row,
+        col,
+        width,
+        height,
+        anchorCellXOffset: image.range.tl.nativeColOff,
+        anchorCellYOffset: image.range.tl.nativeRowOff,
+      });
+    }
+    return arr;
+  }, []);
+  return ar;
+};

package/src/support/syncit.js

@@ -1,49 +1,54 @@
 // this one is locally patched for now
 // import makeSynchronous from 'make-synchronous';
-import path from 'path'
-import { Auth } from "./auth.js"
-import { randomUUID } from 'node:crypto'
-import mime from 'mime';
-import { minFields } from './helpers.js'
-import { mergeParamStrings } from './utils.js'
-import { improveFileCache, checkResponse, getFromFileCache } from "./filecache.js"
-import { checkResponseCacher } from './fetchcacher.js';
-import { docsCacher } from "./docscacher.js"
-import { gmailCacher } from './gmailcacher.js';
-import { formsCacher } from './formscacher.js';
-import { slidesCacher } from './slidescacher.js';
-import { sheetsCacher } from './sheetscacher.js';
-import is from '@sindresorhus/is';
-import { callSync } from './workersync/synchronizer.js';
-
-
-const manifestDefaultPath = './appsscript.json'
-const claspDefaultPath = "./.clasp.json"
-const settingsDefaultPath = "./gasfakes.json"
-const propertiesDefaultPath = "/tmp/gas-fakes/properties"
-const cacheDefaultPath = "/tmp/gas-fakes/cache"
+import path from "path";
+import { Auth } from "./auth.js";
+import { randomUUID } from "node:crypto";
+import mime from "mime";
+import { minFields } from "./helpers.js";
+import { mergeParamStrings } from "./utils.js";
+import {
+  improveFileCache,
+  checkResponse,
+  getFromFileCache,
+} from "./filecache.js";
+import { checkResponseCacher } from "./fetchcacher.js";
+import { docsCacher } from "./docscacher.js";
+import { gmailCacher } from "./gmailcacher.js";
+import { formsCacher } from "./formscacher.js";
+import { slidesCacher } from "./slidescacher.js";
+import { sheetsCacher } from "./sheetscacher.js";
+import is from "@sindresorhus/is";
+import { callSync } from "./workersync/synchronizer.js";
+
+const manifestDefaultPath = "./appsscript.json";
+const claspDefaultPath = "./.clasp.json";
+const settingsDefaultPath = "./gasfakes.json";
+const propertiesDefaultPath = "/tmp/gas-fakes/properties";
+const cacheDefaultPath = "/tmp/gas-fakes/cache";
 // note that functions like Sheets.newGridRange() etc create objects that contain get and set functions
 // the makesynchronous functions need data that can be serialized. so we need to string/parse to normlaize them
-const normalizeSerialization = (ob) => is.nullOrUndefined(ob) || !is.object(ob) ? ob : JSON.parse(JSON.stringify(ob))
-
+const normalizeSerialization = (ob) =>
+  is.nullOrUndefined(ob) || !is.object(ob)
+    ? ob
+    : JSON.parse(JSON.stringify(ob));
 
 /**
  * check and register a result in cache
  * @param {import('./sxdrive.js').SxResult} the result of a sync api call
- * @return {import('./sxdrive.js').SxResult} 
+ * @return {import('./sxdrive.js').SxResult}
  */
 const registerSx = (result, allow404 = false, fields) => {
-  const { data, response } = result
-  checkResponse(data?.id, response, allow404)
+  const { data, response } = result;
+  checkResponse(data?.id, response, allow404);
   if (data?.id) {
     return {
       ...result,
-      data: improveFileCache(data.id, data, fields)
-    }
+      data: improveFileCache(data.id, data, fields),
+    };
   } else {
-    return result
+    return result;
   }
-}
+};
 
 const register = (id, cacher, result, allow404 = false, params) => {
   const { data, response } = result;
@@ -56,8 +61,7 @@ const register = (id, cacher, result, allow404 = false, params) => {
   } else {
     return result;
   }
-}
-
+};
 
 /**
  * sync a call to Drive api to stream a download
@@ -71,21 +75,28 @@ const register = (id, cacher, result, allow404 = false, params) => {
  * @param {object} [p.params] any extra params
  * @return {import('./sxdrive.js').SxResult} from the drive api
  */
-const fxStreamUpMedia = ({ file = {}, blob, fields = "", method = "create", fileId, params = {} }) => {
+const fxStreamUpMedia = ({
+  file = {},
+  blob,
+  fields = "",
+  method = "create",
+  fileId,
+  params = {},
+}) => {
   // merge the required fields with the minimum
-  fields = mergeParamStrings(minFields, fields)
-  const result = callSync('sxStreamUpMedia', {
+  fields = mergeParamStrings(minFields, fields);
+  const result = callSync("sxStreamUpMedia", {
     resource: file,
     bytes: blob ? blob.getBytes() : null,
     fields,
     method,
     mimeType: file.mimeType || blob?.getContentType(),
     fileId,
-    params
-  })
+    params,
+  });
   // check result and register in cache
-  return registerSx(result, false, fields)
-}
+  return registerSx(result, false, fields);
+};
 
 /**
  * sync a call to Drive api
@@ -96,29 +107,37 @@ const fxStreamUpMedia = ({ file = {}, blob, fields = "", method = "create", file
  * @return {DriveResponse} from the drive api
  */
 const fxDrive = ({ prop, method, params, options }) => {
-  return callSync('sxDrive', {
+  return callSync("sxDrive", {
     prop,
     method,
     params: normalizeSerialization(params),
-    options: normalizeSerialization(options)
+    options: normalizeSerialization(options),
   });
-}
+};
 
-const fxGeneric = ({ serviceName, prop, subProp, method, params, options, cacher, idField }) => {
+const fxGeneric = ({
+  serviceName,
+  prop,
+  subProp,
+  method,
+  params,
+  options,
+  cacher,
+  idField,
+}) => {
   const { [idField]: resourceId, ...otherParams } = params;
 
-  if (method === 'get') {
+  if (method === "get") {
     const data = cacher.getEntry(resourceId, otherParams);
     if (data) {
       return {
         data,
         response: {
           status: 200,
-          fromCache: true
-        }
-      }
+          fromCache: true,
+        },
+      };
     }
-
   }
 
   const result = callSync(`sx${serviceName}`, {
@@ -126,20 +145,18 @@ const fxGeneric = ({ serviceName, prop, subProp, method, params, options, cacher
     prop,
     method,
     params: normalizeSerialization(params),
-    options: normalizeSerialization(options)
-  })
+    options: normalizeSerialization(options),
+  });
 
-  if (method === 'get') {
-    return register(resourceId, cacher, result, false, otherParams)
+  if (method === "get") {
+    return register(resourceId, cacher, result, false, otherParams);
   }
 
   if (resourceId) {
-    cacher.clear(resourceId)
+    cacher.clear(resourceId);
   }
-  return result
-}
-
-
+  return result;
+};
 
 /**
  * sync a call to Drive api get
@@ -150,38 +167,43 @@ const fxGeneric = ({ serviceName, prop, subProp, method, params, options, cacher
  * @param {object} p.params the params to add to the request
  * @return {DriveResponse} from the drive api
  */
-const fxDriveGet = ({ id, params, allow404 = false, allowCache = true, options }) => {
-
+const fxDriveGet = ({
+  id,
+  params,
+  allow404 = false,
+  allowCache = true,
+  options,
+}) => {
   // fixup the fields param
   // we'll fiddle with the scopes to populate cache
-  params.fields = mergeParamStrings(minFields, params.fields || "")
-  params.fileId = id
+  params.fields = mergeParamStrings(minFields, params.fields || "");
+  params.fileId = id;
 
   // now we check if it's in cache and already has the necessary fields
   // the cache will check the fields it already has against those requested
   if (allowCache) {
-    const { cachedFile, good } = getFromFileCache(id, params.fields)
-    if (good) return {
-
-      data: cachedFile,
-      // fake a good sxresponse
-      response: {
-        status: 200,
-        fromCache: true
-      }
-    }
+    const { cachedFile, good } = getFromFileCache(id, params.fields);
+    if (good)
+      return {
+        data: cachedFile,
+        // fake a good sxresponse
+        response: {
+          status: 200,
+          fromCache: true,
+        },
+      };
   }
 
   // so we have to hit the API
-  const result = callSync('sxDriveGet', {
+  const result = callSync("sxDriveGet", {
     id,
     params: normalizeSerialization(params),
-    options: normalizeSerialization(options)
+    options: normalizeSerialization(options),
   });
 
   // check result and register in cache
-  return registerSx(result, allow404, params.fields)
-}
+  return registerSx(result, allow404, params.fields);
+};
 
 /**
  * zipper
@@ -190,26 +212,24 @@ const fxDriveGet = ({ id, params, allow404 = false, allowCache = true, options }
  * @returns {FakeBlob} a combined zip file
  */
 const fxZipper = ({ blobs }) => {
-
-  const dupCheck = new Set()
+  const dupCheck = new Set();
   const blobsContent = blobs.map((f, i) => {
-    const ext = mime.getExtension(f.getContentType())
-    const name = f.getName() || `Untitled${i + 1}${ext ? "." + ext : ""}`
+    const ext = mime.getExtension(f.getContentType());
+    const name = f.getName() || `Untitled${i + 1}${ext ? "." + ext : ""}`;
     if (dupCheck.has(name)) {
-      throw new Error(`Duplicate filename ${name} not allowed in zip`)
+      throw new Error(`Duplicate filename ${name} not allowed in zip`);
     }
-    dupCheck.add(name)
+    dupCheck.add(name);
     return {
       name,
-      bytes: f.getBytes()
-    }
-  })
-
-  return callSync('sxZipper', {
-    blobsContent
-  })
+      bytes: f.getBytes(),
+    };
+  });
 
-}
+  return callSync("sxZipper", {
+    blobsContent,
+  });
+};
 
 /**
  * Unzipper
@@ -218,16 +238,15 @@ const fxZipper = ({ blobs }) => {
  * @returns {FakeBlob[]} each of the files unzipped
  */
 const fxUnzipper = ({ blob }) => {
-
   const blobContent = {
     name: blob.getName(),
-    bytes: blob.getBytes()
-  }
+    bytes: blob.getBytes(),
+  };
 
-  return callSync('sxUnzipper', {
-    blobContent
-  })
-}
+  return callSync("sxUnzipper", {
+    blobContent,
+  });
+};
 
 /**
  * initialize all the stuff at the beginning such as manifest content and settings
@@ -238,29 +257,28 @@ const fxUnzipper = ({ blob }) => {
  * @param {string} p.settingsPath where to find the settings file
  * @param {string} p.cachePath the cache files
  * @param {string} p.propertiesPath the properties file location
- * @return {object} the finalized vesions of all the above 
+ * @return {object} the finalized vesions of all the above
  */
 const fxInit = ({
   manifestPath = manifestDefaultPath,
   claspPath = claspDefaultPath,
   settingsPath = settingsDefaultPath,
   cachePath = cacheDefaultPath,
-  propertiesPath = propertiesDefaultPath
+  propertiesPath = propertiesDefaultPath,
 } = {}) => {
-
   // this is the path of the runing main process
-  const mainDir = path.dirname(process.argv[1])
+  const mainDir = path.dirname(process.argv[1]);
 
   // because this is all run in a synced subprocess it's not an async result
-  const synced = callSync('sxInit', {
+  const synced = callSync("sxInit", {
     claspPath,
     settingsPath,
     manifestPath,
     mainDir,
     cachePath,
     propertiesPath,
-    fakeId: randomUUID()
-  })
+    fakeId: randomUUID(),
+  });
 
   const {
     scopes,
@@ -270,24 +288,20 @@ const fxInit = ({
     accessToken,
     settings,
     manifest,
-    clasp
-  } = synced
+    clasp,
+  } = synced;
 
   // set these values from the subprocess for the main project
-  Auth.setProjectId(projectId)
+  Auth.setProjectId(projectId);
   //Auth.setAuth(scopes)
-  Auth.setTokenInfo(tokenInfo)
+  Auth.setTokenInfo(tokenInfo);
   //Auth.setAdcPath(adcPath)
   //Auth.setAccessToken(accessToken)
-  Auth.setSettings(settings)
-  Auth.setClasp(clasp)
-  Auth.setManifest(manifest)
-  return synced
-
-}
-
-
-
+  Auth.setSettings(settings);
+  Auth.setClasp(clasp);
+  Auth.setManifest(manifest);
+  return synced;
+};
 
 /**
  * because we're using a file backed cache we need to syncit
@@ -297,21 +311,17 @@ const fxInit = ({
  * @returns {*}
  */
 const fxStore = (storeArgs, method = "get", ...kvArgs) => {
-
-  return callSync('sxStore', {
+  return callSync("sxStore", {
     method,
     kvArgs,
-    storeArgs
-  })
-}
-
+    storeArgs,
+  });
+};
 
 const fxRefreshToken = () => {
-
-  return callSync('sxRefreshToken');
+  return callSync("sxRefreshToken");
 };
 
-
 /**
  * sync a call to Drive api to stream a download
  * @param {object} p pargs
@@ -321,14 +331,10 @@ const fxRefreshToken = () => {
  * @return {DriveResponse} from the drive api
  */
 const fxDriveMedia = ({ id }) => {
-
-  return callSync('sxDriveMedia', {
-    id
+  return callSync("sxDriveMedia", {
+    id,
   });
-}
-
-
-
+};
 
 /**
  * a sync version of fetching
@@ -338,15 +344,46 @@ const fxDriveMedia = ({ id }) => {
  * @returns {reponse} urlfetch style reponse
  */
 const fxFetch = (url, options, responseFields) => {
+  return callSync("sxFetch", url, options, responseFields);
+};
 
-  return callSync('sxFetch', url, options, responseFields);
-}
+const fxSheets = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Sheets",
+    cacher: sheetsCacher,
+    idField: "spreadsheetId",
+  });
+const fxSlides = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Slides",
+    cacher: slidesCacher,
+    idField: "presentationId",
+  });
+const fxDocs = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Docs",
+    cacher: docsCacher,
+    idField: "documentId",
+  });
+const fxForms = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Forms",
+    cacher: formsCacher,
+    idField: "formId",
+  });
+const fxGmail = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Gmail",
+    cacher: gmailCacher,
+    idField: "id",
+  });
 
-const fxSheets = (args) => fxGeneric({ ...args, serviceName: 'Sheets', cacher: sheetsCacher, idField: 'spreadsheetId' });
-const fxSlides = (args) => fxGeneric({ ...args, serviceName: 'Slides', cacher: slidesCacher, idField: 'presentationId' });
-const fxDocs = (args) => fxGeneric({ ...args, serviceName: 'Docs', cacher: docsCacher, idField: 'documentId' });
-const fxForms = (args) => fxGeneric({ ...args, serviceName: 'Forms', cacher: formsCacher, idField: 'formId' });
-const fxGmail = (args) => fxGeneric({ ...args, serviceName: 'Gmail', cacher: gmailCacher, idField: 'id' });
+const fxGetImagesFromXlsx = (args) => callSync("sxGetImagesFromXlsx", args);
 
 export const Syncit = {
   fxFetch,
@@ -364,4 +401,5 @@ export const Syncit = {
   fxDocs,
   fxForms,
   fxGmail,
-}
+  fxGetImagesFromXlsx,
+};

package/src/support/workersync/sxfunctions.js

@@ -1,10 +1,11 @@
-export * from '../sxdrive.js';
-export * from '../sxsheets.js';
-export * from '../sxdocs.js';
-export * from '../sxslides.js';
-export * from '../sxforms.js';
-export * from '../sxfetch.js';
-export * from '../sxstore.js';
-export * from '../sxzip.js';
-export * from '../sxauth.js';
-export * from '../sxgmail.js';
+export * from "../sxdrive.js";
+export * from "../sxsheets.js";
+export * from "../sxdocs.js";
+export * from "../sxslides.js";
+export * from "../sxforms.js";
+export * from "../sxfetch.js";
+export * from "../sxstore.js";
+export * from "../sxzip.js";
+export * from "../sxauth.js";
+export * from "../sxgmail.js";
+export * from "../sxxlsx.js";