@supersoniks/concorde 4.2.1 → 4.3.0

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

@@ -0,0 +1,148 @@
+import type {
+  DataProviderKey,
+  DataProviderKeyHost,
+} from "../../utils/dataProviderKey";
+import DataProvider from "../../utils/PublisherProxy";
+import { ConnectedComponent, setSubscribable } from "./common";
+import { extractDynamicDependencies, resolveDynamicPath } from "./dynamicPath";
+import {
+  publishDynamicWatchKeys,
+  registerDynamicPropertyWatcher,
+} from "./dynamicPropertyWatch";
+import { getPublisherFromPath } from "./publisherPath";
+
+/**
+ * Publishes property writes to a publisher path. Inverse of @subscribe.
+ * When the property is set, the value is written to the publisher (reflect-only, no subscription).
+ * The decorated property is typed as `T` (or optional / `| null` / `| undefined` for Lit / TS 5).
+ * Supports dynamic paths: use placeholders like "users.${userIndex}.email" in the DataProviderKey.
+ *
+ * @example
+ * const formKey = new DataProviderKey<FormData>("formData");
+ * @publish(formKey.email)
+ * @state()
+ * email = "";
+ *
+ * // Dynamic path + hôte typé via le 2ᵉ générique de la clé :
+ * @publish(new DataProviderKey<string, { userIndex: number }>("users.${userIndex}.email"))
+ * email = "";
+ */
+export function publish<T, U = any>(
+  key: DataProviderKey<T, U>,
+): <K extends string>(
+  target: DataProviderKeyHost<U> & { [P in K]?: T | null | undefined },
+  propertyKey: K,
+) => void {
+  const path = key.path;
+  const dynamicDependencies = extractDynamicDependencies(path);
+
+  return function (target: object, propertyKey: string) {
+    setSubscribable(target);
+    const publisherKey = `__publish_${propertyKey}_publisher__`;
+    const internalValueKey = `__publish_${propertyKey}_value__`;
+
+    const existingDescriptor = Object.getOwnPropertyDescriptor(
+      target as object,
+      propertyKey,
+    );
+    const initialValue =
+      existingDescriptor && !existingDescriptor.get && !existingDescriptor.set
+        ? existingDescriptor.value
+        : undefined;
+
+    Object.defineProperty(target as object, propertyKey, {
+      get() {
+        if (existingDescriptor?.get) {
+          return existingDescriptor.get.call(this);
+        }
+        if (
+          !Object.prototype.hasOwnProperty.call(this, internalValueKey) &&
+          initialValue !== undefined
+        ) {
+          (this as Record<string, unknown>)[internalValueKey] = initialValue;
+        }
+        return (this as Record<string, unknown>)[internalValueKey];
+      },
+      set(newValue: unknown) {
+        if (existingDescriptor?.set) {
+          existingDescriptor.set.call(this, newValue);
+        } else {
+          (this as Record<string, unknown>)[internalValueKey] = newValue;
+        }
+        const publisher = (this as Record<string, unknown>)[publisherKey] as
+          | DataProvider
+          | undefined;
+        if (publisher) {
+          publisher.set(newValue);
+        }
+      },
+      enumerable: existingDescriptor?.enumerable ?? true,
+      configurable: existingDescriptor?.configurable ?? true,
+    });
+
+    (target as ConnectedComponent).__onConnected__((component) => {
+      const comp = component as Record<string, unknown>;
+      const stateKey = `__publish_state_${propertyKey}`;
+      type PublishState = { cleanupWatchers: Array<() => void> };
+      const state: PublishState =
+        (comp[stateKey] as PublishState) ||
+        ((comp[stateKey] as PublishState) = {
+          cleanupWatchers: [],
+        });
+
+      const updatePublisher = () => {
+        let resolvedPath: string | null;
+        if (dynamicDependencies.length) {
+          const resolution = resolveDynamicPath(component, path);
+          resolvedPath = resolution.ready ? resolution.path : null;
+        } else {
+          resolvedPath = path;
+        }
+        const publisher = resolvedPath
+          ? getPublisherFromPath(resolvedPath)
+          : undefined;
+        comp[publisherKey] = publisher ?? null;
+        if (publisher && propertyKey in component) {
+          const currentValue = comp[propertyKey];
+          if (currentValue !== undefined) {
+            publisher.set(currentValue);
+          }
+        }
+      };
+
+      state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      state.cleanupWatchers = [];
+
+      if (dynamicDependencies.length) {
+        for (const dependency of dynamicDependencies) {
+          state.cleanupWatchers.push(
+            registerDynamicPropertyWatcher(
+              publishDynamicWatchKeys.watcherStore,
+              publishDynamicWatchKeys.hooked,
+              comp,
+              dependency,
+              updatePublisher,
+            ),
+          );
+        }
+      }
+
+      updatePublisher();
+    });
+
+    (target as ConnectedComponent).__onDisconnected__((component) => {
+      const comp = component as Record<string, unknown>;
+      const stateKey = `__publish_state_${propertyKey}`;
+      const state = comp[stateKey] as
+        | { cleanupWatchers: Array<() => void> }
+        | undefined;
+      if (state?.cleanupWatchers) {
+        state.cleanupWatchers.forEach((cleanup: () => void) => cleanup());
+      }
+      comp[publisherKey] = undefined;
+    });
+  } as <K extends string>(
+    target: DataProviderKeyHost<U> & { [P in K]?: T | null | undefined },
+    propertyKey: K,
+  ) => void;
+}

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

@@ -0,0 +1,13 @@
+import { Objects } from "@supersoniks/concorde/utils";
+import DataProvider, { PublisherManager } from "../../utils/PublisherProxy";
+
+export function getPublisherFromPath(path: string): DataProvider | null {
+  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;
+}

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

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { DataProviderKey } from "../../utils/dataProviderKey";
+import { subscribe } from "./subscribe";
+
+type ControlStats = {
+  gauge: number;
+  checkedTickets: { id: string }[];
+};
+
+const statsKey = new DataProviderKey<ControlStats>("stats");
+
+describe("subscribe", () => {
+  it("accepts DataProviderKey and binds to path", () => {
+    class TestClass {
+      @subscribe(statsKey.gauge)
+      gauge = 0;
+    }
+    const instance = new TestClass();
+    expect(instance.gauge).toBe(0);
+  });
+});

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

@@ -0,0 +1,32 @@
+import type {
+  DataProviderKey,
+  DataProviderKeyHost,
+} from "../../utils/dataProviderKey";
+import { bind } from "./bind";
+
+/**
+ * Read-only subscription to a publisher path via DataProviderKey<T>. No reflect.
+ * The decorated property is typed as `T` (or optional / `| null` / `| undefined` for Lit / TS 5).
+ * Supports dynamic paths: use placeholders like "users.${userIndex}" in the DataProviderKey.
+ *
+ * @example
+ * const dataKey = new DataProviderKey<Data>("data");
+ * @subscribe(dataKey.count)
+ * @state()
+ * count: number;
+ *
+ * // Dynamic path:
+ * @subscribe(new DataProviderKey<User>("users.${userIndex}"))
+ * user: User | null;
+ */
+export function subscribe<T, U = any>(
+  key: DataProviderKey<T, U>,
+): <K extends string>(
+  target: DataProviderKeyHost<U> & { [P in K]?: T | null | undefined },
+  propertyKey: K,
+) => void {
+  return bind(key) as <K extends string>(
+    target: DataProviderKeyHost<U> & { [P in K]?: T | null | undefined },
+    propertyKey: K,
+  ) => void;
+}

package/src/core/decorators/subscriber/subscribe.type-test.ts

@@ -0,0 +1,32 @@
+/**
+ * Type tests for subscribe — ensures property type must match DataProviderKey<T>.
+ * Excluded from build. To verify: temporarily remove from exclude and run build.
+ * Expected: InvalidUsage and InvalidUsage2 should produce type errors.
+ */
+import { DataProviderKey } from "../../utils/dataProviderKey";
+import { subscribe } from "./subscribe";
+
+type ControlStats = {
+  gauge: number;
+  label: string;
+};
+
+const statsKey = new DataProviderKey<ControlStats>("stats");
+
+// OK: gauge is number, matches DataProviderKey<number>
+class ValidUsage {
+  @subscribe(statsKey.gauge)
+  gauge = 0;
+}
+
+// Should error: gauge should be number, not string
+class InvalidUsage {
+  @subscribe(statsKey.gauge)
+  gauge: string = "";
+}
+
+// Should error: label should be string, not number
+class InvalidUsage2 {
+  @subscribe(statsKey.label)
+  label: number = 0;
+}

package/src/core/utils/api.ts

@@ -36,6 +36,30 @@ export type APIResponse = {
   http: Response;
   processed: ResultTypeInterface;
 };
+
+/** Valeur assignée par `@get` : requête native, réponse `fetch` si HTTP, résultat métier typé `T`. */
+export type ApiGetResult<T> = {
+  request: Request;
+  /** Absent / `undefined` pour les chemins `dataProvider(...)` (pas d’appel réseau). */
+  response?: Response;
+  /** Corps utile sans `_sonic_http_response_` sur l’objet racine. */
+  result: T;
+};
+
+/** Extrait le corps typé depuis le résultat traité par `handleResult`. */
+export function extractTypedApiResult<T>(
+  processed: ResultTypeInterface | null | undefined,
+): T {
+  if (processed == null || typeof processed !== "object") {
+    return processed as T;
+  }
+  if (Array.isArray(processed)) {
+    return processed as T;
+  }
+  const copy = { ...(processed as Record<string, unknown>) };
+  delete copy._sonic_http_response_;
+  return copy as T;
+}
 class API {
   /**
    * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
@@ -149,7 +173,7 @@ class API {
   }
   async handleResult(
     fetchResult: Response,
-    lastCall: APICall
+    lastCall: APICall,
   ): Promise<ResultTypeInterface> {
     API.firstCallDoneFlags.set(this.serviceURL, "done");
     this.lastResult = fetchResult;
@@ -177,14 +201,14 @@ class API {
       if (lastCall.apiMethod === "get") {
         result = await this[lastCall.apiMethod](
           lastCall.path,
-          lastCall.additionalHeaders
+          lastCall.additionalHeaders,
         );
       } else {
         result = await this[lastCall.apiMethod](
           lastCall.path,
           lastCall.data,
           lastCall.method,
-          lastCall.additionalHeaders
+          lastCall.additionalHeaders,
         );
       }
     }
@@ -192,7 +216,7 @@ class API {
     /**
      * Publication en global de la réponse de l'api
      */
-    const apiPublisher = dp<{lastResponse: APIResponse}>("sonic-api");
+    const apiPublisher = dp<{ lastResponse: APIResponse }>("sonic-api");
     apiPublisher.lastResponse.set({
       http: fetchResult,
       processed: result,
@@ -218,7 +242,7 @@ class API {
         Authorization:
           "Basic " +
           window.btoa(
-            unescape(encodeURIComponent(this.userName + ":" + this.password))
+            unescape(encodeURIComponent(this.userName + ":" + this.password)),
           ),
       };
     } else if (this.authToken) {
@@ -237,7 +261,7 @@ class API {
         headers: headers,
         credentials: this.credentials,
         keepalive: this.keepAlive,
-      }
+      },
     );
 
     try {
@@ -344,7 +368,7 @@ class API {
         const loop = () => {
           if (
             ![undefined, "loading"].includes(
-              API.firstCallDoneFlags.get(this.serviceURL)
+              API.firstCallDoneFlags.get(this.serviceURL),
             )
           ) {
             resolve(true);
@@ -400,6 +424,50 @@ class API {
     API.loadingGetPromises.delete(mapKey);
     return result as T & ResultTypeInterface;
   }
+
+  /**
+   * S’appuie sur `get()` puis reformate la réponse : `Request` équivalent à l’appel,
+   * `Response` renseignée par `lastResult` après un GET HTTP (via `handleResult`),
+   * `result` = corps métier typé `T` (sans `_sonic_http_response_` à la racine).
+   * Pour `dataProvider(...)`, pas de `response` (pas de fetch).
+   */
+  async getDetailed<T>(
+    path: string,
+    additionalHeaders?: HeadersInit,
+  ): Promise<ApiGetResult<T> | undefined> {
+    const isDataProvider = /dataProvider\((.*?)\)(.*?)$/.test(path);
+
+    const processed = await this.get<T>(path, additionalHeaders);
+    if (processed == null) {
+      return undefined;
+    }
+
+    const result = extractTypedApiResult<T>(processed as ResultTypeInterface);
+    const url = this.computeURL(path);
+
+    if (isDataProvider) {
+      return {
+        request: new Request(url, { method: "GET" }),
+        result,
+      };
+    }
+
+    const headers = await this.createHeaders(additionalHeaders);
+    const request = new Request(url, {
+      method: "GET",
+      headers: new Headers(headers as HeadersInit),
+      credentials: this.credentials,
+      cache: this.cache,
+      keepalive: this.keepAlive,
+    });
+
+    return {
+      request,
+      response: this.lastResult,
+      result,
+    };
+  }
+
   /**
    * Création du header, avec authentification si besoin
    * ajout du language via le header accept-language qui contient le langue du navigateur
@@ -440,7 +508,7 @@ class API {
     path: string,
     data: SendType,
     method = "POST",
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     const lastCall: APICall = {
       apiMethod: "send",
@@ -471,7 +539,7 @@ class API {
     path: string,
     data: SendType,
     method = "POST",
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     const lastCall: APICall = {
       apiMethod: "submitFormData",
@@ -502,7 +570,7 @@ class API {
   async put<T, SendType = CoreJSType>(
     path: string,
     data: SendType,
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     return this.send<T, SendType>(path, data, "PUT", additionalHeaders);
   }
@@ -513,7 +581,7 @@ class API {
   async post<T, SendType = CoreJSType>(
     path: string,
     data: SendType,
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     return this.send<T, SendType>(path, data, "POST", additionalHeaders);
   }
@@ -523,7 +591,7 @@ class API {
   async patch<T, SendType = CoreJSType>(
     path: string,
     data: SendType,
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     return this.send<T, SendType>(path, data, "PATCH", additionalHeaders);
   }
@@ -534,7 +602,7 @@ class API {
   async delete<T, SendType = CoreJSType>(
     path: string,
     data: SendType,
-    additionalHeaders?: HeadersInit
+    additionalHeaders?: HeadersInit,
   ) {
     return this.send<T, SendType>(path, data, "delete", additionalHeaders);
   }
@@ -548,7 +616,7 @@ export default API;
 let logIsConf = false;
 let logEndPoint = "log";
 let logConfiguration: APIConfiguration = HTML.getApiConfiguration(
-  document.body || document.documentElement
+  document.body || document.documentElement,
 );
 
 let logsToSend: any = [];
@@ -623,6 +691,6 @@ export const configLog = (newConfig: APIConfiguration, endPoint = "log") => {
         timestamp: new Date().toISOString(),
       };
       log(event.reason?.message || "Unknown rejection reason.", errorDetails);
-    }
+    },
   );
 };

package/src/core/utils/dataProviderKey.spec.ts

@@ -0,0 +1,34 @@
+import { DataProviderKey } from "./dataProviderKey";
+
+type LegacyCheckedTicket = { id: string };
+type ControlRateType = "A" | "B";
+type ControlStats = {
+  checkedTickets: LegacyCheckedTicket[];
+  gauge: number;
+  insidePeople: number;
+  soldTickets: number;
+  controlRateType: ControlRateType;
+  totalCheckedTickets: number;
+};
+
+describe("DataProviderKey", () => {
+  it("construit le chemin cumulatif via les accès", () => {
+    const myKey = new DataProviderKey<ControlStats>(
+      "idDonneesDeStats",
+    ).checkedTickets[0];
+    expect(myKey.toString()).toBe("idDonneesDeStats.checkedTickets.0");
+    expect(myKey.path).toBe("idDonneesDeStats.checkedTickets.0");
+  });
+
+  it("permet la navigation type-safe sur les propriétés", () => {
+    const key = new DataProviderKey<ControlStats>("stats");
+    const gaugeKey = key.gauge;
+    expect(gaugeKey.path).toBe("stats.gauge");
+    expect(gaugeKey.toString()).toBe("stats.gauge");
+  });
+
+  it("fonctionne avec new", () => {
+    const key = new DataProviderKey<ControlStats>("root");
+    expect(key.path).toBe("root");
+  });
+});

package/src/core/utils/dataProviderKey.ts

@@ -0,0 +1,86 @@
+/**
+ * Type-safe navigation through composite data structures (publisher paths).
+ * Each property or index access extends the path. Retrieve the final path via toString() or path.
+ * Supports dynamic paths: use placeholders like "users.${userIndex}" in the constructor.
+ *
+ * @example
+ * const myKey = new DataProviderKey<Data>("data").items[0];
+ * myKey.toString();  // "data.items.0"
+ * myKey.path;        // same
+ *
+ * @example
+ * // U = dépendances dynamiques sur l’hôte (voir DataProviderKeyHost) — propagé sur .foo.bar
+ * new DataProviderKey<User, { userIndex: number }>("demoUsers.${userIndex}");
+ */
+
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/**
+ * Prototype de classe décorée : propriétés minimales attendues sur l’hôte quand la clé est
+ * `DataProviderKey<…, U>` (U renseigné à la construction). Avec `U` par défaut (`any`), pas de contrainte.
+ */
+export type DataProviderKeyHost<U> = IsAny<U> extends true
+  ? object
+  : keyof U extends never
+    ? object
+    : object & U;
+
+/**
+ * U : forme minimale du composant pour résoudre les placeholders `${…}` du path ; inchangée lors de la navigation.
+ */
+type DataProviderKeyProxy<T, U = any> = T extends object
+  ? {
+      [K in keyof T as T[K] extends (...args: unknown[]) => unknown
+        ? never
+        : K]: DataProviderKey<T[K], U>;
+    }
+  : object;
+
+export type DataProviderKey<T, U = any> = DataProviderKeyImpl<T, U> &
+  DataProviderKeyProxy<T, U>;
+
+class DataProviderKeyImpl<T, U = any> {
+  declare readonly _phantom?: T;
+  declare readonly _phantomDeps?: U;
+
+  constructor(public readonly path: string) {}
+
+  toString(): string {
+    return this.path;
+  }
+}
+
+function createDataProviderKeyProxy<T, U = any>(
+  key: DataProviderKeyImpl<T, U>,
+): DataProviderKey<T, U> {
+  return new Proxy(key, {
+    get(target, prop: string | symbol) {
+      if (prop === "path") return target.path;
+      if (prop === "toString") return target.toString.bind(target);
+      if (prop === Symbol.toStringTag) return "DataProviderKey";
+      if (typeof prop === "symbol")
+        return (target as unknown as Record<symbol, unknown>)[prop];
+      const newPath = target.path
+        ? `${target.path}.${String(prop)}`
+        : String(prop);
+      return createDataProviderKeyProxy(
+        new DataProviderKeyImpl<unknown, U>(newPath),
+      );
+    },
+  }) as DataProviderKey<T, U>;
+}
+
+export interface DataProviderKeyConstructor {
+  new <T, U = any>(path: string): DataProviderKey<T, U>;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const DataProviderKey: DataProviderKeyConstructor = function (
+  this: any,
+  path: string,
+): DataProviderKey<unknown, any> {
+  if (!(this instanceof DataProviderKey)) {
+    return new (DataProviderKey as DataProviderKeyConstructor)(path);
+  }
+  return createDataProviderKeyProxy(new DataProviderKeyImpl(path));
+} as any;

package/src/core/utils/endpoint.spec.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { Endpoint } from "./endpoint";
+
+describe("Endpoint", () => {
+  it("expose le path normalisé (trim)", () => {
+    const e = new Endpoint<{ x: number }>("  communes?limit=1  ");
+    expect(e.path).toBe("communes?limit=1");
+    expect(e.toString()).toBe("communes?limit=1");
+  });
+
+  it("refuse le path vide", () => {
+    expect(() => new Endpoint("")).toThrow(RangeError);
+    expect(() => new Endpoint("   ")).toThrow(RangeError);
+  });
+
+  it("normalizePath et isNonEmpty", () => {
+    expect(Endpoint.normalizePath("a")).toBe("a");
+    expect(Endpoint.isNonEmpty(" x ")).toBe(true);
+    expect(Endpoint.isNonEmpty("")).toBe(false);
+  });
+
+  it("normalizePath enlève le slash initial et les doubles slash (relatif)", () => {
+    expect(Endpoint.normalizePath("/users/1")).toBe("users/1");
+    expect(Endpoint.normalizePath("//users//1")).toBe("users/1");
+    expect(Endpoint.normalizePath("v1//users//x?limit=1")).toBe(
+      "v1/users/x?limit=1",
+    );
+  });
+
+  it("normalizePath pour URL absolue : pathname sans doubles slash", () => {
+    expect(
+      Endpoint.normalizePath("https://example.com/api//v1//x"),
+    ).toBe("https://example.com/api/v1/x");
+  });
+
+  it("looksLikeDataProviderPath", () => {
+    expect(Endpoint.looksLikeDataProviderPath("dataProvider(foo)")).toBe(true);
+    expect(Endpoint.looksLikeDataProviderPath("  DataProvider(x)")).toBe(true);
+    expect(Endpoint.looksLikeDataProviderPath("users/1")).toBe(false);
+  });
+});