@supersoniks/concorde 3.3.2 → 4.0.0

package/src/core/utils/PublisherProxy.ts

@@ -4,13 +4,17 @@
  * Merci de laisser ce fichier sans la moindre dépendance en dehors de types du ceur.
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * **/
-import {
+import type {
   PublisherInterface,
   CoreJSType,
   PublisherContentType,
 } from "../_types/types";
 import HTML from "./HTML";
+import Objects from "./Objects";
 import { sonicClassPrefix } from "./Utils";
+
+export type Observable = string;
+
 type DynamicFillingListener = any;
 type TemplateFillingListener = {
   propertyMap: Record<string, string>;
@@ -74,7 +78,7 @@ export class PublisherProxy<T = any> {
   constructor(
     target: T,
     parentProxPub: PublisherProxy | null,
-    parentKey?: string
+    parentKey?: string,
   ) {
     this._value_ = target;
     this.parent = parentProxPub || null;
@@ -119,7 +123,7 @@ export class PublisherProxy<T = any> {
   _assignmentId_ = 0;
   _publishInternalMutation_(lockInternalMutationsTransmission = false) {
     this._mutationListeners_.forEach((handler: VoidFunction): void =>
-      handler()
+      handler(),
     );
     if (this._is_savable_ && !PublisherManager.changed) {
       PublisherManager.changed = true;
@@ -127,7 +131,7 @@ export class PublisherProxy<T = any> {
       const saveId = PublisherManager.saveId;
       setTimeout(
         () => PublisherManager.getInstance().saveToLocalStorage(saveId),
-        1000
+        1000,
       );
     }
     if (lockInternalMutationsTransmission) return;
@@ -153,7 +157,7 @@ export class PublisherProxy<T = any> {
 
   _publishFormInvalidation_() {
     this._formInvalidateListeners_.forEach((handler: VoidFunction) =>
-      handler()
+      handler(),
     );
   }
   _publishDynamicFilling_(key: string, value: CoreJSType) {
@@ -376,7 +380,7 @@ export class PublisherProxy<T = any> {
       if (this.parent && this._parentKey_) {
         this.parent._publishDynamicFilling_(
           this._parentKey_,
-          (this._value_ as any).__value
+          (this._value_ as any).__value,
         );
       }
 
@@ -421,7 +425,7 @@ export class PublisherProxy<T = any> {
     if (this.parent && this._parentKey_)
       this.parent._publishDynamicFilling_(
         this._parentKey_,
-        this._value_ as any
+        this._value_ as any,
       );
     /**
      * Si la donnée est complexe (objet, tableau)
@@ -436,7 +440,7 @@ export class PublisherProxy<T = any> {
         const valueV = isVComplex ? v : { __value: v };
         if (!this._proxies_.has(key)) {
           // A surveiller ancienne version
-          // const newPublisher = new Publisher({}, this);
+          // const newPublisher = new DataProvider({}, this);
           // this._proxies_.set(key, newPublisher);
           // newPublisher._proxies_.set("_parent_", this);
 
@@ -488,8 +492,8 @@ export class PublisherProxy<T = any> {
 }
 
 /**
- * Utilitaires de gestion des Publisher
- * Obtenir, replacer ou supprimer un Publisher
+ * Utilitaires de gestion des DataProvider
+ * Obtenir, replacer ou supprimer un DataProvider
  *
  */
 
@@ -501,7 +505,7 @@ export class PublisherManager {
   static instance: PublisherManager | null = null;
   static instances: Map<string, PublisherManager> = new Map();
   enabledLocaStorageProxies: string[] = [];
-  publishers = new Map<string, Publisher>();
+  publishers = new Map<string, PublisherInterface>();
   localStorageData: Record<
     string,
     {
@@ -582,7 +586,7 @@ export class PublisherManager {
         console.warn(
           "No PublisherManager instance registered with id:",
           id,
-          "creating new one"
+          "creating new one",
         );
         return new PublisherManager();
       }
@@ -595,7 +599,7 @@ export class PublisherManager {
     if (PublisherManager.instances.has(id)) {
       console.warn(
         "PublisherManager instance already registered with id: ",
-        id
+        id,
       );
     }
     PublisherManager.instances.set(id, instance);
@@ -607,17 +611,17 @@ export class PublisherManager {
    */
   public static get(
     id: string,
-    options?: { localStorageMode?: string; expirationDelayMs?: number }
+    options?: { localStorageMode?: string; expirationDelayMs?: number },
   ) {
     return PublisherManager.getInstance().get(id, options);
   }
 
-  public static modifiedCollectore: Set<PublisherProxy>[] = [];
+  public static modifiedCollectore: Set<any>[] = [];
   public static collectModifiedPublisher() {
-    PublisherManager.modifiedCollectore.unshift(new Set());
+    PublisherManager.modifiedCollectore.unshift(new Set<any>());
   }
   public static getModifiedPublishers() {
-    return PublisherManager.modifiedCollectore.shift();
+    return PublisherManager.modifiedCollectore.shift() as Set<any>;
   }
 
   /**
@@ -636,38 +640,40 @@ export class PublisherManager {
     await this.isLocalStrorageReady;
     publisher.set(
       this.localStorageData[id + "¤lang_" + HTML.getLanguage()]?.data ||
-        publisher.get()
+        publisher.get(),
     );
   }
 
   initialisedData: string[] = [];
-  get(id: string, options?: PublisherProxyOptions) {
+  get<T = any>(id: string, options?: PublisherProxyOptions): DataProvider<T> {
     const hasLocalStorage = options?.localStorageMode === "enabled";
     const invalidateOnPageShow = options?.invalidateOnPageShow === true;
     if (!this.publishers.has(id)) {
       const data = {};
-      const publisher = new Publisher(data) as PublisherInterface;
+      const publisher = createPublisher(data as T) as DataProvider<T>;
       this.set(id, publisher);
     }
-    const publisher = this.publishers.get(id) as PublisherInterface;
+    const publisher = this.publishers.get(id) as DataProvider<T>;
     if (hasLocalStorage && this.initialisedData.indexOf(id) === -1) {
       if (options?.expirationDelayMs) {
-        publisher._expiration_delay_ = options.expirationDelayMs;
+        (publisher as PublisherProxy<T>)._expiration_delay_ =
+          options.expirationDelayMs;
       }
-      publisher._is_savable_ = true;
+      (publisher as PublisherProxy<T>)._is_savable_ = true;
       this.initialisedData.push(id);
       this.setLocalData(publisher, id);
     }
     if (invalidateOnPageShow) {
-      publisher._invalidate_on_page_show_ = invalidateOnPageShow;
+      (publisher as PublisherProxy<T>)._invalidate_on_page_show_ =
+        invalidateOnPageShow;
     }
-    return this.publishers.get(id) as PublisherInterface;
+    return this.publishers.get(id) as DataProvider<T>;
   }
   /**
    * Remplace un publisher pour l'id fourni par un autre.
    * L'autre publisher n'est pas supprimé.
    */
-  set(id: string, publisher: Publisher) {
+  set<T = any>(id: string, publisher: DataProvider<T>) {
     this.publishers.set(id, publisher);
   }
   /**
@@ -715,7 +721,7 @@ export class PublisherManager {
       if (hasChanged) {
         const compressedData = await this.compress(
           JSON.stringify(this.localStorageData),
-          "gzip"
+          "gzip",
         );
         localStorage.setItem(localStorageDataKey, compressedData);
       }
@@ -749,7 +755,7 @@ export class PublisherManager {
     const decodedString = atob(str);
     const arrayBufferViewFromLocalStorage = Uint8Array.from(
       decodedString,
-      (c) => c.charCodeAt(0)
+      (c) => c.charCodeAt(0),
     );
     const byteArray = arrayBufferViewFromLocalStorage.buffer;
     const win = window as any;
@@ -811,169 +817,194 @@ const internalProps: Set<string> = new Set([
   "_assignmentId_",
   "_invalidate_on_page_show_",
 ]);
-
+// type UnderscoreWrappedKeys<T> = {
+//   [K in keyof T]-?: K extends `_${string}_` ? K : never
+// }[keyof T];
 /**
  * Le Proxy Javascript
  */
-export default class Publisher<
-  T = PublisherContentType
-> extends PublisherProxy<T> {
-  constructor(
-    target: T,
-    parentProxPub: PublisherProxy | null = null,
-    parentKey?: string
-  ) {
-    super(target, parentProxPub, parentKey);
+type WithoutUnderscoreKeys<T> = {
+  [K in keyof T as K extends `_${string}_` ? never : K]: T[K];
+};
 
-    const thisProxy: any = new Proxy(this, {
-      /**
-       * Lorsque l'on écrit monConteneur =  publisher.maClef ou monConteneur = publisher["maClef"] monConteneur contient :
-       * Les methodes de PublisherProxy (onAssign... : voir liste dans kle tableaus si dessous), si la clef est une méthode de PublisherProxy,,
-       * Sinon un autre proxy qui a comme valeur interne la valeur corespondante à la clef dans l'objet.
-       */
-      get: function (publisherInstance: PublisherProxy<T>, sKey: any) {
-        if (internalProps.has(sKey)) return (publisherInstance as any)[sKey];
-        if (sKey == Symbol.toPrimitive) {
-          return () => thisProxy.get();
-        }
+export type DataProvider<T = any> = WithoutUnderscoreKeys<PublisherProxy<T>> & {
+  [K in keyof T]: DataProvider<T[K]>;
+};
 
-        // Support de la notation à points (rigolo mais pas intuitif)
-        // if (sKey.includes(".")) {
-        //   const keys = sKey.split(".");
-        //   return thisProxy[keys.shift()][keys.join(".")];
-        // }
-
-        if (!publisherInstance._proxies_.has(sKey)) {
-          const vValue = (publisherInstance._value_ as any)[sKey];
-
-          const newPublisher = new Publisher(
-            isComplex(vValue) ? vValue : { __value: vValue },
-            publisherInstance,
-            sKey
-          );
-          newPublisher._proxies_.set("_parent_", thisProxy);
-          publisherInstance._proxies_.set(sKey, newPublisher);
-        }
-        return publisherInstance._proxies_.get(sKey);
-      },
-      /**
-       * Lorsque l'on écrit publisher.maClef = value ou publisher["maClef"] = value, on assigne la valeur à la clef dans l'objet interne.
-       * Les gestionnairs associés sopnt déclenchés en conséquence de manière profonde et remontante si nécessaire.
-       */
-      set: function (publisherInstance, sKey: string, vValue) {
-        //Fonctionnement pour la donnée interne pas de dispatch;
-        if (sKey == "_value_") {
-          publisherInstance._value_ = vValue;
-          return true;
-        }
-        if (sKey == "_cachedGet_") {
-          publisherInstance._cachedGet_ = vValue;
-          return true;
-        }
-        if (sKey == "_assignmentId_") {
-          publisherInstance._assignmentId_ = vValue;
-          return true;
-        }
+function createPublisherHandler<T = any>(
+  publisherInstance: PublisherProxy<T>,
+  getProxy: () => DataProvider<T>,
+): ProxyHandler<PublisherProxy<T>> {
+  return {
+    /**
+     * Lorsque l'on écrit monConteneur =  publisher.maClef ou monConteneur = publisher["maClef"] monConteneur contient :
+     * Les methodes de PublisherProxy (onAssign... : voir liste dans kle tableaus si dessous), si la clef est une méthode de PublisherProxy,,
+     * Sinon un autre proxy qui a comme valeur interne la valeur corespondante à la clef dans l'objet.
+     */
+    get: function (_publisherInstance, sKey: any) {
+      if (typeof sKey === "string" && internalProps.has(sKey))
+        return (publisherInstance as any)[sKey];
+      if (sKey == Symbol.toPrimitive) {
+        return () => getProxy().get() as T;
+      }
 
-        if (sKey == "_is_savable_") {
-          publisherInstance._is_savable_ = vValue;
-          return true;
-        }
-        if (sKey == "_expiration_delay_") {
-          publisherInstance._expiration_delay_ = vValue;
-          return true;
-        }
-        if (sKey == "_invalidate_on_page_show_") {
-          publisherInstance._invalidate_on_page_show_ = vValue;
-          return true;
-        }
-        if (sKey == "_instanceCounter_") {
-          publisherInstance._instanceCounter_ = vValue;
-          return true;
-        }
+      // Support de la notation à points (rigolo mais pas intuitif)
+      // if (sKey.includes(".")) {
+      //   const keys = sKey.split(".");
+      //   return thisProxy[keys.shift()][keys.join(".")];
+      // }
 
-        // Support de la notation à points (rigolo mais pas intuitif)
-        // if (sKey.includes(".")) {
-        //   const keys = sKey.split(".");
-        //   thisProxy[keys.shift() || ""][keys.join(".")].set(vValue);
-        //   return true;
-        // }
-
-        //Création du publisher si il n'existe pas
-        if (!publisherInstance._proxies_.has(sKey)) {
-          const newPublisher = new Publisher({}, publisherInstance, sKey);
-          newPublisher._proxies_.set("_parent_", thisProxy);
-          publisherInstance._proxies_.set(sKey, newPublisher);
-        }
-        //mis à jour et publication de la donnée si elle a changé
+      if (!publisherInstance._proxies_.has(sKey)) {
+        const vValue = (publisherInstance._value_ as any)[sKey];
 
-        const prevValue = (publisherInstance._value_ as any)[sKey];
+        const newPublisher = createPublisher(
+          isComplex(vValue) ? vValue : ({ __value: vValue } as any),
+          publisherInstance,
+          sKey,
+        );
+        newPublisher._proxies_.set("_parent_", getProxy());
+        publisherInstance._proxies_.set(sKey, newPublisher);
+      }
+      return publisherInstance._proxies_.get(sKey);
+    },
+    /**
+     * Lorsque l'on écrit publisher.maClef = value ou publisher["maClef"] = value, on assigne la valeur à la clef dans l'objet interne.
+     * Les gestionnairs associés sopnt déclenchés en conséquence de manière profonde et remontante si nécessaire.
+     */
+    set: function (
+      _publisherInstance,
+      sKey: string,
+      vValue: T | PublisherProxy[keyof PublisherProxy],
+    ) {
+      //Fonctionnement pour la donnée interne pas de dispatch;
+      if (sKey == "_value_") {
+        publisherInstance._value_ = vValue;
+        return true;
+      }
+      if (sKey == "_cachedGet_") {
+        publisherInstance._cachedGet_ = vValue;
+        return true;
+      }
+      if (sKey == "_assignmentId_") {
+        publisherInstance._assignmentId_ = vValue;
+        return true;
+      }
 
-        if (prevValue !== vValue) {
-          (publisherInstance._value_ as any)[sKey] = vValue;
-          publisherInstance._publishDynamicFilling_(sKey, vValue);
-          publisherInstance._proxies_
-            .get(sKey)
-            ?.set(isComplex(vValue) ? vValue : { __value: vValue });
-        }
-        //on retourne  le proxy pour pouvoir chainer les assignements
-        // return publisherInstance._proxies_.get(sKey);
+      if (sKey == "_is_savable_") {
+        publisherInstance._is_savable_ = vValue;
         return true;
-      },
-      /**
-       * Autres propriétés classiques d'un objet implémentées par le proxy
-       */
-      deleteProperty: function (publisherInstance, sKey: string) {
-        publisherInstance;
-        publisherInstance._publishDynamicFilling_(sKey, null);
-        // if (!publisherInstance._proxies_.get(sKey)?.hasListener()) {
-        //   publisherInstance._proxies_.delete(sKey);
-        // } else {
-        publisherInstance._proxies_.get(sKey)?.set(null);
-        // }
-        return delete (publisherInstance._value_ as any)[sKey];
-      },
-      // enumerate: function (publisherInstance, sKey): CoreJSType {
-      //   return publisherInstance._value_.keys();
-      // },
-      has: function (publisherInstance, sKey) {
-        publisherInstance;
-        return (
-          sKey in (publisherInstance._value_ as any) &&
-          sKey != "_lockInternalMutationPublishing_"
-        );
-      },
-      defineProperty: function (publisherInstance, sKey, oDesc) {
-        publisherInstance;
-        if (oDesc && "value" in oDesc) {
-          (publisherInstance._value_ as any)[sKey] = oDesc.value;
-        }
+      }
+      if (sKey == "_expiration_delay_") {
+        publisherInstance._expiration_delay_ = vValue;
         return true;
-        // return publisherInstance._value_;
-      },
-      getOwnPropertyDescriptor: function (publisherInstance, sKey) {
-        publisherInstance;
-        sKey;
-        return {
-          enumerable: true,
-          configurable: true,
-        };
-      },
-      ownKeys: function (publisherInstance) {
-        if ((publisherInstance._value_ as any).__value)
-          return Object.keys((publisherInstance._value_ as any).__value);
-        return Object.keys((publisherInstance as any)._value_);
-      },
-    });
-    return thisProxy as any;
-  }
+      }
+      if (sKey == "_invalidate_on_page_show_") {
+        publisherInstance._invalidate_on_page_show_ = vValue;
+        return true;
+      }
+      if (sKey == "_instanceCounter_") {
+        publisherInstance._instanceCounter_ = vValue;
+        return true;
+      }
 
-  getProperty<U, K extends keyof U>(o: U, propertyName: K): U[K] {
-    return o[propertyName]; // o[propertyName] is of type T[K]
-  }
+      // Support de la notation à points (rigolo mais pas intuitif)
+      // if (sKey.includes(".")) {
+      //   const keys = sKey.split(".");
+      //   thisProxy[keys.shift() || ""][keys.join(".")].set(vValue);
+      //   return true;
+      // }
+
+      //Création du publisher si il n'existe pas
+      if (!publisherInstance._proxies_.has(sKey)) {
+        const newPublisher = createPublisher(
+          {} as any,
+          publisherInstance,
+          sKey,
+        );
+        newPublisher._proxies_.set("_parent_", getProxy());
+        publisherInstance._proxies_.set(sKey, newPublisher);
+      }
+      //mis à jour et publication de la donnée si elle a changé
+
+      const prevValue = (publisherInstance._value_ as any)[sKey];
+
+      if (prevValue !== vValue) {
+        (publisherInstance._value_ as any)[sKey] = vValue;
+        publisherInstance._publishDynamicFilling_(sKey, vValue);
+        publisherInstance._proxies_
+          .get(sKey)
+          ?.set(isComplex(vValue) ? vValue : { __value: vValue });
+      }
+      //on retourne  le proxy pour pouvoir chainer les assignements
+      // return publisherInstance._proxies_.get(sKey);
+      return true;
+    },
+    /**
+     * Autres propriétés classiques d'un objet implémentées par le proxy
+     */
+    deleteProperty: function (_publisherInstance, sKey: string) {
+      publisherInstance._publishDynamicFilling_(sKey, null);
+      // if (!publisherInstance._proxies_.get(sKey)?.hasListener()) {
+      //   publisherInstance._proxies_.delete(sKey);
+      // } else {
+      publisherInstance._proxies_.get(sKey)?.set(null);
+      // }
+      return delete (publisherInstance._value_ as any)[sKey];
+    },
+    // enumerate: function (publisherInstance, sKey): CoreJSType {
+    //   return publisherInstance._value_.keys();
+    // },
+    has: function (_publisherInstance, sKey) {
+      return (
+        sKey in (publisherInstance._value_ as any) &&
+        sKey != "_lockInternalMutationPublishing_"
+      );
+    },
+    defineProperty: function (_publisherInstance, sKey, oDesc) {
+      if (oDesc && "value" in oDesc) {
+        (publisherInstance._value_ as any)[sKey] = oDesc.value;
+      }
+      return true;
+      // return publisherInstance._value_;
+    },
+    getOwnPropertyDescriptor: function (_publisherInstance, sKey) {
+      sKey;
+      return {
+        enumerable: true,
+        configurable: true,
+      };
+    },
+    ownKeys: function (_publisherInstance) {
+      if ((publisherInstance._value_ as any).__value)
+        return Object.keys((publisherInstance._value_ as any).__value);
+      return Object.keys((publisherInstance as any)._value_);
+    },
+  };
 }
 
-// if (typeof module != "undefined") module.exports = {Publisher: Publisher, PublisherManager: PublisherManager};
+export function createPublisher<T = any>(
+  target: T,
+  parentProxPub: PublisherProxy<T> | null = null,
+  parentKey?: string,
+) {
+  const instance = new PublisherProxy<T>(target, parentProxPub, parentKey);
+  let proxy = null as unknown as DataProvider<T> & T;
+  const handler = createPublisherHandler<T>(instance, () => proxy);
+  proxy = new Proxy<PublisherProxy<T>>(
+    instance,
+    handler,
+  ) as unknown as DataProvider<T> & T;
+  return proxy;
+}
+
+/**
+ * @deprecated @see {@link DataProvider} instead
+ */
+export default DataProvider;
+
+export type Publisher<T = any> = DataProvider<T>;
+
+// if (typeof module != "undefined") module.exports = {DataProvider: DataProvider, PublisherManager: PublisherManager};
 
 // /**
 //  * A custom webcomponent wich will be linked to a publisher via its attribute "publisher"
@@ -1000,10 +1031,61 @@ class PublisherWebComponent extends HTMLElement {
 try {
   customElements.define(
     SONIC_PREFIX + "-publisher-proxy",
-    PublisherWebComponent
+    PublisherWebComponent,
   );
 } catch (e) {}
 
+export const getObservables = <T = any>(
+  observable: string,
+): Set<DataProvider<T>> => {
+  if (typeof observable === "function") {
+    const func = observable as () => any;
+    PublisherManager.collectModifiedPublisher();
+    func();
+    return PublisherManager.getModifiedPublishers() as Set<DataProvider<T>>;
+  }
+  if (typeof observable === "string") {
+    const split = observable.split(".");
+    const dataProvider: string = split.shift() || "";
+    let publisher = PublisherManager.get(dataProvider);
+    publisher = Objects.traverse(publisher, split);
+    const set = new Set<DataProvider<T>>();
+    set.add(publisher as DataProvider<T>);
+    return set;
+  }
+  return new Set<DataProvider<T>>([observable as DataProvider<T>]);
+};
+
+// get value
+export const get = <T = any>(id: string) => {
+  return getObservables<T>(id).values().next().value?.get() as T;
+};
+
+const deepee = <T = any>(id: string) => {
+  const value = getObservables<T>(id).values().next().value as DataProvider<T>;
+  // if (defaultValue !== undefined && value) {
+  //   const innerValue = value.get();
+  //   if (Objects.isEmpty(innerValue as Record<string, any>)) {
+  //     value.set(defaultValue);
+  //   }
+  // }
+
+  return value;
+};
+
+export const dataProvider: <T = any>(
+  id: string,
+  defaultValue?: T,
+) => DataProvider<T> = deepee;
+export const dp = deepee;
+
+export const set: <T = any>(id: string, value: T) => void = <T>(
+  id: string,
+  value: T,
+) => {
+  getObservables(id).values().next().value?.set(value);
+};
+
 /**
  * next back handling data invalidation
  */

package/src/core/utils/Utils.ts

@@ -22,3 +22,6 @@ let prefixUpperCamelCase = SONIC_PREFIX.replace(/-([a-z])/g, (g) =>
 );
 export const sonicClassPrefix =
   prefixUpperCamelCase.charAt(0).toUpperCase() + prefixUpperCamelCase.slice(1);
+
+
+  

package/src/core/utils/api.ts

@@ -3,7 +3,7 @@
 import HTML from "@supersoniks/concorde/core/utils/HTML";
 import Objects from "@supersoniks/concorde/core/utils/Objects";
 import { CoreJSType } from "@supersoniks/concorde/core/_types/types";
-import { PublisherManager } from "./PublisherProxy";
+import { dp, PublisherManager } from "./PublisherProxy";
 
 export type APIConfiguration = {
   serviceURL: string | null;
@@ -192,13 +192,11 @@ class API {
     /**
      * Publication en global de la réponse de l'api
      */
-    const apiPublisher = PublisherManager.get("sonic-api") as {
-      lastResponse: APIResponse;
-    };
-    apiPublisher.lastResponse = {
+    const apiPublisher = dp<{lastResponse: APIResponse}>("sonic-api");
+    apiPublisher.lastResponse.set({
       http: fetchResult,
       processed: result,
-    };
+    });
 
     return result;
   }

package/src/dataprovider.ts

@@ -0,0 +1 @@
+export * from "@supersoniks/concorde/core/utils/PublisherProxy";