@mcpher/gas-fakes 2.3.11 → 2.3.13

package/src/services/spreadsheetapp/chartenummapping.js

@@ -0,0 +1,15 @@
+export const ChartEnumMapping = {
+  Position: {
+    BOTTOM: "BOTTOM_LEGEND",
+    TOP: "TOP_LEGEND",
+    LEFT: "LEFT_LEGEND",
+    RIGHT: "RIGHT_LEGEND",
+    NONE: "NO_LEGEND",
+  },
+  ChartHiddenDimensionStrategy: {
+    IGNORE_BOTH: "SKIP_HIDDEN_ROWS_AND_COLUMNS",
+    IGNORE_ROWS: "SKIP_HIDDEN_ROWS",
+    IGNORE_COLUMNS: "SKIP_HIDDEN_COLUMNS",
+    SHOW_BOTH: "SHOW_ALL",
+  }
+};

package/src/services/spreadsheetapp/fakebooleancondition.js

@@ -0,0 +1,119 @@
+import { Proxies } from '../../support/proxies.js';
+import { BooleanCriteria } from '../enums/sheetsenums.js';
+import { newFakeColor } from '../common/fakecolor.js';
+import { makeColorFromApi } from '../common/fakecolorbuilder.js';
+
+export const newFakeBooleanCondition = (...args) => {
+  return Proxies.guard(new FakeBooleanCondition(...args));
+};
+
+export class FakeBooleanCondition {
+  constructor(apiCondition, format) {
+    this.__apiCondition = apiCondition;
+    this.__format = format || {};
+  }
+
+  getBackgroundObject() {
+    if (this.__format.backgroundColorStyle) {
+      return makeColorFromApi(this.__format.backgroundColorStyle);
+    }
+    if (this.__format.backgroundColor) {
+      return makeColorFromApi({ rgbColor: this.__format.backgroundColor });
+    }
+    return null;
+  }
+
+  getBold() {
+    return this.__format.textFormat?.bold ?? null;
+  }
+
+  getCriteriaType() {
+    // The API uses slightly different strings than the GAS enum for many rules
+    const map = {
+      'BLANK': 'CELL_EMPTY',
+      'NOT_BLANK': 'CELL_NOT_EMPTY',
+      'DATE_AFTER': 'DATE_AFTER',
+      'DATE_BEFORE': 'DATE_BEFORE',
+      'DATE_EQ': 'DATE_EQUAL_TO',
+      'DATE_NOT_EQ': 'DATE_NOT_EQUAL_TO',
+      'DATE_AFTER_RELATIVE': 'DATE_AFTER_RELATIVE',
+      'DATE_BEFORE_RELATIVE': 'DATE_BEFORE_RELATIVE',
+      'DATE_EQUAL_TO_RELATIVE': 'DATE_EQUAL_TO_RELATIVE',
+      'DATE_EQ_RELATIVE': 'DATE_EQUAL_TO_RELATIVE',
+      'NUMBER_BETWEEN': 'NUMBER_BETWEEN',
+      'NUMBER_NOT_BETWEEN': 'NUMBER_NOT_BETWEEN',
+      'NUMBER_EQ': 'NUMBER_EQUAL_TO',
+      'NUMBER_NOT_EQ': 'NUMBER_NOT_EQUAL_TO',
+      'NUMBER_GREATER': 'NUMBER_GREATER_THAN',
+      'NUMBER_GREATER_THAN_EQ': 'NUMBER_GREATER_THAN_OR_EQUAL_TO',
+      'NUMBER_LESS': 'NUMBER_LESS_THAN',
+      'NUMBER_LESS_THAN_EQ': 'NUMBER_LESS_THAN_OR_EQUAL_TO',
+      'TEXT_CONTAINS': 'TEXT_CONTAINS',
+      'TEXT_NOT_CONTAINS': 'TEXT_DOES_NOT_CONTAIN',
+      'TEXT_EQ': 'TEXT_EQUAL_TO',
+      'TEXT_NOT_EQ': 'TEXT_NOT_EQUAL_TO',
+      'TEXT_STARTS_WITH': 'TEXT_STARTS_WITH',
+      'TEXT_ENDS_WITH': 'TEXT_ENDS_WITH',
+      'CUSTOM_FORMULA': 'CUSTOM_FORMULA'
+    };
+
+    // If the API value contains RELATIVE properties it should probably be resolved to the _RELATIVE equivalents 
+    // However the API 'type' doesn't usually distinguish between DATE_EQ and DATE_EQUAL_TO_RELATIVE at the root level,
+    // they are often just DATE_EQ and the value object specifies if it's relative.
+    // Let's infer if it's relative.
+    let type = this.__apiCondition.type;
+    if (type && type.startsWith('DATE_')) {
+      const isRelative = this.__apiCondition.values && this.__apiCondition.values.some(v => v.relativeDate !== undefined);
+      if (isRelative && !type.endsWith('_RELATIVE')) {
+        type += '_RELATIVE';
+      }
+    }
+
+    const enumKey = map[type] || type;
+
+    // Return the Enum if available
+    if (BooleanCriteria[enumKey]) {
+      return BooleanCriteria[enumKey];
+    }
+    
+    return enumKey || null;
+  }
+
+  getCriteriaValues() {
+    if (!this.__apiCondition.values) return [];
+    
+    // API condition values are typically { userEnteredValue: 'string' } or { relativeDate: 'TODAY' }
+    return this.__apiCondition.values.map(v => {
+      if (v.userEnteredValue !== undefined) return v.userEnteredValue;
+      // In Apps Script, RelativeDate enum values are typically returned as strings matching the enum
+      if (v.relativeDate !== undefined) return SpreadsheetApp.RelativeDate[v.relativeDate] || v.relativeDate; 
+      return null;
+    });
+  }
+
+  getFontColorObject() {
+    if (this.__format.textFormat?.foregroundColorStyle) {
+      return makeColorFromApi(this.__format.textFormat.foregroundColorStyle);
+    }
+    if (this.__format.textFormat?.foregroundColor) {
+      return makeColorFromApi({ rgbColor: this.__format.textFormat.foregroundColor });
+    }
+    return null;
+  }
+
+  getItalic() {
+    return this.__format.textFormat?.italic ?? null;
+  }
+
+  getStrikethrough() {
+    return this.__format.textFormat?.strikethrough ?? null;
+  }
+
+  getUnderline() {
+    return this.__format.textFormat?.underline ?? null;
+  }
+
+  toString() {
+    return 'BooleanCondition';
+  }
+}

package/src/services/spreadsheetapp/fakecellimage.js

@@ -0,0 +1,42 @@
+import { Proxies } from "../../support/proxies.js";
+import { newFakeCellImageBuilder } from "./fakecellimagebuilder.js";
+
+/**
+ * Fake CellImage
+ * @class FakeCellImage
+ */
+export class FakeCellImage {
+  constructor(properties) {
+    this._properties = properties || {};
+  }
+
+  getAltTextDescription() {
+    return this._properties.altTextDescription || null;
+  }
+
+  getAltTextTitle() {
+    return this._properties.altTextTitle || null;
+  }
+
+  getContentUrl() {
+    const url = this._properties.sourceUrl || null;
+    if (url && !url.includes('googleusercontent.com')) {
+      throw new Error('Unexpected error while getting the method or property getContentUrl on object SpreadsheetApp.CellImage.');
+    }
+    return url;
+  }
+
+  toBuilder() {
+    const builder = newFakeCellImageBuilder();
+    if (this._properties.sourceUrl) builder.setSourceUrl(this._properties.sourceUrl);
+    if (this._properties.altTextTitle) builder.setAltTextTitle(this._properties.altTextTitle);
+    if (this._properties.altTextDescription) builder.setAltTextDescription(this._properties.altTextDescription);
+    return builder;
+  }
+
+  toString() {
+    return 'CellImage';
+  }
+}
+
+export const newFakeCellImage = (...args) => Proxies.guard(new FakeCellImage(...args));

package/src/services/spreadsheetapp/fakecellimagebuilder.js

@@ -0,0 +1,59 @@
+import { Proxies } from "../../support/proxies.js";
+import { newFakeCellImage } from "./fakecellimage.js";
+
+/**
+ * Fake CellImageBuilder
+ * @class FakeCellImageBuilder
+ */
+export class FakeCellImageBuilder {
+  constructor() {
+    this._properties = {};
+  }
+
+  build() {
+    return newFakeCellImage(this._properties);
+  }
+
+  getAltTextDescription() {
+    return this._properties.altTextDescription || null;
+  }
+
+  getAltTextTitle() {
+    return this._properties.altTextTitle || null;
+  }
+
+  getContentUrl() {
+    const url = this._properties.sourceUrl || null;
+    if (url && !url.includes('googleusercontent.com')) {
+      throw new Error('Unexpected error while getting the method or property getContentUrl on object SpreadsheetApp.CellImageBuilder.');
+    }
+    return url;
+  }
+
+  setAltTextDescription(description) {
+    this._properties.altTextDescription = description;
+    return this;
+  }
+
+  setAltTextTitle(title) {
+    this._properties.altTextTitle = title;
+    return this;
+  }
+
+  setSourceUrl(url) {
+    this._properties.sourceUrl = url;
+    return this;
+  }
+
+  toBuilder() {
+    const builder = newFakeCellImageBuilder();
+    builder._properties = { ...this._properties };
+    return builder;
+  }
+
+  toString() {
+    return 'CellImageBuilder';
+  }
+}
+
+export const newFakeCellImageBuilder = (...args) => Proxies.guard(new FakeCellImageBuilder(...args));

package/src/services/spreadsheetapp/fakeconditionalformatrule.js

@@ -0,0 +1,55 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeBooleanCondition } from './fakebooleancondition.js';
+import { newFakeGradientCondition } from './fakegradientcondition.js';
+import { newFakeSheetRange } from './fakesheetrange.js';
+import { newFakeConditionalFormatRuleBuilder } from './fakeconditionalformatrulebuilder.js';
+
+export const newFakeConditionalFormatRule = (...args) => {
+  return Proxies.guard(new FakeConditionalFormatRule(...args));
+};
+
+export class FakeConditionalFormatRule {
+  constructor(apiRule, sheet) {
+    this.__apiRule = apiRule;
+    this.__sheet = sheet;
+  }
+
+  copy() {
+    // Builder takes spreadsheet. Sheet gives us spreadsheet via getParent()
+    return newFakeConditionalFormatRuleBuilder(this.__apiRule, this.__sheet.getParent());
+  }
+
+  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 sheetId = gridRange.sheetId;
+      let sheet = this.__sheet; // Default to the sheet this rule was fetched from
+      if (sheetId !== undefined && sheet.getSheetId() !== sheetId) {
+        sheet = this.__sheet.getParent().getSheets().find(s => s.getSheetId() === sheetId);
+      }
+      
+      if (!sheet) return null;
+      return newFakeSheetRange(
+        gridRange,
+        sheet
+      );
+    }).filter(Boolean);
+  }
+
+  toString() {
+    return 'ConditionalFormatRule';
+  }
+}

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');