@glasshome/sync-layer 0.8.2 → 0.9.1

package/dist/{service-C8H42I-Q.d.ts → service-B1gegd-N.d.ts}

@@ -1,4 +1,4 @@
-import { AreaEntry, DeviceEntry, Domain, EntityCategory, EntityRegistryEntry, ServiceCall, ServiceName, WsCommandType } from "@glasshome/ha-types";
+import { AreaEntry, DeviceEntry, Domain, EntityCategory, ServiceCall, ServiceName, WsCommandType } from "@glasshome/ha-types";
 //#region src/core/types.d.ts
 /**
  * Unique entity identifier (e.g., "light.living_room")
@@ -436,7 +436,7 @@ declare function updateEntity(entityId: EntityId, updates: EntityUpdateFields):
  * Send a generic WebSocket command
  */
 declare function sendCommand<T = unknown>(command: {
-  type: WsCommandType | string;
+  type: WsCommandType | (string & {});
   [key: string]: unknown;
 }): Promise<T>;
 /**

package/dist/solid/index.d.ts

@@ -1,7 +1,7 @@
-import { a as toggle, g as CalendarWindowOptions, h as CalendarEventsData, o as turnOff, r as callService, s as turnOn } from "../service-C8H42I-Q.js";
+import { a as toggle, g as CalendarWindowOptions, h as CalendarEventsData, o as turnOff, r as callService, s as turnOn } from "../service-B1gegd-N.js";
 import { Accessor, Resource } from "solid-js";
 import { HassConfig, HassUnitSystem } from "@glasshome/ha-types";
-import { AreaView, CameraStreamData, ConnectionState, EntityHistoryData, EntityView, GlassHomeState, HassEntity, StatisticValue, StatisticsQueryOptions, WeatherForecastsData } from "@glasshome/sync-layer";
+import { AreaView, CameraStreamData, ConnectionState, EntityHistoryData, EntityView, ForecastType, GlassHomeState, HassEntity, StatisticValue, StatisticsQueryOptions, WeatherForecastsData } from "@glasshome/sync-layer";
 //#region src/solid/hooks.d.ts
 /**
  * Get a reactive EntityView for an entity ID.
@@ -96,9 +96,10 @@ declare function useCamera(entityId: Accessor<string> | string): {
  */
 declare function useCalendarEvents(entityId: Accessor<string> | string, options?: CalendarWindowOptions): Accessor<CalendarEventsData | undefined>;
 /**
- * Get reactive weather forecast data.
+ * Get reactive weather forecast data. With `types`, the forecast stays live
+ * while the caller is mounted: Home Assistant pushes each new one, no polling.
  */
-declare function useForecast(entityId: Accessor<string> | string): Accessor<WeatherForecastsData | undefined>;
+declare function useForecast(entityId: Accessor<string> | string, types?: ForecastType[]): Accessor<WeatherForecastsData | undefined>;
 /**
  * Escape hatch for direct store access with a selector.
  *

package/dist/solid/index.js

@@ -1,5 +1,107 @@
-import { A as extractDomain, B as state, I as trackCalendarEvents, L as privilegedConn, M as registerEntity, _ as turnOff, c as entityViewEquals, g as toggle, m as callService, o as getAreaViews, r as buildAreaView, t as fetchStatisticsDuringPeriod, u as getEntityView, v as turnOn, x as isDemoMode } from "../statistics-DyCCTwv2.js";
+import { B as registerEntity, G as setState, I as getEntityView, K as state, M as getAreaViews, P as entityViewEquals, R as extractDomain, U as privilegedConn, f as callService, g as turnOn, h as turnOff, k as buildAreaView, m as toggle, n as trackCalendarEvents, r as buildDemoForecast, s as fetchStatisticsDuringPeriod, y as isDemoMode } from "../track-IkwP6XmO.js";
+import { produce } from "solid-js/store";
 import { createEffect, createMemo, createResource, onCleanup } from "solid-js";
+//#region src/weather/track.ts
+/**
+* Ref-counted live forecasts, the weather analog of `calendar/track`. Each
+* tracked (entity, type) holds one `weather/subscribe_forecast`; Home Assistant
+* pushes the current forecast, then every new one. Data lands in
+* `state.forecasts`, the same place `getForecasts` writes.
+*/
+/** Debounce for untrack, so dashboard switches don't churn subscriptions. */
+const UNTRACK_FLUSH_DELAY_MS = 5e3;
+const counts = /* @__PURE__ */ new Map();
+const active = /* @__PURE__ */ new Map();
+const chains = /* @__PURE__ */ new Map();
+let untrackTimer = null;
+const keyOf = (entityId, type) => `${entityId}|${type}`;
+function parse(key) {
+	const i = key.lastIndexOf("|");
+	return [key.slice(0, i), key.slice(i + 1)];
+}
+/**
+* Keep a forecast live while tracked. Returns the untrack function. Safe while
+* disconnected: the subscription starts on the next `forceResubscribeForecasts()`.
+*/
+function trackForecast(entityId, type) {
+	const key = keyOf(entityId, type);
+	counts.set(key, (counts.get(key) ?? 0) + 1);
+	queueMicrotask(() => {
+		reconcile$1(key);
+	});
+	let untracked = false;
+	return () => {
+		if (untracked) return;
+		untracked = true;
+		const n = (counts.get(key) ?? 1) - 1;
+		if (n > 0) counts.set(key, n);
+		else counts.delete(key);
+		if (untrackTimer) return;
+		untrackTimer = setTimeout(() => {
+			untrackTimer = null;
+			flushAll();
+		}, UNTRACK_FLUSH_DELAY_MS);
+	};
+}
+async function flushAll() {
+	const keys = /* @__PURE__ */ new Set([...counts.keys(), ...active.keys()]);
+	await Promise.all([...keys].map(reconcile$1));
+}
+function reconcile$1(key) {
+	const next = (chains.get(key) ?? Promise.resolve()).then(() => runReconcile(key));
+	chains.set(key, next.catch(() => {}));
+	return next;
+}
+function write(entityId, type, forecast, error) {
+	setState(produce((s) => {
+		const rec = s.forecasts[entityId] ??= {
+			entityId,
+			forecasts: {},
+			loading: {},
+			errors: {},
+			lastFetched: {}
+		};
+		if (forecast) {
+			rec.forecasts[type] = forecast;
+			rec.lastFetched[type] = Date.now();
+		}
+		rec.loading[type] = false;
+		rec.errors[type] = error;
+	}));
+}
+async function runReconcile(key) {
+	const [entityId, type] = parse(key);
+	const current = active.get(key);
+	if (!counts.has(key)) {
+		active.delete(key);
+		chains.delete(key);
+		try {
+			await current?.unsub?.();
+		} catch {}
+		return;
+	}
+	if (current?.unsub) return;
+	if (isDemoMode()) {
+		active.set(key, { unsub: () => {} });
+		write(entityId, type, buildDemoForecast(entityId, type), null);
+		return;
+	}
+	const conn = privilegedConn();
+	if (!conn) return;
+	const entry = { unsub: null };
+	active.set(key, entry);
+	try {
+		entry.unsub = await conn.subscribeMessage((msg) => write(entityId, type, Array.isArray(msg?.forecast) ? msg.forecast : [], null), {
+			type: "weather/subscribe_forecast",
+			entity_id: entityId,
+			forecast_type: type
+		});
+	} catch (err) {
+		active.delete(key);
+		write(entityId, type, null, err instanceof Error ? err : new Error(String(err)));
+	}
+}
+//#endregion
 //#region src/solid/hooks.ts
 /**
 * SolidJS Hooks for Sync-Layer
@@ -228,10 +330,16 @@ function useCalendarEvents(entityId, options) {
 	return createMemo(() => state.calendars[getId()]);
 }
 /**
-* Get reactive weather forecast data.
+* Get reactive weather forecast data. With `types`, the forecast stays live
+* while the caller is mounted: Home Assistant pushes each new one, no polling.
 */
-function useForecast(entityId) {
+function useForecast(entityId, types) {
 	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	createEffect(() => {
+		const id = getId();
+		if (!id || !types) return;
+		for (const type of types) onCleanup(trackForecast(id, type));
+	});
 	return createMemo(() => state.forecasts[getId()]);
 }
 /**