@supersoniks/concorde 4.5.1 → 4.5.2

package/docs/svg/regular/plane.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 6.2.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M576 256C576 305 502.1 336 464.2 336H382.2L282.4 496C276.4 506 266.4 512 254.4 512H189.5C179.5 512 169.5 508 163.5 500C157.6 492 155.6 480.1 158.6 471L201.5 336H152.5L113.6 388C107.6 396 98.61 400 88.62 400H31.7C22.72 400 12.73 396 6.74 388C.7485 380-1.248 370 1.747 360L31.7 256L.7488 152C-1.248 143 .7488 133 6.74 125C12.73 117 22.72 112 31.7 112H88.62C98.61 112 107.6 117 113.6 125L152.5 176H201.5L158.6 41C155.6 32 157.6 21 163.5 13C169.5 5 179.5 0 189.5 0H254.4C265.4 0 277.4 7 281.4 16L381.2 176H463.2C502.1 176 576 208 576 256H576zM527.1 256C525.1 246 489.1 224 463.2 224H355.3L245.4 48H211.5L266.4 224H128.6L80.63 160H53.67L81.63 256L53.67 352H80.63L128.6 288H266.4L211.5 464H245.4L355.3 288H463.2C490.1 288 526.1 267 527.1 256V256z"/></svg>

package/docs/svg/solid/plane.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 6.2.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M482.3 192c34.2 0 93.7 29 93.7 64c0 36-59.5 64-93.7 64l-116.6 0L265.2 495.9c-5.7 10-16.3 16.1-27.8 16.1l-56.2 0c-10.6 0-18.3-10.2-15.4-20.4l49-171.6L112 320 68.8 377.6c-3 4-7.8 6.4-12.8 6.4l-42 0c-7.8 0-14-6.3-14-14c0-1.3 .2-2.6 .5-3.9L32 256 .5 145.9c-.4-1.3-.5-2.6-.5-3.9c0-7.8 6.3-14 14-14l42 0c5 0 9.8 2.4 12.8 6.4L112 192l102.9 0-49-171.6C162.9 10.2 170.6 0 181.2 0l56.2 0c11.5 0 22.1 6.2 27.8 16.1L365.7 192l116.6 0z"/></svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersoniks/concorde",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "license": "MIT",
   "type": "module",
   "main": "",
@@ -286,6 +286,7 @@
     "./decorators/subscriber/bind": "./src/core/decorators/subscriber/bind.ts",
     "./decorators/subscriber/common": "./src/core/decorators/subscriber/common.ts",
     "./decorators/subscriber/dynamicPath": "./src/core/decorators/subscriber/dynamicPath.ts",
+    "./decorators/subscriber/dynamicPropertyWatch.spec": "./src/core/decorators/subscriber/dynamicPropertyWatch.spec.ts",
     "./decorators/subscriber/dynamicPropertyWatch": "./src/core/decorators/subscriber/dynamicPropertyWatch.ts",
     "./decorators/subscriber/onAssign": "./src/core/decorators/subscriber/onAssign.ts",
     "./decorators/subscriber/publish.spec": "./src/core/decorators/subscriber/publish.spec.ts",

package/src/core/decorators/api.ts

@@ -18,7 +18,7 @@ import {
 } from "./subscriber/dynamicPath";
 import {
   getDynamicWatchKeys,
-  registerDynamicPropertyWatcher,
+  observeDynamicProperty,
 } from "./subscriber/dynamicPropertyWatch";
 import { getPublisherFromPath } from "./subscriber/publisherPath";
 
@@ -203,7 +203,7 @@ export function get<T, Ue = any, Uk = any>(
 
       if (usesPublisherConfig) {
         for (const dependency of mergedDynamicDependencies) {
-          const unsubscribe = registerDynamicPropertyWatcher(
+          const unsubscribe = observeDynamicProperty(
             getDynamicWatchKeys.watcherStore,
             getDynamicWatchKeys.hooked,
             component,
@@ -216,7 +216,7 @@ export function get<T, Ue = any, Uk = any>(
       } else {
         if (isDynamicPath) {
           for (const dependency of endpointDynamicDependencies) {
-            const unsubscribe = registerDynamicPropertyWatcher(
+            const unsubscribe = observeDynamicProperty(
               getDynamicWatchKeys.watcherStore,
               getDynamicWatchKeys.hooked,
               component,

package/src/core/decorators/subscriber/ancestorAttribute.ts

@@ -5,13 +5,14 @@ export function ancestorAttribute(attributeName: string) {
   return function (target: unknown, propertyKey: string) {
     if (!target) return;
     setSubscribable(target);
-
-    (target as ConnectedComponent).__onConnected__((component) => {
+    (target as ConnectedComponent).__onBeforeConnected__((component) => {
       const value = HTML.getAncestorAttributeValue(
         component as any,
-        attributeName
+        attributeName,
       );
-      component[propertyKey] = value;
+      if (value !== null) {
+        component[propertyKey] = value;
+      }
     });
   };
 }

package/src/core/decorators/subscriber/bind.ts

@@ -10,13 +10,13 @@ import {
 } from "./dynamicPath";
 import {
   bindDynamicWatchKeys,
-  registerDynamicPropertyWatcher,
+  observeDynamicProperty,
 } from "./dynamicPropertyWatch";
 import { getPublisherFromPath } from "./publisherPath";
 
 function bindImpl(
   path: string,
-  options?: { reflect?: boolean }
+  options?: { reflect?: boolean },
 ): (target: unknown, propertyKey: string) => void {
   const reflect = options?.reflect ?? false;
   const dynamicDependencies = extractDynamicDependencies(path);
@@ -34,7 +34,7 @@ function bindImpl(
     if (reflect) {
       const existingDescriptor = Object.getOwnPropertyDescriptor(
         target as any,
-        propertyKey
+        propertyKey,
       );
       const internalValueKey = `__bind_${propertyKey}_value__`;
       const reflectUpdateFlagKey = `__bind_${propertyKey}_updating_from_publisher__`;
@@ -152,12 +152,12 @@ function bindImpl(
 
       if (isDynamicPath) {
         for (const dependency of dynamicDependencies) {
-          const unsubscribe = registerDynamicPropertyWatcher(
+          const unsubscribe = observeDynamicProperty(
             bindDynamicWatchKeys.watcherStore,
             bindDynamicWatchKeys.hooked,
             component,
             dependency,
-            () => refreshSubscription()
+            () => refreshSubscription(),
           );
           state.cleanupWatchers.push(unsubscribe);
         }
@@ -199,7 +199,10 @@ function bindImpl(
  * @state()
  * count: number = 0;
  */
-export function bind(path: string, options?: { reflect?: boolean }): (target: unknown, propertyKey: string) => void;
+export function bind(
+  path: string,
+  options?: { reflect?: boolean },
+): (target: unknown, propertyKey: string) => void;
 export function bind<T, U = any>(
   key: DataProviderKey<T, U>,
   options?: { reflect?: boolean },
@@ -214,4 +217,3 @@ export function bind(
   const path = hasPath(pathOrKey) ? pathOrKey.path : pathOrKey;
   return bindImpl(path, options);
 }
-

package/src/core/decorators/subscriber/common.ts

@@ -1,12 +1,26 @@
 type ConnectedCallback = (component: ConnectedComponent) => void;
 
 export type ConnectedComponent = Record<string, unknown> & {
+  /** Hooks exécutés avant le connectedCallback d'origine (ex. lecture DOM ancêtre). */
+  __onBeforeConnected__: (callback: ConnectedCallback) => void;
+  /** Hooks exécutés après le connectedCallback d'origine (ex. abonnements). */
   __onConnected__: (callback: ConnectedCallback) => void;
   __onDisconnected__: (callback: ConnectedCallback) => void;
+  __beforeConnectedCallbackCalls__?: Set<ConnectedCallback>;
   __connectedCallbackCalls__?: Set<ConnectedCallback>;
   __disconnectedCallbackCalls__?: Set<ConnectedCallback>;
 };
 
+function onBeforeConnected(
+  this: ConnectedComponent,
+  callback: ConnectedCallback,
+) {
+  if (!this.__beforeConnectedCallbackCalls__) {
+    this.__beforeConnectedCallbackCalls__ = new Set();
+  }
+  this.__beforeConnectedCallbackCalls__.add(callback);
+}
+
 function onConnected(this: ConnectedComponent, callback: ConnectedCallback) {
   if (!this.__connectedCallbackCalls__) {
     this.__connectedCallbackCalls__ = new Set();
@@ -25,15 +39,21 @@ export function setSubscribable(target: any) {
   if (target.__is__setSubscribable__) return;
   target.__is__setSubscribable__ = true;
 
+  target.__onBeforeConnected__ = onBeforeConnected;
   target.__onConnected__ = onConnected;
   target.__onDisconnected__ = onDisconnected;
 
   const originalConnectedCallback = target.connectedCallback;
   target.connectedCallback = function (this: any) {
+    if (this.__beforeConnectedCallbackCalls__) {
+      this.__beforeConnectedCallbackCalls__.forEach(
+        (callback: ConnectedCallback) => callback(this),
+      );
+    }
     originalConnectedCallback?.call(this);
     if (this.__connectedCallbackCalls__) {
       this.__connectedCallbackCalls__.forEach((callback: ConnectedCallback) =>
-        callback(this)
+        callback(this),
       );
     }
   };
@@ -43,7 +63,7 @@ export function setSubscribable(target: any) {
     originalDisconnectedCallback?.call(this);
     if (this.__disconnectedCallbackCalls__) {
       this.__disconnectedCallbackCalls__.forEach(
-        (callback: ConnectedCallback) => callback(this)
+        (callback: ConnectedCallback) => callback(this),
       );
     }
   };

package/src/core/decorators/subscriber/dynamicPropertyWatch.spec.ts

@@ -0,0 +1,125 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { observeDynamicProperty } from "./dynamicPropertyWatch";
+
+const legacyStoreKey = Symbol("legacyStore");
+const legacyHookedKey = Symbol("legacyHooked");
+
+async function flushFrames(count = 2): Promise<void> {
+  for (let i = 0; i < count; i += 1) {
+    await new Promise<void>((resolve) => {
+      requestAnimationFrame(() => resolve());
+    });
+  }
+}
+
+describe("observeDynamicProperty (poll rAF)", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("déclenche le handler quand une prop observée change", async () => {
+    const component = { userIndex: 0 };
+    const onDependencyChange = vi.fn();
+
+    observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "userIndex",
+      onDependencyChange,
+    );
+
+    component.userIndex = 1;
+    await flushFrames();
+
+    expect(onDependencyChange).toHaveBeenCalled();
+  });
+
+  it("ne déclenche pas sans changement de valeur", async () => {
+    const component = { userIndex: 0 };
+    const onDependencyChange = vi.fn();
+
+    observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "userIndex",
+      onDependencyChange,
+    );
+
+    await flushFrames();
+
+    expect(onDependencyChange).not.toHaveBeenCalled();
+  });
+
+  it("propage un changement effectué dans le handler (même frame)", async () => {
+    const component = { a: 0, b: 0 };
+    const onAChange = vi.fn(() => {
+      component.b = 1;
+    });
+    const onBChange = vi.fn();
+
+    observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "a",
+      onAChange,
+    );
+    observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "b",
+      onBChange,
+    );
+
+    component.a = 1;
+    await flushFrames();
+
+    expect(onAChange).toHaveBeenCalled();
+    expect(onBChange).toHaveBeenCalled();
+  });
+
+  it("désinscription : plus de handler après cleanup", async () => {
+    const component = { userIndex: 0 };
+    const onDependencyChange = vi.fn();
+
+    const unobserve = observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "userIndex",
+      onDependencyChange,
+    );
+
+    unobserve();
+    component.userIndex = 2;
+    await flushFrames();
+
+    expect(onDependencyChange).not.toHaveBeenCalled();
+  });
+
+  it("alerte si boucle infinie (handler qui remute la même prop)", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const component = { loop: 0 };
+    const onDependencyChange = vi.fn(() => {
+      component.loop += 1;
+    });
+
+    observeDynamicProperty(
+      legacyStoreKey,
+      legacyHookedKey,
+      component,
+      "loop",
+      onDependencyChange,
+    );
+
+    component.loop = 1;
+    await flushFrames(3);
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("boucle infinie"),
+    );
+  });
+});

package/src/core/decorators/subscriber/dynamicPropertyWatch.ts

@@ -1,104 +1,189 @@
 /**
- * Enregistre des callbacks sur des propriétés Lit (via `willUpdate`) pour
- * réagir aux changements de segments dynamiques `${…}` dans les chemins.
- * Chaque décorateur utilise des clés de stockage distinctes pour éviter les collisions.
+ * Surveillance des props utilisées dans les chemins dynamiques (`${userIndex}`, etc.).
+ *
+ * Modèle :
+ * - `observeDynamicProperty()` enregistre une prop + un handler à appeler si elle change ;
+ * - un seul `requestAnimationFrame` appelle `notifyObservedPropertyChanges()` ;
+ * - pour chaque prop observée : `lastValue` vs valeur lue sur le composant ;
+ * - plusieurs passes dans la même frame si un handler en modifie une autre ;
+ * - garde anti-boucle si une prop ne cesse de changer.
  */
 
-type InstanceStores = Record<PropertyKey, unknown>;
+import { getValueFromExpression } from "./dynamicPath";
 
-export function registerDynamicPropertyWatcher(
-  watcherStoreKey: PropertyKey,
-  hookedStoreKey: PropertyKey,
-  instance: object,
-  propertyName: string,
-  onChange: () => void,
-): () => void {
-  const inst = instance as InstanceStores;
-  const key = String(propertyName);
-  ensureDynamicPropertiesWillUpdate(
-    watcherStoreKey,
-    hookedStoreKey,
-    instance,
-  );
-  if (!inst[watcherStoreKey]) {
-    Object.defineProperty(inst, watcherStoreKey, {
-      value: new Map<string, Set<() => void>>(),
-      enumerable: false,
-      configurable: false,
-      writable: false,
-    });
+/** Une prop du composant lue à chaque frame, avec les handlers à déclencher si elle change. */
+type ObservedProperty = {
+  /** Dernière valeur vue lors de la dernière notification. */
+  lastValue: unknown;
+  /** Handlers enregistrés par les décorateurs (@bind, @get, …). */
+  onChangeHandlers: Set<() => void>;
+};
+
+/** Nom de prop → état d'observation, pour un composant donné. */
+type ObservedProperties = Map<string, ObservedProperty>;
+
+const observedPropertiesByComponent = new WeakMap<object, ObservedProperties>();
+/** Composants ayant au moins une prop observée. */
+const componentsBeingPolled = new Set<object>();
+
+/** Un seul rAF pour toutes les instances et toutes les props observées. */
+let animationFrameId: number | null = null;
+/** Passes de réconciliation dans une même frame avant alerte boucle infinie. */
+const MAX_NOTIFICATION_PASSES_PER_FRAME = 8;
+
+function getObservedProperties(component: object): ObservedProperties {
+  let observedProperties = observedPropertiesByComponent.get(component);
+  if (!observedProperties) {
+    observedProperties = new Map();
+    observedPropertiesByComponent.set(component, observedProperties);
   }
-  const watcherMap = inst[watcherStoreKey] as Map<string, Set<() => void>>;
-  if (!watcherMap.has(key)) {
-    watcherMap.set(key, new Set());
+  return observedProperties;
+}
+
+/** Compare lastValue à la valeur actuelle ; retourne les handlers à exécuter. */
+function findHandlersForChangedProperties(
+  component: object,
+  observedProperties: ObservedProperties,
+): Set<() => void> {
+  const handlersToRun = new Set<() => void>();
+  for (const [propertyName, observed] of observedProperties) {
+    const currentValue = getValueFromExpression(component, propertyName);
+    if (!Object.is(observed.lastValue, currentValue)) {
+      observed.lastValue = currentValue;
+      observed.onChangeHandlers.forEach((handler) => handlersToRun.add(handler));
+    }
   }
-  const watchers = watcherMap.get(key)!;
-  watchers.add(onChange);
-  return () => {
-    watchers.delete(onChange);
-    if (watchers.size === 0) {
-      watcherMap.delete(key);
+  return handlersToRun;
+}
+
+/** Détecte les props observées qui ont changé et appelle leurs handlers (plusieurs passes si cascade). */
+function notifyObservedPropertyChanges(): void {
+  animationFrameId = null;
+
+  let pass = 0;
+  let propertiesChangedThisFrame = true;
+
+  while (propertiesChangedThisFrame && pass < MAX_NOTIFICATION_PASSES_PER_FRAME) {
+    propertiesChangedThisFrame = false;
+    pass += 1;
+
+    for (const component of componentsBeingPolled) {
+      const observedProperties = observedPropertiesByComponent.get(component);
+      if (!observedProperties || observedProperties.size === 0) continue;
+
+      const handlersToRun = findHandlersForChangedProperties(
+        component,
+        observedProperties,
+      );
+      if (handlersToRun.size === 0) continue;
+
+      propertiesChangedThisFrame = true;
+      handlersToRun.forEach((handler) => handler());
     }
-  };
+  }
+
+  if (propertiesChangedThisFrame) {
+    console.warn(
+      "[concorde] dynamic property watch: limite de passes atteinte, boucle infinie probable",
+    );
+  }
+
+  if (componentsBeingPolled.size > 0) {
+    scheduleObservedPropertyChanges();
+  }
 }
 
-export function ensureDynamicPropertiesWillUpdate(
-  watcherStoreKey: PropertyKey,
-  hookedStoreKey: PropertyKey,
-  instance: object,
-): void {
-  const proto = Object.getPrototypeOf(instance);
-  if (!proto || (proto as InstanceStores)[hookedStoreKey]) return;
-  const originalWillUpdate = Object.prototype.hasOwnProperty.call(
-    proto,
-    "willUpdate",
-  )
-    ? (proto as InstanceStores).willUpdate
-    : (Object.getPrototypeOf(proto) as InstanceStores)?.willUpdate;
-  (proto as InstanceStores).willUpdate = function (
-    changedProperties?: Map<unknown, unknown>,
-  ) {
-    const handlers = (this as InstanceStores)[watcherStoreKey] as
-      | Map<string, Set<() => void>>
-      | undefined;
-    if (handlers && handlers.size > 0) {
-      if (changedProperties && changedProperties.size > 0) {
-        changedProperties.forEach((_value, dependency) => {
-          const callbacks = handlers.get(String(dependency));
-          if (callbacks) {
-            callbacks.forEach((cb) => cb());
-          }
-        });
-      } else {
-        handlers.forEach((callbacks) => callbacks.forEach((cb) => cb()));
-      }
+function scheduleObservedPropertyChanges(): void {
+  if (animationFrameId !== null) return;
+  animationFrameId = requestAnimationFrame(notifyObservedPropertyChanges);
+}
+
+function cancelScheduledObservedPropertyChangesIfIdle(): void {
+  if (componentsBeingPolled.size === 0 && animationFrameId !== null) {
+    cancelAnimationFrame(animationFrameId);
+    animationFrameId = null;
+  }
+}
+
+/**
+ * Observe une prop du composant utilisée dans un chemin dynamique.
+ * Retourne une fonction de désinscription.
+ *
+ * Les deux premiers paramètres sont ignorés (legacy API des décorateurs).
+ */
+export function observeDynamicProperty(
+  _legacyWatcherStoreKey: PropertyKey,
+  _legacyHookedStoreKey: PropertyKey,
+  component: object,
+  dependencyPropertyName: string,
+  onDependencyChange: () => void,
+): () => void {
+  const propertyName = String(dependencyPropertyName);
+  const observedProperties = getObservedProperties(component);
+
+  let observed = observedProperties.get(propertyName);
+  if (!observed) {
+    observed = {
+      lastValue: getValueFromExpression(component, propertyName),
+      onChangeHandlers: new Set(),
+    };
+    observedProperties.set(propertyName, observed);
+  }
+  observed.onChangeHandlers.add(onDependencyChange);
+
+  componentsBeingPolled.add(component);
+  scheduleObservedPropertyChanges();
+
+  return () => {
+    const currentObservedProperties =
+      observedPropertiesByComponent.get(component);
+    if (!currentObservedProperties) return;
+
+    const currentObserved = currentObservedProperties.get(propertyName);
+    if (!currentObserved) return;
+
+    currentObserved.onChangeHandlers.delete(onDependencyChange);
+    if (currentObserved.onChangeHandlers.size === 0) {
+      currentObservedProperties.delete(propertyName);
     }
-    if (typeof originalWillUpdate === "function") {
-      originalWillUpdate.call(this, changedProperties);
+
+    if (currentObservedProperties.size === 0) {
+      observedPropertiesByComponent.delete(component);
+      componentsBeingPolled.delete(component);
+      cancelScheduledObservedPropertyChangesIfIdle();
     }
   };
-  (proto as InstanceStores)[hookedStoreKey] = true;
 }
 
-/** Clés utilisées par `@bind`. */
+/** @deprecated Alias conservé pour les décorateurs existants. */
+export const registerDynamicPropertyWatcher = observeDynamicProperty;
+
+/** @deprecated No-op conservé pour compatibilité API. */
+export function ensureDynamicPropertiesWillUpdate(
+  _watcherStoreKey: PropertyKey,
+  _hookedStoreKey: PropertyKey,
+  _instance: object,
+): void {}
+
+/** Clés legacy ignorées par `@bind`. */
 export const bindDynamicWatchKeys = {
   watcherStore: Symbol("__bindDynamicWatcherStore__"),
   hooked: Symbol("__bindDynamicWillUpdateHooked__"),
 } as const;
 
-/** Clés utilisées par `@publish`. */
+/** Clés legacy ignorées par `@publish`. */
 export const publishDynamicWatchKeys = {
   watcherStore: "__publishDynamicWatcherStore__",
   hooked: "__publishDynamicWillUpdateHooked__",
 } as const;
 
-/** Clés utilisées par `@get`. */
+/** Clés legacy ignorées par `@get`. */
 export const getDynamicWatchKeys = {
   watcherStore: "__getDynamicWatcherStore__",
   hooked: "__getDynamicWillUpdateHooked__",
 } as const;
 
-/** Clés utilisées par `@onAssign`. */
+/** Clés legacy ignorées par `@onAssign`. */
 export const onAssignDynamicWatchKeys = {
   watcherStore: Symbol("__onAssignDynamicWatcherStore__"),
   hooked: Symbol("__onAssignDynamicWillUpdateHooked__"),

package/src/core/decorators/subscriber/onAssign.ts

@@ -3,7 +3,7 @@ import { ConnectedComponent, setSubscribable } from "./common";
 import { extractDynamicDependencies, resolveDynamicPath } from "./dynamicPath";
 import {
   onAssignDynamicWatchKeys,
-  registerDynamicPropertyWatcher,
+  observeDynamicProperty,
 } from "./dynamicPropertyWatch";
 import { getPublisherFromPath } from "./publisherPath";
 
@@ -141,7 +141,7 @@ export function onAssign(...values: Array<string>) {
       for (const conf of confs) {
         if (conf.pathConfig.isDynamic) {
           for (const dependency of conf.pathConfig.dynamicDependencies) {
-            const unsubscribe = registerDynamicPropertyWatcher(
+            const unsubscribe = observeDynamicProperty(
               onAssignDynamicWatchKeys.watcherStore,
               onAssignDynamicWatchKeys.hooked,
               component,

package/src/core/decorators/subscriber/publish.ts

@@ -7,7 +7,7 @@ import { ConnectedComponent, setSubscribable } from "./common";
 import { extractDynamicDependencies, resolveDynamicPath } from "./dynamicPath";
 import {
   publishDynamicWatchKeys,
-  registerDynamicPropertyWatcher,
+  observeDynamicProperty,
 } from "./dynamicPropertyWatch";
 import { getPublisherFromPath } from "./publisherPath";
 
@@ -116,7 +116,7 @@ export function publish<T, U = any>(
       if (dynamicDependencies.length) {
         for (const dependency of dynamicDependencies) {
           state.cleanupWatchers.push(
-            registerDynamicPropertyWatcher(
+            observeDynamicProperty(
               publishDynamicWatchKeys.watcherStore,
               publishDynamicWatchKeys.hooked,
               comp,