@mcpher/gas-fakes 2.0.5 → 2.0.6

package/README.md

@@ -181,6 +181,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [oddities](oddities.md) - a collection of oddities uncovered during this project
 - [named colors](named-colors.md)
 - [sandbox](sandbox.md)
+- [senstive scopes](senstive_scopes.md)
 - [using apps script libraries with gas-fakes](libraries.md)
 - [how libhandler works](libhandler.md)
 - [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)

package/package.json

@@ -33,7 +33,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "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/index.js

@@ -8,6 +8,7 @@ import './services/utilities/app.js'
 import './services/spreadsheetapp/app.js'
 import './services/gmailapp/app.js'
 import './services/calendarapp/app.js'
+import './services/chartsapp/app.js'
 import './services/session/app.js'
 import './services/advdrive/app.js'
 import './services/advsheets/app.js'

package/src/services/chartsapp/app.js

@@ -0,0 +1,8 @@
+/**
+ * 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 { newFakeChartsApp as maker } from './fakechartsapp.js'
+let _app = null;
+_app = lazyLoaderApp(_app, 'Charts', maker)

package/src/services/chartsapp/fakechartsapp.js

@@ -0,0 +1,64 @@
+import { Proxies } from "../../support/proxies.js";
+import { notYetImplemented } from "../../support/helpers.js";
+import * as Enums from "../enums/chartsenums.js";
+
+/**
+ * create a new FakeChartsApp instance
+ * @param  {...any} args
+ * @returns {FakeChartsApp}
+ */
+export const newFakeChartsApp = (...args) => {
+  return Proxies.guard(new FakeChartsApp(...args));
+};
+
+/**
+ * basic fake FakeChartsApp
+ * @class FakeChartsApp
+ * @returns {FakeChartsApp}
+ */
+export class FakeChartsApp {
+  constructor() {
+    const enumProps = [
+      "ChartType", //	ChartType	An enumeration of the possible chart types.
+    ];
+
+    // import all known enums as props of chartsapp
+    enumProps.forEach((f) => {
+      this[f] = Enums[f];
+    });
+
+    const props = [
+      "newAreaChart",
+      "newBarChart",
+      "newColumnChart",
+      "newComboChart",
+      "newHistogramChart",
+      "newLineChart",
+      "newPieChart",
+      "newScatterChart",
+      "newSteppedAreaChart",
+      "newWaterfallChart",
+      "newScorecardChart",
+      "newRadarChart",
+      "newGaugeChart",
+      "newOrgChart",
+      "newTimelineChart",
+      "newTreeMapChart",
+      "newTableChart",
+      "newCandlestickChart",
+      "newGeoMapChart",
+      "newBubbleChart",
+      "newDataTable",
+      "newTextStyle",
+    ];
+
+    props.forEach((f) => {
+      this[f] = () => {
+        return notYetImplemented(f);
+      };
+    });
+  }
+  toString() {
+    return "Charts";
+  }
+}

package/src/services/enums/chartsenums.js

@@ -0,0 +1,24 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const ChartType = newFakeGasenum([
+  "AREA", //	Enum	Area chart.
+  "BAR", //	Enum	Bar chart.
+  "COLUMN", //	Enum	Column chart.
+  "COMBO", //	Enum	Combo chart.
+  "HISTOGRAM", //	Enum	Histogram chart.
+  "LINE", //	Enum	Line chart.
+  "PIE", //	Enum	Pie chart.
+  "SCATTER", //	Enum	Scatter chart.
+  "STEPPED_AREA", //	Enum	Stepped area chart.
+  "WATERFALL", //	Enum	Waterfall chart.
+  "SCORECARD", //	Enum	Scorecard chart.
+  "RADAR", //	Enum	Radar chart.
+  "GAUGE", //	Enum	Gauge chart.
+  "ORG", //	Enum	Org chart.
+  "TIMELINE", //	Enum	Timeline chart.
+  "TREE_MAP", //	Enum	Tree map chart.
+  "TABLE", //	Enum	Table chart.
+  "CANDLESTICK", //	Enum	Candlestick chart.
+  "GEOMAP", //	Enum	Geo map chart.
+  "BUBBLE", //	Enum	Bubble chart.
+]);

package/src/services/enums/sheetsenums.js

@@ -1,5 +1,5 @@
 
-import { newFakeGasenum} from "@mcpher/fake-gasenum";
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
 export const AutoFillSeries = newFakeGasenum(["DEFAULT_SERIES", "ALTERNATE_SERIES"])
 export const BandingTheme = newFakeGasenum([
   "LIGHT_GREY", //	Enum	A light grey banding theme.

package/src/services/spreadsheetapp/fakeembeddedchart.js

@@ -0,0 +1,87 @@
+import { Proxies } from "../../support/proxies.js";
+import { notYetImplemented, signatureArgs } from "../../support/helpers.js";
+import { batchUpdate } from "./sheetrangehelpers.js";
+import { newFakeEmbeddedChartBuilder } from "./fakeembeddedchartbuilder.js";
+
+/**
+ * @returns {FakeEmbeddedChart}
+ */
+export const newFakeEmbeddedChart = (apiChart, sheet) => {
+  return Proxies.guard(new FakeEmbeddedChart(apiChart, sheet));
+};
+
+/**
+ * Represents a chart that has been embedded into a spreadsheet.
+ */
+export class FakeEmbeddedChart {
+  /**
+   * @param {object} apiChart The EmbeddedChart object from Sheets API
+   * @param {FakeSheet} sheet The parent sheet
+   */
+  constructor(apiChart, sheet) {
+    this.__apiChart = apiChart;
+    this.__sheet = sheet;
+
+    const props = [
+      "getAs",
+      "getBlob",
+      "getContainerInfo",
+    ];
+    props.forEach((f) => {
+      this[f] = () => notYetImplemented(f);
+    });
+  }
+
+  /**
+   * Returns the ID of this chart.
+   * @returns {number}
+   */
+  getChartId() {
+    return this.__apiChart.chartId;
+  }
+
+  /**
+   * Returns the ID of this chart (alias for getChartId).
+   * @returns {string}
+   */
+  getId() {
+    return this.getChartId().toString();
+  }
+
+  /**
+   * Returns the options of this chart.
+   * @returns {object}
+   */
+  getOptions() {
+    return {
+      get: (key) => {
+        if (key === "title") return this.__apiChart.spec.title;
+        return this.__apiChart.spec.basicChart?.options?.[key];
+      }
+    };
+  }
+
+  /**
+   * Returns a builder to modify this chart.
+   * @returns {FakeEmbeddedChartBuilder}
+   */
+  modify() {
+    return newFakeEmbeddedChartBuilder(this.__sheet).setChartId(this.getChartId()).setApiChart(this.__apiChart);
+  }
+
+  /**
+   * Deletes the chart from the sheet.
+   */
+  remove() {
+    const request = {
+      deleteEmbeddedObject: {
+        objectId: this.getChartId(),
+      },
+    };
+    batchUpdate({ spreadsheet: this.__sheet.getParent(), requests: [request] });
+  }
+
+  toString() {
+    return "EmbeddedChart";
+  }
+}

package/src/services/spreadsheetapp/fakeembeddedchartbuilder.js

@@ -0,0 +1,154 @@
+import { Proxies } from "../../support/proxies.js";
+import { signatureArgs } from "../../support/helpers.js";
+import { Utils } from "../../support/utils.js";
+import { makeSheetsGridRange } from "./sheetrangehelpers.js";
+import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
+
+const { is } = Utils;
+
+/**
+ * @returns {FakeEmbeddedChartBuilder}
+ */
+export const newFakeEmbeddedChartBuilder = (sheet) => {
+  return Proxies.guard(new FakeEmbeddedChartBuilder(sheet));
+};
+
+/**
+ * Builder for embedded charts.
+ */
+export class FakeEmbeddedChartBuilder {
+  constructor(sheet) {
+    this.__sheet = sheet;
+    this.__apiChart = {
+      spec: {
+        title: "",
+        basicChart: {
+          chartType: "COLUMN", // Default
+          legendPosition: "RIGHT_LEGEND",
+          axis: [],
+          domains: [],
+          series: [],
+        },
+      },
+      position: {
+        overlayPosition: {
+          anchorCell: {
+            sheetId: sheet.getSheetId(),
+            rowIndex: 0,
+            columnIndex: 0,
+          },
+          offsetXPixels: 0,
+          offsetYPixels: 0,
+        },
+      },
+    };
+  }
+
+  setChartId(id) {
+    this.__apiChart.chartId = id;
+    return this;
+  }
+
+  setApiChart(apiChart) {
+    this.__apiChart = JSON.parse(JSON.stringify(apiChart));
+    return this;
+  }
+
+  addRange(range) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.addRange");
+    if (nargs !== 1) matchThrow();
+
+    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] } },
+      });
+    }
+    return this;
+  }
+
+  setChartType(type) {
+    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;
+    if (spec.basicChart) return chartType[spec.basicChart.chartType];
+    if (spec.pieChart) return chartType.PIE;
+    if (spec.bubbleChart) return chartType.BUBBLE;
+    if (spec.candlestickChart) return chartType.CANDLESTICK;
+    if (spec.orgChart) return chartType.ORG;
+    if (spec.waterfallChart) return chartType.WATERFALL;
+    if (spec.treemapChart) return chartType.TREE_MAP;
+    if (spec.scorecardChart) return chartType.SCORECARD;
+    if (spec.histogramChart) return chartType.HISTOGRAM;
+
+    return null;
+  }
+
+  setPosition(anchorRowPos, anchorColPos, offsetX, offsetY) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setPosition");
+    if (nargs !== 4) matchThrow();
+
+    this.__apiChart.position.overlayPosition.anchorCell.rowIndex = anchorRowPos - 1;
+    this.__apiChart.position.overlayPosition.anchorCell.columnIndex = anchorColPos - 1;
+    this.__apiChart.position.overlayPosition.offsetXPixels = offsetX;
+    this.__apiChart.position.overlayPosition.offsetYPixels = offsetY;
+    return this;
+  }
+
+  setOption(option, value) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setOption");
+    if (nargs !== 2) matchThrow();
+
+    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 = {};
+      }
+      this.__apiChart.spec.basicChart.options[option] = value;
+    }
+    return this;
+  }
+
+  build() {
+    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);
+  }
+
+  toString() {
+    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/fakesheet.js

@@ -14,6 +14,8 @@ import { FakeTextFinder, newFakeTextFinder } from "./faketextfinder.js";
 import { newFakeNamedRange } from "./fakenamedrange.js";
 import { newFakeProtection } from "./fakeprotection.js";
 import { newFakeOverGridImage } from "./fakeovergridimage.js";
+import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
+import { newFakeEmbeddedChartBuilder } from "./fakeembeddedchartbuilder.js";
 
 import { XMLParser } from "fast-xml-parser";
 import { slogger } from "../../support/slogger.js";
@@ -34,10 +36,6 @@ export class FakeSheet {
     this.__parent = parent;
 
     const props = [
-      "getCharts",
-      "insertChart",
-      "removeChart",
-      "updateChart",
       // "getImages",
       "insertImage",
       "removeImage",
@@ -399,6 +397,63 @@ export class FakeSheet {
     return pivotTables;
   }
 
+  getCharts() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.getCharts");
+    if (nargs !== 0) matchThrow();
+
+    const meta = this.getParent().__getMetaProps(
+      `sheets(charts,properties.sheetId)`
+    );
+    const sheetMeta = meta.sheets.find(
+      (s) => s.properties.sheetId === this.getSheetId()
+    );
+
+    return (sheetMeta?.charts || []).map((c) => newFakeEmbeddedChart(c, this));
+  }
+
+  insertChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.insertChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    const request = {
+      addChart: {
+        chart: chart.__apiChart,
+      },
+    };
+    batchUpdate({ spreadsheet: this.getParent(), requests: [request] });
+    return this;
+  }
+
+  newChart() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.newChart");
+    if (nargs !== 0) matchThrow();
+
+    return newFakeEmbeddedChartBuilder(this);
+  }
+
+  removeChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.removeChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    chart.remove();
+    return this;
+  }
+
+  updateChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.updateChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    const request = {
+      updateEmbeddedObjectPosition: {
+        objectId: chart.getChartId(),
+        newPosition: chart.__apiChart.position,
+        fields: "*",
+      },
+    };
+    batchUpdate({ spreadsheet: this.getParent(), requests: [request] });
+    return this;
+  }
+
   getBandings() {
     const meta = this.getParent().__getMetaProps(
       `sheets(bandedRanges,properties.sheetId)`