@supersoniks/concorde 1.1.35 → 1.1.36

package/core/components/functional/fetch/fetch.d.ts

@@ -17,6 +17,7 @@ declare const Fetch_base: {
         firstUpdated(): void;
         onIntersection(entries: IntersectionObserverEntry[]): void;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;

package/core/components/functional/functional.d.ts

@@ -10,3 +10,4 @@ import "./router/redirect";
 import "./states/states";
 import "./sonic-scope/sonic-scope";
 import "./example/example";
+import "./sdui/sdui";

package/core/components/functional/functional.js

@@ -10,3 +10,4 @@ import "./router/redirect";
 import "./states/states";
 import "./sonic-scope/sonic-scope";
 import "./example/example";
+import "./sdui/sdui";

package/core/components/functional/list/list.d.ts

@@ -19,6 +19,7 @@ declare const List_base: {
         firstUpdated(): void;
         onIntersection(entries: IntersectionObserverEntry[]): void;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;

package/core/components/functional/sdui/sdui.d.ts

@@ -0,0 +1,67 @@
+import { LitElement } from "lit";
+declare type SDUIDescriptor = {
+    js?: Array<string>;
+    css?: Array<string>;
+    library?: Record<string, SDUINode>;
+    nodes?: Array<SDUINode>;
+};
+declare type SDUINode = {
+    library?: string;
+    markup?: string;
+    type?: string;
+    attributes: Record<string, string>;
+    nodes?: Array<SDUINode>;
+    innerHTML?: string;
+    prefix?: string;
+    suffix?: string;
+};
+declare const SonicComponent_base: {
+    new (...args: any[]): {
+        api: import("../../../utils/api").default | null;
+        key: String;
+        isFirstLoad: boolean;
+        isLoading: boolean;
+        iObserver: IntersectionObserver | null;
+        isDefaultLoaderEnabled: boolean;
+        isFetchEnabled: boolean;
+        _endPoint: string;
+        endPoint: string;
+        _fetchData(): Promise<void>;
+        onInvalidate: any;
+        disconnectedCallback(): void;
+        connectedCallback(): void;
+        firstUpdated(): void;
+        onIntersection(entries: IntersectionObserverEntry[]): void;
+        props: any;
+        propertyMap: Object;
+        isConnected: boolean;
+        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;
+        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("../../../utils/api").APIConfiguration;
+        requestUpdate(): void;
+        getAttribute(name: string): string;
+        hasAttribute(attributeName: String): boolean;
+    };
+} & (new (...args: any[]) => import("../../../mixins/Subscriber").SubscriberInterface) & typeof LitElement;
+export declare class SonicComponent extends SonicComponent_base {
+    connectedCallback(): void;
+    get props(): SDUIDescriptor;
+    loadJS(src: string): Promise<unknown>;
+    loadCSS(src: string): Promise<unknown>;
+    set props(value: SDUIDescriptor);
+    updateContents(): Promise<void>;
+    parseChild(props: SDUINode): HTMLElement;
+}
+export {};

package/core/components/functional/sdui/sdui.js

@@ -0,0 +1,130 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LitElement } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { Fetcher, Subscriber } from "@supersoniks/concorde/mixins";
+const tagName = "sonic-sdui"; // For Astro.build
+let SonicComponent = class SonicComponent extends Fetcher(Subscriber(LitElement)) {
+    connectedCallback() {
+        this.noShadowDom = "";
+        this.isFetchEnabled = this.hasAttribute("fetch");
+        super.connectedCallback();
+    }
+    get props() {
+        return super.props;
+    }
+    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");
+                script.src = src;
+                script.onload = () => resolve(true);
+                script.onerror = () => resolve(true);
+                document.head.appendChild(script);
+            }));
+            return p;
+        });
+    }
+    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");
+                cssnode.type = "text/css";
+                cssnode.rel = "stylesheet";
+                cssnode.href = src;
+                cssnode.onload = () => resolve(true);
+                cssnode.onerror = () => resolve(true);
+                document.head.appendChild(cssnode);
+            }));
+            return p;
+        });
+    }
+    set props(value) {
+        super.props = value;
+        this.updateContents();
+    }
+    updateContents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while ([...this.children].filter((elt) => elt.nodeName != "SLOT").length > 0) {
+                this.removeChild(this.children[0]);
+            }
+            if (!this.props)
+                return;
+            try {
+                if (this.props.js) {
+                    for (const src of this.props.js)
+                        this.loadJS(src);
+                }
+                if (this.props.css) {
+                    for (const src of this.props.css)
+                        this.loadCSS(src);
+                }
+            }
+            catch (e) { }
+            let children = this.props.nodes;
+            if (!children)
+                return;
+            for (let child of children) {
+                this.appendChild(this.parseChild(child));
+            }
+        });
+    }
+    parseChild(props) {
+        let type = props.type || "div";
+        let element;
+        if (props.markup) {
+            element = document.createElement("div");
+            element.style.display = "contents";
+            element.innerHTML = props.markup;
+            return element;
+        }
+        if (props.library && this.props.library) {
+            element = this.parseChild(this.props.library[props.library] || { type: "div" });
+        }
+        else
+            element = document.createElement(type);
+        let attributes = props.attributes;
+        for (let k in attributes) {
+            element.setAttribute(k, attributes[k]);
+        }
+        if (props.innerHTML) {
+            element.innerHTML = props.innerHTML;
+        }
+        if (props.nodes) {
+            let children = props.nodes;
+            for (let child of children) {
+                if (element.shadowRoot)
+                    element.shadowRoot.appendChild(this.parseChild(child));
+                else
+                    element.appendChild(this.parseChild(child));
+            }
+        }
+        if (props.prefix || props.suffix) {
+            const container = document.createElement("div");
+            container.innerHTML = (props.prefix || "") + element.outerHTML + (props.suffix || "");
+            container.style.display = "contents";
+            return container;
+        }
+        return element;
+    }
+};
+__decorate([
+    property()
+], SonicComponent.prototype, "props", null);
+SonicComponent = __decorate([
+    customElement(tagName)
+], SonicComponent);
+export { SonicComponent };

package/core/components/ui/button/button.d.ts

@@ -25,7 +25,13 @@ declare const Button_base: {
         _name: string;
         name: string;
         props: any;
-        isConnected: boolean;
+        propertyMap: Object;
+        isConnected: boolean; /**
+         * Un bouton simple avec deux slots, un nommé préfix et un nomé suffix de manière à pouvoir mettre (par exemple) une icone avant ou après le contenu.
+         * * L'objet et ses slot sont en display flex avec direction / alignement et justifications configurables
+         * * Le bouton est comparable au badge car il possèdent tous les deux les propriétés *type* (primary...), *variant*(outline, ghost), size(xs...)...
+         * * Le bouton possède cependant et notamment une propriété href contrairement à un badge
+         */
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;
         querySelectorAll(selector: string): NodeListOf<Element>;

package/core/components/ui/form/checkbox/checkbox.d.ts

@@ -26,6 +26,7 @@ declare const Checkbox_base: {
         _name: string;
         name: string;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;
@@ -74,6 +75,7 @@ declare const Checkbox_base: {
         _name: string;
         name: string;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;

package/core/components/ui/form/input/input.d.ts

@@ -26,6 +26,7 @@ declare const Input_base: {
         _name: string;
         name: string;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;

package/core/components/ui/form/textarea/textarea.d.ts

@@ -26,6 +26,7 @@ declare const Textarea_base: {
         _name: string;
         name: string;
         props: any;
+        propertyMap: Object;
         isConnected: boolean;
         getAncestorAttributeValue(attributeName: string): string;
         hasAncestorAttribute(attributeName: string): boolean;