@prolibu-suite/cobalt-core 0.1.2 → 0.3.0

package/dist/collection/components/co-overlay/co-overlay.js

@@ -1,14 +1,193 @@
 import { h } from "@stencil/core";
+import { afterEventFor } from "./overlayAfterClose";
+import { getFocusableElements, resolveTabIndex } from "./focusTrap";
+/**
+ * Module-level body-scroll lock shared by every overlay instance.
+ * Ref-counted so stacked/nested overlays (e.g. a modal opened from a drawer)
+ * don't release the lock until the LAST one closes.
+ */
+let lockCount = 0;
+let savedOverflow = '';
+function lockBodyScroll() {
+    if (typeof document === 'undefined')
+        return;
+    if (lockCount === 0) {
+        savedOverflow = document.body.style.overflow;
+        document.body.style.overflow = 'hidden';
+    }
+    lockCount++;
+}
+function unlockBodyScroll() {
+    if (typeof document === 'undefined')
+        return;
+    if (lockCount === 0)
+        return;
+    lockCount--;
+    if (lockCount === 0) {
+        document.body.style.overflow = savedOverflow;
+    }
+}
+function nextFrame(cb) {
+    if (typeof requestAnimationFrame === 'function')
+        requestAnimationFrame(cb);
+    else
+        cb();
+}
 export class CoOverlay {
     constructor() {
         /** Whether the overlay is visible */
         this.open = false;
+        /**
+         * Opt-in accessible focus trap. When true, opening the overlay records the
+         * previously-focused element, moves focus into the overlay, cycles Tab /
+         * Shift+Tab within the slotted content, and restores focus on close.
+         * Default false → existing consumers are unchanged.
+         */
+        this.trapFocus = false;
+        /**
+         * Opt-in: emit `coClose` when Escape is pressed while open.
+         * Default false → existing consumers are unchanged.
+         */
+        this.closeOnEscape = false;
+        /** Whether THIS instance currently holds a scroll lock (prevents double-count). */
+        this.hasLock = false;
         this.handleClick = () => {
             this.coClose.emit();
         };
+        this.handleTransitionEnd = (e) => {
+            if (e.target !== this.overlayEl)
+                return;
+            const ev = afterEventFor(e.propertyName, this.open, 'opacity');
+            if (ev === 'after-open')
+                this.coAfterOpen.emit();
+            else if (ev === 'after-close')
+                this.coAfterClose.emit();
+        };
+    }
+    onOpenChange(isOpen) {
+        if (isOpen)
+            this.acquireLock();
+        else
+            this.releaseLock();
+        this.syncPopover();
+        if (this.trapFocus) {
+            if (isOpen)
+                this.captureAndFocus();
+            else
+                this.restoreFocus();
+        }
+    }
+    componentDidLoad() {
+        // Handle the case where the overlay mounts already open.
+        if (this.open)
+            this.acquireLock();
+        this.syncPopover();
+        if (this.open && this.trapFocus)
+            this.captureAndFocus();
+    }
+    disconnectedCallback() {
+        // Safety: never leave the body locked if removed while open.
+        this.releaseLock();
+        // Safety: return focus if we were removed while trapping.
+        if (this.trapFocus)
+            this.restoreFocus();
+    }
+    acquireLock() {
+        if (this.hasLock)
+            return;
+        this.hasLock = true;
+        lockBodyScroll();
+    }
+    releaseLock() {
+        if (!this.hasLock)
+            return;
+        this.hasLock = false;
+        unlockBodyScroll();
+    }
+    /**
+     * Promote the scrim to the browser top layer so it covers the whole viewport
+     * regardless of ancestor `filter`/`mask`/`transform` (which would otherwise
+     * make `position: fixed` resolve against that ancestor, confining the scrim).
+     * The Popover API promotes WITHOUT moving the DOM node, so slots and Stencil
+     * reconciliation are untouched. No-ops gracefully where unsupported.
+     */
+    syncPopover() {
+        const el = this.overlayEl;
+        if (!el || typeof el.showPopover !== 'function')
+            return;
+        try {
+            const isShown = el.matches(':popover-open');
+            if (this.open && !isShown)
+                el.showPopover();
+            else if (!this.open && isShown)
+                el.hidePopover();
+        }
+        catch (_a) {
+            /* not connected yet, or already in the desired state */
+        }
+    }
+    /** Record the current focus and move it into the overlay (guarded by trapFocus). */
+    captureAndFocus() {
+        if (typeof document !== 'undefined') {
+            this.returnFocusEl = document.activeElement;
+        }
+        // Defer so slotted content / the open transition is ready to take focus.
+        nextFrame(() => {
+            var _a;
+            if (!this.open)
+                return;
+            const focusables = getFocusableElements(this.el);
+            if (focusables.length > 0)
+                focusables[0].focus();
+            else
+                (_a = this.overlayEl) === null || _a === void 0 ? void 0 : _a.focus();
+        });
+    }
+    /** Restore focus to the element that had it before the trap engaged. */
+    restoreFocus() {
+        const target = this.returnFocusEl;
+        this.returnFocusEl = null;
+        if (target && typeof target.focus === 'function')
+            target.focus();
+    }
+    /** Deepest active element, descending through nested shadow roots. */
+    deepActiveElement() {
+        if (typeof document === 'undefined')
+            return null;
+        let node = document.activeElement;
+        while (node && node.shadowRoot && node.shadowRoot.activeElement) {
+            node = node.shadowRoot.activeElement;
+        }
+        return node;
+    }
+    handleKeydown(e) {
+        if (!this.open)
+            return;
+        if (this.closeOnEscape && e.key === 'Escape') {
+            this.coClose.emit();
+            return;
+        }
+        if (this.trapFocus && e.key === 'Tab')
+            this.trapTab(e);
+    }
+    trapTab(e) {
+        var _a;
+        const focusables = getFocusableElements(this.el);
+        if (focusables.length === 0) {
+            // Nothing to move to — keep focus pinned to the overlay container.
+            e.preventDefault();
+            (_a = this.overlayEl) === null || _a === void 0 ? void 0 : _a.focus();
+            return;
+        }
+        const activeIndex = focusables.indexOf(this.deepActiveElement());
+        const nextIndex = resolveTabIndex(focusables.length, activeIndex, e.shiftKey);
+        if (nextIndex < 0)
+            return;
+        e.preventDefault();
+        focusables[nextIndex].focus();
     }
     render() {
-        return (h("div", { key: '8f2a8e4ca27d43e10f797265a4b25fea1ef92445', class: { 'co-overlay': true, 'co-overlay--open': this.open }, part: "overlay", onClick: this.handleClick }, h("slot", { key: '6099310206111ba414b3e9f35edf8ba598d6ef4e' })));
+        return (h("div", { key: 'e6a474574b171c1f4f0b55b9165aa22ee7faa7f1', class: { 'co-overlay': true, 'co-overlay--open': this.open }, part: "overlay", popover: "manual", tabindex: this.trapFocus ? -1 : undefined, ref: (el) => (this.overlayEl = el), onClick: this.handleClick, onTransitionEnd: this.handleTransitionEnd }, h("slot", { key: '05a95bc4822c57de49137f2e604f4dbb54f81f9e' })));
     }
     static get is() { return "co-overlay"; }
     static get encapsulation() { return "shadow"; }
@@ -43,6 +222,46 @@ export class CoOverlay {
                 "reflect": true,
                 "attribute": "open",
                 "defaultValue": "false"
+            },
+            "trapFocus": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Opt-in accessible focus trap. When true, opening the overlay records the\npreviously-focused element, moves focus into the overlay, cycles Tab /\nShift+Tab within the slotted content, and restores focus on close.\nDefault false \u2192 existing consumers are unchanged."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "trap-focus",
+                "defaultValue": "false"
+            },
+            "closeOnEscape": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Opt-in: emit `coClose` when Escape is pressed while open.\nDefault false \u2192 existing consumers are unchanged."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "close-on-escape",
+                "defaultValue": "false"
             }
         };
     }
@@ -62,6 +281,52 @@ export class CoOverlay {
                     "resolved": "void",
                     "references": {}
                 }
+            }, {
+                "method": "coAfterClose",
+                "name": "coAfterClose",
+                "bubbles": false,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Slide/fade-out animation finished (overlay fully closed)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "coAfterOpen",
+                "name": "coAfterOpen",
+                "bubbles": false,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Slide/fade-in animation finished (overlay fully open)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "open",
+                "methodName": "onOpenChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "keydown",
+                "method": "handleKeydown",
+                "target": "document",
+                "capture": false,
+                "passive": false
             }];
     }
 }

package/dist/collection/components/co-overlay/focusTrap.js

@@ -0,0 +1,53 @@
+// focusTrap.ts
+//
+// Focus-trap helpers for co-overlay. The Tab-cycling decision is a PURE function
+// (`resolveTabIndex`) so it can be unit-tested in a node env, mirroring the
+// `overlayAfterClose` split. The DOM query lives here too but is only invoked by
+// the component at runtime.
+/** CSS selector matching natively tabbable elements. */
+export const FOCUSABLE_SELECTOR = [
+    'a[href]',
+    'area[href]',
+    'button:not([disabled])',
+    'input:not([disabled]):not([type="hidden"])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    'iframe',
+    'audio[controls]',
+    'video[controls]',
+    '[contenteditable]:not([contenteditable="false"])',
+    '[tabindex]:not([tabindex="-1"])',
+].join(',');
+/**
+ * Decide which focusable index a Tab / Shift+Tab keystroke should move to.
+ *
+ * @param count       number of focusable elements inside the trap
+ * @param activeIndex index of the currently focused element, or -1 when focus
+ *                    is outside the trap (e.g. it escaped to the body)
+ * @param shiftKey    whether Shift is held (backward tabbing)
+ * @returns the index to focus, or -1 when there is nothing to trap
+ *
+ * Pure — no DOM — so the wrap-around edge cases stay unit-testable.
+ */
+export function resolveTabIndex(count, activeIndex, shiftKey) {
+    if (count <= 0)
+        return -1;
+    if (shiftKey) {
+        // Backward: from the first element (or from outside) wrap to the last.
+        return activeIndex <= 0 ? count - 1 : activeIndex - 1;
+    }
+    // Forward: from the last element (or from outside) wrap to the first.
+    return activeIndex === -1 || activeIndex >= count - 1 ? 0 : activeIndex + 1;
+}
+/**
+ * Collect the tabbable elements slotted into the overlay's light DOM, skipping
+ * hidden / aria-hidden ones. (Focusables nested inside further shadow roots are
+ * out of scope — the common dialog/modal content lives in the slotted subtree.)
+ */
+export function getFocusableElements(root) {
+    const nodes = Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR));
+    return nodes.filter((el) => !el.hasAttribute('disabled') &&
+        el.getAttribute('aria-hidden') !== 'true' &&
+        // offsetParent is null for display:none; getClientRects covers position:fixed.
+        (el.offsetParent !== null || el.getClientRects().length > 0));
+}

package/dist/collection/components/co-overlay/overlayAfterClose.js

@@ -0,0 +1,8 @@
+/** Decide which after-animation event a `transitionend` should emit.
+ *  `watched` is the authoritative CSS property (so multi-prop transitions
+ *  — e.g. transform + opacity — fire the after-event exactly once). */
+export function afterEventFor(propertyName, isOpen, watched) {
+    if (propertyName !== watched)
+        return null;
+    return isOpen ? 'after-open' : 'after-close';
+}

package/dist/collection/components/co-page-header/co-page-header.js

@@ -6,7 +6,7 @@ import { h } from "@stencil/core";
  */
 export class CoPageHeader {
     render() {
-        return (h("div", { key: '1a1d93d47a677a42f201b9433604c20e952b36df', class: "co-page-header", part: "page-header" }, h("div", { key: '2c634b9ba352ba4bf0097f81aa51331f8d0fd4d1', class: "co-page-header__left" }, this.icon && (h("span", { key: 'e88bb93d1cbb37ee1c3f4e57a00c72156377a434', class: "co-page-header__icon" }, h("co-icon", { key: '01282c4e2c61789c8f1b95b9a15e7e683cbaf0a7', name: this.icon, size: 24 }))), h("span", { key: '4d3f7b4f86cf178c9a11c91e0da17c3293a911ff', class: "co-page-header__title" }, h("slot", { key: '2291559692047e954b3984f738d6751c9b39ed76' }, this.heading))), h("div", { key: '780971b9a144f8daa53619df25fe69325b12d9da', class: "co-page-header__actions" }, h("slot", { key: 'dc2a010be24395703942b658af059299a92c7fea', name: "actions" }))));
+        return (h("div", { key: '94082a258b3c20350f34f90b90391d4cf461ad2a', class: "co-page-header", part: "page-header" }, h("div", { key: '72cb04b8ac9e97020df05332026ff1127530e0ef', class: "co-page-header__left" }, this.icon && (h("span", { key: 'dde04074f7fa038302ad6fb6e26b0d0ac14df708', class: "co-page-header__icon" }, h("co-icon", { key: '39543a724220ce8b0d67691aa9e96a5d107c70bb', name: this.icon, size: 24 }))), h("span", { key: '690582a7cd3feacd28142229a98f06afd1d5016e', class: "co-page-header__title" }, h("slot", { key: 'e5a836f061981b1126eff7b725ffc1047abadffd' }, this.heading))), h("div", { key: '80353c45ac8266f79b620561f79f1e724f877be8', class: "co-page-header__actions" }, h("slot", { key: '652ec6bc870096944d8795c873f3a5d0d41b3d89', name: "actions" }))));
     }
     static get is() { return "co-page-header"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/co-phone-field/co-phone-field.css

@@ -0,0 +1,293 @@
+:host {
+  display: block;
+  font-family: var(--co-font-family-primary);
+  font-size: var(--co-font-size-14);
+  letter-spacing: var(--co-font-letter-spacing-body);
+  line-height: 1;
+  position: relative;
+}
+
+.co-phone-field {
+  display: flex;
+  flex-direction: column;
+  gap: var(--co-spacing-sm2);
+  position: relative;
+  font-family: var(--co-font-family-primary);
+}
+
+.co-phone-field--disabled {
+  opacity: 0.5;
+  pointer-events: none;
+}
+
+.co-phone-field__label {
+  font-size: var(--co-font-size-14);
+  font-weight: 400;
+  color: var(--co-semantic-text-secondary);
+  padding: 0 var(--co-spacing-xs);
+}
+
+.co-field-required {
+  margin-left: 2px;
+  color: var(--co-color-status-error);
+}
+
+.co-field-required__caption {
+  margin-left: 4px;
+  color: var(--co-semantic-text-muted);
+  font-size: var(--co-font-size-12);
+  font-weight: 400;
+}
+
+.co-field-required__caption::before {
+  content: var(--co-field-required-text, ' (required)');
+}
+
+.co-phone-field__container {
+  display: flex;
+  align-items: center;
+  gap: var(--co-spacing-sm2);
+  padding: var(--co-spacing-sm2) var(--co-spacing-md);
+  background: color-mix(in srgb, var(--co-semantic-surface-secondary) 55%, transparent);
+  -webkit-backdrop-filter: blur(var(--co-glass-blur)) saturate(var(--co-glass-saturate));
+  backdrop-filter: blur(var(--co-glass-blur)) saturate(var(--co-glass-saturate));
+  border: 1px solid var(--co-semantic-border-subtle);
+  border-radius: var(--co-border-radius-xs);
+  transition: border-color 0.15s ease, box-shadow 0.15s ease;
+  min-height: 40px;
+  box-sizing: border-box;
+}
+
+/* ── Size variants (mirror co-input: s 28 / sm 32 / md 40 / lg 48) ── */
+.co-phone-field--s .co-phone-field__container {
+  min-height: 28px;
+  padding: var(--co-spacing-xxs) var(--co-spacing-sm);
+  font-size: var(--co-font-size-12);
+}
+
+.co-phone-field--sm .co-phone-field__container {
+  min-height: 32px;
+  padding: var(--co-spacing-xs) var(--co-spacing-sm);
+  font-size: var(--co-font-size-14);
+}
+
+/* md is the default (40px) — no override needed */
+
+.co-phone-field--lg .co-phone-field__container {
+  min-height: 48px;
+  padding: var(--co-spacing-sm) var(--co-spacing-lg);
+  font-size: var(--co-font-size-16);
+}
+
+.co-phone-field--error .co-phone-field__container {
+  border-color: var(--co-color-status-error);
+}
+
+.co-phone-field__container:focus-within {
+  border-color: var(--co-semantic-border-focus);
+  box-shadow: 0 0 0 2px color-mix(in srgb, var(--co-semantic-border-focus) 15%, transparent);
+}
+
+.co-phone-field__selector {
+  display: flex;
+  align-items: center;
+  gap: var(--co-spacing-xs);
+  padding: 0;
+  background: none;
+  border: none;
+  border-right: 1px solid var(--co-semantic-border-subtle);
+  padding-right: var(--co-spacing-sm);
+  margin-right: var(--co-spacing-sm);
+  cursor: pointer;
+  font-size: inherit;
+  font-family: inherit;
+  color: var(--co-semantic-text-default);
+  white-space: nowrap;
+}
+
+.co-phone-field__selector:hover {
+  opacity: 0.8;
+}
+
+.co-phone-field__flag {
+  width: 20px;
+  height: 15px;
+  border-radius: 2px;
+  object-fit: cover;
+}
+
+.co-phone-field__dial-code {
+  /* Inherits from the container so the size variants cascade (14px at md). */
+  font-size: inherit;
+  color: var(--co-semantic-text-secondary);
+  font-weight: 500;
+}
+
+.co-phone-field__chevron {
+  display: flex;
+  align-items: center;
+  color: var(--co-semantic-text-muted);
+}
+
+.co-phone-field__input {
+  flex: 1;
+  min-width: 0;
+  padding: 0;
+  border: none;
+  outline: none;
+  font-size: inherit;
+  font-family: inherit;
+  font-weight: 400;
+  letter-spacing: inherit;
+  color: var(--co-semantic-text-default);
+  background: transparent;
+  line-height: 1;
+}
+
+.co-phone-field__input::placeholder {
+  color: var(--co-semantic-text-muted);
+}
+
+/* Dropdown */
+.co-phone-field__dropdown {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  right: 0;
+  z-index: 100;
+  margin-top: var(--co-spacing-xs);
+  background: var(--co-semantic-surface-page, #fff);
+  border: 1px solid var(--co-semantic-border-subtle);
+  border-radius: var(--co-border-radius-xs);
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+  max-height: 280px;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.co-phone-field__search {
+  padding: var(--co-spacing-sm);
+  border-bottom: 1px solid var(--co-semantic-border-subtle);
+}
+
+.co-phone-field__search-input {
+  width: 100%;
+  padding: var(--co-spacing-xs) var(--co-spacing-sm);
+  border: 1px solid var(--co-semantic-border-subtle);
+  border-radius: var(--co-border-radius-xxs);
+  font-size: var(--co-font-size-14);
+  font-family: var(--co-font-family-primary);
+  outline: none;
+  background: var(--co-semantic-surface-secondary);
+  color: var(--co-semantic-text-default);
+  box-sizing: border-box;
+}
+
+.co-phone-field__search-input:focus {
+  border-color: var(--co-semantic-border-focus);
+}
+
+.co-phone-field__options {
+  overflow-y: auto;
+  flex: 1;
+}
+
+.co-phone-field__option {
+  display: flex;
+  align-items: center;
+  gap: var(--co-spacing-sm);
+  width: 100%;
+  padding: var(--co-spacing-sm) var(--co-spacing-md);
+  border: none;
+  background: none;
+  cursor: pointer;
+  font-size: var(--co-font-size-14);
+  font-family: var(--co-font-family-primary);
+  color: var(--co-semantic-text-default);
+  text-align: left;
+}
+
+.co-phone-field__option:hover {
+  background: var(--co-semantic-surface-hover);
+}
+
+.co-phone-field__option--selected {
+  background: color-mix(in srgb, var(--co-semantic-border-focus) 8%, transparent);
+  font-weight: 500;
+}
+
+.co-phone-field__option-flag {
+  width: 20px;
+  height: 15px;
+  border-radius: 2px;
+  object-fit: cover;
+  flex-shrink: 0;
+}
+
+.co-phone-field__match {
+  font-weight: 700;
+}
+
+.co-phone-field__option-name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.co-phone-field__option-code {
+  color: var(--co-semantic-text-muted);
+  font-size: var(--co-font-size-12);
+  white-space: nowrap;
+}
+
+.co-phone-field__helper {
+  display: flex;
+  align-items: center;
+  gap: var(--co-spacing-xs);
+  padding: 0 var(--co-spacing-xs);
+  font-size: var(--co-font-size-14);
+  color: var(--co-semantic-text-muted);
+}
+
+.co-phone-field__helper-icon {
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+}
+
+.co-phone-field--error .co-phone-field__helper {
+  color: var(--co-semantic-status-error);
+}
+
+/* ── Horizontal layout: label left; control + helper stacked right ──
+   Set --co-field-label-width on a container to align labels across fields. */
+:host([layout='horizontal']) .co-phone-field {
+  display: grid;
+  grid-template-columns: var(--co-field-label-width, max-content) 1fr;
+  align-items: start;
+  column-gap: var(--co-spacing-md);
+  row-gap: var(--co-spacing-sm2);
+}
+
+:host([layout='horizontal']) .co-phone-field__label {
+  grid-column: 1;
+  grid-row: 1;
+  padding-top: var(--co-spacing-sm2);
+  min-width: 0;
+}
+
+:host([layout='horizontal']) .co-phone-field__label {
+  white-space: normal;
+}
+
+:host([layout='horizontal']) .co-phone-field > :not(.co-phone-field__label) {
+  grid-column: 2;
+  min-width: 0;
+}
+
+@supports not (background: color-mix(in srgb, red, transparent)) {
+  .co-phone-field__container { background: var(--co-semantic-surface-secondary); }
+}