@mcpher/gas-fakes 2.3.11 → 2.3.13

package/src/services/spreadsheetapp/fakedevelopermetadatalocation.js

@@ -1,5 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
 import { Utils } from '../../support/utils.js';
+import { SheetUtils } from '../../support/sheetutils.js';
 import { newFakeSheetRange } from './fakesheetrange.js';
 import { makeGridRange } from './sheetrangehelpers.js';
 
@@ -25,12 +26,27 @@ class FakeDeveloperMetadataLocation {
       return null;
     }
     const dr = this.__location.dimensionRange;
-    const numCols = dr.endIndex - dr.startIndex;
-    return this.getSheet().getRange(1, dr.startIndex + 1, this.getSheet().getMaxRows(), numCols);
+    const startA1 = SheetUtils.columnToLetter(dr.startIndex + 1);
+    const endA1 = SheetUtils.columnToLetter(dr.endIndex);
+    return this.getSheet().getRange(`${startA1}:${endA1}`);
   }
 
   getLocationType() {
-    return SpreadsheetApp.DeveloperMetadataLocationType[this.__location.locationType];
+    if (this.__location.locationType) {
+        return SpreadsheetApp.DeveloperMetadataLocationType[this.__location.locationType];
+    }
+    if (this.__location.spreadsheet) {
+        return SpreadsheetApp.DeveloperMetadataLocationType.SPREADSHEET;
+    }
+    if (this.__location.dimensionRange) {
+        return this.__location.dimensionRange.dimension === 'COLUMNS' ? 
+            SpreadsheetApp.DeveloperMetadataLocationType.COLUMN : 
+            SpreadsheetApp.DeveloperMetadataLocationType.ROW;
+    }
+    if (this.__location.sheetId !== undefined) {
+        return SpreadsheetApp.DeveloperMetadataLocationType.SHEET;
+    }
+    return null;
   }
 
   getRow() {
@@ -38,8 +54,7 @@ class FakeDeveloperMetadataLocation {
       return null;
     }
     const dr = this.__location.dimensionRange;
-    const numRows = dr.endIndex - dr.startIndex;
-    return this.getSheet().getRange(dr.startIndex + 1, 1, numRows, this.getSheet().getMaxColumns());
+    return this.getSheet().getRange(`${dr.startIndex + 1}:${dr.endIndex}`);
   }
 
   getSheet() {
@@ -48,6 +63,13 @@ class FakeDeveloperMetadataLocation {
     return this.__spreadsheet.getSheetById(sheetId);
   }
 
+  getSpreadsheet() {
+    if (this.getLocationType().toString() !== 'SPREADSHEET' || !this.__location.spreadsheet) {
+      return null;
+    }
+    return this.__spreadsheet;
+  }
+
   toString() {
     return 'DeveloperMetadataLocation';
   }

package/src/services/spreadsheetapp/fakeembeddedchartbuilder.js

@@ -3,6 +3,8 @@ import { signatureArgs } from "../../support/helpers.js";
 import { Utils } from "../../support/utils.js";
 import { makeSheetsGridRange } from "./sheetrangehelpers.js";
 import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
+import { newFakeContainerInfo } from "./fakecontainerinfo.js";
+import { ChartEnumMapping } from "./chartenummapping.js";
 
 const { is } = Utils;
 
@@ -23,8 +25,6 @@ export class FakeEmbeddedChartBuilder {
       spec: {
         title: "",
         basicChart: {
-          chartType: "COLUMN", // Default
-          legendPosition: "RIGHT_LEGEND",
           axis: [],
           domains: [],
           series: [],
@@ -60,17 +60,11 @@ export class FakeEmbeddedChartBuilder {
 
     const gridRange = makeSheetsGridRange(range);
 
-    // In Sheets API, ranges are usually mapped to domains or series.
-    // Simplifying: if the range has multiple columns, split it into separate sources if it's a series.
-    // But for this fake, we'll just encourage the user to use single-column ranges or handle it simply.
-
     if (this.__apiChart.spec.basicChart.domains.length === 0) {
       this.__apiChart.spec.basicChart.domains.push({
         domain: { sourceRange: { sources: [gridRange] } },
       });
     } else {
-      // Check if gridRange has multiple columns/rows and split if necessary?
-      // For now, just add it. The test will be updated to use single column ranges.
       this.__apiChart.spec.basicChart.series.push({
         series: { sourceRange: { sources: [gridRange] } },
       });
@@ -82,15 +76,10 @@ export class FakeEmbeddedChartBuilder {
     const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setChartType");
     if (nargs !== 1) matchThrow();
 
-    // type is Charts.ChartType enum (which should match API strings in our fakes)
     this.__apiChart.spec.basicChart.chartType = type.toString();
     return this;
   }
 
-  /**
-   * Returns the chart type.
-   * @returns {ChartType}
-   */
   getChartType() {
     const spec = this.__apiChart.spec;
     const chartType = Charts.ChartType;
@@ -125,9 +114,6 @@ export class FakeEmbeddedChartBuilder {
     if (option === "title") {
       this.__apiChart.spec.title = value;
     } else {
-      // For other options, we might want to store them in a general options object if needed,
-      // but for now, we'll just focus on "title" as requested.
-      // SpreadsheetApp.EmbeddedChartBuilder.setOption(option, value)
       if (!this.__apiChart.spec.basicChart.options) {
         this.__apiChart.spec.basicChart.options = {};
       }
@@ -140,14 +126,162 @@ export class FakeEmbeddedChartBuilder {
     const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.build");
     if (nargs !== 0) matchThrow();
 
-    // In a real GAS, build() returns an EmbeddedChart that is NOT yet inserted.
-    // Here we return the api object wrapped in a FakeEmbeddedChart if needed,
-    // or just the raw object that insertChart will use.
-    // Actually, gas.Sheet.insertChart expects an EmbeddedChart object.
-    return newFakeEmbeddedChart(this.__apiChart, this.__sheet);
+    // Perform translation from GAS internal state to Sheets REST API Spec
+    const apiChart = JSON.parse(JSON.stringify(this.__apiChart));
+    const spec = apiChart.spec;
+    const basic = spec.basicChart;
+
+    // 1. Translate Enums
+    if (basic && basic.legendPosition) {
+      basic.legendPosition = ChartEnumMapping.Position[basic.legendPosition] || basic.legendPosition;
+    }
+
+    if (spec.hiddenDimensionStrategy) {
+      spec.hiddenDimensionStrategy = ChartEnumMapping.ChartHiddenDimensionStrategy[spec.hiddenDimensionStrategy] || spec.hiddenDimensionStrategy;
+    }
+
+    // Translate background color from Hex to RGB object if present
+    if (basic && basic.options?.backgroundColor) {
+      const hex = basic.options.backgroundColor;
+      const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+      if (result) {
+        spec.backgroundColorStyle = {
+          rgbColor: {
+            red: parseInt(result[1], 16) / 255,
+            green: parseInt(result[2], 16) / 255,
+            blue: parseInt(result[3], 16) / 255
+          }
+        };
+      }
+    }
+
+    // 2. Handle Specialized Spec Blocks
+    if (basic && basic.chartType === "PIE") {
+      spec.pieChart = {
+        domain: basic.domains?.[0]?.domain,
+        series: basic.series?.[0]?.series,
+        threeDimensional: basic.options?.is3D || false,
+        pieHole: basic.options?.pieHole || 0,
+      };
+      if (basic.legendPosition) spec.pieChart.legendPosition = basic.legendPosition;
+      delete spec.basicChart;
+    } else if (basic && basic.chartType === "HISTOGRAM") {
+      spec.histogramChart = {
+        series: [
+          {
+            data: basic.series?.[0]?.series || basic.domains?.[0]?.domain,
+          }
+        ],
+      };
+      if (basic.legendPosition) spec.histogramChart.legendPosition = basic.legendPosition;
+      delete spec.basicChart;
+    } else if (basic) {
+      // Sheets API quirk: even if basicChart.chartType is set, it often defaults to rendering as a LINE 
+      // chart unless the series array explicitly mirrors the type.
+      basic.series = basic.series || [];
+      if (basic.chartType === "COMBO") {
+        if (basic.series.length === 0) basic.series.push({ type: "COLUMN" });
+      }
+      
+      basic.series.forEach(s => {
+        if (!s.type) s.type = basic.chartType === "COMBO" ? "COLUMN" : basic.chartType;
+      });
+
+      // Clean up internal-only 'options' field that the API doesn't recognize
+      delete basic.options;
+    }
+
+    return newFakeEmbeddedChart(apiChart, this.__sheet);
   }
 
+  // --- Sub-builder coercion methods ---
+  asAreaChart() { return this.setChartType("AREA"); }
+  asBarChart() { return this.setChartType("BAR"); }
+  asColumnChart() { return this.setChartType("COLUMN"); }
+  asComboChart() { return this.setChartType("COMBO"); }
+  asHistogramChart() { return this.setChartType("HISTOGRAM"); }
+  asLineChart() { return this.setChartType("LINE"); }
+  asPieChart() { return this.setChartType("PIE"); }
+  asScatterChart() { return this.setChartType("SCATTER"); }
+  asTableChart() { return this.setChartType("TABLE"); }
+
+  // --- Common Builder Methods ---
+  clearRanges() {
+    this.__apiChart.spec.basicChart.domains = [];
+    this.__apiChart.spec.basicChart.series = [];
+    return this;
+  }
+  
+  getContainer() {
+    return newFakeContainerInfo(this.__apiChart.position.overlayPosition || {});
+  }
+  
+  getRanges() {
+    // In gas-fakes, we don't deeply parse and unwrap ranges back from the API spec for this fake, returning empty array.
+    return [];
+  }
+  
+  removeRange(range) { return this; }
+  
+  setHiddenDimensionStrategy(strategy) {
+    this.__apiChart.spec.hiddenDimensionStrategy = strategy ? strategy.toString() : "IGNORE_ROWS";
+    return this;
+  }
+  
+  setMergeStrategy(strategy) { return this; }
+  setNumHeaders(headers) { return this; }
+  setTransposeRowsAndColumns(transpose) { return this; }
+
+  // --- Chart Specific Builder Methods ---
+  reverseCategories() { return this; }
+  setBackgroundColor(color) { return this.setOption("backgroundColor", color); }
+  setColors(colors) { return this; }
+  setLegendPosition(position) { 
+    this.__apiChart.spec.basicChart.legendPosition = position ? position.toString() : "RIGHT_LEGEND";
+    return this; 
+  }
+  setLegendTextStyle(textStyle) { return this; }
+  setPointStyle(pointStyle) { return this; }
+  setRange(min, max) { return this; }
+  setStacked() { return this; }
+  setTitle(title) { 
+    this.__apiChart.spec.title = title;
+    return this; 
+  }
+  setTitleTextStyle(textStyle) { return this; }
+  setXAxisTextStyle(textStyle) { return this; }
+  setXAxisTitle(title) { return this; }
+  setXAxisTitleTextStyle(textStyle) { return this; }
+  setYAxisTextStyle(textStyle) { return this; }
+  setYAxisTitle(title) { return this; }
+  setYAxisTitleTextStyle(textStyle) { return this; }
+  useLogScale() { return this; }
+  set3D() { return this.setOption("is3D", true); }
+  enablePaging(enable, pageSize) { return this; }
+  enableRtlTable(enable) { return this; }
+  enableSorting(enable) { return this; }
+  setFirstRowNumber(number) { return this; }
+  setInitialSortingAscending(column) { return this; }
+  setInitialSortingDescending(column) { return this; }
+  showRowNumberColumn(show) { return this; }
+  useAlternatingRowStyle(use) { return this; }
+  setXAxisLogScale() { return this; }
+  setXAxisRange(min, max) { return this; }
+  setYAxisLogScale() { return this; }
+  setYAxisRange(min, max) { return this; }
+  reverseDirection() { return this; }
+
   toString() {
+    const type = this.__apiChart.spec.basicChart?.chartType;
+    if (type) {
+      // The API uses string constants like "COLUMN", "PIE", "SCATTER".
+      // We convert them to CamelCase format like "EmbeddedPieChartBuilder".
+      const formattedType = type.charAt(0).toUpperCase() + type.slice(1).toLowerCase();
+      // Handle the underscore in STEPPED_AREA
+      const finalType = formattedType.replace(/_([a-z])/g, function (g) { return g[1].toUpperCase(); });
+      return `Embedded${finalType}ChartBuilder`;
+    }
+
     const hex = Math.floor(Math.random() * 0xffffffff).toString(16).padStart(8, "0");
     return `com.google.apps.maestro.server.beans.trix.impl.ChartPropertyApiEmbeddedChartBuilder@${hex}`;
   }

package/src/services/spreadsheetapp/fakegradientcondition.js

@@ -0,0 +1,71 @@
+import { Proxies } from '../../support/proxies.js';
+import { makeColorFromApi } from '../common/fakecolorbuilder.js';
+import { InterpolationType } from '../enums/sheetsenums.js';
+
+export const newFakeGradientCondition = (...args) => {
+  return Proxies.guard(new FakeGradientCondition(...args));
+};
+
+export class FakeGradientCondition {
+  constructor(apiGradient) {
+    this.__apiGradient = apiGradient || {};
+  }
+
+  __getColor(point) {
+    if (!point) return null;
+    if (point.colorStyle) return makeColorFromApi(point.colorStyle);
+    if (point.color) return makeColorFromApi({ rgbColor: point.color });
+    return null;
+  }
+
+  __getType(point) {
+    if (!point || !point.type) return null;
+    return InterpolationType[point.type] || null;
+  }
+
+  __getValue(point) {
+    if (!point) return "";
+    if (point.type === 'MIN' || point.type === 'MAX') return "";
+    return point.value !== undefined ? point.value : "";
+  }
+
+  getMaxColorObject() {
+    return this.__getColor(this.__apiGradient.maxpoint);
+  }
+
+  getMaxType() {
+    return this.__getType(this.__apiGradient.maxpoint);
+  }
+
+  getMaxValue() {
+    return this.__getValue(this.__apiGradient.maxpoint);
+  }
+
+  getMidColorObject() {
+    return this.__getColor(this.__apiGradient.midpoint);
+  }
+
+  getMidType() {
+    return this.__getType(this.__apiGradient.midpoint);
+  }
+
+  getMidValue() {
+    return this.__getValue(this.__apiGradient.midpoint);
+  }
+
+  getMinColorObject() {
+    return this.__getColor(this.__apiGradient.minpoint);
+  }
+
+  getMinType() {
+    return this.__getType(this.__apiGradient.minpoint);
+  }
+
+  getMinValue() {
+    return this.__getValue(this.__apiGradient.minpoint);
+  }
+
+  toString() {
+    return 'GradientCondition';
+  }
+}

package/src/services/spreadsheetapp/fakesheet.js

@@ -5,6 +5,7 @@ import { Utils } from "../../support/utils.js";
 import { SheetUtils } from "../../support/sheetutils.js";
 import { batchUpdate, makeSheetsGridRange } from "./sheetrangehelpers.js";
 import { newFakeFilter } from "./fakefilter.js";
+import { newFakeConditionalFormatRule } from "./fakeconditionalformatrule.js";
 import { newFakePivotTable } from "./fakepivottable.js";
 import { newFakeBanding } from "./fakebanding.js";
 import { newFakeDeveloperMetadataFinder } from "./fakedevelopermetadatafinder.js";
@@ -378,6 +379,68 @@ export class FakeSheet {
       : null;
   }
 
+  /**
+   * clearConditionalFormatRules() https://developers.google.com/apps-script/reference/spreadsheet/sheet#clearconditionalformatrules
+   * Removes all conditional format rules from the sheet. Equivalent to calling setConditionalFormatRules(rules) with an empty array as input.
+   */
+  clearConditionalFormatRules() {
+    this.setConditionalFormatRules([]);
+  }
+
+  /**
+   * getConditionalFormatRules() https://developers.google.com/apps-script/reference/spreadsheet/sheet#getconditionalformatrules
+   * Get all conditional format rules in this sheet.
+   * @returns {FakeConditionalFormatRule[]} An array of all rules in the sheet.
+   */
+  getConditionalFormatRules() {
+    const meta = this.getParent().__getMetaProps(
+      `sheets(conditionalFormats,properties.sheetId)`
+    );
+    const sheetMeta = meta.sheets.find(
+      (s) => s.properties.sheetId === this.getSheetId()
+    );
+    const rules = sheetMeta?.conditionalFormats || [];
+    return rules.map(rule => newFakeConditionalFormatRule(rule, this));
+  }
+
+  /**
+   * setConditionalFormatRules(rules) https://developers.google.com/apps-script/reference/spreadsheet/sheet#setconditionalformatrulesrules
+   * Replaces all currently existing conditional format rules in the sheet with the input rules. Rules are evaluated in their input order.
+   * @param {FakeConditionalFormatRule[]} rules The array of conditional format rules to set.
+   */
+  setConditionalFormatRules(rules) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.setConditionalFormatRules");
+    if (nargs !== 1 || !Array.isArray(rules)) matchThrow();
+
+    const requests = [];
+
+    // Delete existing rules
+    const existingRules = this.getConditionalFormatRules();
+    const existingCount = existingRules.length;
+    for (let i = existingCount - 1; i >= 0; i--) {
+      requests.push({
+        deleteConditionalFormatRule: {
+          sheetId: this.getSheetId(),
+          index: i
+        }
+      });
+    }
+
+    // Add new rules
+    rules.forEach((rule, index) => {
+      requests.push({
+        addConditionalFormatRule: {
+          rule: rule.__apiRule,
+          index: index
+        }
+      });
+    });
+
+    if (requests.length > 0) {
+      Sheets.Spreadsheets.batchUpdate({ requests: requests }, this.__parent.getId());
+    }
+  }
+
   getPivotTables() {
     const meta = this.getParent().__getMetaProps(
       `sheets(data(rowData(values(pivotTable))),properties.sheetId)`

package/src/services/spreadsheetapp/fakesheetrange.js

@@ -2611,6 +2611,17 @@ skipFilteredRows	Boolean	Whether to avoid clearing filtered rows.
     // options = { valueInputOption: "RAW" },
     options = { valueInputOption: "USER_ENTERED" },
   }) {
+    // Intercept FakeCellImage objects and convert to =IMAGE(url) formula
+    const processedValues = values.map(row => 
+      row.map(cell => {
+        if (cell && typeof cell === 'object' && cell.toString() === 'CellImage') {
+          const url = cell._properties?.sourceUrl || null;
+          return url ? `=IMAGE("${url}")` : "";
+        }
+        return cell;
+      })
+    );
+
     const range = single
       ? this.__getRangeWithSheet(this.__getTopLeft())
       : this.__getWithSheet();
@@ -2620,7 +2631,7 @@ skipFilteredRows	Boolean	Whether to avoid clearing filtered rows.
         {
           majorDimension: "ROWS",
           range,
-          values,
+          values: processedValues,
         },
       ],
     };

package/src/services/spreadsheetapp/fakespreadsheet.js

@@ -152,17 +152,6 @@ export class FakeSpreadsheet {
       "deleteColumn",
       "getImages",
       "find",
-      "sort",
-      "addEditor",
-      "addEditors",
-      "addViewers",
-      "addViewer",
-      "removeViewer",
-      "removeEditor",
-
-      // these convert to a pdf so we'll need to figure out how to do that
-      // probably using the Drive export
-      "getAs",
       "getBlob",
     ];
 
@@ -181,6 +170,36 @@ export class FakeSpreadsheet {
     return this.__getFirstSheet();
   }
 
+  addViewer(emailAddress) {
+    this.__file.addViewer(emailAddress);
+    return this;
+  }
+
+  addEditor(emailAddress) {
+    this.__file.addEditor(emailAddress);
+    return this;
+  }
+
+  addViewers(emailAddresses) {
+    this.__file.addViewers(emailAddresses);
+    return this;
+  }
+
+  addEditors(emailAddresses) {
+    this.__file.addEditors(emailAddresses);
+    return this;
+  }
+
+  removeViewer(emailAddress) {
+    this.__file.removeViewer(emailAddress);
+    return this;
+  }
+
+  removeEditor(emailAddress) {
+    this.__file.removeEditor(emailAddress);
+    return this;
+  }
+
   
   addDeveloperMetadata(key, value, visibility) {
     const { nargs, matchThrow } = signatureArgs(

package/src/services/spreadsheetapp/fakespreadsheetapp.js

@@ -12,8 +12,10 @@ import { newFakeRichTextValueBuilder } from "../common/fakerichtextvalue.js";
 import { newFakeTextStyleBuilder } from "../common/faketextstylebuilder.js";
 import { newFakeFilterCriteriaBuilder } from "./fakefiltercriteriabuilder.js";
 import { newFakeDataValidationBuilder } from "./fakedatavalidationbuilder.js";
+import { newFakeConditionalFormatRuleBuilder } from "./fakeconditionalformatrulebuilder.js";
 import { newFakeDataSourceSpecBuilder } from "./fakedatasourcespecbuilder.js";
-import { FakeTextFinder, newFakeTextFinder } from "./faketextfinder.js";
+import { newFakeTextFinder } from "./faketextfinder.js";
+import { newFakeCellImageBuilder } from "./fakecellimagebuilder.js";
 
 import * as Enums from "../enums/sheetsenums.js";
 
@@ -79,7 +81,6 @@ export class FakeSpreadsheetApp {
 
     const props = [
       "getActive",
-      "newConditionalFormatRule",
       "getActiveSheet",
       "getCurrentCell",
       "getActiveRange",
@@ -89,7 +90,6 @@ export class FakeSpreadsheetApp {
       "setCurrentCell",
       "setActiveRange",
       "setActiveRangeList",
-      "newCellImage",
       "getUi",
       "open",
 
@@ -228,6 +228,15 @@ export class FakeSpreadsheetApp {
     return this.openById(match[1]);
   }
 
+  /**
+   * newCellImage() https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet-app#newcellimage
+   * Creates a builder for a CellImage.
+   * @returns {FakeCellImageBuilder}
+   */
+  newCellImage() {
+    return newFakeCellImageBuilder();
+  }
+
   /**
    * newColor() https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet-app#newcolor
    * Creates a builder for a Color.
@@ -237,6 +246,15 @@ export class FakeSpreadsheetApp {
     return newFakeColorBuilder();
   }
 
+  /**
+   * newConditionalFormatRule() https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet-app#newconditionalformatrule
+   * Creates a builder for a conditional formatting rule.
+   * @returns {FakeConditionalFormatRuleBuilder}
+   */
+  newConditionalFormatRule() {
+    return newFakeConditionalFormatRuleBuilder();
+  }
+
   /**
    * newTextStyle() https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet-app#newTextStyle()
    * Creates a builder for a TextStyle.

package/src/services/urlfetchapp/app.js

@@ -116,6 +116,37 @@ const fetchAll = (requests) => {
   return responses.map(({ data }) => responsify(data))
 }
 
+const getRequest = (url, options = {}) => {
+  const defaultMethod = 'get';
+  const request = {
+    url: url,
+    method: (options.method || defaultMethod).toLowerCase(),
+    headers: options.headers || {},
+  };
+
+  // Apps Script defaults
+  if (options.contentType) {
+    request.contentType = options.contentType;
+  }
+  
+  if (options.payload) {
+    request.payload = options.payload;
+  }
+  
+  if (options.useIntranet !== undefined) {
+    request.useIntranet = options.useIntranet;
+  }
+
+  // Add standard fetch behavior
+  if (request.method === 'post' || request.method === 'put' || request.method === 'patch') {
+     if (!request.contentType) {
+       request.contentType = 'application/x-www-form-urlencoded';
+     }
+  }
+
+  return request;
+}
+
 
 // This will eventually hold a proxy for DriveApp
 let _app = null
@@ -131,7 +162,8 @@ if (typeof globalThis[name] === typeof undefined) {
     if (!_app) {
       _app = {
         fetch,
-        fetchAll
+        fetchAll,
+        getRequest
       }
     }
     // this is the actual driveApp we'll return from the proxy

package/src/support/fileiterators.js

@@ -31,7 +31,9 @@ export const getPermissionIterator = ({
         pageToken = nextPageToken
 
         // format the results into the folder or file object
-        tank = permissions
+        // we must copy the array because the cache returns a reference 
+        // and splicing it would empty the cache for subsequent calls
+        tank = [...permissions]
       }
 
       // if we've got anything in the tank send back the oldest one

package/src/support/filesharers.js

@@ -4,14 +4,18 @@ import { newFakeUser } from '../services/common/fakeuser.js';
 
 /**
  * get the file sharers
- * @returns {FakeUser} the file viewers
+ * @param {string} id the file id
+ * @param {string|string[]} roles the role or roles to filter by
+ * @returns {FakeUser[]} the file viewers
  */
-export const getSharers = (id, role) => {
+export const getSharers = (id, roles) => {
+  const roleList = Array.isArray(roles) ? roles : [roles]
   const pit = getPermissionIterator({ id })
   const viewers = []
   while (pit.hasNext()) {
     const permission = pit.next()
-    if (permission.role === role && permission.type === "user") viewers.push(makeUserFromPermission(permission))
+    // console.log(`...DEBUG: permission for ${id}:`, JSON.stringify(permission))
+    if (roleList.includes(permission.role) && permission.type === "user") viewers.push(makeUserFromPermission(permission))
   }
   return viewers
 }