@supersoniks/concorde 4.9.96 → 4.9.97-visual-stack.0

package/dist/js/core/utils/PublisherProxy.js

@@ -0,0 +1,970 @@
+import { resolveStaticPublisherPath } from "./dataProviderKey";
+import HTML from "./HTML";
+import Objects from "./Objects";
+import { sonicClassPrefix } from "./Utils";
+const DP_OPTION_KEYS = new Set([
+    "localStorageMode",
+    "expirationDelayMs",
+    "invalidateOnPageShow",
+]);
+function isDpOptions(value) {
+    if (value == null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.keys(value).some((key) => DP_OPTION_KEYS.has(key));
+}
+function isLeaf(value) {
+    return Object.prototype.hasOwnProperty.call(value, "__value");
+}
+function isComplex(value) {
+    return typeof value === "object" && value !== null;
+}
+let SONIC_PREFIX = "sonic";
+if (typeof __BUILD_DATE__ === "undefined") {
+    window.__BUILD_DATE__ = "No build date";
+}
+if (typeof __SONIC_PREFIX__ === "undefined") {
+    SONIC_PREFIX = "sonic";
+}
+export const prefix = SONIC_PREFIX;
+const localStorageDataKey = SONIC_PREFIX == "sonic"
+    ? "publisher-proxies-data"
+    : SONIC_PREFIX + "-publisher-proxies-data";
+/**
+ * Custom Proxy contient les méthodes des publishers retournés par PublisherManager.get(publisherId) qui seront utilisées couramment
+ */
+export class PublisherProxy {
+    constructor(target, parentProxPub, parentKey) {
+        this._proxies_ = new Map();
+        this._is_savable_ = false;
+        this._expiration_delay_ = 1000 * 60 * 60 * 12;
+        this._invalidate_on_page_show_ = false;
+        this._invalidateListeners_ = new Set();
+        this._formInvalidateListeners_ = new Set();
+        this._assignListeners_ = new Set();
+        this._mutationListeners_ = new Set();
+        this._fillListeners_ = new Set();
+        this._templateFillListeners_ = new Set();
+        this._lockInternalMutationPublishing_ = false;
+        this._instanceCounter_ = 0;
+        this._assignmentId_ = 0;
+        this._value_ = target;
+        this.parent = parentProxPub || null;
+        this._parentKey_ = parentKey;
+        this.root = this;
+        this._instanceCounter_ = 0;
+        while (this.root.parent) {
+            this.root = this.root.parent;
+        }
+    }
+    /**
+     * Supprime le proxy et ses sous proxy
+     * Supprime les écouteurs associés
+     */
+    delete() {
+        for (const key in this._proxies_.keys()) {
+            if (key == "_parent_")
+                continue;
+            this._proxies_.get(key)?.delete();
+        }
+        this._invalidateListeners_.clear();
+        this._formInvalidateListeners_.clear();
+        this._assignListeners_.clear();
+        this._mutationListeners_.clear();
+        this._fillListeners_.clear();
+        this._templateFillListeners_.clear();
+        this._proxies_.clear();
+        PublisherProxy.instances.delete(this._instanceCounter_);
+    }
+    /**
+     * Utile pour savoir si quelque chose est en écoute d'une modification sur le proxy via une des methodes associées
+     */
+    hasListener() {
+        return (this._templateFillListeners_.size > 0 ||
+            this._assignListeners_.size > 0 ||
+            this._invalidateListeners_.size > 0 ||
+            this._formInvalidateListeners_.size > 0 ||
+            this._mutationListeners_.size > 0 ||
+            this._fillListeners_.size > 0);
+    }
+    _publishInternalMutation_(lockInternalMutationsTransmission = false) {
+        this._mutationListeners_.forEach((handler) => handler());
+        if (this._is_savable_ && !PublisherManager.changed) {
+            PublisherManager.changed = true;
+            PublisherManager.saveId++;
+            const saveId = PublisherManager.saveId;
+            setTimeout(() => PublisherManager.getInstance().saveToLocalStorage(saveId), 1000);
+        }
+        if (lockInternalMutationsTransmission)
+            return;
+        if (this.parent) {
+            this.parent._publishInternalMutation_();
+        }
+    }
+    async _publishAssignement_(lockInternalMutationsTransmission = false) {
+        this._assignmentId_++;
+        const currentId = this._assignmentId_;
+        if (currentId !== this._assignmentId_)
+            return;
+        const newValue = this.get();
+        this._assignListeners_.forEach((handler) => {
+            handler(newValue);
+        });
+        this._publishInternalMutation_(lockInternalMutationsTransmission);
+    }
+    _publishInvalidation_() {
+        this._invalidateListeners_.forEach((handler) => handler());
+    }
+    _publishFormInvalidation_() {
+        this._formInvalidateListeners_.forEach((handler) => handler());
+    }
+    _publishDynamicFilling_(key, value) {
+        this._fillListeners_.forEach((handler) => {
+            if (handler[key] !== value)
+                handler[key] = value;
+        });
+        this._publishTemplateFilling_(key, value);
+    }
+    _publishTemplateFilling_(key, value) {
+        this._templateFillListeners_.forEach((handler) => {
+            const desc = Object.getOwnPropertyDescriptor(handler, key);
+            if (desc && !desc.set && !desc.writable)
+                return;
+            if (handler.propertyMap && handler.propertyMap[key]) {
+                key = handler.propertyMap[key];
+            }
+            if (typeof handler[key] != "undefined" && handler[key] !== value) {
+                handler[key] = value;
+            }
+        });
+    }
+    /**
+     * Appel la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
+     * hanlder reçois alors la nouvelle valeur interne du proxy en paramètre
+     */
+    onAssign(handler, directHandlerCall = true) {
+        if (typeof handler != "function")
+            return;
+        if (this._assignListeners_.has(handler))
+            return;
+        this._assignListeners_.add(handler);
+        if (directHandlerCall)
+            handler(this.get());
+    }
+    /**
+     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
+     */
+    offAssign(handler) {
+        this._assignListeners_.delete(handler);
+    }
+    /**
+     * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
+     */
+    onInvalidate(handler) {
+        if (typeof handler != "function")
+            return;
+        this._invalidateListeners_.add(handler);
+    }
+    /**
+     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
+     */
+    offInvalidate(handler) {
+        if (typeof handler != "function")
+            return;
+        this._invalidateListeners_.delete(handler);
+    }
+    /**
+     * Flag les données comme étant invalides
+     */
+    invalidate() {
+        this._publishInvalidation_();
+    }
+    /**
+     * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
+     */
+    onFormInvalidate(handler) {
+        if (typeof handler != "function")
+            return;
+        this._formInvalidateListeners_.add(handler);
+    }
+    /**
+     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
+     */
+    offFormInvalidate(handler) {
+        if (typeof handler != "function")
+            return;
+        this._formInvalidateListeners_.delete(handler);
+    }
+    invalidateForm() {
+        this._publishFormInvalidation_();
+    }
+    /**
+     * Appel la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
+     *
+     */
+    onInternalMutation(handler) {
+        if (typeof handler != "function")
+            return;
+        this._mutationListeners_.add(handler);
+        handler();
+    }
+    /**
+     * Stop les Appels de la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
+     */
+    offInternalMutation(handler) {
+        if (typeof handler != "function")
+            return;
+        this._mutationListeners_.delete(handler);
+    }
+    /**
+     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     * Remplit uniquement les valeurs déjà présentes dans l'objet / tableau passé en paramètre
+     */
+    startTemplateFilling(handler) {
+        this._templateFillListeners_.add(handler);
+        if (typeof this._value_ != "object")
+            return;
+        for (const z in this._value_) {
+            let valueKey = z;
+            const value = this._value_[z];
+            if (handler.propertyMap && handler.propertyMap[z]) {
+                valueKey = handler.propertyMap[z];
+            }
+            if (typeof handler[z] != "undefined" && handler[z] !== value) {
+                handler[valueKey] = value;
+            }
+        }
+    }
+    /**
+     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     */
+    stopTemplateFilling(handler) {
+        this._templateFillListeners_.delete(handler);
+    }
+    /**
+     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     * Remplit toute valeur qu'elle soit présente ou pas initialement dans l'objet
+     */
+    startDynamicFilling(handler) {
+        this._fillListeners_.add(handler);
+        for (const z in this._value_) {
+            const value = this._value_[z];
+            if (handler[z] !== value)
+                handler[z] = value;
+        }
+    }
+    /*
+     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
+     */
+    stopDynamicFilling(handler) {
+        this._fillListeners_.delete(handler);
+    }
+    /**
+     * Assigne une nouvelle valeur au proxy ce qui déclenche la transmission de la donnée en fonction des "écouteurs" associés
+     */
+    set(newValue, lockInternalMutationsTransmission = false) {
+        /**
+         * On retounre tout de suite si la valeur n'a pas changé
+         */
+        if (this._value_ === newValue)
+            return true;
+        /**
+         * On retounre tout de suite si la valeur n'a pas changé
+         * et qu'elle est primitive
+         */
+        if ((isComplex(this._value_) &&
+            isComplex(newValue) &&
+            newValue &&
+            isLeaf(this._value_) &&
+            isLeaf(newValue) &&
+            this._value_.__value === newValue.__value) ||
+            (!isComplex(newValue) && newValue === this._value_.__value)) {
+            return true;
+        }
+        /**
+         * On assigne la nouvelle valeur
+         */
+        /** Si la valeur est complexe on assigne newValue directe sinon on le met dans une sous valeur __value */
+        this._value_ = isComplex(newValue)
+            ? newValue
+            : { __value: newValue };
+        this._cachedGet_ = undefined;
+        /**
+         * Si il s'agit d'une valeur primitive (un entier, une chaine ) la valeure en renseignée par un objet contenant la vaeur {__value}
+         * On publie juste et on sen va.
+         */
+        const isLeafNewValue = isLeaf(this._value_);
+        if (this._parentKey_ && this.parent) {
+            //si le parent n'a pas de valeur, on la crée en renseignant this.value et on retourne.
+            const valueTosetInParent = isLeaf(this._value_)
+                ? this._value_.__value
+                : this._value_;
+            if (this.parent?.get() == null && this.parent?.get() == undefined) {
+                //if _parentKey_ is a number, we assume it's an array
+                if (!isNaN(Number(this._parentKey_))) {
+                    const parent = [];
+                    parent[Number(this._parentKey_)] = valueTosetInParent;
+                    this.parent.set(parent);
+                }
+                else {
+                    this.parent.set({ [this._parentKey_]: valueTosetInParent });
+                }
+                // return;
+            }
+            else {
+                //on mets à jour la valeur de la clef dans l'objet parnet pour refléter le changement au ca sou elle n'existait pas
+                this.parent._value_[this._parentKey_] = valueTosetInParent;
+            }
+        }
+        if (isLeafNewValue) {
+            // Si la valeur précédente était composite, on reset tous les sous-éléments à null
+            this._proxies_.forEach((_subProxy, key) => {
+                /**
+                 *
+                 * On reùmplace les undefined par des nuls pour eviter la suppression des clefs sauf pour les clef  tableaux
+                 **/
+                if (key != "_parent_") {
+                    _subProxy.set(null);
+                    this._publishDynamicFilling_(key, null);
+                }
+            });
+            //await  //await here gives better performance but can cause issues with some listeners
+            this._publishAssignement_(lockInternalMutationsTransmission);
+            if (this.parent && this._parentKey_) {
+                this.parent._publishDynamicFilling_(this._parentKey_, this._value_.__value);
+            }
+            return true;
+        }
+        /**
+         * On fait la diff sur l'existant.
+         * On maintient les proxys à supprimer et ceux à ajouter.
+         * On met à jour leur valeur interne
+         * On publie les maj au fur et a mesure de modifications
+         */
+        for (const key in this._value_) {
+            const currentValue = this._value_[key];
+            if (currentValue === undefined)
+                delete this._value_[key];
+        }
+        this._proxies_.forEach((_subProxy, key) => {
+            /**
+             *
+             * On reùmplace les undefined par des nuls pour eviter la suppression des clefs sauf pour les clef  tableaux
+             **/
+            const currentValue = this._value_[key];
+            if (key != "_parent_") {
+                if (currentValue === undefined &&
+                    currentValue !== null &&
+                    isNaN(Number(key))) {
+                    _subProxy.set(null);
+                    this._publishDynamicFilling_(key, null);
+                }
+            }
+        });
+        /**
+         * On prévient les écouteurs que la valeur a changé
+         */
+        //await  //await here gives better performance but can cause issues with some listeners
+        this._publishAssignement_();
+        if (this.parent && this._parentKey_)
+            this.parent._publishDynamicFilling_(this._parentKey_, this._value_);
+        /**
+         * Si la donnée est complexe (objet, tableau)
+         * on crée les proxys pour les sous-éléments qui n'en on pas
+         * On renseigne les nouvelles valeurs internes des proxies
+         */
+        if (isComplex(this._value_)) {
+            for (const key in this._value_) {
+                const v = newValue[key];
+                const isVComplex = isComplex(v);
+                const valueV = isVComplex ? v : { __value: v };
+                if (!this._proxies_.has(key)) {
+                    // A surveiller ancienne version
+                    // const newPublisher = new DataProvider({}, this);
+                    // this._proxies_.set(key, newPublisher);
+                    // newPublisher._proxies_.set("_parent_", this);
+                    this._publishDynamicFilling_(key, v);
+                    continue;
+                }
+                //await //await here gives better performance but can cause issues with some listeners
+                this._proxies_.get(key)?.set(valueV, true);
+                this._publishDynamicFilling_(key, v);
+            }
+        }
+        return true;
+    }
+    get() {
+        trackModifiedPublisher(this);
+        if (this._cachedGet_ !== undefined)
+            return this._cachedGet_;
+        if (Object.prototype.hasOwnProperty.call(this._value_, "__value")) {
+            const v = this._value_.__value;
+            return (this._cachedGet_ = (v != undefined ? v : null));
+        }
+        return (this._cachedGet_ = (this._value_ != undefined ? this._value_ : null));
+    }
+    /**
+     * retourner le webcomponent auquel le proxy est associé
+     */
+    get $tag() {
+        if (!this._instanceCounter_) {
+            PublisherProxy.instancesCounter++;
+            this._instanceCounter_ = PublisherProxy.instancesCounter;
+        }
+        PublisherProxy.instances.set(this._instanceCounter_, this);
+        const str = "<" +
+            SONIC_PREFIX +
+            '-publisher-proxy publisher="' +
+            this._instanceCounter_ +
+            '"></' +
+            SONIC_PREFIX +
+            "-publisher-proxy>";
+        return str;
+    }
+}
+PublisherProxy.instances = new Map();
+PublisherProxy.instancesCounter = 0;
+/**
+ * Utilitaires de gestion des DataProvider
+ * Obtenir, replacer ou supprimer un DataProvider
+ *
+ */
+const modifiedCollectore = [];
+function trackModifiedPublisher(proxy) {
+    if (modifiedCollectore.length > 0)
+        modifiedCollectore[0].add(proxy);
+}
+export function collectModifiedPublisher() {
+    modifiedCollectore.unshift(new Set());
+}
+export function getModifiedPublishers() {
+    return modifiedCollectore.shift();
+}
+export class PublisherManager {
+    constructor() {
+        this.enabledLocaStorageProxies = [];
+        this.publishers = new Map();
+        this.localStorageData = {};
+        this.isLocalStrorageReady = null;
+        this.initialisedData = [];
+        if (PublisherManager.instance != null)
+            throw "Singleton / use getInstance";
+        PublisherManager.instance = this;
+        this.isLocalStrorageReady = this.cleanStorageData();
+        PublisherManager.initPageShowHandler();
+    }
+    static initPageShowHandler() {
+        if (PublisherManager.pageShowHandlerInitialized)
+            return;
+        PublisherManager.pageShowHandlerInitialized = true;
+        window.addEventListener("pageshow", (e) => {
+            if (e.persisted)
+                PublisherManager.getInstance().invalidateAll();
+        });
+    }
+    invalidateAll() {
+        this.publishers.forEach((publisher) => {
+            if (!publisher._invalidate_on_page_show_) {
+                return;
+            }
+            publisher.invalidate();
+        });
+    }
+    async cleanStorageData() {
+        return new Promise((resolve) => {
+            const doiIt = async () => {
+                try {
+                    let compressedData = localStorage.getItem(localStorageDataKey);
+                    let localStorageJSON = null;
+                    if (compressedData)
+                        localStorageJSON = await this.decompress(compressedData, "gzip");
+                    if (localStorageJSON) {
+                        try {
+                            this.localStorageData = JSON.parse(localStorageJSON);
+                        }
+                        catch (e) {
+                            this.localStorageData = {};
+                        }
+                    }
+                    else {
+                        compressedData = await this.compress("{}", "gzip");
+                        localStorage.setItem(localStorageDataKey, compressedData);
+                        this.localStorageData = {};
+                    }
+                    const expirationDelay = 1000 * 60 * 60 * 12;
+                    for (const key in this.localStorageData) {
+                        const item = this.localStorageData[key];
+                        const expires = new Date().getTime() -
+                            (item.expirationDelayMs || expirationDelay);
+                        if (item.lastModifiationMS < expires) {
+                            delete this.localStorageData[key];
+                        }
+                    }
+                    resolve(true);
+                }
+                catch (e) {
+                    window.requestAnimationFrame(() => {
+                        resolve(false);
+                    });
+                    console.warn("no publisher cache in this browser");
+                }
+            };
+            doiIt();
+        });
+    }
+    /**
+     * PublisherManager est un singleton
+     */
+    static getInstance(id) {
+        if (id) {
+            const pm = PublisherManager.instances.get(id);
+            if (pm) {
+                return pm;
+            }
+            else {
+                console.warn("No PublisherManager instance registered with id:", id, "creating new one");
+                return new PublisherManager();
+            }
+        }
+        if (PublisherManager.instance == null)
+            return new PublisherManager();
+        return PublisherManager.instance;
+    }
+    /**
+     * shortcut static pour obtenir un publisher vias sont id/adresse sans taper getInstance.
+     * Si le publisher n'existe pas, il est créé.
+     */
+    static get(id, options) {
+        return PublisherManager.getInstance().get(id, options);
+    }
+    /**
+     * Obtenir un publisher vias sont id/adresse
+     * Si le publisher n'existe pas, il est créé.
+     */
+    async setLocalData(publisher, id) {
+        await this.isLocalStrorageReady;
+        publisher.set(this.localStorageData[id + "¤lang_" + HTML.getLanguage()]?.data ||
+            publisher.get());
+    }
+    get(id, options) {
+        const hasLocalStorage = options?.localStorageMode === "enabled";
+        const invalidateOnPageShow = options?.invalidateOnPageShow === true;
+        if (!this.publishers.has(id)) {
+            const data = {};
+            const publisher = createPublisher(data);
+            this.set(id, publisher);
+        }
+        const publisher = this.publishers.get(id);
+        if (hasLocalStorage && this.initialisedData.indexOf(id) === -1) {
+            if (options?.expirationDelayMs) {
+                publisher._expiration_delay_ =
+                    options.expirationDelayMs;
+            }
+            publisher._is_savable_ = true;
+            this.initialisedData.push(id);
+            this.setLocalData(publisher, id);
+        }
+        if (invalidateOnPageShow) {
+            publisher._invalidate_on_page_show_ =
+                invalidateOnPageShow;
+        }
+        return this.publishers.get(id);
+    }
+    /**
+     * Remplace un publisher pour l'id fourni par un autre.
+     * L'autre publisher n'est pas supprimé.
+     */
+    set(id, publisher) {
+        this.publishers.set(id, publisher);
+    }
+    /**
+     * @warning
+     * !!!!! ATTENTION !!!!!
+     * Il est fort à aprier que vous ne voulez pas utiliser cette methode
+     * Il s'agit d'une supression complete
+     * * du publisher de la liste
+     * * des bindings
+     * * de même que ses sous publishers
+     *
+     * UTILISEZ PLUTÔT la méthode publisher.set({}) pour réinitialiser un publisher sans perdre les ecouteurs
+     */
+    delete(id) {
+        if (!this.publishers.has(id))
+            return false;
+        this.publishers.delete(id);
+        return true;
+    }
+    async saveToLocalStorage(saveId = 0) {
+        /**
+         * si l'id a changé et que ce n'est pas un multiple de 10, on ne sauve pas
+         * on sauvegarde quand même tous les 10 au cas ou on aurrait des changements en continue, par exemple à chaque frame
+         */
+        if (saveId !== PublisherManager.saveId && saveId % 10 != 0)
+            return;
+        try {
+            if (!PublisherManager.changed || PublisherManager.saving)
+                return;
+            PublisherManager.saving = true;
+            PublisherManager.changed = false;
+            const keys = Array.from(this.publishers.keys());
+            let hasChanged = false;
+            for (const key of keys) {
+                const publisher = this.publishers.get(key);
+                if (!publisher?._is_savable_)
+                    continue;
+                const data = publisher?.get();
+                if (!data)
+                    continue;
+                this.localStorageData[key + "¤lang_" + HTML.getLanguage()] = {
+                    lastModifiationMS: new Date().getTime(),
+                    expirationDelayMs: publisher._expiration_delay_,
+                    data: data,
+                };
+                hasChanged = true;
+            }
+            // on enregistre les données
+            if (hasChanged) {
+                const compressedData = await this.compress(JSON.stringify(this.localStorageData), "gzip");
+                localStorage.setItem(localStorageDataKey, compressedData);
+            }
+            PublisherManager.saving = false;
+            if (PublisherManager.changed) {
+                PublisherManager.saveId++;
+                const saveId = PublisherManager.saveId;
+                setTimeout(() => this.saveToLocalStorage(saveId), 1000);
+            }
+        }
+        catch (e) {
+            PublisherManager.saving = false;
+        }
+    }
+    async compress(string, encoding) {
+        const byteArray = new TextEncoder().encode(string);
+        const win = window;
+        const cs = new win.CompressionStream(encoding);
+        const writer = cs.writable.getWriter();
+        writer.write(byteArray);
+        writer.close();
+        const result = await new Response(cs.readable).arrayBuffer();
+        const arrayBufferView = new Uint8Array(result);
+        let str = "";
+        for (let i = 0; i < arrayBufferView.length; i++) {
+            str += String.fromCharCode(arrayBufferView[i]);
+        }
+        return btoa(str);
+    }
+    async decompress(str, encoding) {
+        const decodedString = atob(str);
+        const arrayBufferViewFromLocalStorage = Uint8Array.from(decodedString, (c) => c.charCodeAt(0));
+        const byteArray = arrayBufferViewFromLocalStorage.buffer;
+        const win = window;
+        const cs = new win.DecompressionStream(encoding);
+        const writer = cs.writable.getWriter();
+        writer.write(byteArray);
+        writer.close();
+        const result = await new Response(cs.readable).arrayBuffer();
+        return new TextDecoder().decode(result);
+    }
+}
+PublisherManager.buildDate = __BUILD_DATE__;
+PublisherManager.changed = false;
+PublisherManager.saving = false;
+PublisherManager.saveId = 0;
+PublisherManager.instance = null;
+PublisherManager.instances = new Map();
+PublisherManager.pageShowHandlerInitialized = false;
+/**
+ * Partage le singleton entre le bundle core et les addons CDN (3d / shader / hf).
+ * Sans cela, chaque IIFE aurait sa propre classe `PublisherManager` et des
+ * dataProviders isolés.
+ */
+if (typeof window !== "undefined") {
+    const win = window;
+    const sharedKey = sonicClassPrefix + "PublisherManager";
+    const Shared = (win[sharedKey] || PublisherManager);
+    if (!win[sharedKey])
+        win[sharedKey] = PublisherManager;
+    if (Shared !== PublisherManager) {
+        const syncKeys = [
+            "instance",
+            "instances",
+            "changed",
+            "saving",
+            "saveId",
+            "pageShowHandlerInitialized",
+        ];
+        for (const key of syncKeys) {
+            Object.defineProperty(PublisherManager, key, {
+                configurable: true,
+                get() {
+                    return Shared[key];
+                },
+                set(value) {
+                    Shared[key] = value;
+                },
+            });
+        }
+    }
+}
+const internalProps = new Set([
+    "invalidate",
+    "onInvalidate",
+    "offInvalidate",
+    "invalidateForm",
+    "onFormInvalidate",
+    "offFormInvalidate",
+    "onAssign",
+    "offAssign",
+    "startDynamicFilling",
+    "stopDynamicFilling",
+    "startTemplateFilling",
+    "stopTemplateFilling",
+    "onInternalMutation",
+    "offInternalMutation",
+    "set",
+    "get",
+    "$tag",
+    "_cachedGet_",
+    "_templateFillListeners_",
+    "_fillListeners_",
+    "_assignListeners_",
+    "_invalidateListeners_",
+    "_formInvalidateListeners_",
+    "_publishInternalMutation_",
+    "hasListener",
+    "delete",
+    "_mutationListeners_",
+    "_publishDynamicFilling_",
+    "_publishInvalidation_",
+    "_publishFormInvalidation_",
+    "_publishTemplateFilling_",
+    "_publishAssignement_",
+    "_proxies_",
+    "parent",
+    "_parentKey_",
+    "_value_",
+    "_is_savable_",
+    "_expiration_delay_",
+    "_lockInternalMutationPublishing_",
+    "_instanceCounter_",
+    "_assignmentId_",
+    "_invalidate_on_page_show_",
+]);
+function createPublisherHandler(publisherInstance, getProxy) {
+    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) {
+            if (typeof sKey === "string" && internalProps.has(sKey))
+                return publisherInstance[sKey];
+            if (sKey == Symbol.toPrimitive) {
+                return () => getProxy().get();
+            }
+            // 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_[sKey];
+                const newPublisher = createPublisher(isComplex(vValue) ? vValue : { __value: vValue }, 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, 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;
+            }
+            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(".");
+            //   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({}, 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_[sKey];
+            if (prevValue !== vValue) {
+                publisherInstance._value_[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) {
+            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_[sKey];
+        },
+        // enumerate: function (publisherInstance, sKey): CoreJSType {
+        //   return publisherInstance._value_.keys();
+        // },
+        has: function (_publisherInstance, sKey) {
+            return (sKey in publisherInstance._value_ &&
+                sKey != "_lockInternalMutationPublishing_");
+        },
+        defineProperty: function (_publisherInstance, sKey, oDesc) {
+            if (oDesc && "value" in oDesc) {
+                publisherInstance._value_[sKey] = oDesc.value;
+            }
+            return true;
+            // return publisherInstance._value_;
+        },
+        getOwnPropertyDescriptor: function (_publisherInstance, sKey) {
+            sKey;
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
+        ownKeys: function (_publisherInstance) {
+            if (publisherInstance._value_.__value)
+                return Object.keys(publisherInstance._value_.__value);
+            return Object.keys(publisherInstance._value_);
+        },
+    };
+}
+export function createPublisher(target, parentProxPub = null, parentKey) {
+    const instance = new PublisherProxy(target, parentProxPub, parentKey);
+    let proxy = null;
+    const handler = createPublisherHandler(instance, () => proxy);
+    proxy = new Proxy(instance, handler);
+    return proxy;
+}
+// if (typeof module != "undefined") module.exports = {DataProvider: DataProvider, PublisherManager: PublisherManager};
+class PublisherWebComponent extends HTMLElement {
+    constructor() {
+        super();
+        this.publisherId = "";
+        this.onAssign = (value) => {
+            this.innerHTML = value.toString();
+        };
+    }
+    connectedCallback() {
+        this.publisherId = this.getAttribute("publisher") || "";
+        this.publisher = PublisherProxy.instances.get(parseInt(this.publisherId));
+        this.publisher?.onAssign(this.onAssign);
+    }
+    disconnectedCallback() {
+        this.publisher?.offAssign(this.onAssign);
+    }
+}
+try {
+    customElements.define(SONIC_PREFIX + "-publisher-proxy", PublisherWebComponent);
+}
+catch (e) { }
+export const getObservables = (observable, options) => {
+    if (typeof observable === "function") {
+        const func = observable;
+        collectModifiedPublisher();
+        func();
+        return getModifiedPublishers();
+    }
+    if (typeof observable === "string") {
+        const split = observable.split(".");
+        const dataProvider = split.shift() || "";
+        let publisher = PublisherManager.get(dataProvider, options);
+        publisher = Objects.traverse(publisher, split);
+        const set = new Set();
+        set.add(publisher);
+        return set;
+    }
+    return new Set([observable]);
+};
+export function get(id) {
+    const path = resolveStaticPublisherPath(id);
+    return getObservables(path).values().next().value?.get();
+}
+function deepee(id, _defaultValue, options) {
+    const path = resolveStaticPublisherPath(id);
+    const value = getObservables(path, options).values().next()
+        .value;
+    // if (defaultValue !== undefined && value) {
+    //   const innerValue = value.get();
+    //   if (Objects.isEmpty(innerValue as Record<string, any>)) {
+    //     value.set(defaultValue);
+    //   }
+    // }
+    return value;
+}
+function isDataProvider(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        typeof value.get === "function" &&
+        typeof value.set === "function" &&
+        typeof value.onAssign === "function");
+}
+function resolvePublisherRef(ref, options) {
+    if (isDataProvider(ref))
+        return ref;
+    return deepee(ref, undefined, options);
+}
+export function dataProvider(id, second) {
+    if (isDpOptions(second))
+        return deepee(id, undefined, second);
+    return deepee(id, second);
+}
+export function dp(id, second) {
+    if (isDpOptions(second))
+        return deepee(id, undefined, second);
+    return deepee(id, second);
+}
+export function mirrorDp(aliasKey, source) {
+    PublisherManager.getInstance().set(resolveStaticPublisherPath(aliasKey), resolvePublisherRef(source));
+}
+export function set(id, value) {
+    const path = resolveStaticPublisherPath(id);
+    getObservables(path).values().next().value?.set(value);
+}
+//# sourceMappingURL=PublisherProxy.js.map