@switchbot/homebridge-switchbot 2.7.1-beta.0 → 2.7.1

package/src/irdevice/airconditioner.ts

@@ -1,7 +1,7 @@
+import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 import { request } from 'undici';
 import { SwitchBotPlatform } from '../platform';
-import { irDevicesConfig, irdevice, Devices } from '../settings';
-import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
+import { Devices, irDevicesConfig, irdevice } from '../settings';
 
 /**
  * Platform Accessory
@@ -19,8 +19,7 @@ export class AirConditioner {
   CurrentRelativeHumidity?: CharacteristicValue;
   TargetHeaterCoolerState!: CharacteristicValue;
   CurrentHeaterCoolerState!: CharacteristicValue;
-  HeatingThresholdTemperature!: CharacteristicValue;
-  CoolingThresholdTemperature!: CharacteristicValue;
+  ThresholdTemperature!: CharacteristicValue;
 
   // Others
   state!: string;
@@ -66,7 +65,7 @@ export class AirConditioner {
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
     (this.coolerService = accessory.getService(this.platform.Service.HeaterCooler) || accessory.addService(this.platform.Service.HeaterCooler)),
-    `${accessory.displayName} ${device.remoteType}`;
+      `${accessory.displayName} ${device.remoteType}`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
     // when creating multiple services of the same type, you need to use the following syntax to specify a name and subtype id:
@@ -80,18 +79,11 @@ export class AirConditioner {
     }
 
     // handle on / off events using the Active characteristic
-    this.coolerService.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
+    this.coolerService.getCharacteristic(this.platform.Characteristic.Active)
+      .onSet(this.ActiveSet.bind(this));
 
-    this.coolerService
-      .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
-      .setProps({
-        minValue: 0,
-        maxValue: 100,
-        minStep: 0.01,
-      })
-      .onGet(() => {
-        return this.CurrentTemperatureGet();
-      });
+    this.coolerService.getCharacteristic(this.platform.Characteristic.CurrentTemperature)
+      .onGet(this.CurrentTemperatureGet.bind(this));
 
     if (this.hide_automode) {
       this.TargetHeaterCoolerState = 1 || 2;
@@ -108,64 +100,46 @@ export class AirConditioner {
         ` hide_automode: ${this.hide_automode}, TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
       );
     }
+
     if (this.meter) {
       this.coolerService
-          .getCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity)
-          .setProps({
-              minStep: 0.1,
-          })
-          .onGet(() => {
-              return this.CurrentRelativeHumidityGet();
-          });
-  }
-    this.coolerService
-      .getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState)
+        .getCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity)
+        .onGet(this.CurrentRelativeHumidityGet.bind(this));
+    }
+
+    this.coolerService.getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState)
       .setProps({
         validValues: this.ValidValues,
       })
-      .onGet(async () => {
-        return this.TargetHeaterCoolerStateGet();
-      })
+      .onGet(this.TargetHeaterCoolerStateGet.bind(this))
       .onSet(this.TargetHeaterCoolerStateSet.bind(this));
 
-    this.coolerService.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).onGet(async () => {
-      return this.CurrentHeaterCoolerStateGet();
-    });
+    this.coolerService.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState)
+      .onGet(this.CurrentHeaterCoolerStateGet.bind(this));
 
-    this.coolerService
-      .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
+
+    this.coolerService.getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
       .setProps({
-        minValue: 16,
-        maxValue: 30,
-        minStep: 1,
+        minStep: 0.5,
       })
-      .onGet(() => {
-        return this.HeatingThresholdTemperatureGet();
-      })
-      .onSet(this.HeatingThresholdTemperatureSet.bind(this));
+      .onGet(this.ThresholdTemperatureGet.bind(this))
+      .onSet(this.ThresholdTemperatureSet.bind(this));
 
-    this.coolerService
-      .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
+    this.coolerService.getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
       .setProps({
-        minValue: 16,
-        maxValue: 30,
-        minStep: 1,
-      })
-      .onGet(() => {
-        return this.CoolingThresholdTemperatureGet();
+        minStep: 0.5,
       })
-      .onSet(this.CoolingThresholdTemperatureSet.bind(this));
+      .onGet(this.ThresholdTemperatureGet.bind(this))
+      .onSet(this.ThresholdTemperatureSet.bind(this));
 
-    this.coolerService
-      .getCharacteristic(this.platform.Characteristic.RotationSpeed)
+    this.coolerService.getCharacteristic(this.platform.Characteristic.RotationSpeed)
       .setProps({
+        format: "int",
         minStep: 1,
         minValue: 1,
         maxValue: 4,
       })
-      .onGet(async () => {
-        return this.RotationSpeedGet();
-      })
+      .onGet(this.RotationSpeedGet.bind(this))
       .onSet(this.RotationSpeedSet.bind(this));
   }
 
@@ -237,19 +211,20 @@ export class AirConditioner {
       this.state = 'off';
     }
     if (this.CurrentMode === 1) {
-      this.CurrentTemperature = 25;
+      // Remove or make configurable?
+      this.ThresholdTemperature = 25;
       this.debugLog(
         `${this.device.remoteType}: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},`
-        + ` CurrentTemperature: ${this.CurrentTemperature}`,
+        + ` ThresholdTemperature: ${this.ThresholdTemperature}`,
       );
     }
-    const parameter = `${this.CurrentTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
+    const parameter = `${this.ThresholdTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
 
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
       await this.context();
-      if (this.CurrentTemperature < this.accessory.context.CurrentTemperature) {
+      if (this.ThresholdTemperature < this.accessory.context.CurrentTemperature) {
         this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
-      } else if (this.CurrentTemperature > this.accessory.context.CurrentTemperature) {
+      } else if (this.ThresholdTemperature > this.accessory.context.CurrentTemperature) {
         this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
       }
     } else {
@@ -289,14 +264,16 @@ export class AirConditioner {
       this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
         + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` Connection Type: ${this.device.connectionType}, disablePushDetials: ${this.disablePushDetail}`);
+        + ` Connection Type: ${this.device.connectionType}, disablePushDetails: ${this.disablePushDetail}`);
       this.updateHomeKitCharacteristics();
     }
   }
 
   async CurrentTemperatureGet(): Promise<CharacteristicValue> {
-    if (this.meter?.context) {
-      this.CurrentTemperature = this.meter.context.CurrentTemperature;
+    if (this.meter) {
+      this.CurrentTemperature = this.meter.context?.CurrentTemperature
+        || this.meter.getService(this.platform.Service.TemperatureSensor)?.getCharacteristic(this.platform.Characteristic.CurrentTemperature).value
+        || 24;
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using CurrentTemperature from ${this.meter.context?.deviceType} (${this.meter.context?.deviceID})`)
     } else if (this.CurrentTemperature === undefined) {
       this.CurrentTemperature = 24;
@@ -308,24 +285,24 @@ export class AirConditioner {
   }
 
   async CurrentRelativeHumidityGet(): Promise<CharacteristicValue> {
-    if (this.meter?.context) {
-        this.CurrentRelativeHumidity = this.meter.context.CurrentRelativeHumidity;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using CurrentRelativeHumidity from ${this.meter.context?.deviceType} (${this.meter.context?.deviceID})`)
+    if (this.meter) {
+      this.CurrentRelativeHumidity = this.meter.context?.CurrentRelativeHumidity
+        || this.meter.getService(this.platform.Service.HumiditySensor)?.getCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity).value
+        || 0;
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using CurrentRelativeHumidity from ${this.meter.context?.deviceType} (${this.meter.context?.deviceID})`)
     }
     else if (this.CurrentRelativeHumidity === undefined) {
-        this.CurrentRelativeHumidity = 0;
+      this.CurrentRelativeHumidity = 0;
     }
     else {
-        this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity;
+      this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity;
     }
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
     return this.CurrentRelativeHumidity as CharacteristicValue;
-}
+  }
 
   async RotationSpeedGet(): Promise<number> {
-    if (!this.CurrentFanSpeed) {
-      this.RotationSpeed = 4;
-    } else if (this.CurrentFanSpeed === 1) {
+    if (!this.CurrentFanSpeed || this.CurrentFanSpeed === 1) {
       this.RotationSpeed = 4;
     } else {
       this.RotationSpeed = this.CurrentFanSpeed - 1;
@@ -385,30 +362,17 @@ export class AirConditioner {
   }
 
   async TargetHeaterCoolerStateSet(value: CharacteristicValue): Promise<void> {
-    if (this.hide_automode) {
-      if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
-        this.TargetHeaterCoolerStateHEAT();
-      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.COOL) {
-        this.TargetHeaterCoolerStateCOOL();
-      } else {
-        this.errorLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
-          ` hide_automode: ${this.hide_automode} `,
-        );
-      }
+    if (!this.hide_automode && value === this.platform.Characteristic.TargetHeaterCoolerState.AUTO) {
+      this.TargetHeaterCoolerStateAUTO();
+    } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
+      this.TargetHeaterCoolerStateHEAT();
+    } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.COOL) {
+      this.TargetHeaterCoolerStateCOOL();
     } else {
-      if (value === this.platform.Characteristic.TargetHeaterCoolerState.AUTO) {
-        this.TargetHeaterCoolerStateAUTO();
-      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
-        this.TargetHeaterCoolerStateHEAT();
-      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.COOL) {
-        this.TargetHeaterCoolerStateCOOL();
-      } else {
-        this.errorLog(
-          `${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
-          ` hide_automode: ${this.hide_automode} `,
-        );
-      }
+      this.errorLog(
+        `${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
+        ` hide_automode: ${this.hide_automode} `,
+      );
     }
     this.pushAirConditionerStatusChanges();
   }
@@ -436,11 +400,11 @@ export class AirConditioner {
 
   async CurrentHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
-      if (this.CurrentTemperature < this.accessory.context.CurrentTemperature) {
+      if (this.ThresholdTemperature < this.accessory.context.CurrentTemperature) {
         this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-          + ` Get (COOLLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-      } else if (this.CurrentTemperature > this.accessory.context.CurrentTemperature) {
+          + ` Get (COOLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+      } else if (this.ThresholdTemperature > this.accessory.context.CurrentTemperature) {
         this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
           + ` Get (HEATING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
@@ -453,29 +417,16 @@ export class AirConditioner {
     return this.CurrentHeaterCoolerState;
   }
 
-  async HeatingThresholdTemperatureGet(): Promise<CharacteristicValue> {
-    await this.context();
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
-    return this.HeatingThresholdTemperature;
-  }
-
-  async HeatingThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
-    this.CurrentTemperature = value;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set HeatingThresholdTemperature: ${this.HeatingThresholdTemperature},` +
-      ` CurrentTemperatureCached: ${this.accessory.context.CurrentTemperature}`);
-    this.pushAirConditionerStatusChanges();
-  }
-
-  async CoolingThresholdTemperatureGet(): Promise<CharacteristicValue> {
+  async ThresholdTemperatureGet(): Promise<CharacteristicValue> {
     await this.context();
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
-    return this.CoolingThresholdTemperature;
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.ThresholdTemperature}`);
+    return this.ThresholdTemperature;
   }
 
-  async CoolingThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
-    this.CurrentTemperature = value;
-    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set CoolingThresholdTemperature: ${this.CoolingThresholdTemperature},` +
-      ` CurrentTemperatureCached: ${this.accessory.context.CurrentTemperature}`);
+  async ThresholdTemperatureSet(value: CharacteristicValue): Promise<void> {
+    this.ThresholdTemperature = value;
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.ThresholdTemperature},` +
+      ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
     this.pushAirConditionerStatusChanges();
   }
 
@@ -503,14 +454,14 @@ export class AirConditioner {
     }
     if (this.meter) {
       if (this.CurrentRelativeHumidity === undefined) {
-          this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
       }
       else {
-          this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
-          this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
-          this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+        this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
+        this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
       }
-  }
+    }
     if (this.TargetHeaterCoolerState === undefined) {
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     } else {
@@ -530,24 +481,15 @@ export class AirConditioner {
         + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
       );
     }
-    if (this.HeatingThresholdTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
-    } else {
-      this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperature;
-      this.coolerService?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
-      this.debugLog(
-        `${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`,
-      );
-    }
-    if (this.CoolingThresholdTemperature === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
+    if (this.ThresholdTemperature === undefined) {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.ThresholdTemperature}`);
     } else {
-      this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperature;
-      this.coolerService?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
+      this.accessory.context.ThresholdTemperature = this.ThresholdTemperature;
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.ThresholdTemperature);
+      this.coolerService?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.ThresholdTemperature);
       this.debugLog(
         `${this.device.remoteType}: ${this.accessory.displayName}`
-        + ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`,
+        + ` updateCharacteristic ThresholdTemperature: ${this.ThresholdTemperature}`,
       );
     }
   }
@@ -646,6 +588,7 @@ export class AirConditioner {
     this.coolerService.updateCharacteristic(this.platform.Characteristic.Active, e);
     this.coolerService.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
     this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
+    this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, e);
     this.coolerService.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
     this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
     this.coolerService.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
@@ -686,12 +629,8 @@ export class AirConditioner {
       this.CurrentTemperature = this.accessory.context.CurrentTemperature;
     }
 
-    if (this.CoolingThresholdTemperature === undefined) {
-      this.CoolingThresholdTemperature = this.CurrentTemperature;
-    }
-
-    if (this.HeatingThresholdTemperature === undefined) {
-      this.HeatingThresholdTemperature = this.CurrentTemperature;
+    if (this.ThresholdTemperature === undefined) {
+      this.ThresholdTemperature = 24;
     }
 
     if (this.device.irair?.hide_automode) {
@@ -701,17 +640,17 @@ export class AirConditioner {
       this.hide_automode = this.device.irair?.hide_automode;
       this.accessory.context.hide_automode = this.hide_automode;
     }
-    
+
     if (this.device.irair?.meterUuid) {
-      this.meter = this.platform.accessories.find((accessory) => accessory.UUID === this.device.irair?.meterUuid)
+      this.meter = this.platform.accessories.find((accessory) => accessory.UUID === this.device.irair?.meterUuid);
     }
     if (this.meter) {
       if (this.CurrentRelativeHumidity === undefined) {
-          this.CurrentRelativeHumidity = 0;
+        this.CurrentRelativeHumidity = 0;
       } else {
-          this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity;
+        this.CurrentRelativeHumidity = this.accessory.context.CurrentRelativeHumidity;
       }
-  }
+    }
   }
 
   async config({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
@@ -783,10 +722,8 @@ export class AirConditioner {
   }
 
   debugWarnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging?.includes('debug')) {
-        this.platform.log.warn('[DEBUG]', String(...log));
-      }
+    if (this.enablingDeviceLogging() && this.deviceLogging?.includes('debug')) {
+      this.platform.log.warn('[DEBUG]', String(...log));
     }
   }
 
@@ -797,10 +734,8 @@ export class AirConditioner {
   }
 
   debugErrorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging?.includes('debug')) {
-        this.platform.log.error('[DEBUG]', String(...log));
-      }
+    if (this.enablingDeviceLogging() && this.deviceLogging?.includes('debug')) {
+      this.platform.log.error('[DEBUG]', String(...log));
     }
   }
 

package/.github/npm-version-script.js

@@ -1,81 +0,0 @@
-#!/bin/env node
-
-/**
- * This scripts queries the npm registry to pull out the latest version for a given tag.
- */
-
-const fs = require("fs");
-const semver = require("semver");
-const child_process = require("child_process");
-const assert = require("assert");
-
-const BRANCH_VERSION_PATTERN = /^([A-Za-z]*)-(\d+.\d+.\d+)$/
-
-// Load the contents of the package.json file
-const packageJSON = JSON.parse(fs.readFileSync("package.json", "utf8"));
-
-let refArgument = process.argv[2];
-let tagArgument = process.argv[3] || "latest";
-
-if (refArgument == null) {
-  console.error("ref argument is missing");
-  console.error("Usage: npm-version-script.js <ref> [tag]");
-  process.exit(1);
-}
-
-/**
- * Queries the NPM registry for the latest version for the provided tag.
- * @param tag The tag to query for.
- * @returns {string} Returns the version.
- */
-function getTagVersionFromNpm(tag) {
-  try {
-    return child_process.execSync(`npm info ${packageJSON.name} version --tag="${tag}"`).toString("utf8").trim();
-  } catch (e) {
-    throw e;
-  }
-}
-
-function desiredTargetVersion(ref) {
-  // ref is a GitHub action ref string
-  if (ref.startsWith("refs/pull/")) {
-    throw Error("The version script was executed inside a PR!");
-  }
-
-  assert(ref.startsWith("refs/heads/"))
-  let branchName = ref.slice("refs/heads/".length);
-
-  let results = branchName.match(BRANCH_VERSION_PATTERN);
-  if (results != null) {
-    if (results[1] !== tagArgument) {
-      console.warn(`The base branch name (${results[1]}) differs from the tag name ${tagArgument}`);
-    }
-
-    return results[2];
-  }
-
-  // legacy mode were we use the `betaVersion` property in the package.json
-  if (branchName === "beta" && packageJSON.betaVersion) {
-    return packageJSON.betaVersion
-  }
-
-  throw new Error("Malformed branch name for ref: " + ref + ". Can't derive the base version. Use a branch name like: beta-x.x.x!");
-}
-
-// derive the base version from the branch ref
-const baseVersion = desiredTargetVersion(refArgument);
-
-// query the npm registry for the latest version of the provided tag name
-const latestReleasedVersion = getTagVersionFromNpm(tagArgument); // e.g. 0.7.0-beta.12
-const latestReleaseBase = semver.inc(latestReleasedVersion, "patch"); // will produce 0.7.0 (removing the preid, needed for the equality check below)
-
-let publishTag;
-if (semver.eq(baseVersion, latestReleaseBase)) { // check if we are releasing another version for the latest beta
-  publishTag = latestReleasedVersion; // set the current latest beta to be incremented
-} else {
-  publishTag = baseVersion; // start of with a new beta version
-}
-
-// save the package.json
-packageJSON.version = publishTag;
-fs.writeFileSync("package.json", JSON.stringify(packageJSON, null, 2));