@digital-alchemy/hass 25.2.2 → 25.3.2

package/src/services/id-by.service.mts

@@ -1,26 +1,23 @@
-import { TServiceParams } from "@digital-alchemy/core";
+import { FIRST, SINGLE, TServiceParams } from "@digital-alchemy/core";
 
-import {
-  TAreaId,
-  TDeviceId,
-  TFloorId,
-  TLabelId,
-  TPlatformId,
-  TUniqueId,
-  TUniqueIDMapping,
-} from "../dynamic.mts";
+import { domain, EntityRegistryItem, IDByInterface } from "../index.mts";
 import {
   ALL_DOMAINS,
   ANY_ENTITY,
-  EntityRegistryItem,
-  IDByInterface,
+  HassUniqueIdMapping,
   PICK_ENTITY,
   PICK_FROM_AREA,
   PICK_FROM_DEVICE,
   PICK_FROM_FLOOR,
   PICK_FROM_LABEL,
   PICK_FROM_PLATFORM,
-} from "../helpers/index.mts";
+  TAreaId,
+  TDeviceId,
+  TFloorId,
+  TLabelId,
+  TPlatformId,
+  TUniqueId,
+} from "../user.mts";
 
 export function IDByExtension({
   hass,
@@ -44,22 +41,53 @@ export function IDByExtension({
     );
   }
 
-  // * unique_id
+  /**
+   * unique_id
+   *
+   * ## Dev note on logic here
+   *
+   * unique_ids are not ACTUALLY unique when iterating through the registry from here
+   * hacs does this a bunch, using a sensor with the same unique_id as an update entity
+   *
+   * The logic here will look up ALL entities with the "unique"_id, then check to see if there are multiple results
+   * It is assumed by both this code and type-writer that the unique_id lookup will refer to the not update entity
+   */
   function unique_id<
     UNIQUE_ID extends TUniqueId,
-    ENTITY_ID extends Extract<TUniqueIDMapping[UNIQUE_ID], ANY_ENTITY> = Extract<
-      TUniqueIDMapping[UNIQUE_ID],
+    ENTITY_ID extends Extract<HassUniqueIdMapping[UNIQUE_ID], ANY_ENTITY> = Extract<
+      HassUniqueIdMapping[UNIQUE_ID],
       ANY_ENTITY
     >,
   >(unique_id: UNIQUE_ID): ENTITY_ID {
     hass.entity.warnEarly("byUniqueId");
-    const entity = hass.entity.registry.current.find(
+    let list = hass.entity.registry.current.filter(
       i => i.unique_id === unique_id,
-    ) as EntityRegistryItem<ENTITY_ID>;
-    if (!entity) {
+    ) as EntityRegistryItem<ENTITY_ID>[];
+    if (is.empty(list)) {
       logger.error({ name: unique_id, unique_id }, `could not find an entity`);
       return undefined;
     }
+    if (list.length > SINGLE) {
+      const trimmed = list.filter(
+        i =>
+          // @ts-expect-error issue in dev types
+          domain(i.entity_id) !== "update",
+      );
+      if (trimmed.length > SINGLE) {
+        logger.warn(
+          { available_entity_ids: trimmed.map(i => i.entity_id), unique_id },
+          `unique_id collision during lookup (chose first in list)`,
+        );
+      } else {
+        logger.trace(
+          { unique_id },
+          `chose {%s} over update entity during lookup`,
+          trimmed[FIRST].entity_id,
+        );
+      }
+      list = trimmed;
+    }
+    const [entity] = list;
     return entity?.entity_id;
   }
 

package/src/services/label.service.mts

@@ -1,6 +1,5 @@
 import { debounce, TServiceParams } from "@digital-alchemy/core";
 
-import { TLabelId } from "../dynamic.mts";
 import {
   EARLY_ON_READY,
   HassLabelService,
@@ -8,6 +7,7 @@ import {
   LabelDefinition,
   LabelOptions,
 } from "../helpers/index.mts";
+import { TLabelId } from "../user.mts";
 
 export function Label({
   hass,

package/src/services/reference.service.mts

@@ -2,31 +2,31 @@ import { DOWN, NONE, sleep, TAnyFunction, TServiceParams, UP } from "@digital-al
 import dayjs, { Dayjs } from "dayjs";
 import { Get } from "type-fest";
 
-import {
-  TAreaId,
-  TDeviceId,
-  TFloorId,
-  TLabelId,
-  TPlatformId,
-  TRawDomains,
-  TUniqueId,
-  TUniqueIDMapping,
-} from "../dynamic.mts";
 import {
   ALL_SERVICE_DOMAINS,
-  ANY_ENTITY,
   ByIdProxy,
   domain,
   ENTITY_STATE,
   HassReferenceService,
+  RemoveCallback,
+} from "../helpers/index.mts";
+import {
+  ANY_ENTITY,
+  HassUniqueIdMapping,
   PICK_ENTITY,
   PICK_FROM_AREA,
   PICK_FROM_DEVICE,
   PICK_FROM_FLOOR,
   PICK_FROM_LABEL,
   PICK_FROM_PLATFORM,
-  RemoveCallback,
-} from "../helpers/index.mts";
+  TAreaId,
+  TDeviceId,
+  TFloorId,
+  TLabelId,
+  TPlatformId,
+  TRawDomains,
+  TUniqueId,
+} from "../user.mts";
 import { SERVICE_LIST_UPDATED } from "./config.service.mts";
 import { SOCKET_CONNECTED } from "./websocket-api.service.mts";
 
@@ -187,7 +187,7 @@ export function ReferenceService({
               event.on(SOCKET_CONNECTED, removableCallback);
               listeners.add(remove);
 
-              return is.removeFn(remove);
+              return internal.removeFn(remove);
             };
           }
 
@@ -227,7 +227,7 @@ export function ReferenceService({
               };
               listeners.add(remove);
               event.once(entity_id, wrapped);
-              return is.removeFn(remove);
+              return internal.removeFn(remove);
             };
           }
 
@@ -304,6 +304,7 @@ export function ReferenceService({
                 listeners.add(remove);
 
                 const complete = (entity: ENTITY_STATE<ENTITY_ID>) => {
+                  // eslint-disable-next-line sonarjs/different-types-comparison
                   if (entity.state !== state) {
                     logger.trace(
                       {
@@ -339,7 +340,7 @@ export function ReferenceService({
         // #MARK: service calls
         if (hass.configure.isService(entity_domain, property)) {
           return async function (data = {}) {
-            // @ts-expect-error it's fine
+            // @ts-expect-error i don't care, this is fine
             return await hass.call[entity_domain][property]({
               entity_id,
               ...data,
@@ -434,8 +435,8 @@ export function ReferenceService({
 
     unique_id: <
       UNIQUE_ID extends TUniqueId,
-      ENTITY_ID extends Extract<TUniqueIDMapping[UNIQUE_ID], ANY_ENTITY> = Extract<
-        TUniqueIDMapping[UNIQUE_ID],
+      ENTITY_ID extends Extract<HassUniqueIdMapping[UNIQUE_ID], ANY_ENTITY> = Extract<
+        HassUniqueIdMapping[UNIQUE_ID],
         ANY_ENTITY
       >,
     >(

package/src/services/websocket-api.service.mts

@@ -508,7 +508,7 @@ export function WebsocketAPI({
     } else {
       socketEvents.on(event, callback);
     }
-    return is.removeFn(() => {
+    return internal.removeFn(() => {
       logger.trace({ context, event, name: onEvent }, `removing socket event listener`);
       socketEvents.removeListener(event, callback);
     });
@@ -542,7 +542,7 @@ export function WebsocketAPI({
       // attach anyways, for restarts or whatever
     }
     event.on(SOCKET_CONNECTED, wrapped);
-    return is.removeFn(() => event.removeListener(SOCKET_CONNECTED, wrapped));
+    return internal.removeFn(() => event.removeListener(SOCKET_CONNECTED, wrapped));
   }
 
   // #MARK: return object

package/src/testing/area.spec.mts

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TAreaId } from "../dynamic.mts";
 import { AREA_REGISTRY_UPDATED, AreaDetails } from "../helpers/index.mts";
 import { hassTestRunner, INTERNAL_MESSAGE } from "../mock_assistant/index.mts";
+import { TAreaId } from "../user.mts";
 
 describe("Area", () => {
   const EXAMPLE_AREA = {

package/src/testing/entity.spec.mts

@@ -1,7 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { ANY_ENTITY, ENTITY_STATE } from "../helpers/index.mts";
+import { ENTITY_STATE } from "../index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
+import { ANY_ENTITY } from "../user.mts";
 
 describe("Entity", () => {
   afterEach(async () => {

package/src/testing/floor.spec.mts

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TFloorId } from "../dynamic.mts";
 import { FLOOR_REGISTRY_UPDATED, FloorDetails } from "../helpers/index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
+import { TFloorId } from "../user.mts";
 
 describe("Floor", () => {
   const EXAMPLE_FLOOR = {

package/src/testing/id-by.spec.mts

@@ -1,5 +1,5 @@
-import { PICK_ENTITY } from "../helpers/index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
+import { PICK_ENTITY } from "../user.mts";
 
 describe("ID By", () => {
   afterEach(async () => {

package/src/testing/label.spec.mts

@@ -1,8 +1,8 @@
 import { sleep } from "@digital-alchemy/core";
 
-import { TLabelId } from "../dynamic.mts";
 import { LABEL_REGISTRY_UPDATED, LabelDefinition } from "../helpers/index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
+import { TLabelId } from "../user.mts";
 
 describe("Label", () => {
   const EXAMPLE_LABEL = {

package/src/testing/ref-by.spec.mts

@@ -1,7 +1,8 @@
 import dayjs from "dayjs";
 
-import { ANY_ENTITY, ENTITY_STATE } from "../helpers/index.mts";
+import { ENTITY_STATE } from "../helpers/index.mts";
 import { hassTestRunner } from "../mock_assistant/index.mts";
+import { ANY_ENTITY } from "../user.mts";
 
 describe("References", () => {
   afterEach(async () => {

package/src/user.mts

@@ -0,0 +1,97 @@
+/* eslint-disable sonarjs/class-name */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+
+// #MARK: utility
+type UnPrefix<T> = T extends `_${infer Platform}` ? Platform : never;
+
+// #MARK: merging
+export interface HassUniqueIdMapping {
+  // "{unique_id}": "{entity_id}"
+}
+
+export interface HassDomainMapping {
+  // "{domain}": "{entity_id}" | "{entity_id}" | ....
+}
+
+// ? prefix everything with "_" to ensure valid keys
+export interface HassPlatformMapping {
+  // "_{platform}": "{entity_id}" | "{entity_id}" | ....
+}
+
+export interface HassDeviceMapping {
+  // "_{device}": "{entity_id}" | "{entity_id}" | ....
+}
+
+export interface HassAreaMapping {
+  // "_{area}": "{entity_id}" | "{entity_id}" | ....
+}
+
+export interface HassLabelMapping {
+  // "_{label}": "{entity_id}" | "{entity_id}" | ....
+}
+
+export interface HassFloorMapping {
+  // "_{label}": "{entity_id}" | "{entity_id}" | ....
+}
+
+export interface HassEntitySetupMapping {
+  // "{entity_id}": { attributes, context, entity_id, state }
+}
+
+export interface iCallService {
+  // "{service_domain}": { "{service}": fn }
+}
+
+export interface HassZoneMapping {
+  // "zone": true
+}
+
+// #MARK: extract
+export type TAreaId = UnPrefix<keyof HassAreaMapping>;
+export type TDeviceId = UnPrefix<keyof HassDeviceMapping>;
+export type TFloorId = UnPrefix<keyof HassFloorMapping>;
+export type TLabelId = UnPrefix<keyof HassLabelMapping>;
+export type TPlatformId = UnPrefix<keyof HassPlatformMapping>;
+
+export type TRawDomains = keyof HassDomainMapping;
+export type TZoneId = keyof HassZoneMapping;
+export type ALL_DOMAINS = keyof HassDomainMapping;
+export type TUniqueId = keyof HassUniqueIdMapping;
+export type ANY_ENTITY = keyof HassEntitySetupMapping;
+export type TRawEntityIds = keyof HassEntitySetupMapping;
+
+export type PICK_FROM_AREA<ID extends TAreaId, DOMAIN extends ALL_DOMAINS = ALL_DOMAINS> = Extract<
+  HassAreaMapping[`_${ID}`],
+  PICK_ENTITY<DOMAIN>
+>;
+
+export type PICK_FROM_LABEL<
+  ID extends TLabelId,
+  DOMAIN extends ALL_DOMAINS = ALL_DOMAINS,
+> = Extract<HassLabelMapping[`_${ID}`], PICK_ENTITY<DOMAIN>>;
+
+export type PICK_FROM_FLOOR<
+  ID extends TFloorId,
+  DOMAIN extends ALL_DOMAINS = ALL_DOMAINS,
+> = Extract<HassFloorMapping[`_${ID}`], PICK_ENTITY<DOMAIN>>;
+
+export type PICK_FROM_DEVICE<
+  ID extends TDeviceId,
+  DOMAIN extends ALL_DOMAINS = ALL_DOMAINS,
+> = Extract<HassDeviceMapping[`_${ID}`], PICK_ENTITY<DOMAIN>>;
+
+export type PICK_FROM_PLATFORM<
+  ID extends TPlatformId,
+  DOMAIN extends ALL_DOMAINS = ALL_DOMAINS,
+> = Extract<HassPlatformMapping[`_${ID}`], PICK_ENTITY<DOMAIN>>;
+
+export type GetDomain<ENTITY extends `${ALL_DOMAINS}.${string}`> =
+  ENTITY extends `${infer domain}.${string}` ? domain : never;
+
+/**
+ * Pick any valid entity, optionally limiting by domain
+ */
+export type PICK_ENTITY<DOMAIN extends ALL_DOMAINS = ALL_DOMAINS> = Extract<
+  TRawEntityIds,
+  `${DOMAIN}.${string}`
+>;