@mcpher/gas-fakes 2.3.2 → 2.3.4

package/README.md

@@ -184,6 +184,8 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [getting started](GETTING_STARTED.md) - how to handle authentication for Workspace scopes.
 - [readme](README.md)
 - [gas fakes cli](gas-fakes-cli.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](ksuite_poc.md)
 - [msgraph as a back end](msgraph.md)
 - [gas-fakes in serverless containers](https://docs.google.com/presentation/d/1JlXF9T--DD4ERHopyP3WyAMhjRCxxHblgCP5ynxaJ3k/edit?usp=sharing)
@@ -193,6 +195,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [running gas-fakes on google kubernetes engine](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Amazon AWS lambda](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Azure ACA](https://github.com/brucemcpherson/gas-fakes-containers)
+- [running gas-fakes on Github actions](https://github.com/brucemcpherson/gas-fakes-containers)
 - [Yes – you can run native apps script code on Azure ACA as well!](https://ramblings.mcpher.com/yes-you-can-run-native-apps-script-code-on-azure-aca-as-well/)
 - [Yes – you can run native apps script code on AWS Lambda!](https://ramblings.mcpher.com/apps-script-on-aws-lambda/)
 - [initial idea and thoughts](https://ramblings.mcpher.com/a-proof-of-concept-implementation-of-apps-script-environment-on-node/)

package/package.json

@@ -10,7 +10,7 @@
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@sindresorhus/is": "^7.2.0",
     "acorn": "^8.16.0",
-    "archiver": "^7.0.1",
+    "adm-zip": "^0.5.16",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fast-xml-parser": "^5.5.9",
@@ -24,12 +24,8 @@
     "mime": "^4.1.0",
     "prompts": "^2.4.2",
     "sleep-synchronously": "^2.0.0",
-    "unzipper": "^0.12.3",
     "zod": "^4.3.6"
   },
-  "overrides": {
-    "minimatch": "^10.0.3"
-  },
   "type": "module",
   "scripts": {
     "pub": "npm publish --access public",
@@ -39,7 +35,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "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/services/spreadsheetapp/fakeembeddedchart.js

@@ -40,6 +40,86 @@ export class FakeEmbeddedChart {
     return newFakeContainerInfo(this.__apiChart.position?.overlayPosition);
   }
 
+  /**
+   * Returns the ranges that this chart uses for its source data.
+   * @returns {FakeSheetRange[]}
+   */
+  getRanges() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChart.getRanges");
+    if (nargs !== 0) matchThrow();
+
+    const ranges = [];
+    const spec = this.__apiChart.spec;
+
+    const extractRanges = (chartData) => {
+      if (chartData?.sourceRange?.sources) {
+        chartData.sourceRange.sources.forEach((gridRange) => {
+          const sheet = this.__sheet.getParent().getSheetById(gridRange.sheetId);
+          if (sheet) {
+            const numRows = (gridRange.endRowIndex !== undefined ? gridRange.endRowIndex : sheet.getMaxRows()) - gridRange.startRowIndex;
+            const numCols = (gridRange.endColumnIndex !== undefined ? gridRange.endColumnIndex : sheet.getMaxColumns()) - gridRange.startColumnIndex;
+            ranges.push(
+              sheet.getRange(
+                gridRange.startRowIndex + 1,
+                gridRange.startColumnIndex + 1,
+                numRows,
+                numCols
+              )
+            );
+          }
+        });
+      }
+    };
+
+    if (spec.basicChart) {
+      spec.basicChart.domains?.forEach((d) => extractRanges(d.domain));
+      spec.basicChart.series?.forEach((s) => extractRanges(s.series));
+    }
+    if (spec.pieChart) {
+      extractRanges(spec.pieChart.domain);
+      spec.pieChart.series?.forEach((s) => extractRanges(s.series));
+    }
+    if (spec.bubbleChart) {
+      extractRanges(spec.bubbleChart.domain);
+      extractRanges(spec.bubbleChart.series);
+      extractRanges(spec.bubbleChart.ids);
+      extractRanges(spec.bubbleChart.labels);
+      extractRanges(spec.bubbleChart.sizes);
+    }
+    if (spec.candlestickChart) {
+      spec.candlestickChart.data?.forEach((d) => {
+        extractRanges(d.highSeries?.series);
+        extractRanges(d.lowSeries?.series);
+        extractRanges(d.openSeries?.series);
+        extractRanges(d.closeSeries?.series);
+      });
+    }
+    if (spec.histogramChart) {
+      spec.histogramChart.series?.forEach((s) => extractRanges(s.data));
+    }
+    if (spec.orgChart) {
+      extractRanges(spec.orgChart.labels);
+      extractRanges(spec.orgChart.parentLabels);
+      extractRanges(spec.orgChart.tooltips);
+    }
+    if (spec.scorecardChart) {
+      extractRanges(spec.scorecardChart.keyValueData);
+      extractRanges(spec.scorecardChart.baselineValueData);
+    }
+    if (spec.treemapChart) {
+      extractRanges(spec.treemapChart.labels);
+      extractRanges(spec.treemapChart.parentLabels);
+      extractRanges(spec.treemapChart.sizeData);
+      extractRanges(spec.treemapChart.colorData);
+    }
+    if (spec.waterfallChart) {
+      extractRanges(spec.waterfallChart.domain?.domain);
+      spec.waterfallChart.series?.forEach((s) => extractRanges(s.data));
+    }
+
+    return ranges;
+  }
+
   /**
    * Returns the ID of this chart.
    * @returns {number}

package/src/support/sxzip.js

@@ -5,19 +5,9 @@
  * note
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
-import archiver from 'archiver';
-import unzipper from 'unzipper';
+import AdmZip from 'adm-zip';
 import { syncWarn, syncError } from './workersync/synclogger.js';
 
-const streamToBuffer = (stream) => {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on('data', chunk => chunks.push(chunk));
-    stream.on('error', err => reject(err));
-    stream.on('end', () => resolve(Buffer.concat(chunks)));
-  });
-};
-
 /**
  * create a zipped version of multiple files
  * @param {object} p params
@@ -25,23 +15,14 @@ const streamToBuffer = (stream) => {
  * @return  {byte[]} the zipped content
  */
 export const sxZipper = async (_Auth, { blobsContent }) => {
- 
-  const archive = archiver.create('zip', {});
-
   try {
-    // It's important to handle warnings, as they don't necessarily reject the promise.
-    archive.on('warning', (err) => syncWarn(`Archiver warning: ${err}`));
-
-    // Start collecting the buffer in parallel. This promise resolves when the stream ends.
-    const bufferPromise = streamToBuffer(archive);
+    const zip = new AdmZip();
 
     blobsContent.forEach((f) => {
-      archive.append(Buffer.from(f.bytes), { name: f.name });
+      zip.addFile(f.name, Buffer.from(f.bytes));
     });
 
-    // Wait for BOTH the stream to end (which gives us the buffer) AND
-    // for finalization to be complete. This is the most robust way.
-    const [buffer] = await Promise.all([bufferPromise, archive.finalize()]);
+    const buffer = zip.toBuffer();
     return Array.from(buffer);
   } catch (err) {
     syncError('sxZipper failed', err);
@@ -56,23 +37,24 @@ export const sxZipper = async (_Auth, { blobsContent }) => {
  * @return  {SerializedBlob[]} the unzipped content
  */
 export const sxUnzipper = async (_Auth, { blobContent }) => {
-
-  const buffer = Buffer.from(blobContent.bytes)
-  const unzipped = await unzipper.Open.buffer(buffer)
-
-  // By wrapping the Promise.all in a try/catch, we ensure that if any
-  // single file stream fails, the entire operation rejects cleanly.
   try {
-    const result = await Promise.all(
-      unzipped.files.map(async (file) => {
-        const buffer = await streamToBuffer(file.stream());
-        return { bytes: Array.from(buffer), name: file.path };
-      })
-    );
+    const buffer = Buffer.from(blobContent.bytes);
+    const zip = new AdmZip(buffer);
+    const zipEntries = zip.getEntries();
+    
+    // Ignore directory entries (they end with a slash)
+    const result = zipEntries
+      .filter(zipEntry => !zipEntry.isDirectory)
+      .map(zipEntry => {
+        return { 
+          bytes: Array.from(zipEntry.getData()), 
+          name: zipEntry.entryName 
+        };
+      });
 
     return result;
   } catch (err) {
     syncError('An error occurred while unzipping a file stream inside the archive.', err);
-    throw err; // Re-throw to be caught by the main worker error handler
+    throw err;
   }
 }