@supersoniks/concorde 3.2.6 → 3.3.2

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

@@ -0,0 +1,305 @@
+import { Objects } from "@supersoniks/concorde/utils";
+
+import { PublisherProxy, PublisherManager } from "../../utils/PublisherProxy";
+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 PublisherProxy | null;
+}
+
+export function bind(path: string, options?: { reflect?: boolean }) {
+  const reflect = options?.reflect ?? false;
+  const dynamicDependencies = extractDynamicDependencies(path);
+  const isDynamicPath = dynamicDependencies.length > 0;
+
+  return function (target: unknown, propertyKey: string) {
+    if (!target) return;
+    setSubscribable(target);
+    const stateKey = `__bind_state_${propertyKey}`;
+    const publisherKey = `__bind_${propertyKey}_publisher__`;
+    const isUpdatingFromPublisherKey = reflect
+      ? `__bind_${propertyKey}_updating_from_publisher__`
+      : null;
+
+    if (reflect) {
+      const existingDescriptor = Object.getOwnPropertyDescriptor(
+        target as any,
+        propertyKey
+      );
+      const internalValueKey = `__bind_${propertyKey}_value__`;
+      const reflectUpdateFlagKey = `__bind_${propertyKey}_updating_from_publisher__`;
+      const initialValue =
+        existingDescriptor && !existingDescriptor.get && !existingDescriptor.set
+          ? existingDescriptor.value
+          : undefined;
+
+      Object.defineProperty(target as any, propertyKey, {
+        get() {
+          if (existingDescriptor?.get) {
+            return existingDescriptor.get.call(this);
+          }
+          if (
+            !Object.prototype.hasOwnProperty.call(this, internalValueKey) &&
+            initialValue !== undefined
+          ) {
+            (this as any)[internalValueKey] = initialValue;
+          }
+          return (this as any)[internalValueKey];
+        },
+        set(newValue: unknown) {
+          if (existingDescriptor?.set) {
+            existingDescriptor.set.call(this, newValue);
+          } else {
+            (this as any)[internalValueKey] = newValue;
+          }
+          if (
+            !(this as any)[reflectUpdateFlagKey] &&
+            (this as any)[publisherKey]
+          ) {
+            (this as any)[publisherKey].set(newValue);
+          }
+        },
+        enumerable: existingDescriptor?.enumerable ?? true,
+        configurable: existingDescriptor?.configurable ?? true,
+      });
+    }
+
+    (target as ConnectedComponent).__onConnected__((component) => {
+      const state =
+        (component as any)[stateKey] ||
+        ((component as any)[stateKey] = {
+          cleanupWatchers: [] as Array<() => void>,
+          unsubscribePublisher: null as null | (() => void),
+          currentPath: null as string | null,
+        });
+
+      if (state.unsubscribePublisher) {
+        state.unsubscribePublisher();
+        state.unsubscribePublisher = null;
+      }
+      state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      state.cleanupWatchers = [];
+      state.currentPath = null;
+
+      const subscribeToPath = (resolvedPath: string | null) => {
+        if (!resolvedPath) {
+          if (state.unsubscribePublisher) {
+            state.unsubscribePublisher();
+            state.unsubscribePublisher = null;
+          }
+          state.currentPath = null;
+          (component as any)[publisherKey] = null;
+          return;
+        }
+        if (resolvedPath === state.currentPath) {
+          return;
+        }
+        if (state.unsubscribePublisher) {
+          state.unsubscribePublisher();
+          state.unsubscribePublisher = null;
+        }
+
+        const publisher = getPublisherFromPath(resolvedPath);
+        if (!publisher) {
+          state.currentPath = null;
+          (component as any)[publisherKey] = null;
+          return;
+        }
+
+        const onAssign = (value: unknown) => {
+          if (reflect && isUpdatingFromPublisherKey) {
+            (component as any)[isUpdatingFromPublisherKey] = true;
+          }
+          component[propertyKey] = value;
+          if (reflect && isUpdatingFromPublisherKey) {
+            (component as any)[isUpdatingFromPublisherKey] = false;
+          }
+        };
+
+        publisher.onAssign(onAssign);
+        state.unsubscribePublisher = () => {
+          publisher.offAssign(onAssign);
+          if ((component as any)[publisherKey] === publisher) {
+            (component as any)[publisherKey] = null;
+          }
+        };
+        state.currentPath = resolvedPath;
+        (component as any)[publisherKey] = publisher;
+      };
+
+      const refreshSubscription = () => {
+        if (isDynamicPath) {
+          const resolution = resolveDynamicPath(component, path);
+          if (!resolution.ready) {
+            subscribeToPath(null);
+            return;
+          }
+          subscribeToPath(resolution.path);
+          return;
+        }
+        subscribeToPath(path);
+      };
+
+      if (isDynamicPath) {
+        for (const dependency of dynamicDependencies) {
+          const unsubscribe = registerDynamicWatcher(
+            component as Record<string, unknown>,
+            dependency,
+            () => refreshSubscription()
+          );
+          state.cleanupWatchers.push(unsubscribe);
+        }
+      }
+
+      refreshSubscription();
+    });
+
+    (target as ConnectedComponent).__onDisconnected__((component) => {
+      const state = (component as any)[stateKey];
+      if (!state) return;
+      if (state.unsubscribePublisher) {
+        state.unsubscribePublisher();
+        state.unsubscribePublisher = null;
+      }
+      state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      state.cleanupWatchers = [];
+      state.currentPath = null;
+      (component as any)[publisherKey] = null;
+    });
+  };
+}
+

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

@@ -0,0 +1,50 @@
+type ConnectedCallback = (component: ConnectedComponent) => void;
+
+export type ConnectedComponent = Record<string, unknown> & {
+  __onConnected__: (callback: ConnectedCallback) => void;
+  __onDisconnected__: (callback: ConnectedCallback) => void;
+  __connectedCallbackCalls__?: Set<ConnectedCallback>;
+  __disconnectedCallbackCalls__?: Set<ConnectedCallback>;
+};
+
+function onConnected(this: ConnectedComponent, callback: ConnectedCallback) {
+  if (!this.__connectedCallbackCalls__) {
+    this.__connectedCallbackCalls__ = new Set();
+  }
+  this.__connectedCallbackCalls__.add(callback);
+}
+
+function onDisconnected(this: ConnectedComponent, callback: ConnectedCallback) {
+  if (!this.__disconnectedCallbackCalls__) {
+    this.__disconnectedCallbackCalls__ = new Set();
+  }
+  this.__disconnectedCallbackCalls__.add(callback);
+}
+
+export function setSubscribable(target: any) {
+  if (target.__is__setSubscribable__) return;
+  target.__is__setSubscribable__ = true;
+
+  target.__onConnected__ = onConnected;
+  target.__onDisconnected__ = onDisconnected;
+
+  const originalConnectedCallback = target.connectedCallback;
+  target.connectedCallback = function (this: any) {
+    originalConnectedCallback?.call(this);
+    if (this.__connectedCallbackCalls__) {
+      this.__connectedCallbackCalls__.forEach((callback: ConnectedCallback) =>
+        callback(this)
+      );
+    }
+  };
+
+  const originalDisconnectedCallback = target.disconnectedCallback;
+  target.disconnectedCallback = function (this: any) {
+    originalDisconnectedCallback?.call(this);
+    if (this.__disconnectedCallbackCalls__) {
+      this.__disconnectedCallbackCalls__.forEach(
+        (callback: ConnectedCallback) => callback(this)
+      );
+    }
+  };
+}

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

@@ -0,0 +1,318 @@
+import { Objects } from "@supersoniks/concorde/utils";
+
+import { PublisherProxy, PublisherManager } 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 PublisherProxy | null;
+}
+
+type Callback = (...values: unknown[]) => void;
+type PathConfiguration = {
+  originalPath: string;
+  dynamicDependencies: string[];
+  isDynamic: boolean;
+};
+
+type Configuration = {
+  callbacks: Set<Callback>;
+  publisher: PublisherProxy | null;
+  onAssign: (value: unknown) => void;
+  unsubscribePublisher: (() => void) | null;
+  pathConfig: PathConfiguration;
+  index: number;
+};
+
+export function onAssign(...values: Array<string>) {
+  const pathConfigs: PathConfiguration[] = values.map((path) => {
+    const dynamicDependencies = extractDynamicDependencies(path);
+    return {
+      originalPath: path,
+      dynamicDependencies,
+      isDynamic: dynamicDependencies.length > 0,
+    };
+  });
+
+  return function (
+    target: unknown,
+    _propertyKey: string,
+    descriptor: PropertyDescriptor
+  ) {
+    setSubscribable(target);
+    const stateKey = `__onAssign_state__`;
+    let callback: Callback;
+
+    (target as ConnectedComponent).__onConnected__((component) => {
+      const state =
+        (component as any)[stateKey] ||
+        ((component as any)[stateKey] = {
+          cleanupWatchers: [] as Array<() => void>,
+          configurations: [] as Configuration[],
+        });
+
+      // Nettoyage des watchers et configurations précédentes
+      state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      state.cleanupWatchers = [];
+      state.configurations.forEach((conf: Configuration) => {
+        if (conf.unsubscribePublisher) {
+          conf.unsubscribePublisher();
+        }
+      });
+      state.configurations = [];
+
+      const onAssignValues: unknown[] = [];
+      const confs: Configuration[] = [];
+
+      // Initialisation des configurations
+      for (let i = 0; i < values.length; i++) {
+        const pathConfig = pathConfigs[i];
+        const callbacks: Set<Callback> = new Set();
+        const onAssign = (assignedValue: unknown) => {
+          onAssignValues[i] = assignedValue;
+          if (
+            onAssignValues.filter((v) => v !== null && v !== undefined)
+              .length === values.length
+          ) {
+            callbacks.forEach((callback) => callback(...onAssignValues));
+          }
+        };
+        confs.push({
+          publisher: null,
+          onAssign,
+          callbacks,
+          unsubscribePublisher: null,
+          pathConfig,
+          index: i,
+        });
+      }
+
+      const subscribeToPath = (
+        conf: Configuration,
+        resolvedPath: string | null
+      ) => {
+        // Désabonnement de l'ancien publisher
+        if (conf.unsubscribePublisher) {
+          conf.unsubscribePublisher();
+          conf.unsubscribePublisher = null;
+        }
+
+        // Réinitialiser la valeur pour ce chemin lors du changement
+        onAssignValues[conf.index] = null;
+        conf.publisher = null;
+
+        if (!resolvedPath) {
+          return;
+        }
+
+        const publisher = getPublisherFromPath(resolvedPath);
+        if (!publisher) {
+          return;
+        }
+
+        publisher.onAssign(conf.onAssign);
+        conf.unsubscribePublisher = () => {
+          publisher.offAssign(conf.onAssign);
+          if (conf.publisher === publisher) {
+            conf.publisher = null;
+          }
+        };
+        conf.publisher = publisher;
+      };
+
+      const refreshSubscriptions = () => {
+        for (const conf of confs) {
+          if (conf.pathConfig.isDynamic) {
+            const resolution = resolveDynamicPath(
+              component,
+              conf.pathConfig.originalPath
+            );
+            if (!resolution.ready) {
+              subscribeToPath(conf, null);
+              continue;
+            }
+            subscribeToPath(conf, resolution.path);
+          } else {
+            subscribeToPath(conf, conf.pathConfig.originalPath);
+          }
+        }
+      };
+
+      // Enregistrement des watchers pour les chemins dynamiques
+      for (const conf of confs) {
+        if (conf.pathConfig.isDynamic) {
+          for (const dependency of conf.pathConfig.dynamicDependencies) {
+            const unsubscribe = registerDynamicWatcher(
+              component as Record<string, unknown>,
+              dependency,
+              () => refreshSubscriptions()
+            );
+            state.cleanupWatchers.push(unsubscribe);
+          }
+        }
+      }
+
+      // Initialisation du callback
+      callback = descriptor.value.bind(component);
+      for (const conf of confs) {
+        conf.callbacks.add(callback);
+      }
+
+      // Initialisation des abonnements
+      refreshSubscriptions();
+
+      state.configurations = confs;
+    });
+
+    (target as ConnectedComponent).__onDisconnected__((component) => {
+      const state = (component as any)[stateKey];
+      if (!state) return;
+
+      state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      state.cleanupWatchers = [];
+
+      state.configurations.forEach((conf: Configuration) => {
+        if (conf.unsubscribePublisher) {
+          conf.unsubscribePublisher();
+        }
+        conf.callbacks.delete(callback);
+      });
+      state.configurations = [];
+    });
+  };
+}

package/src/core/mixins/Fetcher.ts

@@ -121,21 +121,30 @@ const Fetcher = <
     @property({ type: Number }) refetchEveryMs = 0;
     refetchTimeOutId?: ReturnType<typeof setTimeout>;
 
-    private isFetching = false;
-    private mustRefetch = false;
+    /**
+     * _isFetching est une propriété sensée privée qui permet de savoir si un fetch est en cours
+     * Elle ne peut pas etre veritablement privée actuellement en raison d'une limitation contextuelle a traiter
+     */
+    _isFetching = false;
+
+    /**
+     * _mustRefetch est une propriété sensée privée qui permet de savoir si un fetch est en cours
+     * Elle ne peut pas etre veritablement privée actuellement en raison d'une limitation contextuelle a traiter
+     */
+    _mustRefetch = false;
     handleStartFetching(): "fetching" | "okToFetch" {
-      if (this.isFetching) {
-        this.mustRefetch = true;
+      if (this._isFetching) {
+        this._mustRefetch = true;
         return "fetching";
       }
-      this.isFetching = true;
+      this._isFetching = true;
       return "okToFetch";
     }
 
     handleEndFetching() {
-      this.isFetching = false;
-      if (this.mustRefetch) {
-        this.mustRefetch = false;
+      this._isFetching = false;
+      if (this._mustRefetch) {
+        this._mustRefetch = false;
         this._fetchData();
       }
     }