@mcpher/gas-fakes 2.3.10 → 2.3.13

package/src/services/spreadsheetapp/fakeconditionalformatrulebuilder.js

@@ -0,0 +1,330 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeConditionalFormatRule } from './fakeconditionalformatrule.js';
+import { newFakeBooleanCondition } from './fakebooleancondition.js';
+import { newFakeGradientCondition } from './fakegradientcondition.js';
+import { makeSheetsGridRange } from './sheetrangehelpers.js';
+import { BooleanCriteria, InterpolationType } from '../enums/sheetsenums.js';
+import { Utils } from '../../support/utils.js';
+
+export const newFakeConditionalFormatRuleBuilder = (...args) => {
+  return Proxies.guard(new FakeConditionalFormatRuleBuilder(...args));
+};
+
+export class FakeConditionalFormatRuleBuilder {
+  constructor(apiRule = {}, spreadsheet = null) {
+    // We deep clone so that modifications to the builder don't affect the original rule immediately
+    this.__apiRule = JSON.parse(JSON.stringify(apiRule));
+    this.__spreadsheet = spreadsheet;
+    
+    // Ensure we have at least one rule type established, defaulting to booleanRule if nothing is set
+    if (!this.__apiRule.booleanRule && !this.__apiRule.gradientRule) {
+      this.__apiRule.booleanRule = {
+        condition: { type: 'CUSTOM_FORMULA', values: [] },
+        format: {}
+      };
+    }
+  }
+
+  __ensureBooleanRule() {
+    if (this.__apiRule.gradientRule) {
+      delete this.__apiRule.gradientRule;
+    }
+    if (!this.__apiRule.booleanRule) {
+      this.__apiRule.booleanRule = { condition: { type: 'CUSTOM_FORMULA', values: [] }, format: {} };
+    }
+    return this.__apiRule.booleanRule;
+  }
+
+  __ensureGradientRule() {
+    if (this.__apiRule.booleanRule) {
+      delete this.__apiRule.booleanRule;
+    }
+    if (!this.__apiRule.gradientRule) {
+      this.__apiRule.gradientRule = { minpoint: {}, midpoint: {}, maxpoint: {} };
+    }
+    return this.__apiRule.gradientRule;
+  }
+
+  __setBooleanFormatProperty(property, value) {
+    const rule = this.__ensureBooleanRule();
+    if (!rule.format) rule.format = {};
+    if (property === 'backgroundColorStyle') {
+       // Reset standard rgbColor if style is set
+       delete rule.format.backgroundColor;
+       if (value === null) {
+         delete rule.format.backgroundColorStyle;
+       } else {
+         rule.format.backgroundColorStyle = value;
+       }
+    } else if (property === 'backgroundColor') {
+       delete rule.format.backgroundColorStyle;
+       if (value === null) {
+         delete rule.format.backgroundColor;
+       } else {
+         rule.format.backgroundColor = value;
+       }
+    } else {
+      if (!rule.format.textFormat) rule.format.textFormat = {};
+      if (property === 'foregroundColorStyle') {
+        delete rule.format.textFormat.foregroundColor;
+        if (value === null) {
+          delete rule.format.textFormat.foregroundColorStyle;
+        } else {
+          rule.format.textFormat.foregroundColorStyle = value;
+        }
+      } else if (property === 'foregroundColor') {
+        delete rule.format.textFormat.foregroundColorStyle;
+        if (value === null) {
+          delete rule.format.textFormat.foregroundColor;
+        } else {
+          rule.format.textFormat.foregroundColor = value;
+        }
+      } else {
+        if (value === null) {
+          delete rule.format.textFormat[property];
+        } else {
+          rule.format.textFormat[property] = value;
+        }
+      }
+    }
+    return this;
+  }
+
+  __colorToApiStyle(colorObj) {
+    if (!colorObj) return null;
+    const type = colorObj.getColorType().toString();
+    if (type === 'THEME') {
+      return { themeColor: colorObj.asThemeColor().getThemeColorType().toString() };
+    } else if (type === 'RGB') {
+      const rgb = colorObj.asRgbColor();
+      return {
+        rgbColor: {
+          red: rgb.getRed() / 255,
+          green: rgb.getGreen() / 255,
+          blue: rgb.getBlue() / 255
+        }
+      };
+    }
+    return null;
+  }
+
+  __cssToApiColor(cssColor) {
+    if (!cssColor) return null;
+    const hex = Utils.validateHex(cssColor);
+    if (!hex) return null;
+    return {
+      red: hex.r / 255,
+      green: hex.g / 255,
+      blue: hex.b / 255
+    };
+  }
+
+  build() {
+    let sheet = null;
+    if (this.__spreadsheet) {
+      if (this.__apiRule.ranges && this.__apiRule.ranges.length > 0) {
+         const sheetId = this.__apiRule.ranges[0].sheetId;
+         sheet = this.__spreadsheet.getSheets().find(s => s.getSheetId() === sheetId);
+      }
+      // If no ranges yet or sheet not found, just use the active sheet as a fallback context
+      // Note: getActiveSheet() might be stubbed.
+      if (!sheet && typeof this.__spreadsheet.getActiveSheet === 'function') {
+        try {
+          sheet = this.__spreadsheet.getActiveSheet();
+        } catch(e) {}
+      }
+    }
+
+    // Clean up empty gradient points so the API doesn't complain
+    if (this.__apiRule.gradientRule) {
+      const g = this.__apiRule.gradientRule;
+      ['minpoint', 'midpoint', 'maxpoint'].forEach(pt => {
+        if (g[pt] && Object.keys(g[pt]).length === 0) {
+          delete g[pt];
+        }
+      });
+    }
+    
+    return newFakeConditionalFormatRule(this.__apiRule, sheet);
+  }
+
+  copy() {
+    return newFakeConditionalFormatRuleBuilder(this.__apiRule, this.__spreadsheet);
+  }
+
+  getBooleanCondition() {
+    if (!this.__apiRule.booleanRule) return null;
+    return newFakeBooleanCondition(
+      this.__apiRule.booleanRule.condition,
+      this.__apiRule.booleanRule.format
+    );
+  }
+
+  getGradientCondition() {
+    if (!this.__apiRule.gradientRule) return null;
+    return newFakeGradientCondition(this.__apiRule.gradientRule);
+  }
+
+  getRanges() {
+    if (!this.__apiRule.ranges) return [];
+    return this.__apiRule.ranges.map(gridRange => {
+      const sheet = this.__spreadsheet.getSheets().find(s => s.getSheetId() === gridRange.sheetId);
+      if (!sheet) return null;
+      return sheet.getRange(
+        gridRange.startRowIndex + 1,
+        gridRange.startColumnIndex + 1,
+        (gridRange.endRowIndex || sheet.getMaxRows()) - gridRange.startRowIndex,
+        (gridRange.endColumnIndex || sheet.getMaxColumns()) - gridRange.startColumnIndex
+      );
+    }).filter(Boolean);
+  }
+
+  setBackground(color) {
+    return this.__setBooleanFormatProperty('backgroundColor', this.__cssToApiColor(color));
+  }
+
+  setBackgroundObject(color) {
+    return this.__setBooleanFormatProperty('backgroundColorStyle', this.__colorToApiStyle(color));
+  }
+
+  setBold(bold) {
+    return this.__setBooleanFormatProperty('bold', bold);
+  }
+
+  setFontColor(color) {
+    return this.__setBooleanFormatProperty('foregroundColor', this.__cssToApiColor(color));
+  }
+
+  setFontColorObject(color) {
+    return this.__setBooleanFormatProperty('foregroundColorStyle', this.__colorToApiStyle(color));
+  }
+
+  setItalic(italic) {
+    return this.__setBooleanFormatProperty('italic', italic);
+  }
+
+  setStrikethrough(strikethrough) {
+    return this.__setBooleanFormatProperty('strikethrough', strikethrough);
+  }
+
+  setUnderline(underline) {
+    return this.__setBooleanFormatProperty('underline', underline);
+  }
+
+  __setGradientPoint(point, color, type, value) {
+    const rule = this.__ensureGradientRule();
+    if (!rule[point]) rule[point] = {};
+    if (color !== undefined) {
+      if (typeof color === 'string') {
+        rule[point].color = this.__cssToApiColor(color);
+        delete rule[point].colorStyle;
+      } else if (color !== null) {
+        rule[point].colorStyle = this.__colorToApiStyle(color);
+        delete rule[point].color;
+      }
+    }
+    if (type !== undefined) rule[point].type = type.toString();
+    if (value !== undefined) rule[point].value = value.toString();
+    return this;
+  }
+
+  setGradientMaxpoint(color) {
+    return this.__setGradientPoint('maxpoint', color, InterpolationType.MAX, "");
+  }
+
+  setGradientMaxpointObject(color) {
+    return this.__setGradientPoint('maxpoint', color, InterpolationType.MAX, "");
+  }
+
+  setGradientMaxpointObjectWithValue(color, type, value) {
+    return this.__setGradientPoint('maxpoint', color, type, value);
+  }
+
+  setGradientMaxpointWithValue(color, type, value) {
+    return this.__setGradientPoint('maxpoint', color, type, value);
+  }
+
+  setGradientMidpointObjectWithValue(color, type, value) {
+    return this.__setGradientPoint('midpoint', color, type, value);
+  }
+
+  setGradientMidpointWithValue(color, type, value) {
+    return this.__setGradientPoint('midpoint', color, type, value);
+  }
+
+  setGradientMinpoint(color) {
+    return this.__setGradientPoint('minpoint', color, InterpolationType.MIN, "");
+  }
+
+  setGradientMinpointObject(color) {
+    return this.__setGradientPoint('minpoint', color, InterpolationType.MIN, "");
+  }
+
+  setGradientMinpointObjectWithValue(color, type, value) {
+    return this.__setGradientPoint('minpoint', color, type, value);
+  }
+
+  setGradientMinpointWithValue(color, type, value) {
+    return this.__setGradientPoint('minpoint', color, type, value);
+  }
+
+  setRanges(ranges) {
+    const arr = Array.isArray(ranges) ? ranges : [ranges];
+    this.__apiRule.ranges = arr.map(r => makeSheetsGridRange(r));
+    return this;
+  }
+
+  __setBooleanCriteria(type, args = []) {
+    const rule = this.__ensureBooleanRule();
+    rule.condition = {
+      type: type,
+      values: args.map(a => {
+         // handle relative dates vs userEnteredValues
+         if (a && a.toString().indexOf('DATE_') === 0 || ['TODAY', 'TOMORROW', 'YESTERDAY', 'PAST_WEEK', 'PAST_MONTH', 'PAST_YEAR'].includes(a.toString())) {
+             return { relativeDate: a.toString() };
+         }
+         // Handle real Date objects
+         if (a instanceof Date) {
+            // Sheets API accepts dates in "MM/dd/yyyy" format for userEnteredValue, or as a formula like "=DATE(y,m,d)"
+            // Let's format it as a formula to be globally safe, or as MM/dd/yyyy.
+            // Actually, Sheets accepts "MM/dd/yyyy" universally in userEnteredValue for dates.
+            const m = a.getMonth() + 1;
+            const d = a.getDate();
+            const y = a.getFullYear();
+            return { userEnteredValue: `${m}/${d}/${y}` };
+         }
+         return { userEnteredValue: a.toString() };
+      })
+    };
+    return this;
+  }
+
+  whenCellEmpty() { return this.__setBooleanCriteria('BLANK'); }
+  whenCellNotEmpty() { return this.__setBooleanCriteria('NOT_BLANK'); }
+  whenDateAfter(date) { return this.__setBooleanCriteria('DATE_AFTER', [date]); }
+  whenDateBefore(date) { return this.__setBooleanCriteria('DATE_BEFORE', [date]); }
+  whenDateEqualTo(date) { return this.__setBooleanCriteria('DATE_EQ', [date]); }
+  whenFormulaSatisfied(formula) { return this.__setBooleanCriteria('CUSTOM_FORMULA', [formula]); }
+  whenNumberBetween(start, end) { return this.__setBooleanCriteria('NUMBER_BETWEEN', [start, end]); }
+  whenNumberEqualTo(number) { return this.__setBooleanCriteria('NUMBER_EQ', [number]); }
+  whenNumberGreaterThan(number) { return this.__setBooleanCriteria('NUMBER_GREATER', [number]); }
+  whenNumberGreaterThanOrEqualTo(number) { return this.__setBooleanCriteria('NUMBER_GREATER_THAN_EQ', [number]); }
+  whenNumberLessThan(number) { return this.__setBooleanCriteria('NUMBER_LESS', [number]); }
+  whenNumberLessThanOrEqualTo(number) { return this.__setBooleanCriteria('NUMBER_LESS_THAN_EQ', [number]); }
+  whenNumberNotBetween(start, end) { return this.__setBooleanCriteria('NUMBER_NOT_BETWEEN', [start, end]); }
+  whenNumberNotEqualTo(number) { return this.__setBooleanCriteria('NUMBER_NOT_EQ', [number]); }
+  whenTextContains(text) { return this.__setBooleanCriteria('TEXT_CONTAINS', [text]); }
+  whenTextDoesNotContain(text) { return this.__setBooleanCriteria('TEXT_NOT_CONTAINS', [text]); }
+  whenTextEndsWith(text) { return this.__setBooleanCriteria('TEXT_ENDS_WITH', [text]); }
+  whenTextEqualTo(text) { return this.__setBooleanCriteria('TEXT_EQ', [text]); }
+  whenTextStartsWith(text) { return this.__setBooleanCriteria('TEXT_STARTS_WITH', [text]); }
+
+  withCriteria(criteria, args) {
+    // API type is usually same as the enum, except enum uses string keys matching API types mostly.
+    return this.__setBooleanCriteria(criteria.toString(), args);
+  }
+
+  toString() {
+    return 'ConditionalFormatRuleBuilder';
+  }
+}

package/src/services/spreadsheetapp/fakedevelopermetadata.js

@@ -1,5 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
 import { Utils } from '../../support/utils.js';
+import { signatureArgs } from '../../support/helpers.js';
 import { newFakeDeveloperMetadataLocation } from './fakedevelopermetadatalocation.js';
 import { batchUpdate, makeSheetsGridRange } from './sheetrangehelpers.js';
 
@@ -40,11 +41,36 @@ class FakeDeveloperMetadata {
     return SpreadsheetApp.DeveloperMetadataVisibility[this.__metadata.visibility];
   }
 
-  moveTo(location) {
+  moveToColumn(column) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "moveToColumn")
+    if (nargs !== 1 || column.toString() !== 'Range') matchThrow()
+    return this.__moveTo(column)
+  }
+
+  moveToRow(row) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "moveToRow")
+    if (nargs !== 1 || row.toString() !== 'Range') matchThrow()
+    return this.__moveTo(row)
+  }
+
+  moveToSheet(sheet) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "moveToSheet")
+    if (nargs !== 1 || sheet.toString() !== 'Sheet') matchThrow()
+    return this.__moveTo(sheet)
+  }
+
+  moveToSpreadsheet() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "moveToSpreadsheet")
+    if (nargs !== 0) matchThrow()
+    return this.__moveTo(this.__spreadsheet)
+  }
+
+  __moveTo(location) {
     const newLocation = {};
-    if (location.toString() === 'Sheet') {
+    const locType = location.toString()
+    if (locType === 'Sheet') {
       newLocation.sheetId = location.getSheetId();
-    } else if (location.toString() === 'Range') {
+    } else if (locType === 'Range') {
       const isEntireRow = location.getNumRows() === 1 && location.getColumn() === 1 && location.getNumColumns() === location.getSheet().getMaxColumns();
       const isEntireColumn = location.getNumColumns() === 1 && location.getRow() === 1 && location.getNumRows() === location.getSheet().getMaxRows();
 
@@ -63,8 +89,10 @@ class FakeDeveloperMetadata {
         startIndex: startIndex,
         endIndex: endIndex,
       };
+    } else if (locType === 'Spreadsheet') {
+      newLocation.spreadsheet = true;
     } else {
-      throw new Error('Location must be a Sheet or Range.');
+      throw new Error('Location must be a Sheet, Range or Spreadsheet.');
     }
 
     this.__updateMetadata({ location: newLocation }, 'location');

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}`;
   }