@supersoniks/concorde 1.1.42 → 1.1.44

package/core/utils/Arrays.d.ts

@@ -2,19 +2,19 @@ declare class Arrays {
     /**
      * Vérifie si les deux tableaux ont le même contenu
      */
-    static areEqual(array1: Array<any>, array2: Array<any>): boolean;
+    static areEqual<U>(array1: Array<U>, array2: Array<U>): boolean;
     /**
      * Fournie une fonction to1D qui transforme un tableau 2D en un tableau 1D par concaténation
      */
-    static from2d(source: Array<Array<Record<string, any>>>): {
+    static from2d(source: any): {
         to1D: () => {
             /**Obtenir le tableau final*/
-            get: () => Record<string, any>[];
+            get: () => any;
             everyItem: () => {
                 has: () => {
                     same: () => {
                         value: () => {
-                            forKey: (key: string) => boolean;
+                            forKey: (key: string) => any;
                         };
                     };
                 };
@@ -28,10 +28,10 @@ declare class Arrays {
                 };
             };
             map: (f: (elt: Record<string, any>) => any) => any;
-            filter: (f: (elt: Record<string, any>) => any) => any;
-            find: (f: (elt: Record<string, any>) => any) => Record<string, any> | undefined;
-            some: (f: (elt: Record<string, any>) => any) => boolean;
-            every: (f: (elt: Record<string, any>) => any) => boolean;
+            filter: (f: (elt: any) => any) => any;
+            find: (f: (elt: Record<string, any>) => any) => any;
+            some: (f: (elt: Record<string, any>) => any) => any;
+            every: (f: (elt: Record<string, any>) => any) => any;
             group: () => {
                 byKey: (key: string) => any;
             };
@@ -54,14 +54,14 @@ declare class Arrays {
      * puis data.everyItem().has().same().value().forkey("key");
      * Peu mieux faire. ou voir a remplacer un jour par loadHash par exemple.
      **/
-    static from(source: Array<Record<string, any>>): {
+    static from(source: any): {
         /**Obtenir le tableau final*/
-        get: () => Record<string, any>[];
+        get: () => any;
         everyItem: () => {
             has: () => {
                 same: () => {
                     value: () => {
-                        forKey: (key: string) => boolean;
+                        forKey: (key: string) => any;
                     };
                 };
             };
@@ -75,10 +75,10 @@ declare class Arrays {
             };
         };
         map: (f: (elt: Record<string, any>) => any) => any;
-        filter: (f: (elt: Record<string, any>) => any) => any;
-        find: (f: (elt: Record<string, any>) => any) => Record<string, any> | undefined;
-        some: (f: (elt: Record<string, any>) => any) => boolean;
-        every: (f: (elt: Record<string, any>) => any) => boolean;
+        filter: (f: (elt: any) => any) => any;
+        find: (f: (elt: Record<string, any>) => any) => any;
+        some: (f: (elt: Record<string, any>) => any) => any;
+        every: (f: (elt: Record<string, any>) => any) => any;
         group: () => {
             byKey: (key: string) => any;
         };

package/core/utils/Arrays.js

@@ -16,6 +16,7 @@ class Arrays {
     /**
      * Fournie une fonction to1D qui transforme un tableau 2D en un tableau 1D par concaténation
      */
+    /*eslint-disable @typescript-eslint/no-explicit-any*/
     static from2d(source) {
         return {
             to1D: () => {
@@ -25,6 +26,7 @@ class Arrays {
             },
         };
     }
+    /*eslint-enable @typescript-eslint/no-explicit-any*/
     /**
      * Fournie des méthodes pour manipuler un tableau
      * A l'écriture cela permet d'avoir des phrases du type:
@@ -32,6 +34,7 @@ class Arrays {
      * puis data.everyItem().has().same().value().forkey("key");
      * Peu mieux faire. ou voir a remplacer un jour par loadHash par exemple.
      **/
+    /*eslint-disable @typescript-eslint/no-explicit-any*/
     static from(source) {
         return {
             /**Obtenir le tableau final*/
@@ -47,7 +50,7 @@ class Arrays {
                                             forKey: (key) => {
                                                 if (source.length < 1)
                                                     return true;
-                                                let first = (source[0] || {})[key];
+                                                const first = (source[0] || {})[key];
                                                 return source.every((item) => (item || {})[key] == first);
                                             },
                                         };
@@ -89,14 +92,14 @@ class Arrays {
             group: () => {
                 return {
                     byKey: (key) => {
-                        let result = [];
-                        let keys = new Map();
-                        for (let item of source) {
-                            let value = item[key];
+                        const result = [];
+                        const keys = new Map();
+                        for (const item of source) {
+                            const value = item[key];
                             if (!keys.has(value)) {
-                                let idx = result.length;
+                                const idx = result.length;
                                 keys.set(value, idx);
-                                let pushable = { items: [] };
+                                const pushable = { items: [] };
                                 pushable[key] = value;
                                 result.push(pushable);
                             }
@@ -111,7 +114,7 @@ class Arrays {
                     duplicates: () => {
                         return {
                             forKey: (key) => {
-                                let set = [...new Set(source.map((item) => item[key]))];
+                                const set = [...new Set(source.map((item) => item[key]))];
                                 return Arrays.from(set.map((value) => source.find((item) => item[key] == value)));
                             },
                         };
@@ -121,7 +124,7 @@ class Arrays {
                             havingSameValue: () => {
                                 return {
                                     forKey: (key) => {
-                                        let areValuesDifferentForKey = (compared1, key) => (compared2) => compared1[key] != compared2[key];
+                                        const areValuesDifferentForKey = (compared1, key) => (compared2) => compared1[key] != compared2[key];
                                         return Arrays.from(source.filter((elt) => toRemoveFromSource.every(areValuesDifferentForKey(elt, key))));
                                     },
                                 };

package/core/utils/DataBindObserver.d.ts

@@ -1,12 +1,19 @@
-declare type BindedVariablesDescriptor = {
-    expression: String;
+import { PublisherInterface, PublisherContentType } from "@supersoniks/concorde/core/_types/types";
+import { SearchableDomElement } from "@supersoniks/concorde/core/utils/HTML";
+type BindedVariablesDescriptor = {
+    expression: string;
     variables: Array<Array<string>>;
 };
-declare type DataBindItem = {
+type DataBindItem = {
     propertyToUpdate: string;
     bindedVariablesDescriptor: BindedVariablesDescriptor;
 };
+type PublisherListenerConfig<ValueType extends PublisherContentType = PublisherContentType> = {
+    publisher: PublisherInterface<ValueType>;
+    onAssign: (value?: ValueType) => void;
+};
 /**
+ *
  * En appelant DataBindObserver.observe(HTMLElement) sun un élément html, tout les éléments peuvent être liés à au publisher a l'adresse déterminée parl'attribut dataProvider de l'un de ses ancêtres.
  * Pour cela un MutationObserver est créé pour observer les changements d'attributs de l'élément.
  * On peut alors ecrire ce genre de choses de manière a lier dynamiquement les données du publisher à l'élément html.
@@ -18,28 +25,28 @@ export default class DataBindObserver {
     /**
      * Maintient la liste des éléments observés de manière à pouvoir les désinscrire quand ils sont supprimés.
      */
-    static observedElements: Map<Node, MutationObserver>;
+    static observedElements: Map<SearchableDomElement, MutationObserver>;
     /**
      * Commencer à observer un élément html.
      */
     static enabled: boolean;
     static disable(): void;
-    static observe(element: HTMLElement): void;
+    static observe(element: SearchableDomElement): void;
     /**
      * Arrêter à observer un élément html.
      */
-    static unObserve(element: HTMLElement): void;
+    static unObserve(element: SearchableDomElement): void;
     static onAdded(elt: HTMLElement): void;
     static onRemoved(elt: HTMLElement): void;
     /**
      * Callback appelé par le MutationObserver
      */
     static onMutation(list: MutationRecord[]): void;
-    static publisherListeners: Map<HTMLElement, any[]>;
+    static publisherListeners: Map<SearchableDomElement, PublisherListenerConfig[]>;
     /**
      * La liaison avec le publisher supprimée ici.
      */
-    static removePublisherListeners(target: HTMLElement): void;
+    static removePublisherListeners(target: SearchableDomElement): void;
     /**
      *
      * Cette fonction prend l'expression fournie et trouves toutes les occurences du type $.clef1.clef2.clef3 ou $a.b par exemple.
@@ -59,18 +66,18 @@ export default class DataBindObserver {
      *   Cela représente la propriété à mettre à jour sur l'élément lors de la modification d'une des variables liées dans le publicheur.
      * * Propriété "bindedVariablesDescriptor" du DataBindItem : voir la fonction getVariablesDescriptor
      */
-    static getDataBindItems(element: HTMLElement): DataBindItem[];
+    static getDataBindItems(element: SearchableDomElement): DataBindItem[];
     /**
      * Cette fonction récuperer le (sous) publisher a l'adresse donnée.
      * Si l'une des clef de l'adresse est _self_, on garde le publisher courant et on passe à la suite.
      * Ceci est un cas spécial, c'est pour ça qu'on utilisa pes Objects.traverse.
      * Il y a toujours un publisher quelque soit l'adresse ce qui permet de cibler des valeurs qui n'existent pas encore
      */
-    static getSubPublisher(pub: any, pathArray: string[]): any;
+    static getSubPublisher<T extends PublisherContentType>(pub: PublisherInterface<T>, pathArray?: string[]): PublisherInterface;
     /**
      * La liaison avec le publisher est faite ici.
      * TODO Sans doute factoriser
      */
-    static addPublisherListeners(target: HTMLElement): void;
+    static addPublisherListeners(target: SearchableDomElement): void;
 }
 export {};

package/core/utils/DataBindObserver.js

@@ -1,7 +1,8 @@
 import Format from "@supersoniks/concorde/core/utils/Format";
 import HTML from "@supersoniks/concorde/core/utils/HTML";
-import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy.mjs";
+import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
 /**
+ *
  * En appelant DataBindObserver.observe(HTMLElement) sun un élément html, tout les éléments peuvent être liés à au publisher a l'adresse déterminée parl'attribut dataProvider de l'un de ses ancêtres.
  * Pour cela un MutationObserver est créé pour observer les changements d'attributs de l'élément.
  * On peut alors ecrire ce genre de choses de manière a lier dynamiquement les données du publisher à l'élément html.
@@ -23,14 +24,16 @@ export default class DataBindObserver {
             return;
         if (DataBindObserver.observedElements.has(element))
             return;
-        let obs = new MutationObserver(DataBindObserver.onMutation);
-        let opt = {};
+        const obs = new MutationObserver(DataBindObserver.onMutation);
+        const opt = {};
         opt.childList = true;
         opt.subtree = true;
         opt.attributes = true;
         opt.attributeFilter = ["data-bind"];
         obs.observe(element, opt);
-        element.querySelectorAll("[data-bind]").forEach((e) => DataBindObserver.addPublisherListeners(e));
+        element
+            .querySelectorAll("[data-bind]")
+            .forEach((e) => DataBindObserver.addPublisherListeners(e));
         DataBindObserver.observedElements.set(element, obs);
     }
     /**
@@ -39,7 +42,7 @@ export default class DataBindObserver {
     static unObserve(element) {
         if (!element)
             return;
-        let observer = this.observedElements.get(element);
+        const observer = this.observedElements.get(element);
         if (!observer)
             return;
         observer.disconnect();
@@ -57,9 +60,7 @@ export default class DataBindObserver {
         if (elt.hasAttribute && elt.hasAttribute("data-bind"))
             DataBindObserver.removePublisherListeners(elt);
         if (elt.querySelectorAll)
-            elt
-                .querySelectorAll("[data-bind]")
-                .forEach((e) => DataBindObserver.removePublisherListeners(e));
+            elt.querySelectorAll("[data-bind]").forEach((e) => DataBindObserver.removePublisherListeners(e));
         else
             elt.childNodes.forEach((elt) => DataBindObserver.onRemoved(elt));
     }
@@ -67,18 +68,16 @@ export default class DataBindObserver {
      * Callback appelé par le MutationObserver
      */
     static onMutation(list) {
-        for (let l of list) {
+        for (const l of list) {
             switch (l.type) {
                 case "attributes":
                     DataBindObserver.addPublisherListeners(l.target);
                     break;
                 case "childList":
-                    var added = l.addedNodes;
-                    var removed = l.removedNodes;
-                    added.forEach((elt) => {
+                    l.addedNodes.forEach((elt) => {
                         DataBindObserver.onAdded(elt);
                     });
-                    removed.forEach((elt) => {
+                    l.removedNodes.forEach((elt) => {
                         DataBindObserver.onRemoved(elt);
                     });
                     break;
@@ -89,12 +88,13 @@ export default class DataBindObserver {
      * La liaison avec le publisher supprimée ici.
      */
     static removePublisherListeners(target) {
-        let conf = DataBindObserver.publisherListeners.get(target);
+        const conf = DataBindObserver.publisherListeners.get(target);
         if (!conf)
             return;
         DataBindObserver.publisherListeners.delete(target);
         conf.forEach((currentConf) => {
-            currentConf.publisher.offAssign(currentConf.onAssign);
+            var _a;
+            (_a = currentConf.publisher) === null || _a === void 0 ? void 0 : _a.offAssign(currentConf.onAssign);
         });
     }
     /**
@@ -128,12 +128,14 @@ export default class DataBindObserver {
      * * Propriété "bindedVariablesDescriptor" du DataBindItem : voir la fonction getVariablesDescriptor
      */
     static getDataBindItems(element) {
+        if (!("attributes" in element))
+            return [];
         return Array.from(element.attributes)
             .filter((attribute) => attribute.name.indexOf("::") == 0)
             .map((e) => {
-            let name = e.name.substring(2);
+            const name = e.name.substring(2);
             return {
-                propertyToUpdate: name.replace(/\-((html)|\w)/g, (match) => match.substring(1).toUpperCase()),
+                propertyToUpdate: name.replace(/-((html)|\w)/g, (match) => match.substring(1).toUpperCase()),
                 bindedVariablesDescriptor: DataBindObserver.getVariablesDescriptor(e.value),
             };
         });
@@ -145,9 +147,13 @@ export default class DataBindObserver {
      * Il y a toujours un publisher quelque soit l'adresse ce qui permet de cibler des valeurs qui n'existent pas encore
      */
     static getSubPublisher(pub, pathArray) {
-        for (let key of pathArray) {
+        if (!pathArray)
+            return pub;
+        for (const key of pathArray) {
             if (key == "_self_")
                 continue;
+            if (!pub)
+                return null;
             pub = pub[key];
         }
         return pub;
@@ -161,13 +167,12 @@ export default class DataBindObserver {
         /**
          * On récupère le publisher viea le dataProvider d'un ancêtre de l'élément.
          */
-        let node = target;
-        let dataProviderId = HTML.getAncestorAttributeValue(node.parentNode || node.host || node, "dataProvider");
+        const dataProviderId = HTML.getAncestorAttributeValue((target.parentNode || target.host || target), "dataProvider");
         if (!dataProviderId)
             return;
-        let publisher = PublisherManager.getInstance().get(dataProviderId);
-        let dataBindItems = DataBindObserver.getDataBindItems(target);
-        let conf = [];
+        const publisher = PublisherManager.getInstance().get(dataProviderId);
+        const dataBindItems = DataBindObserver.getDataBindItems(target);
+        const conf = [];
         /**
          * Pour chaque attribut => dataBindItems on fait la liaison avec les (sous) publishers associés aux variables extraites
          * Lorsqu'une assignation est faite sur un des publishers liés, on met à jour la propriété de target dont le nom est renseigne dans l'attribut "propertyToUpdate du databindItem".
@@ -176,18 +181,19 @@ export default class DataBindObserver {
          * Attentions, les Objets/tableaus sont rendus en chaine avant l'interprétation dans ce cas.
          */
         dataBindItems.forEach((dataBindItem) => {
-            let bindedVariablesDescriptor = dataBindItem.bindedVariablesDescriptor;
-            let propertyToUpdate = dataBindItem.propertyToUpdate;
-            for (let value of bindedVariablesDescriptor.variables) {
-                let publisherPathArray = value;
+            const bindedVariablesDescriptor = dataBindItem.bindedVariablesDescriptor;
+            const propertyToUpdate = dataBindItem.propertyToUpdate;
+            for (const value of bindedVariablesDescriptor.variables) {
+                const publisherPathArray = value;
                 let pub = publisher;
                 pub = DataBindObserver.getSubPublisher(publisher, publisherPathArray);
-                let rec = target;
-                let currentConf = {
+                const rec = target;
+                const currentConf = {
                     publisher: pub,
                     onAssign: () => {
-                        let values = bindedVariablesDescriptor.variables.map((dataPath) => {
-                            return DataBindObserver.getSubPublisher(publisher, dataPath).get();
+                        const values = bindedVariablesDescriptor.variables.map((dataPath) => {
+                            var _a;
+                            return (_a = DataBindObserver.getSubPublisher(publisher, dataPath)) === null || _a === void 0 ? void 0 : _a.get();
                         });
                         let expression = bindedVariablesDescriptor.expression;
                         let hasUndeterminatedValue = false;
@@ -213,35 +219,23 @@ export default class DataBindObserver {
                          */
                         for (let i = 0; i < values.length; i++) {
                             let value = values[i];
-                            let variable = bindedVariablesDescriptor.variables[i];
-                            if (value === null
-                            // Objects.isObject(value) &&
-                            // value.hasOwnProperty("__value") &&
-                            // Objects.isUndefindOrNull(value.__value)
-                            ) {
+                            const variable = bindedVariablesDescriptor.variables[i];
+                            if (value === null) {
                                 hasUndeterminatedValue = true;
                                 value = undefined;
                             }
                             expression = expression.replace("$" + variable.join("."), value);
                         }
-                        /**
-                         * Ce bout de code doit être un relicat
-                         */
-                        // if (Objects.isObject(expression) && !expression.hasOwnProperty("__value")) {
-                        //   rec[propertyToUpdate] = expression;
-                        //   return;
-                        // } else if (Objects.isObject(expression) && !expression.__value) expression = "";
-                        // else
                         if (expression.indexOf("|") != -1) {
-                            let funcDelimiterIdx = expression.indexOf("|");
+                            const funcDelimiterIdx = expression.indexOf("|");
                             if (funcDelimiterIdx == 0) {
                                 expression = Format.js(expression.substring(1));
                             }
                             else {
-                                let funcName = expression.substring(0, funcDelimiterIdx);
-                                let funcArgs = expression.substring(funcDelimiterIdx + 1);
-                                let fmt = Format;
-                                expression = hasUndeterminatedValue ? "" : fmt[funcName] ? fmt[funcName](funcArgs) : expression;
+                                const funcName = expression.substring(0, funcDelimiterIdx);
+                                const funcArgs = expression.substring(funcDelimiterIdx + 1);
+                                const fmtFunc = Format[funcName];
+                                expression = hasUndeterminatedValue ? "" : fmtFunc ? fmtFunc(funcArgs) : expression;
                             }
                         }
                         else {
@@ -250,7 +244,7 @@ export default class DataBindObserver {
                         rec[propertyToUpdate] = expression;
                     },
                 };
-                pub.onAssign(currentConf.onAssign);
+                pub === null || pub === void 0 ? void 0 : pub.onAssign(currentConf.onAssign);
                 conf.push(currentConf);
             }
         });
@@ -267,6 +261,5 @@ DataBindObserver.observedElements = new Map();
 DataBindObserver.enabled = true;
 DataBindObserver.publisherListeners = new Map();
 DataBindObserver.observe(document.documentElement);
-let win = window;
-if (!win.SonicDataBindObserver)
-    win.SonicDataBindObserver = DataBindObserver;
+if (!window.SonicDataBindObserver)
+    window.SonicDataBindObserver = DataBindObserver;

package/core/utils/Electron.d.ts

@@ -1,3 +1,7 @@
 export default class Electron {
-    static fixBlankLink(link: any): void;
+    static fixBlankLink(link: {
+        target: string | null;
+        href: string;
+        addEventListener: (type: string, callback: (e?: Event) => void) => void;
+    }): void;
 }

package/core/utils/Electron.js

@@ -1,9 +1,11 @@
 export default class Electron {
     static fixBlankLink(link) {
         const electronStr = "electron";
-        const electron = typeof require == 'undefined' ? null : require(electronStr);
+        const electron = typeof require == "undefined" ? null : require(electronStr);
         if (typeof electron && link.target == "_blank") {
-            link.addEventListener("click", () => { electron === null || electron === void 0 ? void 0 : electron.shell.openExternal(link.href); });
+            link.addEventListener("click", () => {
+                electron === null || electron === void 0 ? void 0 : electron.shell.openExternal(link.href);
+            });
         }
     }
 }

package/core/utils/HTML.d.ts

@@ -1,15 +1,22 @@
+export type SearchableDomElement = HTMLElement | ShadowRoot;
 declare class HTML {
     /**
      * retourne la langue de la page courante telle que défini via l'attribut lang de la balise html
      */
     static getLanguage(): string;
-    static getCookies(): any;
+    static getCookies(): Record<string, string>;
     /**
      * Va de parent en parent en partant de node pour trouver un attribut
      * @param attributeName nom de l'attribut
      * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
      */
-    static getAncestorAttributeValue(node: any, attributeName: string): string | null;
+    static getAncestorAttributeValue(node: SearchableDomElement | null, attributeName: string): string | null;
+    /**
+     * Va de parent en parent en partant de node pour trouver un attribut
+     * @param attributeName nom de l'attribut
+     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+     */
+    static getClosestForm(node: SearchableDomElement): SearchableDomElement | null;
     /**
      * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
      * */

package/core/utils/HTML.js

@@ -27,24 +27,43 @@ class HTML {
      * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
      */
     static getAncestorAttributeValue(node, attributeName) {
-        while (!(node.hasAttribute && node.hasAttribute(attributeName))) {
+        if (!node)
+            return null;
+        while (!("hasAttribute" in node && node.hasAttribute(attributeName))) {
             const newNode = node.parentNode || node.host;
             if (!newNode)
                 break;
-            node = node.parentNode || node.host;
+            node = (node.parentNode || node.host);
         }
-        if (!node.hasAttribute) {
+        if (!("hasAttribute" in node)) {
             return null;
         }
         return node.getAttribute(attributeName);
     }
+    /**
+     * Va de parent en parent en partant de node pour trouver un attribut
+     * @param attributeName nom de l'attribut
+     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
+     */
+    static getClosestForm(node) {
+        while (!(node.nodeName && node.nodeName.toLowerCase() === "form")) {
+            const newNode = node.parentNode || node.host;
+            if (!newNode)
+                break;
+            node = (node.parentNode || node.host);
+        }
+        if (!node.nodeName) {
+            return null;
+        }
+        return node;
+    }
     /**
      * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
      * */
     static loadJS(src) {
         return __awaiter(this, void 0, void 0, function* () {
             const p = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                let script = document.createElement("script");
+                const script = document.createElement("script");
                 script.src = src;
                 script.onload = () => resolve(true);
                 script.onerror = () => resolve(true);
@@ -59,7 +78,7 @@ class HTML {
     static loadCSS(src) {
         return __awaiter(this, void 0, void 0, function* () {
             const p = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                var cssnode = document.createElement("link");
+                const cssnode = document.createElement("link");
                 cssnode.type = "text/css";
                 cssnode.rel = "stylesheet";
                 cssnode.href = src;

package/core/utils/LocationHandler.d.ts

@@ -1,10 +1,11 @@
 declare type Listener = {
     location: string;
 };
-declare type ActivableLink = {
-    location: string;
-    href: string;
-    autoActive: "strict" | "partial" | "disabled";
+declare type ActivableLink = HTMLElement & {
+    location?: string;
+    href?: string;
+    goBack?: string | null;
+    autoActive?: "strict" | "partial" | "disabled";
     setAttribute(name: string, value: string): void;
     removeAttribute(name: string): void;
 };
@@ -34,7 +35,7 @@ export default class LocationHandler {
      * Si l'attribut replaceState est présent la naviguation se fait via un replaceState
      * Voir link et button pour les exemples d'implémentation
      **/
-    static changeFromComponent(component: any): void;
+    static changeFromComponent(component: ActivableLink): void;
     /**
      *
      * @param component ActivableLink