@telesign/boreal-web-components 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/cjs/bds-dialog.cjs.entry.js

@@ -0,0 +1,373 @@
+'use strict';
+
+var index = require('./index-CwYIVC9N.js');
+var floating_mixin = require('./floating.mixin-Bje4320w.js');
+var attributes = require('./attributes-wIHueigW.js');
+var validateProps = require('./validateProps-CJe9X5x8.js');
+var states = require('./states-BweP5Vpu.js');
+
+const backdropMixin = (Base) => {
+    /**
+     * Backdrop mixin class that extends floatingMixin to provide backdrop functionality for dialogs.
+     * Handles showing/hiding dialogs, backdrop clicks, escape key handling, and scroll locking.
+     *
+     * @example
+     * ```typescript
+     * import { Component, Mixin, h } from '@stencil/core';
+     * import { backdropMixin } from './backdrop.mixin';
+     * import { BackdropHooks } from '@/services/floating/interfaces/Backdrop';
+     *
+     * @Component({ tag: 'my-dialog' })
+     * export class MyDialog extends Mixin(backdropMixin) {
+     *
+     *   // Optional: Override hooks for custom behavior
+     *   get hooks(): BackdropHooks {
+     *     return {
+     *       onAfterShow: () => console.log('Dialog shown'),
+     *       onBeforeClose: () => console.log('Dialog closing'),
+     *       onAfterHide: () => console.log('Dialog hidden'),
+     *     };
+     *   }
+     *
+     *   render() {
+     *     return (
+     *       <dialog
+     *         ref={(el) => (this.dialogElement = el)}
+     *         onClick={(e) => this.handleBackdropClick(e)}
+     *         onKeyDown={(e) => this.handleKeydown(e)}
+     *       >
+     *         <div>Dialog content</div>
+     *       </dialog>
+     *     );
+     *   }
+     * }
+     * ```
+     */
+    class Backdrop extends floating_mixin.floatingMixin(Base) {
+        constructor() {
+            super(...arguments);
+            /**
+             * Indicates whether the dialog is currently in the process of closing.
+             */
+            this.isClosing = false;
+        }
+        /**
+         * Override in component to provide custom hooks.
+         * @returns {BackdropHooks} The custom hooks object.
+         */
+        get hooks() {
+            return {};
+        }
+        /**
+         * Shows the dialog element by calling showModal and setting isVisible to true.
+         * Overrides floating mixin showElement()
+         */
+        showElement() {
+            this.dialogElement.showModal();
+            this.isVisible = true;
+        }
+        /**
+         * Hides the dialog element by calling close and setting isVisible to false, and resets isClosing.
+         * Overrides floating mixin hideElement()
+         */
+        hideElement() {
+            this.dialogElement.close();
+            this.isVisible = false;
+            this.isClosing = false;
+        }
+        /**
+         * Closes the dialog element, preventing multiple close attempts and calling hooks if available.
+         * * If the onBEforeClose() hook is passed, the implementation SHOULD call the hide() function.
+         */
+        closeElement() {
+            if (this.preventClose)
+                return;
+            if (this.isClosing)
+                return;
+            this.isClosing = true;
+            if (this.hooks.onBeforeClose !== undefined)
+                this.onBeforeClose(this.dialogElement);
+            else
+                this.hide();
+        }
+        /**
+         * Toggles the visibility of the dialog: closes if visible, shows if hidden.
+         */
+        toggle() {
+            this.isVisible ? this.closeElement() : this.show();
+        }
+        /**
+         * Overrides the hooks inherited from floating mixin.
+         * Hook called after the dialog is shown. Locks the scroll and calls custom hooks.
+         * @param target The target HTMLElement
+         */
+        onAfterShow(target) {
+            this.previousOverflow = document.body.style.overflow;
+            document.body.style.overflow = 'hidden';
+            this.hooks.onAfterShow?.(target);
+        }
+        /**
+         * Hook called after the dialog is hidden. Restores the previous overflow style and calls custom hooks.
+         * @param target The target HTMLElement
+         */
+        onAfterHide(target) {
+            document.body.style.overflow = this.previousOverflow ?? '';
+            this.hooks.onAfterHide?.(target);
+        }
+        /**
+         * A lifecycle hook that is invoked just before the dialog begins to close.
+         * This provides an opportunity to perform custom actions, such as triggering closing animations,
+         * before the dialog is actually hidden from view.
+         * * If the onBeforeClose() hook is passed, the implementation SHOULD call the hide() function.
+         * @param target The target HTMLElement, typically the dialog element.
+         */
+        onBeforeClose(target) {
+            this.hooks.onBeforeClose?.(target);
+        }
+        /**
+         * Handle backdrop click to close the dialog.
+         * @param e Mouse Event at click
+         */
+        handleBackdropClick(e) {
+            if (!this.backdropClose)
+                return;
+            if (e.target === this.dialogElement) {
+                e.preventDefault();
+                e.stopImmediatePropagation();
+                this.closeElement();
+            }
+        }
+        /**
+         * Handle Escape keydown to close the dialog.
+         * @param ev KeyboardEvent
+         */
+        handleKeydown(ev) {
+            if (ev.key === 'Escape') {
+                ev.preventDefault();
+                ev.stopImmediatePropagation();
+            }
+            if (!this.escapeClose || ev.repeat || ev.key !== 'Escape')
+                return;
+            this.closeElement();
+        }
+        /**
+         * Adds a transition class to the dialog element.
+         * Cleanup and closing logic must be handled by the caller.
+         */
+        addTransitionAnimation(animationClassName) {
+            this.dialogElement.classList.add(animationClassName);
+        }
+        /**
+         * Removes a transition class to the dialog element.
+         * Calling must be handled by the caller.
+         */
+        removeTransitionAnimation(animationClassName) {
+            this.dialogElement.classList.remove(animationClassName);
+        }
+    }
+    return Backdrop;
+};
+
+const DIALOG_SIZES = {
+    SMALL: 'sm',
+    MEDIUM: 'md',
+    LARGE: 'lg',
+    FULL: 'full',
+};
+const DIALOG_VARIANT = {
+    ...states.STATUS_VARIANT,
+    DEFAULT: 'default',
+};
+const DIALOG_VARIANT_ICON = {
+    INFO: 'bds-icon-info-circle-fill',
+    SUCCESS: 'bds-icon-check-circle-fill',
+    WARNING: 'bds-icon-info-major-triangle-up-fill',
+    DANGER: 'bds-icon-alert-circle-fill',
+};
+const DIALOG_LAYOUT = {
+    DEFAULT: 'default',
+    HEADERLESS: 'headerless',
+    FOOTERLESS: 'footerless',
+};
+const DIALOG_CONTENT_PADDING = {
+    DEFAULT: 'default',
+    NONE: 'none',
+};
+
+const bdsDialogCss = () => `@charset "UTF-8";.bds-dialog{font-family:var(--boreal-typography-font-family-primary);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column}.bds-dialog__header{height:var(--boreal-spacing-4xl);display:-ms-flexbox;display:flex;-ms-flex-pack:justify;justify-content:space-between;padding:var(--boreal-spacing-s) var(--boreal-spacing-s) var(--boreal-spacing-s) var(--boreal-spacing-l)}.bds-dialog__header:empty{display:none}.bds-dialog__header-right,.bds-dialog__header-left{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;gap:var(--boreal-spacing-2xs)}.bds-dialog__title{color:var(--boreal-text-default-light);font-size:var(--boreal-typography-font-size-md);font-weight:var(--boreal-typography-font-weight-semibold);line-height:var(--boreal-typography-line-height-md)}.bds-dialog__body{height:100%;overflow-y:auto;padding:var(--boreal-spacing-s) var(--boreal-spacing-l)}.bds-dialog__footer{padding:var(--boreal-spacing-s) var(--boreal-spacing-xs)}.bds-dialog__body,.bds-dialog__footer{-webkit-box-shadow:0 var(--boreal-spacing-4xs) var(--boreal-spacing-4xs) 0 var(--boreal-stroke-default-light) inset;box-shadow:0 var(--boreal-spacing-4xs) var(--boreal-spacing-4xs) 0 var(--boreal-stroke-default-light) inset}.bds-dialog__body:empty,.bds-dialog__footer:empty{display:none}.bds-dialog--sm{width:min(448px, 100vw - var(--boreal-spacing-m) * 2)}.bds-dialog--md{width:min(640px, 100vw - var(--boreal-spacing-m) * 2)}.bds-dialog--lg{width:min(960px, 100vw - var(--boreal-spacing-m) * 2)}.bds-dialog--full{width:min(1280px, 100vw - var(--boreal-spacing-m) * 2);height:calc(100vh - var(--boreal-spacing-4xl))}.bds-dialog--custom-size{width:var(--bds-dialog-width, auto);height:var(--bds-dialog-height, auto)}.bds-dialog--info .bds-dialog__variant-icon{color:var(--boreal-icon-info-base)}.bds-dialog--warning .bds-dialog__variant-icon{color:var(--boreal-icon-warning-base)}.bds-dialog--danger .bds-dialog__variant-icon{color:var(--boreal-icon-danger-base)}.bds-dialog--success .bds-dialog__variant-icon{color:var(--boreal-icon-success-base)}.bds-dialog--no-padding{padding:0}bds-dialog dialog{border:none;border-radius:var(--boreal-radius-xs);background-color:var(--boreal-white);-webkit-box-shadow:0 8px 12px 0 rgba(19, 19, 22, 0.15);box-shadow:0 8px 12px 0 rgba(19, 19, 22, 0.15);-ms-flex-item-align:center;align-self:center;justify-self:center}bds-dialog dialog::-webkit-backdrop{opacity:0;-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease}bds-dialog dialog::-ms-backdrop{opacity:0;-ms-transition:opacity 0.3s ease;transition:opacity 0.3s ease}bds-dialog dialog,bds-dialog dialog::backdrop{opacity:0;-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease}bds-dialog dialog[open].enter::-webkit-backdrop{opacity:1}bds-dialog dialog[open].enter::-ms-backdrop{opacity:1}bds-dialog dialog[open].enter,bds-dialog dialog[open].enter::backdrop{opacity:1}`;
+
+const BdsDialog = class extends index.Mixin(backdropMixin) {
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.bdsOpen = index.createEvent(this, "bdsOpen");
+        this.bdsClose = index.createEvent(this, "bdsClose");
+        this.bdsMaximize = index.createEvent(this, "bdsMaximize");
+        this.inheritedAttributes = {};
+        /** Controls whether the dialog is open. */
+        this.active = false;
+        /** Controls whether the dialog is closable. */
+        this.preventClose = false;
+        /** Dialog custom height */
+        this.height = '';
+        /** Dialog custom width */
+        this.width = '';
+        /** Layout type: 'default', 'headerless', or 'footerless'. */
+        this.layout = DIALOG_LAYOUT.DEFAULT;
+        /** Content padding: 'default' or 'none'. */
+        this.contentPadding = DIALOG_CONTENT_PADDING.DEFAULT;
+        /** Close dialog when clicking the backdrop. */
+        this.backdropClose = false;
+        /** Close dialog when pressing Escape. */
+        this.escapeClose = false;
+        /** Dialog size: 'small', 'medium', 'large', or 'full'. */
+        this.size = DIALOG_SIZES.MEDIUM;
+        /** Visual variant: 'default', 'info', 'success', 'warning', or 'danger'. */
+        this.variant = DIALOG_VARIANT.DEFAULT;
+        /** Title text displayed in the header. */
+        this.titleDialog = '';
+        /** Show maximize button to toggle full-screen. */
+        this.maximizable = false;
+        /** Hide the close button in the header. */
+        this.closable = false;
+        this.onDialogTransitionEnd = (ev) => {
+            if (ev.target !== this.dialogElement)
+                return;
+            if (ev.pseudoElement === '::backdrop')
+                return;
+            if (this.preventClose)
+                return;
+            if (!this.isClosing)
+                return;
+            this.hide();
+        };
+    }
+    handleIsOpenChange(active) {
+        if (this.dialogElement === undefined)
+            return;
+        if (active)
+            this.show();
+        else
+            this.closeElement();
+    }
+    componentWillLoad() {
+        this.checkPropValues();
+        this.inheritedAttributes = {
+            ...attributes.inheritAriaAttributes(this.el),
+        };
+    }
+    componentDidLoad() {
+        if (this.active)
+            this.handleIsOpenChange(this.active);
+    }
+    checkPropValues() {
+        validateProps.validatePropValue(Object.values(DIALOG_LAYOUT), DIALOG_LAYOUT.DEFAULT, this.el, 'layout');
+        validateProps.validatePropValue(Object.values(DIALOG_CONTENT_PADDING), DIALOG_CONTENT_PADDING.DEFAULT, this.el, 'contentPadding');
+        validateProps.validatePropValue(Object.values(DIALOG_SIZES), DIALOG_SIZES.MEDIUM, this.el, 'size');
+        validateProps.validatePropValue(Object.values(DIALOG_VARIANT), DIALOG_VARIANT.DEFAULT, this.el, 'variant');
+    }
+    handleMaximize() {
+        this.bdsMaximize.emit();
+    }
+    /**
+     * Opens the dialog programmatically.
+     * This method triggers the show functionality to display the dialog.
+     */
+    async open() {
+        this.show();
+    }
+    /**
+     * Closes the dialog programmatically.
+     * This method triggers the close functionality to hide the dialog.
+     */
+    async close() {
+        this.closeElement();
+    }
+    get isHeaderLeftVisible() {
+        return this.isHeaderRightVisible || this.titleDialog;
+    }
+    get isHeaderRightVisible() {
+        return this.maximizable || this.closable;
+    }
+    get hooks() {
+        return {
+            onAfterShow: () => this.onOpenDialog(),
+            onBeforeClose: () => this.transitionBeforeClose(),
+            onAfterHide: () => this.resetComponent(),
+        };
+    }
+    /**
+     * Handles the transition logic before closing the dialog.
+     * Sets the active prop to false, removes the enter transition animation,
+     * and checks if there's a transition duration. If no transition, hides immediately;
+     * otherwise, the hide will be triggered after the transition ends.
+     */
+    transitionBeforeClose() {
+        if (this.active)
+            this.active = false;
+        this.removeTransitionAnimation('enter');
+        const { transitionDuration } = getComputedStyle(this.dialogElement);
+        const duration = parseFloat(transitionDuration);
+        const hasTransition = transitionDuration && !Number.isNaN(duration) && duration > 0;
+        if (!hasTransition) {
+            this.hide();
+            return;
+        }
+    }
+    onOpenDialog() {
+        this.addTransitionAnimation('enter');
+        this.bdsOpen.emit();
+    }
+    resetComponent() {
+        this.bdsClose.emit();
+    }
+    /** Render helper functions */
+    getVariantIcon() {
+        const iconMap = {
+            info: DIALOG_VARIANT_ICON.INFO,
+            success: DIALOG_VARIANT_ICON.SUCCESS,
+            warning: DIALOG_VARIANT_ICON.WARNING,
+            danger: DIALOG_VARIANT_ICON.DANGER,
+            default: '',
+        };
+        if (iconMap[this.variant] === undefined)
+            return iconMap['default'];
+        return iconMap[this.variant];
+    }
+    getStyles() {
+        return {
+            'bds-dialog': true,
+            [`bds-dialog--${this.variant}`]: true,
+            [`bds-dialog--${this.size}`]: true,
+            [`bds-dialog--custom-size`]: this.width.length > 0 || this.height.length > 0,
+        };
+    }
+    getFixedSize() {
+        return {
+            ...(this.width && { '--bds-dialog-width': `${this.width}px` }),
+            ...(this.height && { '--bds-dialog-height': `${this.height}px` }),
+        };
+    }
+    getHeaderLeftElement() {
+        return (this.isHeaderLeftVisible && (index.h("div", { class: "bds-dialog__header-left" }, this.getVariantIcon() && (index.h("em", { "aria-hidden": "true", class: `bds-dialog__variant-icon ${this.getVariantIcon()}` })), this.titleDialog && (index.h("span", { id: "bds-dialog-title", class: "bds-dialog__title" }, this.titleDialog)))));
+    }
+    getHeaderRightElement() {
+        return (this.isHeaderRightVisible && (index.h("div", { class: "bds-dialog__header-right" }, this.maximizable && (index.h("bds-button", { "aria-label": "maximize", type: "button", onBdsClick: () => this.handleMaximize() }, index.h("em", { class: "bds-icon-arrows-out" }))), this.closable && (index.h("bds-button", { "aria-label": "close", type: "button", onBdsClick: () => this.closeElement() }, index.h("em", { class: "bds-icon-close" }))))));
+    }
+    render() {
+        const inheritedAriaAttr = this.inheritedAttributes;
+        return (index.h("dialog", { key: '73f9b2516aa414e3016e8a18b5f0d2de7f46a09a', onClick: e => this.handleBackdropClick(e), onKeyDown: e => this.handleKeydown(e), onTransitionEnd: this.onDialogTransitionEnd, ref: el => {
+                if (el !== undefined)
+                    this.dialogElement = el;
+            }, style: { ...this.getFixedSize() }, ...(this.titleDialog.length > 0 && { 'aria-labelledby': 'bds-dialog-title' }), ...inheritedAriaAttr }, index.h("div", { key: 'ef900b6a99ed650db043fb8123c90c3cd7322ec6', class: this.getStyles() }, this.layout !== DIALOG_LAYOUT.HEADERLESS && (index.h("div", { key: '81d96f353eef6bd9f38baba8702b88599d6c02a3', class: "bds-dialog__header" }, this.getHeaderLeftElement(), this.getHeaderRightElement())), index.h("div", { key: 'd36d2c112a87e885e53bd4a8740530ac7b196980', class: `bds-dialog__body ${this.contentPadding === 'none' ? 'bds-dialog--no-padding' : ''}` }, index.h("slot", { key: 'c296c8e91a44d7f40284586b3b425a6b87964cdd' })), this.layout !== DIALOG_LAYOUT.FOOTERLESS && (index.h("div", { key: '98c17852b5dc519207c66850c38d679d31d27b5b', class: "bds-dialog__footer" }, index.h("slot", { key: '159426b4095804e6da864d86a0f6ef7a8e2197e3', name: "footer" }))))));
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "active": [{
+                "handleIsOpenChange": 0
+            }]
+    }; }
+};
+BdsDialog.style = bdsDialogCss();
+
+exports.bds_dialog = BdsDialog;

package/dist/cjs/bds-divider.cjs.entry.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var index = require('./index-CwYIVC9N.js');
+var validateProps = require('./validateProps-CJe9X5x8.js');
+
+const DIVIDER_ORIENTATIONS = {
+    HORIZONTAL: 'horizontal',
+    VERTICAL: 'vertical',
+};
+
+const bdsDividerCss = () => `@charset "UTF-8";bds-divider[orientation=vertical]{display:inline-block;height:100%}bds-divider[orientation=horizontal]{display:block;width:100%}.bds-divider{background-color:var(--boreal-ui-default-lighter)}.bds-divider--horizontal{width:100%;height:var(--boreal-spacing-4xs)}.bds-divider--vertical{width:var(--boreal-spacing-4xs);height:100%}`;
+
+const BdsDivider = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        /**
+         * The orientation of the divider.
+         * Allowed values: horizontal | vertical
+         */
+        this.orientation = DIVIDER_ORIENTATIONS.HORIZONTAL;
+    }
+    checkPropValues() {
+        validateProps.validatePropValue(Object.values(DIVIDER_ORIENTATIONS), DIVIDER_ORIENTATIONS.HORIZONTAL, this.el, 'orientation');
+    }
+    get orientationClass() {
+        return {
+            'bds-divider': true,
+            [`bds-divider--${this.orientation}`]: true,
+        };
+    }
+    componentWillLoad() {
+        this.checkPropValues();
+    }
+    render() {
+        return index.h("div", { key: 'd34f930e98129a75ca706f4695e40e577d5a12f6', part: "divider", class: this.orientationClass, role: "separator", "aria-orientation": this.orientation });
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "orientation": [{
+                "checkPropValues": 0
+            }]
+    }; }
+};
+BdsDivider.style = bdsDividerCss();
+
+exports.bds_divider = BdsDivider;