@supersoniks/concorde 2.0.2 → 2.0.3

package/core/directives/DataProvider.js

@@ -19,19 +19,22 @@ function getObservables(observable) {
         set.add(publisher);
         return set;
     }
-    return new Set(observable);
+    return new Set([observable]);
 }
 class ObserveDirective extends AsyncDirective {
-    constructor() {
-        super(...arguments);
+    unsubscribe() {
+        this.observables.forEach((publisher) => publisher.offAssign(this.onAssign));
+    }
+    /* eslint-disable @typescript-eslint/no-explicit-any*/
+    constructor(partInfo) {
+        super(partInfo);
         this.observables = new Set();
         this.onAssign = (v) => {
             this.setValue(v);
         };
+        this.node = partInfo.options?.host;
     }
-    unsubscribe() {
-        this.observables.forEach((publisher) => publisher.offAssign(this.onAssign));
-    }
+    /* eslint-enable @typescript-eslint/no-explicit-any*/
     render(observable) {
         if (this.observable !== observable) {
             this.observable = observable;
@@ -63,7 +66,7 @@ class ObserveDirective extends AsyncDirective {
     // When the directive is disconnected from the DOM, unsubscribe to ensure
     // the directive instance can be garbage collected
     disconnected() {
-        this.unsubscribe?.();
+        this.unsubscribe();
     }
     // If the subtree the directive is in was disconnected and subsequently
     // re-connected, re-subscribe to make the directive operable again
@@ -82,6 +85,18 @@ export const sub = dir;
 export const get = (id) => {
     return getObservables(id).values().next().value.get();
 };
-const deepee = (id) => getObservables(id).values().next();
+const deepee = (id, defaultValue) => {
+    const value = getObservables(id).values().next().value;
+    if (defaultValue !== undefined) {
+        const innerValue = value.get();
+        if (Objects.isEmpty(innerValue)) {
+            value.set(defaultValue);
+        }
+    }
+    return value;
+};
 export const dataProvider = deepee;
 export const dp = deepee;
+export const set = (id, value) => {
+    getObservables(id).values().next().value.set(value);
+};

package/core/directives/Wording.d.ts

@@ -0,0 +1,42 @@
+import { AsyncDirective } from "lit/async-directive.js";
+import { APIConfiguration } from "@supersoniks/concorde/core/utils/api";
+import API from "@supersoniks/concorde/core/utils/api";
+import { SearchableDomElement } from "../utils/HTML";
+type ApiCallKey = {
+    apiConfiguration: APIConfiguration;
+    wordingProvider: string | null;
+    wordingVersionProvider: string | null;
+};
+type ApiCallValue = {
+    api: API;
+    keysToTranslate: Set<string>;
+    translatedKeys: Set<string>;
+    wordingProvider: string | null;
+    callIndex: number;
+    wordingVersionProvider: string | null;
+    apiCallKey: ApiCallKey;
+};
+export declare const loadingString = "";
+export declare const isWordingReady: (key: string) => boolean;
+export default class WordingDirective extends AsyncDirective {
+    static publisher: any;
+    unsubscribe(): void;
+    key?: string;
+    node?: SearchableDomElement;
+    useUnsafeHTML: boolean;
+    constructor(partInfo: any);
+    render(key: string, useUnsafeHTML?: boolean): symbol;
+    static firstCall: boolean;
+    static callApi(node: SearchableDomElement | null, key: string, relaunch?: boolean, usedApiCall?: ApiCallValue): Promise<void>;
+    static versionProviderHandlers: Map<ApiCallValue, (v: number) => void>;
+    static handleVersionProvider(node: SearchableDomElement): ((v: number) => void) | undefined;
+    onAssign: (v: unknown) => void;
+    subscribe(key: string): void;
+    disconnected(): void;
+    reconnected(): void;
+}
+export declare const wording: (key: string, useUnsafeHTML?: boolean | undefined) => import("lit-html/directive").DirectiveResult<typeof WordingDirective>;
+export declare const unsafeWording: (key: string) => import("lit-html/directive").DirectiveResult<typeof WordingDirective>;
+export declare const t: (key: string, useUnsafeHTML?: boolean | undefined) => import("lit-html/directive").DirectiveResult<typeof WordingDirective>;
+export declare const w: (key: string, useUnsafeHTML?: boolean | undefined) => import("lit-html/directive").DirectiveResult<typeof WordingDirective>;
+export {};

package/core/directives/Wording.js

@@ -0,0 +1,202 @@
+import { AsyncDirective } from "lit/async-directive.js";
+import { directive } from "lit/directive.js";
+import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
+import { dp } from "@supersoniks/concorde/core/directives/DataProvider";
+import { noChange } from "lit";
+import API from "@supersoniks/concorde/core/utils/api";
+import Objects from "../utils/Objects";
+import HTML from "../utils/HTML";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+const apiCalls = new Map();
+const getApiCall = (node) => {
+    if (!node)
+        return null;
+    const configuration = HTML.getApiConfiguration(node);
+    const wordingProvider = HTML.getAncestorAttributeValue(node, "wordingProvider");
+    const wordingVersionProvider = HTML.getAncestorAttributeValue(node, "wordingVersionProvider");
+    const searchedKey = { apiConfiguration: configuration, wordingProvider: wordingProvider, wordingVersionProvider: wordingVersionProvider };
+    //touver une api avec la même configuration en comparant les avec l'utilitaire Objects deepEqual
+    let apiCall = null;
+    for (const [key, value] of apiCalls) {
+        if (Objects.deepEqual(key, searchedKey)) {
+            apiCall = value;
+            break;
+        }
+    }
+    if (!apiCall) {
+        const api = new API(configuration);
+        apiCall = {
+            api,
+            keysToTranslate: new Set(),
+            translatedKeys: new Set(),
+            wordingProvider,
+            callIndex: 0,
+            wordingVersionProvider: wordingVersionProvider,
+            apiCallKey: searchedKey,
+        };
+        apiCalls.set(searchedKey, apiCall);
+    }
+    return apiCall;
+};
+export const loadingString = "";
+export const isWordingReady = (key) => {
+    const value = WordingDirective.publisher["wording_" + key].get();
+    return value !== loadingString && value != null;
+};
+class WordingDirective extends AsyncDirective {
+    unsubscribe() {
+        WordingDirective.publisher["wording_" + this.key].offAssign(this.onAssign);
+    }
+    /* eslint-disable @typescript-eslint/no-explicit-any*/
+    constructor(partInfo) {
+        super(partInfo);
+        this.useUnsafeHTML = false;
+        this.onAssign = (v) => {
+            const value = this.useUnsafeHTML ? unsafeHTML(v) : v;
+            this.setValue(value);
+        };
+        this.node = partInfo.options.host; // options n'est pas déclaré sur PartInfo mais exist en réalité d'où le typage "any"
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any*/
+    render(key, useUnsafeHTML = false) {
+        this.useUnsafeHTML = useUnsafeHTML;
+        if (this.key !== key) {
+            this.key = key;
+            if (this.isConnected) {
+                this.subscribe(key);
+            }
+        }
+        return noChange;
+    }
+    static async callApi(node, key, relaunch = true, usedApiCall) {
+        await PublisherManager.getInstance().isLocalStrorageReady;
+        if (WordingDirective.firstCall) {
+            WordingDirective.firstCall = false;
+            //clean keys of the publisher that are equivalent to the loading string
+            const keys = Object.keys(WordingDirective.publisher.get());
+            for (const key of keys) {
+                if (WordingDirective.publisher.get()[key] === loadingString) {
+                    delete WordingDirective.publisher[key];
+                }
+            }
+        }
+        if (node) {
+            const wordingVersionProvider = HTML.getAncestorAttributeValue(node, "wordingVersionProvider");
+            if (wordingVersionProvider) {
+                dp(wordingVersionProvider).onAssign(WordingDirective.handleVersionProvider(node));
+            }
+        }
+        let hasWordingForKey = WordingDirective.publisher.get()["wording_" + key] != null;
+        const apiCall = usedApiCall || getApiCall(node);
+        if (!apiCall)
+            return;
+        if (hasWordingForKey && key !== "") {
+            apiCall.translatedKeys.add(key);
+            return;
+        }
+        apiCall.callIndex++;
+        const callIndex = apiCall.callIndex;
+        const wordingProvider = apiCall.wordingProvider ?? "";
+        // if the wording provider is unfortunately not set, we don't call the api now.
+        // We will try later
+        if (!wordingProvider && relaunch) {
+            window.setTimeout(async () => {
+                WordingDirective.callApi(null, key, false, apiCall);
+            }, 1000);
+            return;
+        }
+        //
+        //
+        const api = apiCall.api;
+        window.queueMicrotask(async () => {
+            hasWordingForKey = WordingDirective.publisher["wording_" + key].get() != null;
+            if (!hasWordingForKey && key !== "") {
+                apiCall.keysToTranslate.add(key);
+                WordingDirective.publisher["wording_" + key] = loadingString;
+            }
+            if (callIndex !== apiCall.callIndex)
+                return;
+            const wordings = Array.from(apiCall.keysToTranslate);
+            if (!wordings.length)
+                return;
+            const splittedUrl = wordingProvider.split("?");
+            const locationURL = splittedUrl.shift();
+            const queryString = (splittedUrl.length > 0 ? splittedUrl.join("?") + "&" : "") + "labels[]=" + wordings.join("&labels[]=");
+            const calledURL = locationURL + "?" + queryString;
+            apiCall.translatedKeys = new Set([...apiCall.translatedKeys, ...apiCall.keysToTranslate]);
+            apiCall.keysToTranslate.clear();
+            const result = (await api.get(calledURL));
+            for (const key in result) {
+                WordingDirective.publisher["wording_" + key] = result[key];
+            }
+        });
+    }
+    //check if the wording version has changed
+    static handleVersionProvider(node) {
+        const apiCall = getApiCall(node);
+        if (!apiCall)
+            return;
+        if (WordingDirective.versionProviderHandlers.has(apiCall)) {
+            return WordingDirective.versionProviderHandlers.get(apiCall);
+        }
+        const versionProviderHandler = function (version) {
+            const wordingVersionProvider = apiCall.wordingVersionProvider;
+            if (!wordingVersionProvider)
+                return;
+            //
+            const currentVersions = WordingDirective.publisher.get().__wording_versions__ ?? [];
+            if (version == null)
+                return;
+            const currentVersionData = currentVersions.find((v) => v.serviceURL === apiCall.api.serviceURL) || {
+                serviceURL: apiCall.api.serviceURL,
+                version: 0,
+            };
+            if (!currentVersions.includes(currentVersionData))
+                currentVersions.push(currentVersionData);
+            if (version === currentVersionData.version) {
+                return;
+            }
+            currentVersionData.version = version;
+            WordingDirective.publisher.set({ __wording_versions__: currentVersions });
+            for (const apiCall of apiCalls.values()) {
+                apiCall.keysToTranslate = new Set(apiCall.translatedKeys);
+                if (apiCall.keysToTranslate.size > 0) {
+                    WordingDirective.callApi(null, "", false, apiCall);
+                }
+            }
+        };
+        WordingDirective.versionProviderHandlers.set(apiCall, versionProviderHandler);
+        return versionProviderHandler;
+    }
+    // Subscribes to the key, calling the directive's asynchronous
+    // setValue API each time the value changes
+    subscribe(key) {
+        this.unsubscribe();
+        // this.onAssign = (v: unknown) => {
+        //   this.setValue(v);
+        // };
+        WordingDirective.publisher["wording_" + key].onAssign(this.onAssign);
+        WordingDirective.callApi(this.node, key);
+    }
+    // When the directive is disconnected from the DOM, unsubscribe to ensure
+    // the directive instance can be garbage collected
+    disconnected() {
+        this.unsubscribe();
+    }
+    // If the subtree the directive is in was disconnected and subsequently
+    // re-connected, re-subscribe to make the directive operable again
+    reconnected() {
+        if (!this.key)
+            return;
+        this.subscribe(this.key);
+    }
+}
+WordingDirective.publisher = PublisherManager.get("sonic-wording", { localStorageMode: "enabled" });
+WordingDirective.firstCall = true;
+WordingDirective.versionProviderHandlers = new Map();
+export default WordingDirective;
+//autoUpdate directive
+export const wording = directive(WordingDirective);
+export const unsafeWording = (key) => wording(key, true);
+export const t = wording;
+export const w = wording;

package/core/mixins/Fetcher.d.ts

@@ -2,11 +2,13 @@
 import "@supersoniks/concorde/core/components/ui/button/button";
 import { SubscriberInterface } from "@supersoniks/concorde/core/mixins/Subscriber";
 import API from "@supersoniks/concorde/core/utils/api";
-import { PublisherContentType } from "../_types/types";
 import { MixinArgsType } from "../_types/types";
 import { ResultTypeInterface } from "@supersoniks/concorde/core/utils/api";
 type Constructor<T> = new (...args: MixinArgsType[]) => T;
-declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, PropsType extends PublisherContentType = PublisherContentType>(superClass: T, propsType?: PropsType | undefined) => {
+export declare const invalidateFetchersInError: () => void;
+export declare const onFetchError: (errorListener: (apiResponse: Response) => void) => void;
+export declare const offFetchError: (errorListener: (apiResponse: Response) => void) => void;
+declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, PropsType extends unknown = unknown>(superClass: T, propsType?: PropsType | undefined) => {
     new (...args: MixinArgsType[]): {
         api: API | null;
         /**
@@ -23,20 +25,19 @@ declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, P
          */
         isLoading: boolean;
         lazyLoad?: boolean | undefined;
-        noLoader?: boolean | undefined;
         /**
          * IObserver est l'intersection observer qui permet de charger les données au scroll si l'attribut lazyload est renseigné
          */
         iObserver: IntersectionObserver | null;
-        /**
-         * un loader est affiché par défaut si l'attribut noLoader n'est pas renseigné
-         */
-        isDefaultLoaderEnabled: boolean;
         /**
          * On peut désactiver le fetch programmatiquement via cette propriété.
          * Cela est le cas pour le composant sonic-list qui ne fetch que si l'attribut fetch est renseigné
          */
         isFetchEnabled: boolean;
+        /**
+         * Result of the fetch
+         */
+        fetchedData: any;
         _endPoint: string;
         props: (PropsType & ResultTypeInterface) | null;
         endPoint: string;
@@ -84,10 +85,6 @@ declare const Fetcher: <T extends Constructor<SubscriberInterface<PropsType>>, P
         getAttribute(name: string): string;
         hasAttribute(attributeName: string): boolean;
         getBoundingClientRect(): DOMRect;
-        onConnected(callback: (component: any) => void): void;
-        offConnected(callback: (component: any) => void): void;
-        onDisconnected(callback: (component: any) => void): void;
-        offDisconnected(callback: (component: any) => void): void;
     };
 } & T;
 export default Fetcher;

package/core/mixins/Fetcher.js

@@ -5,12 +5,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import "@supersoniks/concorde/core/components/ui/button/button";
-import { Loader } from "@supersoniks/concorde/core/components/ui/loader/loader";
 import { SonicToast } from "@supersoniks/concorde/core/components/ui/toast/toast";
 import API from "@supersoniks/concorde/core/utils/api";
 import Objects from "@supersoniks/concorde/core/utils/Objects";
 import { PublisherManager } from "@supersoniks/concorde/utils";
 import { property } from "lit/decorators.js";
+const fetchersInError = new Set();
+export const invalidateFetchersInError = () => {
+    const fetchersInErrorCopy = new Set(fetchersInError);
+    fetchersInError.clear();
+    for (const fetcher of fetchersInErrorCopy) {
+        fetcher._fetchData();
+    }
+};
+const errorsListeners = new Set();
+export const onFetchError = (errorListener) => {
+    errorsListeners.add(errorListener);
+};
+export const offFetchError = (errorListener) => {
+    errorsListeners.delete(errorListener);
+};
+const dispatchFetchError = (apiResponse) => {
+    for (const listener of errorsListeners) {
+        listener(apiResponse);
+    }
+};
 const Fetcher = (superClass, propsType) => {
     propsType;
     class FetcherElement extends superClass {
@@ -34,15 +53,15 @@ const Fetcher = (superClass, propsType) => {
              * IObserver est l'intersection observer qui permet de charger les données au scroll si l'attribut lazyload est renseigné
              */
             this.iObserver = null;
-            /**
-             * un loader est affiché par défaut si l'attribut noLoader n'est pas renseigné
-             */
-            this.isDefaultLoaderEnabled = true;
             /**
              * On peut désactiver le fetch programmatiquement via cette propriété.
              * Cela est le cas pour le composant sonic-list qui ne fetch que si l'attribut fetch est renseigné
              */
             this.isFetchEnabled = true;
+            /**
+             * Result of the fetch
+             */
+            this.fetchedData = null;
             this._endPoint = "";
             this.requestId = 0;
             this.refetchEveryMs = 0;
@@ -70,6 +89,7 @@ const Fetcher = (superClass, propsType) => {
          * Un Toast est affiché si le chargement échoue
          */
         async _fetchData() {
+            this.requestUpdate();
             if (!this.isFetchEnabled)
                 return;
             this.api = new API(this.getApiConfiguration());
@@ -82,10 +102,6 @@ const Fetcher = (superClass, propsType) => {
             }
             if (!this.isConnected)
                 return;
-            const hasLoader = this.isDefaultLoaderEnabled && !this.noLoader;
-            if (hasLoader) {
-                Loader.show();
-            }
             const headerData = PublisherManager.getInstance().get(this.getAncestorAttributeValue("headersDataProvider")).get();
             this.isLoading = true;
             if (Objects.isObject(this.props) && Object.keys(this.props || {}).length > 0 && this.isFirstLoad) {
@@ -96,33 +112,33 @@ const Fetcher = (superClass, propsType) => {
                 });
             }
             let data = await this.api.get(this.endPoint || this.dataProvider || "", headerData);
+            this.fetchedData = data;
+            if (this.api.lastResult && !this.api.lastResult.ok) {
+                fetchersInError.add(this);
+                dispatchFetchError(this.api.lastResult);
+            }
             if (!this.isConnected) {
-                if (hasLoader)
-                    Loader.hide();
                 return;
             }
-            // Je garde ça mais normalement ça n'arrive jamais
             if (!data) {
-                SonicToast.add({ text: "Network Error", status: "error" });
+                // Cela n'arrive normalement que lorsque l'on quitte une page pendant un fetch on n'affiche donc pas de message
                 this.isLoading = false;
-                if (hasLoader) {
-                    Loader.hide();
+                if (this.refetchEveryMs && this.isConnected) {
+                    this.refetchTimeOutId = setTimeout(() => this._fetchData(), this.refetchEveryMs);
                 }
                 return;
             }
-            // Si data ne contient que la réponse HTTP, avec un statut not ok, on affiche un message
             else if (data._sonic_http_response_ && !data._sonic_http_response_.ok && Object.keys(data).length === 1) {
+                // Si data ne contient que la réponse HTTP, avec un statut not ok, on affiche un message
                 SonicToast.add({ text: "Network Error", status: "error" });
             }
-            if (hasLoader) {
-                Loader.hide();
-            }
             if (this.key) {
                 const response = data._sonic_http_response_;
                 /* preserveOtherKeys s'exprime lorsque le paramètre "key" est défini
                  * Conserve les autres propriétés de l'objet reçu, en plus des propriétés définies sous "key"
                  */
-                data = Objects.traverse(data, this.key.split("."), this.hasAttribute("preserveOtherKeys"));
+                const path = this.key.split(".");
+                data = Objects.traverse(data, path, this.hasAttribute("preserveOtherKeys"));
                 if (data && Objects.isObject(data) && response)
                     data._sonic_http_response_ = response;
             }
@@ -143,12 +159,11 @@ const Fetcher = (superClass, propsType) => {
         connectedCallback() {
             // this.noShadowDom = "";
             this.lazyLoad = this.lazyLoad !== undefined ? this.lazyLoad : this.hasAttribute("lazyload");
-            this.noLoader = this.noLoader !== undefined ? this.noLoader : this.hasAttribute("noloader");
             super.connectedCallback();
             if (!this.isFetchEnabled) {
                 return;
             }
-            this.key = this.getAttribute("key");
+            this.key = this.key != "" ? this.key : this.getAttribute("key");
             if (this.props) {
                 this.publisher.set(this.props);
             }
@@ -174,6 +189,7 @@ const Fetcher = (superClass, propsType) => {
             const options = {
                 root: null,
                 rootMargin: Math.max(window.innerWidth * boundsRatio, window.innerHeight * boundsRatio) + "px",
+                threshold: 0.9,
             };
             this.iObserver = new IntersectionObserver((entries) => this.onIntersection(entries), options);
             let elt = (this.shadowRoot ? this.shadowRoot.children[0] : this.children[0]);

package/core/mixins/FormCheckable.d.ts

@@ -46,6 +46,7 @@ declare const Form: <T extends Constructor<FormElementInterface>>(superClass: T)
         getFormPublisher(): any;
         updateDataValue(): void;
         handleBlur(e?: Event | undefined): void;
+        setValueFromPublisher(value: string | object | string[] | null | undefined): void;
         focus?: (() => void) | undefined;
         shadowRoot?: ShadowRoot | undefined;
         error: boolean;
@@ -82,10 +83,6 @@ declare const Form: <T extends Constructor<FormElementInterface>>(superClass: T)
         getAttribute(name: string): string;
         hasAttribute(attributeName: string): boolean;
         getBoundingClientRect(): DOMRect;
-        onConnected(callback: (component: any) => void): void;
-        offConnected(callback: (component: any) => void): void;
-        onDisconnected(callback: (component: any) => void): void;
-        offDisconnected(callback: (component: any) => void): void;
     };
 } & T;
 export default Form;

package/core/mixins/FormElement.d.ts

@@ -9,6 +9,7 @@ export interface FormElementInterface extends SubscriberInterface {
     handleChange(e?: Event): void;
     handleBlur(e?: Event): void;
     getValueForFormPublisher(): FormElementValue;
+    setValueFromPublisher(value: FormElementValue): void;
     validateFormElement(): void;
     focus?: () => void;
     forceAutoFill: boolean;

package/core/mixins/FormElement.js

@@ -39,7 +39,7 @@ const Form = (superClass) => {
             this.onValueAssign = (value) => {
                 this.setValueFromPublisher(value);
             };
-            this.onFormValueAssign = (value) => {
+            this.onFormValueAssign = async (value) => {
                 this.setFormValueFromPublisher(value);
             };
             this.onFormDataInValidate = () => {
@@ -74,8 +74,7 @@ const Form = (superClass) => {
         }
         getFormPublisher() {
             if (!this.formDataProvider)
-                this.formDataProvider =
-                    this.getAncestorAttributeValue("formDataProvider");
+                this.formDataProvider = this.getAncestorAttributeValue("formDataProvider");
             if (this.formDataProvider) {
                 return PublisherManager.get(this.formDataProvider);
             }
@@ -121,9 +120,7 @@ const Form = (superClass) => {
         }
         initPublisher() {
             let formPublisher = this.getFormPublisher();
-            const value = this.hasAncestorAttribute("initFromPublisher") &&
-                this._name &&
-                formPublisher[this._name].get()
+            const value = this.hasAncestorAttribute("initFromPublisher") && this._name && formPublisher[this._name].get()
                 ? formPublisher[this._name].get()
                 : this.getAttribute("value");
             if (this._name && this.publisher)

package/core/mixins/FormInput.d.ts

@@ -16,13 +16,15 @@ declare const Form: <T extends Constructor<FormElementInterface>>(superClass: T)
         description: string | undefined;
         _label?: string | undefined;
         label: string | undefined;
+        status: "default" | "success" | "error" | "warning" | "info";
         tabindex?: number | undefined;
-        autocomplete?: "url" | "name" | "on" | "additional-name" | "address-level1" | "address-level2" | "address-level3" | "address-level4" | "address-line1" | "address-line2" | "address-line3" | "bday-day" | "bday-month" | "bday-year" | "cc-csc" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-family-name" | "cc-given-name" | "cc-name" | "cc-number" | "cc-type" | "country" | "country-name" | "current-password" | "family-name" | "given-name" | "honorific-prefix" | "honorific-suffix" | "new-password" | "one-time-code" | "organization" | "postal-code" | "street-address" | "transaction-amount" | "transaction-currency" | "username" | "email" | "tel" | "tel-area-code" | "tel-country-code" | "tel-extension" | "tel-local" | "tel-national" | "language" | "nickname" | "organization-title" | "cc-additional-name" | "bday" | "sex" | "impp" | "photo" | undefined;
+        autocomplete?: "url" | "name" | "off" | "on" | "additional-name" | "address-level1" | "address-level2" | "address-level3" | "address-level4" | "address-line1" | "address-line2" | "address-line3" | "bday-day" | "bday-month" | "bday-year" | "cc-csc" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-family-name" | "cc-given-name" | "cc-name" | "cc-number" | "cc-type" | "country" | "country-name" | "current-password" | "family-name" | "given-name" | "honorific-prefix" | "honorific-suffix" | "new-password" | "one-time-code" | "organization" | "postal-code" | "street-address" | "transaction-amount" | "transaction-currency" | "username" | "email" | "tel" | "tel-area-code" | "tel-country-code" | "tel-extension" | "tel-local" | "tel-national" | "language" | "nickname" | "organization-title" | "cc-additional-name" | "bday" | "sex" | "impp" | "photo" | undefined;
         getFormPublisher(): any;
         updateDataValue(): void;
         handleChange(e?: Event | undefined): void;
         handleBlur(e?: Event | undefined): void;
         getValueForFormPublisher(): string | object | string[] | null | undefined;
+        setValueFromPublisher(value: string | object | string[] | null | undefined): void;
         focus?: (() => void) | undefined;
         shadowRoot?: ShadowRoot | undefined;
         error: boolean;
@@ -63,10 +65,6 @@ declare const Form: <T extends Constructor<FormElementInterface>>(superClass: T)
         hasAttribute(attributeName: string): boolean;
         disconnectedCallback(): void;
         getBoundingClientRect(): DOMRect;
-        onConnected(callback: (component: any) => void): void;
-        offConnected(callback: (component: any) => void): void;
-        onDisconnected(callback: (component: any) => void): void;
-        offDisconnected(callback: (component: any) => void): void;
     };
 } & T;
 export default Form;

package/core/mixins/FormInput.js

@@ -15,6 +15,7 @@ const Form = (superClass) => {
              * On peut essayer text, date, color, email par exemple, mais pas radio/checkbox/range a priori
              */
             this._type = "text";
+            this.status = "default";
             args;
         }
         validateFormElement() {
@@ -66,6 +67,9 @@ const Form = (superClass) => {
     __decorate([
         property()
     ], FormInput.prototype, "label", null);
+    __decorate([
+        property({ type: String, reflect: true })
+    ], FormInput.prototype, "status", void 0);
     __decorate([
         property({ type: Number })
     ], FormInput.prototype, "tabindex", void 0);

package/core/mixins/Subscriber.d.ts

@@ -31,10 +31,6 @@ export interface SubscriberInterface<PropsType = CoreJSType> {
     hasAttribute(attributeName: string): boolean;
     disconnectedCallback(): void;
     getBoundingClientRect(): DOMRect;
-    onConnected(callback: (component: any) => void): void;
-    offConnected(callback: (component: any) => void): void;
-    onDisconnected(callback: (component: any) => void): void;
-    offDisconnected(callback: (component: any) => void): void;
 }
 declare const Subscriber: <PropsType = CoreJSType, T extends Constructor<LitElement> = Constructor<LitElement>>(superClass: T, type?: PropsType | undefined) => Constructor<SubscriberInterface<PropsType>> & T;
 export default Subscriber;