@supersoniks/concorde 2.0.7 → 3.0.1

package/core/decorators/Subscriber.js

@@ -1,166 +0,0 @@
-import { Objects } from "@supersoniks/concorde/utils";
-import { PublisherManager } from "../utils/PublisherProxy";
-function onConnected(callback) {
-    if (!this.__connectedCallbackCalls__)
-        this.__connectedCallbackCalls__ = new Set();
-    this.__connectedCallbackCalls__.add(callback);
-}
-function __onDisconnected__(callback) {
-    if (!this.__disconnectedCallbackCalls__)
-        this.__disconnectedCallbackCalls__ = new Set();
-    this.__disconnectedCallbackCalls__.add(callback);
-}
-function setSubscribable(target) {
-    if (target.__is__setSubscribable__)
-        return;
-    target.__is__setSubscribable__ = true;
-    target.__onConnected__ = onConnected;
-    target.__onDisconnected__ = __onDisconnected__;
-    // target.offConnected = onConnected;
-    // target.offDisconnected = __onDisconnected__;
-    const originalConnectedCallback = target.connectedCallback;
-    target.connectedCallback = function () {
-        originalConnectedCallback.call(this);
-        if (this.__connectedCallbackCalls__) {
-            this.__connectedCallbackCalls__.forEach((callback) => callback(this));
-        }
-    };
-    const originalDisconnectedCallback = target.disconnectedCallback;
-    target.disconnectedCallback = function () {
-        originalDisconnectedCallback.call(this);
-        if (this.__disconnectedCallbackCalls__) {
-            this.__disconnectedCallbackCalls__.forEach((callback) => callback(this));
-        }
-    };
-}
-export function bind(path) {
-    const split = path.split(".");
-    if (split.length == 0) {
-        return function () {
-            //Empty def function
-        };
-    }
-    const dataProvider = split.shift() || "";
-    let publisher = PublisherManager.get(dataProvider);
-    publisher = Objects.traverse(publisher, split);
-    return function (target, propertyKey) {
-        if (!target)
-            return;
-        let onAssign;
-        setSubscribable(target);
-        target.__onConnected__((component) => {
-            onAssign = (value) => {
-                component[propertyKey] = value;
-            };
-            publisher.onAssign(onAssign);
-        });
-        target.__onDisconnected__(() => {
-            publisher.offAssign(onAssign);
-        });
-    };
-}
-export function onAssign(...values) {
-    const onAssignValues = [];
-    const confs = [];
-    for (let i = 0; i < values.length; i++) {
-        const value = values[i];
-        const split = value.split(".");
-        if (split.length == 0) {
-            continue;
-        }
-        const dataProvider = split.shift() || "";
-        let publisher = PublisherManager.get(dataProvider);
-        publisher = Objects.traverse(publisher, split);
-        const callbacks = new Set();
-        const onAssign = (value) => {
-            onAssignValues[i] = value;
-            if (onAssignValues.filter((v) => v !== null).length == values.length)
-                callbacks.forEach((callback) => callback(...onAssignValues));
-        };
-        confs.push({ publisher, onAssign, callbacks });
-    }
-    return function (target, _propertyKey, descriptor) {
-        setSubscribable(target);
-        let callback;
-        target.__onConnected__((component) => {
-            for (const conf of confs) {
-                callback = descriptor.value.bind(component);
-                conf.callbacks.add(callback);
-                conf.publisher.onAssign(conf.onAssign);
-            }
-        });
-        target.__onDisconnected__(() => {
-            for (const conf of confs) {
-                conf.callbacks.delete(callback);
-                conf.publisher.offAssign(conf.onAssign);
-            }
-        });
-    };
-}
-export function autoSubscribe() {
-    return function (target, propertyKey, descriptor) {
-        let renderId = 0;
-        const originalMethod = descriptor.value;
-        const originalDC = target.constructor.prototype.disconnectedCallback;
-        target.constructor.prototype.disconnectedCallback = function () {
-            originalDC.apply(this);
-            this.__removeAutoSubscribe__();
-        };
-        const originalConnectedCallback = target.connectedCallback;
-        target.connectedCallback = function () {
-            originalConnectedCallback?.call(this);
-            this[propertyKey]();
-        };
-        descriptor.value = function (...args) {
-            let publishers = new Set();
-            const onAssign = () => {
-                renderId++;
-                const id = renderId;
-                window.queueMicrotask(() => {
-                    if (id !== renderId)
-                        return;
-                    this[propertyKey]();
-                });
-            };
-            //on désabone les publishers du rendu précédant
-            publishers.forEach((publisher) => {
-                publisher.offAssign(onAssign);
-            });
-            //on collecte les publisher modifiés pour s'abonner pour la prochaine modification
-            PublisherManager.collectModifiedPublisher();
-            const result = originalMethod.apply(this, args);
-            publishers = PublisherManager.getModifiedPublishers() || new Set();
-            publishers.forEach((publisher) => {
-                publisher.onAssign(onAssign, false);
-            });
-            this.__removeAutoSubscribe__ = () => {
-                publishers.forEach((publisher) => {
-                    publisher.offAssign(onAssign);
-                });
-            };
-            return result;
-        };
-    };
-}
-export function autoFill(values) {
-    return function (target) {
-        setSubscribable(target);
-        for (const value of values) {
-            const split = value.split(".");
-            if (split.length == 0) {
-                continue;
-            }
-            const dataProvider = split.shift() || "";
-            let publisher = PublisherManager.get(dataProvider);
-            publisher = Objects.traverse(publisher, split);
-            target.__onConnected__((component) => {
-                publisher.startTemplateFilling(component);
-            });
-            target.__onDisconnected__(() => {
-                (component) => {
-                    publisher.stopTemplateFilling(component);
-                };
-            });
-        }
-    };
-}

package/core/directives/DataProvider.d.ts

@@ -1,23 +0,0 @@
-import { AsyncDirective } from "lit/async-directive.js";
-import { PublisherProxy } from "@supersoniks/concorde/core/utils/PublisherProxy";
-import { SearchableDomElement } from "../utils/HTML";
-type Observable = PublisherProxy | string | (() => unknown);
-declare class ObserveDirective extends AsyncDirective {
-    observables: Set<PublisherProxy>;
-    unsubscribe(): void;
-    observable?: Observable;
-    node?: SearchableDomElement;
-    constructor(partInfo: any);
-    render(observable: Observable): symbol;
-    onAssign: (v: unknown) => void;
-    subscribe(observable: Observable): void;
-    disconnected(): void;
-    reconnected(): void;
-}
-export declare const subscribe: (observable: Observable) => import("lit-html/directive").DirectiveResult<typeof ObserveDirective>;
-export declare const sub: (observable: Observable) => import("lit-html/directive").DirectiveResult<typeof ObserveDirective>;
-export declare const get: (id: Observable) => any;
-export declare const dataProvider: (id: Observable, defaultValue?: any) => any;
-export declare const dp: (id: Observable, defaultValue?: any) => any;
-export declare const set: (id: Observable, value: unknown) => void;
-export {};

package/core/directives/DataProvider.js

@@ -1,102 +0,0 @@
-import { AsyncDirective } from "lit/async-directive.js";
-import { directive } from "lit/directive.js";
-import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
-import { noChange } from "lit";
-import Objects from "../utils/Objects";
-function getObservables(observable) {
-    if (typeof observable === "function") {
-        const func = observable;
-        PublisherManager.collectModifiedPublisher();
-        func();
-        return PublisherManager.getModifiedPublishers() || new Set();
-    }
-    if (typeof observable === "string") {
-        const split = observable.split(".");
-        const dataProvider = split.shift() || "";
-        let publisher = PublisherManager.get(dataProvider);
-        publisher = Objects.traverse(publisher, split);
-        const set = new Set();
-        set.add(publisher);
-        return set;
-    }
-    return new Set([observable]);
-}
-class ObserveDirective extends AsyncDirective {
-    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;
-    }
-    /* eslint-enable @typescript-eslint/no-explicit-any*/
-    render(observable) {
-        if (this.observable !== observable) {
-            this.observable = observable;
-            if (this.isConnected) {
-                this.subscribe(observable);
-            }
-        }
-        return noChange;
-    }
-    // Subscribes to the observable, calling the directive's asynchronous
-    // setValue API each time the value changes
-    subscribe(observable) {
-        this.unsubscribe();
-        if (typeof observable === "function") {
-            this.onAssign = () => {
-                this.setValue(observable());
-            };
-        }
-        else {
-            this.onAssign = (v) => {
-                this.setValue(v);
-            };
-        }
-        this.observables = getObservables(observable);
-        this.observables.forEach((publisher) => {
-            publisher.onAssign(this.onAssign);
-        });
-    }
-    // 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.observable)
-            return;
-        this.subscribe(this.observable);
-    }
-}
-const dir = directive(ObserveDirective);
-//
-//autoUpdate directive
-export const subscribe = dir;
-export const sub = dir;
-// get value
-export const get = (id) => {
-    return getObservables(id).values().next().value.get();
-};
-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

@@ -1,42 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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

@@ -1,90 +0,0 @@
-/// <reference types="node" />
-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 { MixinArgsType } from "../_types/types";
-import { ResultTypeInterface } from "@supersoniks/concorde/core/utils/api";
-type Constructor<T> = new (...args: MixinArgsType[]) => T;
-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;
-        /**
-         * Après le chargement des données on traverse l'objet reçu en fonctione de la cible exprimées dans cette propriété avec la dot syntaxe.
-         * C'est cette donnée cible qui est injectée dans les pros et donc disponible via le publisher disponible globalement via PublisherManager.get(dataProvider)
-         */
-        key: string;
-        /**
-         * isFirstLoad vaut true jusqu'au premier chargement de données
-         */
-        isFirstLoad: boolean;
-        /**
-         * isLoading vaut true pendant le chargement des données
-         */
-        isLoading: boolean;
-        lazyLoad?: 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;
-        /**
-         * 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;
-        requestId: number;
-        refetchEveryMs: number;
-        refetchTimeOutId?: NodeJS.Timeout | undefined;
-        /**
-         *
-         * C'est ici que les données sont chargées via l'utilitaire API
-         * Elles sont ensuite injectées dans le publisher en accord avec la cible définie dans la propriété key
-         * Un Toast est affiché si le chargement échoue
-         */
-        _fetchData(): Promise<void>;
-        onInvalidate?: (() => void) | undefined;
-        disconnectedCallback(): void;
-        connectedCallback(): void;
-        /**
-         * Première update, le comportement de lazyload est géré ici a l'aide d'un intersection observer.
-         */
-        lazyLoadSpan?: HTMLSpanElement | undefined;
-        handleLazyLoad(): void;
-        onIntersection(entries: IntersectionObserverEntry[]): void;
-        propertyMap: object;
-        isConnected: boolean;
-        children: HTMLCollection;
-        appendChild(node: Node): Node;
-        getAncestorAttributeValue(attributeName: string): string;
-        hasAncestorAttribute(attributeName: string): boolean;
-        querySelectorAll(selector: string): NodeListOf<Element>;
-        publisher: any;
-        dataProvider: string | null;
-        noShadowDom: string | null;
-        debug: HTMLElement | null;
-        defferedDebug: boolean | null;
-        displayContents: boolean;
-        shadowRoot?: ShadowRoot | undefined;
-        dispatchEvent(event: Event): void;
-        setAttribute(name: string, value: string): void;
-        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
-        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
-        removeAttribute(name: string): void;
-        initPublisher(): void;
-        getApiConfiguration(): import("@supersoniks/concorde/core/utils/api").APIConfiguration;
-        requestUpdate(): void;
-        getAttribute(name: string): string;
-        hasAttribute(attributeName: string): boolean;
-        getBoundingClientRect(): DOMRect;
-    };
-} & T;
-export default Fetcher;