@teslemetry/api 0.4.0 → 0.5.1

package/dist/index.cjs

@@ -3009,6 +3009,10 @@ var TeslemetryVehicleStream = class extends events.EventEmitter {
 			this.fields = event.config.fields;
 		});
 	}
+	on(event, listener) {
+		this.root.sse.sendCache(this.vin, event, listener);
+		return super.on(event, listener);
+	}
 	/** Get the current configuration for the vehicle */
 	async getConfig() {
 		const { data, response } = await getApiConfigByVin({ path: { vin: this.vin } });
@@ -3080,6 +3084,8 @@ var TeslemetryVehicleStream = class extends events.EventEmitter {
 		this.addField(field).catch((error) => {
 			this.logger.error(`Failed to add field ${field}:`, error);
 		});
+		const data = this.root.sse.cache?.[this.vin]?.data?.[field];
+		if (data !== void 0) callback(data);
 		this.data.on(field, callback);
 		return () => this.data.off(field, callback);
 	}
@@ -3096,16 +3102,69 @@ var TeslemetryStream = class extends events.EventEmitter {
 	active = false;
 	connected = false;
 	vin;
-	cache;
+	cache = {};
+	cloudCache;
+	localCache;
 	logger;
 	vehicles = /* @__PURE__ */ new Map();
 	constructor(root, options) {
 		super();
 		this.root = root;
 		this.vin = options?.vin;
-		this.cache = options?.cache;
+		if (typeof options?.cache === "boolean") {
+			this.cloudCache = options.cache;
+			this.localCache = options.cache;
+		} else {
+			this.cloudCache = options?.cache?.cloud;
+			this.localCache = options?.cache?.local;
+		}
 		this.logger = root.logger;
 		if (this.vin) this.getVehicle(this.vin);
+		if (this.localCache) this.startLocalCache();
+	}
+	sendCache(vin, event, listener) {
+		if (this.cache) {
+			const vehicleCache = this.cache[vin];
+			if (event === "connectivity" && vehicleCache.connectivity) for (const networkInterface in vehicleCache.connectivity) {
+				const typedNetworkInterface = networkInterface;
+				const status = vehicleCache.connectivity[typedNetworkInterface];
+				if (status !== void 0) listener({
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					vin,
+					networkInterface: typedNetworkInterface,
+					status,
+					isCache: true
+				});
+			}
+			else if (event === "state" && vehicleCache.state) listener({
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				vin,
+				state: vehicleCache.state,
+				isCache: true
+			});
+			else if (event === "data" && vehicleCache.data) listener({
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				vin,
+				data: vehicleCache.data,
+				isCache: true
+			});
+			else if (event === "errors" && vehicleCache.errors) listener({
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				vin,
+				errors: vehicleCache.errors,
+				isCache: true
+			});
+			else if (event === "alerts" && vehicleCache.alerts) listener({
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				vin,
+				alerts: vehicleCache.alerts,
+				isCache: true
+			});
+		}
+	}
+	on(event, listener) {
+		for (const vin in this.cache) this.sendCache(vin, event, listener);
+		return super.on(event, listener);
 	}
 	getVehicle(vin) {
 		if (!this.vehicles.has(vin)) new TeslemetryVehicleStream(this.root, vin);
@@ -3122,7 +3181,7 @@ var TeslemetryStream = class extends events.EventEmitter {
 			const sse = await getSseByVin_({
 				client: this.root.client,
 				path: { vin: this.vin || "" },
-				query: { cache: this.cache }
+				query: { cache: this.cloudCache }
 			});
 			this.logger.info(`Connected to stream`);
 			retries = 0;
@@ -3181,6 +3240,48 @@ var TeslemetryStream = class extends events.EventEmitter {
 			else if ("config" in event) vehicle.emit("config", event);
 		}
 	}
+	cacheState(event) {
+		this.cache[event.vin] ??= {};
+		this.cache[event.vin].state = event.state;
+	}
+	cacheData(event) {
+		this.cache[event.vin] ??= { data: {} };
+		this.cache[event.vin].data = {
+			...this.cache[event.vin].data,
+			...event.data
+		};
+	}
+	cacheErrors(event) {
+		this.cache[event.vin] ??= {};
+		this.cache[event.vin].errors = event.errors;
+	}
+	cacheAlerts(event) {
+		this.cache[event.vin] ??= {};
+		this.cache[event.vin].alerts = event.alerts;
+	}
+	cacheConnectivity(event) {
+		this.cache[event.vin] ??= {};
+		this.cache[event.vin].connectivity ??= {};
+		this.cache[event.vin].connectivity[event.networkInterface] = event.status;
+	}
+	startLocalCache() {
+		this.localCache = true;
+		this.on("state", this.cacheState);
+		this.on("data", this.cacheData);
+		this.on("errors", this.cacheErrors);
+		this.on("alerts", this.cacheAlerts);
+		this.on("connectivity", this.cacheConnectivity);
+		this.logger.info(`Started local cache`);
+	}
+	stopLocalCache() {
+		this.localCache = false;
+		this.off("state", this.cacheState);
+		this.off("data", this.cacheData);
+		this.off("errors", this.cacheErrors);
+		this.off("alerts", this.cacheAlerts);
+		this.off("connectivity", this.cacheConnectivity);
+		this.logger.info(`Stopped local cache`);
+	}
 };
 
 //#endregion
@@ -3245,6 +3346,15 @@ var TeslemetryChargingApi = class {
 var TeslemetryEnergyApi = class extends events.EventEmitter {
 	root;
 	siteId;
+	refreshDelay = 3e4;
+	refreshInterval = {
+		siteInfo: null,
+		liveStatus: null
+	};
+	refreshClients = {
+		siteInfo: /* @__PURE__ */ new Set(),
+		liveStatus: /* @__PURE__ */ new Set()
+	};
 	constructor(root, siteId) {
 		if (root.api.energySites.has(siteId)) throw new Error("Energy site already exists");
 		super();
@@ -3386,6 +3496,34 @@ var TeslemetryEnergyApi = class extends events.EventEmitter {
 		});
 		return data;
 	}
+	requestPolling(endpoint) {
+		if (!this.refreshInterval[endpoint]) switch (endpoint) {
+			case "siteInfo":
+				this.refreshInterval[endpoint] = setInterval(() => {
+					this.getSiteInfo();
+				}, this.refreshDelay);
+				this.getSiteInfo();
+				break;
+			case "liveStatus":
+				this.refreshInterval[endpoint] = setInterval(() => {
+					this.getLiveStatus();
+				}, this.refreshDelay);
+				this.getLiveStatus();
+				break;
+			default: throw new Error(`Invalid endpoint: ${endpoint}`);
+		}
+		const symbol = Symbol("refreshClient");
+		this.refreshClients[endpoint].add(symbol);
+		return () => {
+			this.refreshClients[endpoint].delete(symbol);
+			if (this.refreshClients[endpoint].size === 0) {
+				if (this.refreshInterval[endpoint]) {
+					clearInterval(this.refreshInterval[endpoint]);
+					this.refreshInterval[endpoint] = null;
+				}
+			}
+		};
+	}
 };
 
 //#endregion
@@ -4907,7 +5045,7 @@ const consoleLogger = {
 
 //#endregion
 //#region package.json
-var version = "0.4.0";
+var version = "0.5.1";
 
 //#endregion
 //#region src/Teslemetry.ts
@@ -4968,27 +5106,25 @@ var Teslemetry = class {
 	* @returns A promise that resolves to an object containing vehicle and energy site names, API, and SSE instances.
 	*/
 	async createProducts() {
-		const { data } = await getApi1Products({ client: this.client });
-		const result = {
-			vehicles: {},
-			energySites: {}
+		const { data } = await getApiMetadata({ client: this.client });
+		return {
+			vehicles: Object.fromEntries(Object.entries(data.vehicles).map(([vin, metadata]) => [vin, {
+				name: metadata.name ?? useTeslaModel(vin),
+				vin,
+				api: this.api.getVehicle(vin),
+				sse: this.sse.getVehicle(vin),
+				metadata
+			}])),
+			energySites: Object.fromEntries(Object.entries(data.energy_sites ?? {}).map(([id, metadata]) => {
+				const siteId = Number(id);
+				return [id, {
+					name: metadata.name ?? "Unnamed",
+					id: siteId,
+					api: this.api.getEnergySite(siteId),
+					metadata
+				}];
+			}))
 		};
-		data.response?.forEach((product) => {
-			if (product.device_type === "vehicle") result.vehicles[product.vin] = {
-				name: product.display_name ?? useTeslaModel(product.vin),
-				vin: product.vin,
-				api: this.api.getVehicle(product.vin),
-				sse: this.sse.getVehicle(product.vin),
-				product
-			};
-			if (product.device_type === "energy") result.energySites[product.energy_site_id] = {
-				name: product.site_name ?? "Unnamed",
-				site: product.energy_site_id,
-				api: this.api.getEnergySite(product.energy_site_id),
-				product
-			};
-		});
-		return result;
 	}
 	/**
 	* Get a vehicle API instance for the specified VIN.