@supersoniks/concorde 4.2.1 → 4.3.0

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

@@ -1,147 +1,23 @@
-import { Objects } from "@supersoniks/concorde/utils";
-
-import DataProvider, { PublisherManager } from "../../utils/PublisherProxy";
+import type {
+  DataProviderKey,
+  DataProviderKeyHost,
+} from "../../utils/dataProviderKey";
 import { ConnectedComponent, setSubscribable } from "./common";
-
-const dynamicWatcherStore = Symbol("__bindDynamicWatcherStore__");
-const dynamicWillUpdateHookedStore = Symbol("__bindDynamicWillUpdateHooked__");
-
-function registerDynamicWatcher(
-  instance: any,
-  propertyName: string,
-  onChange: () => void
-) {
-  const key = String(propertyName);
-  ensureWillUpdateHook(instance);
-  if (!instance[dynamicWatcherStore]) {
-    Object.defineProperty(instance, dynamicWatcherStore, {
-      value: new Map<string, Set<() => void>>(),
-      enumerable: false,
-      configurable: false,
-      writable: false,
-    });
-  }
-  const watcherMap = instance[dynamicWatcherStore] as Map<
-    string,
-    Set<() => void>
-  >;
-  if (!watcherMap.has(key)) {
-    watcherMap.set(key, new Set());
-  }
-  const watchers = watcherMap.get(key)!;
-  watchers.add(onChange);
-  return () => {
-    watchers.delete(onChange);
-    if (watchers.size === 0) {
-      watcherMap.delete(key);
-    }
-  };
-}
-
-function ensureWillUpdateHook(instance: any) {
-  const proto = Object.getPrototypeOf(instance);
-  if (!proto || proto[dynamicWillUpdateHookedStore]) return;
-  const originalWillUpdate = Object.prototype.hasOwnProperty.call(
-    proto,
-    "willUpdate"
-  )
-    ? proto.willUpdate
-    : Object.getPrototypeOf(proto)?.willUpdate;
-  proto.willUpdate = function (changedProperties?: Map<unknown, unknown>) {
-    const handlers = this[dynamicWatcherStore] 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()));
-      }
-    }
-    originalWillUpdate?.call(this, changedProperties);
-  };
-  proto[dynamicWillUpdateHookedStore] = true;
-}
-
-function extractDynamicDependencies(path: string) {
-  const patterns = [/\$\{([^}]+)\}/g, /\{\$([^}]+)\}/g];
-  const deps = new Set<string>();
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(path)) !== null) {
-      const cleaned = cleanPlaceholder(match[1]);
-      if (!cleaned) continue;
-      const [root] = cleaned.split(".");
-      if (root) deps.add(root);
-    }
-  }
-  return Array.from(deps);
-}
-
-function cleanPlaceholder(value: string) {
-  return value.trim().replace(/^this\./, "");
-}
-
-function resolveDynamicPath(component: any, template: string) {
-  let missing = false;
-  const replaceValue = (_match: string, expression: string) => {
-    const cleaned = cleanPlaceholder(expression);
-    const resolved = getValueFromExpression(component, cleaned);
-    if (resolved === undefined || resolved === null) {
-      missing = true;
-      return "";
-    }
-    return `${resolved}`;
-  };
-  const resolvedPath = template
-    .replace(/\$\{([^}]+)\}/g, replaceValue)
-    .replace(/\{\$([^}]+)\}/g, replaceValue)
-    .trim();
-  if (missing || !resolvedPath.length) {
-    return { ready: false, path: null };
-  }
-  const segments = resolvedPath.split(".").filter(Boolean);
-  if (segments.length === 0 || !segments[0]) {
-    return { ready: false, path: null };
-  }
-  return { ready: true, path: resolvedPath };
-}
-
-function getValueFromExpression(component: any, expression: string) {
-  if (!expression) return undefined;
-  const segments = expression.split(".").filter(Boolean);
-  if (segments.length === 0) return undefined;
-  let current: unknown = component;
-  for (const segment of segments) {
-    if (
-      current === undefined ||
-      current === null ||
-      typeof current !== "object"
-    ) {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[segment];
-  }
-  return current;
-}
-
-function getPublisherFromPath(path: string) {
-  const segments = path.split(".").filter((segment) => segment.length > 0);
-  if (segments.length === 0) return null;
-  const dataProvider = segments.shift() || "";
-  if (!dataProvider) return null;
-  let publisher = PublisherManager.get(dataProvider);
-  if (!publisher) return null;
-  publisher = Objects.traverse(publisher, segments);
-  return publisher as DataProvider | null;
-}
-
-export function bind(path: string, options?: { reflect?: boolean }) {
+import {
+  extractDynamicDependencies,
+  hasPath,
+  resolveDynamicPath,
+} from "./dynamicPath";
+import {
+  bindDynamicWatchKeys,
+  registerDynamicPropertyWatcher,
+} from "./dynamicPropertyWatch";
+import { getPublisherFromPath } from "./publisherPath";
+
+function bindImpl(
+  path: string,
+  options?: { reflect?: boolean }
+): (target: unknown, propertyKey: string) => void {
   const reflect = options?.reflect ?? false;
   const dynamicDependencies = extractDynamicDependencies(path);
   const isDynamicPath = dynamicDependencies.length > 0;
@@ -276,8 +152,10 @@ export function bind(path: string, options?: { reflect?: boolean }) {
 
       if (isDynamicPath) {
         for (const dependency of dynamicDependencies) {
-          const unsubscribe = registerDynamicWatcher(
-            component as Record<string, unknown>,
+          const unsubscribe = registerDynamicPropertyWatcher(
+            bindDynamicWatchKeys.watcherStore,
+            bindDynamicWatchKeys.hooked,
+            component,
             dependency,
             () => refreshSubscription()
           );
@@ -303,3 +181,37 @@ export function bind(path: string, options?: { reflect?: boolean }) {
   };
 }
 
+/**
+ * Bidirectional binding to a publisher path. Subscribes to changes and optionally reflects writes back.
+ * Accepts either a string path (legacy) or DataProviderKey&lt;T&gt; for type-safe binding.
+ * Supports dynamic paths: use placeholders like "users.${userIndex}" in the path or DataProviderKey.
+ *
+ * @example
+ * // String path (legacy):
+ * @bind("demoData.firstName")
+ * @state()
+ * firstName = "";
+ *
+ * @example
+ * // DataProviderKey with type validation:
+ * const dataKey = new DataProviderKey<Data>("data");
+ * @bind(dataKey.count, { reflect: true })
+ * @state()
+ * count: number = 0;
+ */
+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 },
+): <K extends string>(
+  target: DataProviderKeyHost<U> & { [P in K]?: T | null | undefined },
+  propertyKey: K,
+) => void;
+export function bind(
+  pathOrKey: string | DataProviderKey<unknown, unknown>,
+  options?: { reflect?: boolean },
+): (target: unknown, propertyKey: string) => void {
+  const path = hasPath(pathOrKey) ? pathOrKey.path : pathOrKey;
+  return bindImpl(path, options);
+}
+

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

@@ -0,0 +1,77 @@
+/** Lit / décorateurs : chemins publisher avec `${prop}` ou `{$prop}`. */
+
+export function cleanPlaceholder(value: string): string {
+  return value.trim().replace(/^this\./, "");
+}
+
+export function getValueFromExpression(
+  component: unknown,
+  expression: string,
+): unknown {
+  if (!expression) return undefined;
+  const segments = expression.split(".").filter(Boolean);
+  if (segments.length === 0) return undefined;
+  let current: unknown = component;
+  for (const segment of segments) {
+    if (
+      current === undefined ||
+      current === null ||
+      typeof current !== "object"
+    ) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current;
+}
+
+export function resolveDynamicPath(
+  component: unknown,
+  template: string,
+): { ready: boolean; path: string | null } {
+  let missing = false;
+  const replaceValue = (_match: string, expression: string) => {
+    const cleaned = cleanPlaceholder(expression);
+    const resolved = getValueFromExpression(component, cleaned);
+    if (resolved === undefined || resolved === null) {
+      missing = true;
+      return "";
+    }
+    return `${resolved}`;
+  };
+  const resolvedPath = template
+    .replace(/\$\{([^}]+)\}/g, replaceValue)
+    .replace(/\{\$([^}]+)\}/g, replaceValue)
+    .trim();
+  if (missing || !resolvedPath.length) {
+    return { ready: false, path: null };
+  }
+  const segments = resolvedPath.split(".").filter(Boolean);
+  if (segments.length === 0 || !segments[0]) {
+    return { ready: false, path: null };
+  }
+  return { ready: true, path: resolvedPath };
+}
+
+export function extractDynamicDependencies(path: string): string[] {
+  const patterns = [/\$\{([^}]+)\}/g, /\{\$([^}]+)\}/g];
+  const deps = new Set<string>();
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(path)) !== null) {
+      const cleaned = (match[1] || "").trim().replace(/^this\./, "");
+      if (!cleaned) continue;
+      const [root] = cleaned.split(".");
+      if (root) deps.add(root);
+    }
+  }
+  return Array.from(deps);
+}
+export function hasPath(obj: unknown): obj is { path: string } {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "path" in obj &&
+    typeof (obj as { path: unknown }).path === "string"
+  );
+}

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

@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+type InstanceStores = Record<PropertyKey, unknown>;
+
+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,
+    });
+  }
+  const watcherMap = inst[watcherStoreKey] as Map<string, Set<() => void>>;
+  if (!watcherMap.has(key)) {
+    watcherMap.set(key, new Set());
+  }
+  const watchers = watcherMap.get(key)!;
+  watchers.add(onChange);
+  return () => {
+    watchers.delete(onChange);
+    if (watchers.size === 0) {
+      watcherMap.delete(key);
+    }
+  };
+}
+
+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()));
+      }
+    }
+    if (typeof originalWillUpdate === "function") {
+      originalWillUpdate.call(this, changedProperties);
+    }
+  };
+  (proto as InstanceStores)[hookedStoreKey] = true;
+}
+
+/** Clés utilisées par `@bind`. */
+export const bindDynamicWatchKeys = {
+  watcherStore: Symbol("__bindDynamicWatcherStore__"),
+  hooked: Symbol("__bindDynamicWillUpdateHooked__"),
+} as const;
+
+/** Clés utilisées par `@publish`. */
+export const publishDynamicWatchKeys = {
+  watcherStore: "__publishDynamicWatcherStore__",
+  hooked: "__publishDynamicWillUpdateHooked__",
+} as const;
+
+/** Clés utilisées par `@get`. */
+export const getDynamicWatchKeys = {
+  watcherStore: "__getDynamicWatcherStore__",
+  hooked: "__getDynamicWillUpdateHooked__",
+} as const;
+
+/** Clés utilisées par `@onAssign`. */
+export const onAssignDynamicWatchKeys = {
+  watcherStore: Symbol("__onAssignDynamicWatcherStore__"),
+  hooked: Symbol("__onAssignDynamicWillUpdateHooked__"),
+} as const;

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

@@ -1,149 +1,11 @@
-import { Objects } from "@supersoniks/concorde/utils";
-
-import DataProvider, { PublisherManager } from "../../utils/PublisherProxy";
+import DataProvider from "../../utils/PublisherProxy";
 import { ConnectedComponent, setSubscribable } from "./common";
-
-const dynamicWatcherStore = Symbol("__onAssignDynamicWatcherStore__");
-const dynamicWillUpdateHookedStore = Symbol(
-  "__onAssignDynamicWillUpdateHooked__"
-);
-
-function registerDynamicWatcher(
-  instance: any,
-  propertyName: string,
-  onChange: () => void
-) {
-  const key = String(propertyName);
-  ensureWillUpdateHook(instance);
-  if (!instance[dynamicWatcherStore]) {
-    Object.defineProperty(instance, dynamicWatcherStore, {
-      value: new Map<string, Set<() => void>>(),
-      enumerable: false,
-      configurable: false,
-      writable: false,
-    });
-  }
-  const watcherMap = instance[dynamicWatcherStore] as Map<
-    string,
-    Set<() => void>
-  >;
-  if (!watcherMap.has(key)) {
-    watcherMap.set(key, new Set());
-  }
-  const watchers = watcherMap.get(key)!;
-  watchers.add(onChange);
-  return () => {
-    watchers.delete(onChange);
-    if (watchers.size === 0) {
-      watcherMap.delete(key);
-    }
-  };
-}
-
-function ensureWillUpdateHook(instance: any) {
-  const proto = Object.getPrototypeOf(instance);
-  if (!proto || proto[dynamicWillUpdateHookedStore]) return;
-
-  const originalWillUpdate = Object.prototype.hasOwnProperty.call(
-    proto,
-    "willUpdate"
-  )
-    ? proto.willUpdate
-    : Object.getPrototypeOf(proto)?.willUpdate;
-
-  proto.willUpdate = function (changedProperties?: Map<unknown, unknown>) {
-    const handlers = this[dynamicWatcherStore] 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()));
-      }
-    }
-    originalWillUpdate?.call(this, changedProperties);
-  };
-  proto[dynamicWillUpdateHookedStore] = true;
-}
-
-function extractDynamicDependencies(path: string) {
-  const patterns = [/\$\{([^}]+)\}/g, /\{\$([^}]+)\}/g];
-  const deps = new Set<string>();
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(path)) !== null) {
-      const cleaned = cleanPlaceholder(match[1]);
-      if (!cleaned) continue;
-      const [root] = cleaned.split(".");
-      if (root) deps.add(root);
-    }
-  }
-  return Array.from(deps);
-}
-
-function cleanPlaceholder(value: string) {
-  return value.trim().replace(/^this\./, "");
-}
-
-function resolveDynamicPath(component: any, template: string) {
-  let missing = false;
-  const replaceValue = (_match: string, expression: string) => {
-    const cleaned = cleanPlaceholder(expression);
-    const resolved = getValueFromExpression(component, cleaned);
-    if (resolved === undefined || resolved === null) {
-      missing = true;
-      return "";
-    }
-    return `${resolved}`;
-  };
-  const resolvedPath = template
-    .replace(/\$\{([^}]+)\}/g, replaceValue)
-    .replace(/\{\$([^}]+)\}/g, replaceValue)
-    .trim();
-  if (missing || !resolvedPath.length) {
-    return { ready: false, path: null };
-  }
-  const segments = resolvedPath.split(".").filter(Boolean);
-  if (segments.length === 0 || !segments[0]) {
-    return { ready: false, path: null };
-  }
-  return { ready: true, path: resolvedPath };
-}
-
-function getValueFromExpression(component: any, expression: string) {
-  if (!expression) return undefined;
-  const segments = expression.split(".").filter(Boolean);
-  if (segments.length === 0) return undefined;
-  let current: unknown = component;
-  for (const segment of segments) {
-    if (
-      current === undefined ||
-      current === null ||
-      typeof current !== "object"
-    ) {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[segment];
-  }
-  return current;
-}
-
-function getPublisherFromPath(path: string) {
-  const segments = path.split(".").filter((segment) => segment.length > 0);
-  if (segments.length === 0) return null;
-  const dataProvider = segments.shift() || "";
-  if (!dataProvider) return null;
-  let publisher = PublisherManager.get(dataProvider);
-  if (!publisher) return null;
-  publisher = Objects.traverse(publisher, segments);
-  return publisher as DataProvider | null;
-}
+import { extractDynamicDependencies, resolveDynamicPath } from "./dynamicPath";
+import {
+  onAssignDynamicWatchKeys,
+  registerDynamicPropertyWatcher,
+} from "./dynamicPropertyWatch";
+import { getPublisherFromPath } from "./publisherPath";
 
 type Callback = (...values: unknown[]) => void;
 type PathConfiguration = {
@@ -279,8 +141,10 @@ export function onAssign(...values: Array<string>) {
       for (const conf of confs) {
         if (conf.pathConfig.isDynamic) {
           for (const dependency of conf.pathConfig.dynamicDependencies) {
-            const unsubscribe = registerDynamicWatcher(
-              component as Record<string, unknown>,
+            const unsubscribe = registerDynamicPropertyWatcher(
+              onAssignDynamicWatchKeys.watcherStore,
+              onAssignDynamicWatchKeys.hooked,
+              component,
               dependency,
               () => refreshSubscriptions()
             );

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

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { DataProviderKey } from "../../utils/dataProviderKey";
+import { publish } from "./publish";
+
+type FormData = {
+  email: string;
+};
+
+const formKey = new DataProviderKey<FormData>("formData");
+
+describe("publish", () => {
+  it("decorates property and allows get/set", () => {
+    class TestClass {
+      @publish(formKey.email)
+      email = "";
+    }
+    const instance = new TestClass();
+    instance.email = "test@example.com";
+    expect(instance.email).toBe("test@example.com");
+  });
+});