@glasshome/sync-layer 0.1.0

package/dist/query/area-builder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Area Query Builder
+ *
+ * Fluent API for filtering and querying areas.
+ *
+ * @packageDocumentation
+ */
+import type { AreaId, AreaView, Callback, FloorId, LabelId, PredicateFunc, UnsubscribeFunc } from "../core/types";
+export interface AreaQueryBuilder {
+    byFloor(floorId: FloorId): AreaQueryBuilder;
+    byLabel(labelId: LabelId): AreaQueryBuilder;
+    where(predicate: PredicateFunc<AreaView>): AreaQueryBuilder;
+    orderBy(key: keyof AreaView | string, direction?: "asc" | "desc"): AreaQueryBuilder;
+    get(): AreaView[];
+    first(): AreaView | undefined;
+    subscribe(callback: Callback<AreaView[]>): UnsubscribeFunc;
+}
+/**
+ * Create a query builder for areas
+ */
+export declare function areas(): AreaQueryBuilder;
+/**
+ * Create a query for a single area
+ */
+export declare function area(areaId: AreaId): AreaView | undefined;

package/dist/query/builder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Query Builder
+ *
+ * Fluent API for filtering, sorting, projecting, and subscribing to entities.
+ *
+ * @packageDocumentation
+ */
+import type { EntityId, EntityView } from "../core/types";
+import type { EntitiesQueryBuilder, EntityQueryBuilder } from "./types";
+/**
+ * Create a query builder for multiple entities
+ */
+export declare function entities(): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query builder for a single entity
+ */
+export declare function entity(entityId: EntityId): EntityQueryBuilder;
+export type { EntitiesQueryBuilder, EntityQueryBuilder, UnsubscribeFunc } from "./types";

package/dist/query/helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Query Engine Helpers
+ *
+ * Helper functions to make query engine usage easier and more intuitive.
+ *
+ * @packageDocumentation
+ */
+import type { AreaId, EntityDomain, EntityView } from "../core/types";
+import type { EntitiesQueryBuilder } from "./types";
+/**
+ * Create a search query builder
+ */
+export declare function searchEntities(searchText: string): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query for entities in an area by domain
+ */
+export declare function entitiesByAreaAndDomain(areaId: AreaId, domain: EntityDomain): EntitiesQueryBuilder<EntityView>;
+/**
+ * Create a query for entities matching a predicate
+ */
+export declare function entitiesWhere(predicate: (entity: EntityView) => boolean): EntitiesQueryBuilder<EntityView>;

package/dist/query/memoization.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Query memoization
+ *
+ * @packageDocumentation
+ */
+import type { QueryState } from "./types";
+/**
+ * Build a unique signature for a query
+ */
+export declare function buildQuerySignature(query: QueryState): string;
+/**
+ * Execute query (no caching -- SolidJS createMemo handles this in Plan 03)
+ */
+export declare function memoizedExecute<T>(signature: string, compute: () => T): T;
+/**
+ * Check if cache should be invalidated
+ */
+export declare function isCacheStale(lastCheck: number, maxAge: number): boolean;

package/dist/query/projections.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Projection utilities
+ *
+ * Functions for transforming entity views into different shapes.
+ *
+ * @packageDocumentation
+ */
+import type { EntityId, EntityView, MapFunc } from "../core/types";
+/**
+ * Project entities to IDs only
+ *
+ * @param entities - Array of entity views
+ * @returns Array of entity IDs
+ */
+export declare function projectToIds(entities: EntityView[]): EntityId[];
+/**
+ * Pick specific fields from entities
+ *
+ * @param entities - Array of entity views
+ * @param keys - Array of field names to include
+ * @returns Array of objects with only specified fields
+ */
+export declare function projectPick<K extends keyof EntityView>(entities: EntityView[], keys: K[]): Pick<EntityView, K>[];
+/**
+ * Pluck a single field from entities
+ *
+ * Supports dot-notation for nested fields (e.g., "attributes.brightness")
+ *
+ * @param entities - Array of entity views
+ * @param key - Field name or dot-path to extract
+ * @returns Array of field values
+ */
+export declare function projectPluck(entities: EntityView[], key: string): any[];
+/**
+ * Map entities using a custom function
+ *
+ * @param entities - Array of entity views
+ * @param mapper - Function to transform each entity
+ * @returns Array of mapped values
+ */
+export declare function projectMap<R>(entities: EntityView[], mapper: MapFunc<EntityView, R>): R[];
+/**
+ * Get nested value from object using dot-notation
+ *
+ * @param obj - Object to extract value from
+ * @param path - Dot-notation path (e.g., "attributes.brightness")
+ * @returns Value at path or undefined
+ *
+ * @example
+ * ```typescript
+ * const entity = { attributes: { brightness: 255 } };
+ * getNestedValue(entity, "attributes.brightness"); // 255
+ * ```
+ */
+export declare function getNestedValue(obj: any, path: string): any;
+/**
+ * Set nested value in object using dot-notation
+ *
+ * @param obj - Object to set value in
+ * @param path - Dot-notation path
+ * @param value - Value to set
+ *
+ * @internal
+ */
+export declare function setNestedValue(obj: any, path: string, value: any): void;
+/**
+ * Check if a value is a primitive
+ *
+ * @param value - Value to check
+ * @returns True if primitive
+ *
+ * @internal
+ */
+export declare function isPrimitive(value: any): boolean;

package/dist/query/types.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Query-related types
+ *
+ * Type definitions for the query builder system.
+ *
+ * @packageDocumentation
+ */
+import type { AreaId, AreaView, Callback, DeviceId, EntityDomain, EntityId, EntityView, FloorId, LabelId, MapFunc, PredicateFunc, UnsubscribeFunc } from "../core/types";
+export type { UnsubscribeFunc };
+/**
+ * Main query builder interface for multiple entities
+ *
+ * Provides a fluent API for filtering, sorting, projecting, and subscribing.
+ *
+ * @template T - The result type (defaults to EntityView)
+ */
+export interface EntitiesQueryBuilder<T = EntityView> {
+    /**
+     * Filter by area
+     *
+     * @param areaId - Area ID to filter by
+     * @returns Query builder for chaining
+     */
+    byArea(areaId: AreaId): EntitiesQueryBuilder<T>;
+    /**
+     * Filter by domain
+     *
+     * @param domain - Domain to filter by (e.g., "light", "sensor")
+     * @returns Query builder for chaining
+     */
+    byDomain(domain: EntityDomain): EntitiesQueryBuilder<T>;
+    /**
+     * Filter by device
+     *
+     * @param deviceId - Device ID to filter by
+     * @returns Query builder for chaining
+     */
+    byDevice(deviceId: DeviceId): EntitiesQueryBuilder<T>;
+    /**
+     * Filter by floor
+     *
+     * @param floorId - Floor ID to filter by
+     * @returns Query builder for chaining
+     */
+    byFloor(floorId: FloorId): EntitiesQueryBuilder<T>;
+    /**
+     * Filter by label
+     *
+     * @param labelId - Label ID to filter by
+     * @returns Query builder for chaining
+     */
+    byLabel(labelId: LabelId): EntitiesQueryBuilder<T>;
+    /**
+     * Filter with custom predicate
+     *
+     * @param predicate - Function to test each entity
+     * @returns Query builder for chaining
+     */
+    where(predicate: PredicateFunc<EntityView>): EntitiesQueryBuilder<T>;
+    /**
+     * Search entities by text (searches id, name, friendlyName)
+     *
+     * @param searchText - Text to search for
+     * @returns Query builder for chaining
+     */
+    search(searchText: string): EntitiesQueryBuilder<T>;
+    /**
+     * Sort results
+     *
+     * @param key - Property key or dot-path (e.g., "name", "attributes.brightness")
+     * @param direction - Sort direction ("asc" or "desc")
+     * @returns Query builder for chaining
+     */
+    orderBy(key: string, direction?: "asc" | "desc"): EntitiesQueryBuilder<T>;
+    /**
+     * Project to entity IDs only
+     *
+     * @returns Query builder for entity IDs
+     */
+    ids(): EntitiesQueryBuilder<EntityId>;
+    /**
+     * Pick specific fields
+     *
+     * @param keys - Array of field names to include
+     * @returns Query builder with picked fields
+     */
+    pick<K extends keyof EntityView>(keys: K[]): EntitiesQueryBuilder<Pick<EntityView, K>>;
+    /**
+     * Extract a single field from each entity
+     *
+     * @param key - Field name to extract
+     * @returns Query builder for field values
+     */
+    pluck<K extends keyof EntityView>(key: K): EntitiesQueryBuilder<EntityView[K]>;
+    /**
+     * Map entities to new values
+     *
+     * @param mapper - Function to transform each entity
+     * @returns Query builder for mapped values
+     */
+    map<R>(mapper: MapFunc<EntityView, R>): EntitiesQueryBuilder<R>;
+    /**
+     * Limit the number of results
+     *
+     * @param limit - Maximum number of results to return
+     * @returns Query builder for chaining
+     */
+    take(limit: number): EntitiesQueryBuilder<T>;
+    /**
+     * Skip a number of results (for pagination)
+     *
+     * @param count - Number of results to skip
+     * @returns Query builder for chaining
+     */
+    skip(count: number): EntitiesQueryBuilder<T>;
+    /**
+     * Get distinct values by a key
+     *
+     * @param key - Field name or dot-path to get distinct values for
+     * @returns Query builder for distinct values
+     */
+    distinct(key: string): EntitiesQueryBuilder<T>;
+    /**
+     * Execute query and return results
+     *
+     * @returns Array of results
+     */
+    get(): T[];
+    /**
+     * Get first result
+     *
+     * @returns First result or undefined
+     */
+    first(): T | undefined;
+    /**
+     * Subscribe to query results
+     *
+     * Receives updates when entities matching the query change.
+     *
+     * @param callback - Function called with results
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: Callback<T[]>): UnsubscribeFunc;
+}
+/**
+ * Query builder interface for areas
+ */
+export interface AreaQueryBuilder {
+    /**
+     * Filter areas by floor
+     */
+    byFloor(floorId: FloorId): AreaQueryBuilder;
+    /**
+     * Filter areas by label
+     */
+    byLabel(labelId: LabelId): AreaQueryBuilder;
+    /**
+     * Filter areas using a predicate
+     */
+    where(predicate: PredicateFunc<AreaView>): AreaQueryBuilder;
+    /**
+     * Order results by a key
+     */
+    orderBy(key: keyof AreaView | string, direction?: "asc" | "desc"): AreaQueryBuilder;
+    /**
+     * Execute query and get results
+     */
+    get(): AreaView[];
+    /**
+     * Get first result
+     */
+    first(): AreaView | undefined;
+    /**
+     * Subscribe to query results
+     */
+    subscribe(callback: Callback<AreaView[]>): UnsubscribeFunc;
+}
+/**
+ * Query builder interface for a single entity
+ */
+export interface EntityQueryBuilder {
+    /**
+     * Get entity view
+     *
+     * @returns Entity view or undefined
+     */
+    get(): EntityView | undefined;
+    /**
+     * Extract a single field
+     *
+     * @param key - Field name to extract
+     * @returns Field value or undefined
+     */
+    pluck<K extends keyof EntityView>(key: K): EntityView[K] | undefined;
+    /**
+     * Subscribe to entity changes
+     *
+     * @param callback - Function called with entity view
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: Callback<EntityView | undefined>): UnsubscribeFunc;
+}
+/**
+ * Internal query state (not exported)
+ *
+ * @internal
+ */
+export interface QueryState {
+    /** Index-based filters (use indices for fast lookup) */
+    indexFilters: IndexFilter[];
+    /** Predicate-based filters (run on each entity) */
+    predicateFilters: PredicateFunc<EntityView>[];
+    /** Sort functions */
+    sorts: SortConfig[];
+    /** Projection configuration */
+    projection?: ProjectionConfig;
+    /** Search text (for text search functionality) */
+    searchText?: string;
+    /** Limit number of results */
+    take?: number;
+    /** Skip number of results (for pagination) */
+    skip?: number;
+    /** Distinct key for deduplication */
+    distinct?: string;
+}
+/**
+ * Index filter (uses store indices for fast lookup)
+ *
+ * @internal
+ */
+export interface IndexFilter {
+    type: "domain" | "area" | "device" | "floor" | "label";
+    value: string;
+}
+/**
+ * Sort configuration
+ *
+ * @internal
+ */
+export interface SortConfig {
+    key: string;
+    direction: "asc" | "desc";
+}
+/**
+ * Projection configuration
+ *
+ * @internal
+ */
+export type ProjectionConfig = {
+    type: "ids";
+} | {
+    type: "pick";
+    keys: string[];
+} | {
+    type: "pluck";
+    key: string;
+} | {
+    type: "map";
+    mapper: MapFunc<EntityView, any>;
+};

package/dist/solid/hooks.d.ts

@@ -0,0 +1,88 @@
+/**
+ * SolidJS Hooks for Sync-Layer
+ *
+ * Thin createMemo wrappers over the native SolidJS store.
+ * Since the store IS SolidJS (Plan 01 replaced Zustand with createStore),
+ * no subscription bridge is needed -- SolidJS auto-tracks fine-grained
+ * reactivity through the store proxy.
+ *
+ * Every hook is just `createMemo(() => state.something)`.
+ *
+ * @packageDocumentation
+ */
+import type { Accessor } from "solid-js";
+import type { CameraStreamData } from "../camera/types";
+import { callService, toggle, turnOff, turnOn } from "../commands/service";
+import type { GlassHomeState } from "../core/store";
+import type { AreaView, ConnectionState, EntityView, HassEntity } from "../core/types";
+import type { EntityHistoryData } from "../history/types";
+import type { WeatherForecastsData } from "../weather/types";
+/**
+ * Get a reactive EntityView for an entity ID.
+ *
+ * Direct createMemo over store -- zero overhead, fine-grained reactivity.
+ * Only re-runs when the specific entity's data changes.
+ */
+export declare function useEntity(entityId: Accessor<string> | string): Accessor<EntityView | undefined>;
+/**
+ * Get reactive EntityViews for multiple entity IDs.
+ */
+export declare function useEntities(entityIds: Accessor<string[]>): Accessor<EntityView[]>;
+/**
+ * Get raw HassEntity state (without EntityView transformation).
+ */
+export declare function useEntityState(entityId: Accessor<string> | string): Accessor<HassEntity | undefined>;
+/**
+ * Get reactive connection status.
+ */
+export declare function useConnection(): {
+    status: Accessor<ConnectionState>;
+    isConnected: Accessor<boolean>;
+};
+/**
+ * Get all service call functions.
+ */
+export declare function useService(): {
+    callService: typeof callService;
+    turnOn: typeof turnOn;
+    turnOff: typeof turnOff;
+    toggle: typeof toggle;
+};
+/** Get turnOn command function */
+export declare function useTurnOn(): typeof turnOn;
+/** Get turnOff command function */
+export declare function useTurnOff(): typeof turnOff;
+/** Get toggle command function */
+export declare function useToggle(): typeof toggle;
+/**
+ * Get reactive list of all area views.
+ */
+export declare function useAreas(): Accessor<AreaView[]>;
+/**
+ * Get a reactive AreaView for a specific area.
+ */
+export declare function useArea(areaId: Accessor<string> | string): Accessor<AreaView | undefined>;
+/**
+ * Get reactive entity history data.
+ *
+ * History data is populated into the store via subscriptions;
+ * this hook simply reads it reactively.
+ */
+export declare function useEntityHistory(entityId: Accessor<string> | string): Accessor<EntityHistoryData | undefined>;
+/**
+ * Get reactive camera stream data.
+ */
+export declare function useCamera(entityId: Accessor<string> | string): {
+    stream: Accessor<CameraStreamData | null>;
+    refresh: () => void;
+};
+/**
+ * Get reactive weather forecast data.
+ */
+export declare function useForecast(entityId: Accessor<string> | string): Accessor<WeatherForecastsData | undefined>;
+/**
+ * Escape hatch for direct store access with a selector.
+ *
+ * Use when no specific hook exists for your data need.
+ */
+export declare function useStore<T>(selector: (s: GlassHomeState) => T): Accessor<T>;

package/dist/solid/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SolidJS Adapter for @glasshome/sync-layer
+ *
+ * Thin reactive layer over the native SolidJS store.
+ * Import from `@glasshome/sync-layer/solid`.
+ *
+ * @packageDocumentation
+ */
+export { useArea, useAreas, useCamera, useConnection, useEntities, useEntity, useEntityHistory, useEntityState, useForecast, useService, useStore, useToggle, useTurnOff, useTurnOn, } from "./hooks";
+export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, } from "./indices";

package/dist/solid/index.js

@@ -0,0 +1,176 @@
+import { state } from "../store-B1sbyexX.js";
+import { buildAreaView, callService, getEntityView, toggle, turnOff, turnOn } from "../area-views-B-m8vwce.js";
+import { extractDomain } from "../types-Csog0nqk.js";
+import { createMemo } from "solid-js";
+
+//#region src/solid/hooks.ts
+/**
+* Get a reactive EntityView for an entity ID.
+*
+* Direct createMemo over store -- zero overhead, fine-grained reactivity.
+* Only re-runs when the specific entity's data changes.
+*/
+function useEntity(entityId) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	return createMemo(() => {
+		const id = getId();
+		if (!id) return void 0;
+		return getEntityView(id);
+	});
+}
+/**
+* Get reactive EntityViews for multiple entity IDs.
+*/
+function useEntities(entityIds) {
+	return createMemo(() => {
+		return entityIds().map((id) => getEntityView(id)).filter((v) => v !== void 0);
+	});
+}
+/**
+* Get raw HassEntity state (without EntityView transformation).
+*/
+function useEntityState(entityId) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	return createMemo(() => state.entities[getId()]);
+}
+/**
+* Get reactive connection status.
+*/
+function useConnection() {
+	const status = createMemo(() => state.connectionState);
+	const isConnected = createMemo(() => state.connectionState === "connected");
+	return {
+		status,
+		isConnected
+	};
+}
+/**
+* Get all service call functions.
+*/
+function useService() {
+	return {
+		callService,
+		turnOn,
+		turnOff,
+		toggle
+	};
+}
+/** Get turnOn command function */
+function useTurnOn() {
+	return turnOn;
+}
+/** Get turnOff command function */
+function useTurnOff() {
+	return turnOff;
+}
+/** Get toggle command function */
+function useToggle() {
+	return toggle;
+}
+/**
+* Get reactive list of all area views.
+*/
+function useAreas() {
+	return createMemo(() => {
+		return Object.keys(state.areas).map((areaId) => {
+			try {
+				return buildAreaView(areaId);
+			} catch {
+				return void 0;
+			}
+		}).filter((v) => v !== void 0);
+	});
+}
+/**
+* Get a reactive AreaView for a specific area.
+*/
+function useArea(areaId) {
+	const getId = typeof areaId === "function" ? areaId : () => areaId;
+	return createMemo(() => {
+		const id = getId();
+		if (!id || !state.areas[id]) return void 0;
+		try {
+			return buildAreaView(id);
+		} catch {
+			return void 0;
+		}
+	});
+}
+/**
+* Get reactive entity history data.
+*
+* History data is populated into the store via subscriptions;
+* this hook simply reads it reactively.
+*/
+function useEntityHistory(entityId) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	return createMemo(() => state.history[getId()]);
+}
+/**
+* Get reactive camera stream data.
+*/
+function useCamera(entityId) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	return {
+		stream: createMemo(() => state.streams[getId()] ?? null),
+		refresh: () => {}
+	};
+}
+/**
+* Get reactive weather forecast data.
+*/
+function useForecast(entityId) {
+	const getId = typeof entityId === "function" ? entityId : () => entityId;
+	return createMemo(() => state.forecasts[getId()]);
+}
+/**
+* Escape hatch for direct store access with a selector.
+*
+* Use when no specific hook exists for your data need.
+*/
+function useStore(selector) {
+	return createMemo(() => selector(state));
+}
+
+//#endregion
+//#region src/solid/indices.ts
+/**
+* Group items by a key function
+*/
+function groupBy(items, keyFn) {
+	const result = {};
+	for (const item of items) {
+		const key = keyFn(item);
+		if (key) (result[key] ??= []).push(item);
+	}
+	return result;
+}
+/** Entity IDs grouped by domain (e.g., "light" -> ["light.living_room", ...]) */
+const byDomain = createMemo(() => groupBy(Object.keys(state.entities), (id) => extractDomain(id)));
+/** Entity IDs grouped by area (via entity registry area_id) */
+const byArea = createMemo(() => groupBy(Object.keys(state.entityRegistry), (id) => state.entityRegistry[id]?.area_id ?? null));
+/** Entity IDs grouped by device (via entity registry device_id) */
+const byDevice = createMemo(() => groupBy(Object.keys(state.entityRegistry), (id) => state.entityRegistry[id]?.device_id ?? null));
+/** Entity IDs grouped by floor (device -> area -> floor chain) */
+const byFloor = createMemo(() => {
+	const result = {};
+	for (const [entityId, reg] of Object.entries(state.entityRegistry)) if (reg.device_id) {
+		const device = state.devices[reg.device_id];
+		if (device?.area_id) {
+			const area = state.areas[device.area_id];
+			if (area?.floor_id) (result[area.floor_id] ??= []).push(entityId);
+		}
+	}
+	return result;
+});
+/** Entity IDs grouped by label */
+const byLabel = createMemo(() => {
+	const result = {};
+	for (const [entityId, reg] of Object.entries(state.entityRegistry)) for (const label of reg.labels ?? []) (result[label] ??= []).push(entityId);
+	return result;
+});
+/** All entity IDs currently in the store */
+const allEntityIds = createMemo(() => Object.keys(state.entities));
+
+//#endregion
+export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCamera, useConnection, useEntities, useEntity, useEntityHistory, useEntityState, useForecast, useService, useStore, useToggle, useTurnOff, useTurnOn };