@pine-ds/core 5.0.0-mercury.0 → 5.0.0

package/dist/cjs/truncation-tooltip-CM5HgRHh.js

@@ -0,0 +1,430 @@
+'use strict';
+
+var floatingUi_dom = require('./floating-ui.dom-Dw41zbyY.js');
+var portalTarget = require('./portal-target-e8WQ6dLx.js');
+
+// Controls that clipped text can sit inside that already take focus, so the text adds no tab stop of its own.
+// Not any `[tabindex]`: a focusable scroll region full of chips would show every chip's tooltip at once.
+const FOCUSABLE_WRAPPER = 'a[href], button, summary, pds-button, pds-link, pds-tab, pds-dropdown-menu-item, [role="option"], [role="treeitem"]';
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+/**
+ * The text `el` actually shows, with every `<slot>` it holds replaced by the
+ * nodes assigned to it.
+ *
+ * `textContent` counts a slot as empty, so a component that renders a clipped
+ * text around a slot of its own — `pds-alert` renders `<pds-text truncate><slot/></pds-text>` —
+ * would leave the tooltip with nothing to show and so no tooltip at all, even
+ * though the text is clipped and holds a tab stop.
+ *
+ * Text nodes only, as `textContent` counts too: Stencil leaves comment nodes
+ * among slotted content to mark where it was relocated from, and their data is
+ * not text anyone reads.
+ */
+function flattenedText(el) {
+    let text = '';
+    const add = (node) => {
+        var _a;
+        const slot = node;
+        // `flatten` returns the slot's own children when nothing is assigned, which is what renders then.
+        if (node.nodeName === 'SLOT' && typeof slot.assignedNodes === 'function') {
+            slot.assignedNodes({ flatten: true }).forEach(add);
+        }
+        else if (node.nodeType === ELEMENT_NODE) {
+            text += flattenedText(node);
+        }
+        else if (node.nodeType === TEXT_NODE) {
+            text += (_a = node.textContent) !== null && _a !== void 0 ? _a : '';
+        }
+    };
+    el.childNodes.forEach(add);
+    return text;
+}
+/** CSS class prefix used for truncation tooltip portal elements */
+const TOOLTIP_CLASS = 'pds-truncation-tooltip';
+/**
+ * Injects the truncation tooltip styles into the document head.
+ * Uses the same design tokens as pds-tooltip for visual consistency.
+ * Only injects once — checks the DOM to avoid duplicates.
+ *
+ * Z-Index Strategy:
+ * Uses --pine-z-index-nuclear (9999) to ensure tooltips appear above all other UI elements.
+ * This is necessary because tooltips are portaled to document.body, or into the modal dialog or
+ * open popover around the host (the top layer, which no z-index reaches from the body), and must overlay:
+ * - Modal dialogs
+ * - Dropdown menus
+ * - Other floating UI elements
+ * If you encounter z-index conflicts, ensure your overlays use Pine's z-index tokens
+ * or adjust --pine-z-index-nuclear in your theme.
+ */
+function injectStyles() {
+    if (document.querySelector('[data-pds-truncation-tooltip]'))
+        return;
+    const style = document.createElement('style');
+    style.setAttribute('data-pds-truncation-tooltip', '');
+    style.textContent = `
+    .${TOOLTIP_CLASS} {
+      position: fixed;
+      z-index: var(--pine-z-index-nuclear, 9999);
+    }
+    .${TOOLTIP_CLASS}__content {
+      background-color: var(--pine-color-primary, #1a1a2e);
+      border-radius: calc(var(--pine-dimension-xs, 4px) * 1.25);
+      box-shadow: var(--pine-box-shadow, 0 2px 8px rgba(0,0,0,0.15));
+      color: var(--pine-color-text-primary, #fff);
+      cursor: text;
+      font-family: var(--pine-font-family-body, sans-serif);
+      font-size: var(--pine-font-size-body-sm, 0.875rem);
+      letter-spacing: var(--pine-letter-spacing, normal);
+      line-height: var(--pine-line-height-body, 1.5);
+      max-width: 320px;
+      opacity: 0;
+      padding: var(--pine-dimension-xs, 4px) calc(var(--pine-dimension-md, 12px) / 2);
+      transition: opacity 0.15s ease-in-out, visibility 0.15s ease-in-out;
+      user-select: text;
+      visibility: hidden;
+      width: max-content;
+      word-break: break-word;
+    }
+    .${TOOLTIP_CLASS}--visible .${TOOLTIP_CLASS}__content {
+      opacity: 1;
+      visibility: visible;
+    }
+    :is(dialog, [popover]) > .${TOOLTIP_CLASS} {
+      font-style: normal;
+      font-weight: normal;
+      text-align: start;
+      text-indent: 0;
+      text-transform: none;
+      white-space: normal;
+      word-spacing: normal;
+    }
+  `;
+    document.head.appendChild(style);
+}
+/**
+ * Checks if an element's content is overflowing horizontally (i.e. text is truncated).
+ */
+function isOverflowing(el) {
+    return el.scrollWidth > el.clientWidth;
+}
+/**
+ * Engines without `:focus-visible` throw on the selector, so there every
+ * focus counts as visible rather than none.
+ */
+function isFocusVisible(el) {
+    try {
+        return el.matches(':focus-visible');
+    }
+    catch (_a) {
+        return true;
+    }
+}
+/**
+ * Sets up automatic tooltip behavior for a truncated element.
+ *
+ * When the element's text overflows, hovering the host element or giving it
+ * keyboard focus will display a tooltip showing the full text content. The
+ * tooltip is rendered as a portal on document.body, or in the modal dialog or open popover around
+ * the host, and positioned with Floating UI.
+ *
+ * Also owns the element's `tabindex` while it is clipped — see syncTabIndex.
+ *
+ * @returns A cleanup function that removes all listeners, observers, and DOM elements.
+ */
+function setupTruncationTooltip(options) {
+    const { hostEl, contentEl, getTooltipText, placement = 'top', reference = hostEl, manageTabIndex = true, focusEl = hostEl } = options;
+    injectStyles();
+    let portalEl = null;
+    let stopWatchingPortalHost = null;
+    let isHovering = false;
+    let isHoveringPortal = false;
+    let isFocused = false;
+    let hideTimeout = null;
+    let resizeObserver = null;
+    let resizeDebounce = null;
+    let ownsTabIndex = false;
+    let disposed = false;
+    /**
+     * The tab stop exists only to give the tooltip a focusable anchor, so it
+     * belongs on the element while the text is actually clipped and not a moment
+     * longer. Deriving it from the caller's prop instead leaves a dead stop on
+     * every element that opted into truncation but happens to fit — in a row of
+     * chips that doubles the tab stops, half of them landing on a span with no
+     * role, no name of its own, and nothing to reveal.
+     *
+     * Ownership is tracked rather than inferred from the value: if the consumer
+     * already put a tabindex on the element (a roving -1, say), that is theirs
+     * and we never touch it.
+     */
+    function syncTabIndex() {
+        if (!manageTabIndex)
+            return;
+        if (isOverflowing(contentEl)) {
+            if (!ownsTabIndex && contentEl.hasAttribute('tabindex'))
+                return;
+            ownsTabIndex = true;
+            contentEl.setAttribute('tabindex', '0');
+        }
+        else if (ownsTabIndex) {
+            ownsTabIndex = false;
+            contentEl.removeAttribute('tabindex');
+        }
+    }
+    // Use ResizeObserver to re-evaluate overflow when the element resizes
+    // Debounced to prevent performance issues during rapid window resizing
+    if (typeof ResizeObserver !== 'undefined') {
+        resizeObserver = new ResizeObserver(() => {
+            if (resizeDebounce) {
+                clearTimeout(resizeDebounce);
+            }
+            resizeDebounce = setTimeout(() => {
+                resizeDebounce = null;
+                syncTabIndex();
+                // If tooltip is showing but text no longer overflows, hide it
+                if (portalEl && portalEl.isConnected && !isOverflowing(contentEl)) {
+                    hideTooltip();
+                }
+            }, 100);
+        });
+        resizeObserver.observe(contentEl);
+    }
+    // Measure now so the common case is right on the first paint, rather than
+    // waiting out the observer's debounce.
+    syncTabIndex();
+    // A web font swapping in changes scrollWidth without changing the clipped
+    // box's size, so ResizeObserver never fires for it — the element would keep
+    // whatever the fallback font measured. Re-measure once the fonts settle.
+    if (typeof document !== 'undefined' && document.fonts !== undefined) {
+        document.fonts.ready.then(() => {
+            if (!disposed)
+                syncTabIndex();
+        });
+    }
+    function createPortal() {
+        if (portalEl)
+            return;
+        const text = getTooltipText();
+        if (!text || text.trim() === '')
+            return;
+        portalEl = document.createElement('div');
+        portalEl.className = TOOLTIP_CLASS;
+        portalEl.setAttribute('role', 'tooltip');
+        portalEl.setAttribute('aria-hidden', 'false');
+        const contentDiv = document.createElement('div');
+        contentDiv.className = `${TOOLTIP_CLASS}__content`;
+        contentDiv.textContent = text.trim();
+        portalEl.appendChild(contentDiv);
+        const portalHost = portalTarget.findPortalTarget(hostEl, portalTarget.isTopLayerInDocument);
+        portalHost.appendChild(portalEl);
+        // Closing that host moves no pointer, so a tooltip opened by touch would outlive it unseen.
+        if (portalHost !== document.body)
+            stopWatchingPortalHost = portalTarget.onTopLayerClose(portalHost, closeWithPortalHost);
+        // Allow the user to hover into the tooltip to select/copy text
+        portalEl.addEventListener('mouseenter', handlePortalMouseEnter);
+        portalEl.addEventListener('mouseleave', handlePortalMouseLeave);
+        positionTooltip().then(() => {
+            if (portalEl) {
+                portalEl.classList.add(`${TOOLTIP_CLASS}--visible`);
+            }
+        });
+    }
+    async function positionTooltip() {
+        if (!portalEl)
+            return;
+        try {
+            const { x, y } = await floatingUi_dom.computePosition(reference, portalEl, {
+                placement,
+                strategy: 'fixed',
+                middleware: [floatingUi_dom.offset(4), floatingUi_dom.flip(), floatingUi_dom.shift({ padding: 5 })],
+            });
+            Object.assign(portalEl.style, {
+                left: `${x}px`,
+                top: `${y}px`,
+            });
+        }
+        catch (_a) {
+            // Fallback: position above the element with bounds checking
+            if (portalEl) {
+                const rect = reference.getBoundingClientRect();
+                const portalRect = portalEl.getBoundingClientRect();
+                const padding = 5;
+                // Ensure tooltip stays within viewport bounds
+                const left = Math.max(padding, Math.min(rect.left, window.innerWidth - portalRect.width - padding));
+                const top = Math.max(padding, rect.top - portalRect.height - 8);
+                portalEl.style.left = `${left}px`;
+                portalEl.style.top = `${top}px`;
+            }
+        }
+    }
+    function removePortal() {
+        if (stopWatchingPortalHost !== null) {
+            stopWatchingPortalHost();
+            stopWatchingPortalHost = null;
+        }
+        if (portalEl) {
+            portalEl.removeEventListener('mouseenter', handlePortalMouseEnter);
+            portalEl.removeEventListener('mouseleave', handlePortalMouseLeave);
+            portalEl.classList.remove(`${TOOLTIP_CLASS}--visible`);
+            // Check if portal is still in the DOM before removing
+            if (portalEl.parentNode && portalEl.isConnected) {
+                try {
+                    portalEl.parentNode.removeChild(portalEl);
+                }
+                catch (e) {
+                    // Portal was already removed, ignore error
+                }
+            }
+            portalEl = null;
+        }
+    }
+    function cancelHideTimeout() {
+        if (hideTimeout !== null) {
+            clearTimeout(hideTimeout);
+            hideTimeout = null;
+        }
+    }
+    function showTooltip() {
+        cancelHideTimeout();
+        if (!isOverflowing(contentEl))
+            return;
+        createPortal();
+    }
+    function hideTooltip() {
+        if (isHovering || isHoveringPortal || isFocused)
+            return;
+        removePortal();
+    }
+    // Hover and focus can't outlast a host that's no longer shown, so none of them keeps it open.
+    function closeWithPortalHost() {
+        isHovering = false;
+        isHoveringPortal = false;
+        isFocused = false;
+        cancelHideTimeout();
+        removePortal();
+    }
+    /**
+     * Schedules tooltip removal after a short delay.
+     *
+     * The 100ms delay serves two purposes:
+     * 1. Gives users time to move their cursor from the truncated text to the tooltip portal
+     *    without it closing, enabling text selection/copying from the tooltip
+     * 2. Prevents flickering when the user briefly moves the cursor during normal interaction
+     */
+    function scheduleHide() {
+        cancelHideTimeout();
+        hideTimeout = setTimeout(() => {
+            hideTimeout = null;
+            hideTooltip();
+        }, 100);
+    }
+    function handleMouseEnter() {
+        isHovering = true;
+        showTooltip();
+    }
+    function handleMouseLeave() {
+        isHovering = false;
+        scheduleHide();
+    }
+    function handlePortalMouseEnter() {
+        isHoveringPortal = true;
+        cancelHideTimeout();
+    }
+    function handlePortalMouseLeave() {
+        isHoveringPortal = false;
+        scheduleHide();
+    }
+    // A second tab stop inside focusEl, such as another clipped text, bubbles its focus here too. Its event.target is
+    // retargeted to the stop's outermost element in focusEl's tree, which sits beside hostEl rather than around or in it.
+    function isFocusForHost(target) {
+        return focusEl === hostEl || target === focusEl || target.contains(hostEl) || hostEl.contains(target);
+    }
+    // Keyboard focus only: focus from a click would pin the tooltip open after the pointer leaves.
+    // Events from inside a shadow root arrive retargeted to its host, so test the innermost target.
+    function showForVisibleFocus(event) {
+        if (!isFocusVisible(event.composedPath()[0]))
+            return;
+        if (!isFocusForHost(event.target))
+            return;
+        isFocused = true;
+        showTooltip();
+    }
+    // A key press after a click makes focus visible in place, with no new focusin. keyup, not
+    // keydown, so Tab's focus move lands first; Escape asks to dismiss, never to reveal.
+    function handleKeyUp(event) {
+        if (isFocused || event.key === 'Escape')
+            return;
+        showForVisibleFocus(event);
+    }
+    function handleFocusOut() {
+        isFocused = false;
+        scheduleHide();
+    }
+    hostEl.addEventListener('mouseenter', handleMouseEnter);
+    hostEl.addEventListener('mouseleave', handleMouseLeave);
+    focusEl.addEventListener('focusin', showForVisibleFocus);
+    focusEl.addEventListener('focusout', handleFocusOut);
+    focusEl.addEventListener('keyup', handleKeyUp);
+    // Return cleanup function
+    return () => {
+        disposed = true;
+        cancelHideTimeout();
+        if (resizeDebounce) {
+            clearTimeout(resizeDebounce);
+            resizeDebounce = null;
+        }
+        if (resizeObserver) {
+            resizeObserver.disconnect();
+        }
+        // Hand the element back as we found it — truncation may simply have been
+        // turned off, in which case the element outlives this teardown.
+        if (ownsTabIndex) {
+            ownsTabIndex = false;
+            contentEl.removeAttribute('tabindex');
+        }
+        hostEl.removeEventListener('mouseenter', handleMouseEnter);
+        hostEl.removeEventListener('mouseleave', handleMouseLeave);
+        focusEl.removeEventListener('focusin', showForVisibleFocus);
+        focusEl.removeEventListener('focusout', handleFocusOut);
+        focusEl.removeEventListener('keyup', handleKeyUp);
+        removePortal();
+    };
+}
+/**
+ * Keeps tooltips bound to the elements a component's render clips, for a component
+ * that re-renders while those elements stay in place.
+ *
+ * Each tooltip holds listeners and an observer on its element, so it is rebound
+ * only when a different set of elements renders: rebinding on every render would
+ * tear down a tooltip the pointer is still inside, and a component can render
+ * again on every keystroke or when it opens its popover.
+ *
+ * Call `sync` from `componentDidRender`, and from `connectedCallback` too, since
+ * moving an element reconnects it without rendering it again. Call `destroy` from
+ * `disconnectedCallback`.
+ *
+ * @param getOptions - The options for one element, read when it is bound.
+ */
+function bindTruncationTooltips(getOptions) {
+    let bound = [];
+    let cleanups = [];
+    const destroy = () => {
+        cleanups.forEach((cleanup) => cleanup());
+        cleanups = [];
+        bound = [];
+    };
+    const sync = (els) => {
+        const next = Array.from(els).filter((el) => el != null);
+        if (next.length === bound.length && next.every((el, index) => el === bound[index]))
+            return;
+        destroy();
+        bound = next;
+        cleanups = next.map((el) => setupTruncationTooltip(getOptions(el)));
+    };
+    return { sync, destroy };
+}
+
+exports.FOCUSABLE_WRAPPER = FOCUSABLE_WRAPPER;
+exports.bindTruncationTooltips = bindTruncationTooltips;
+exports.flattenedText = flattenedText;
+exports.setupTruncationTooltip = setupTruncationTooltip;

package/dist/cjs/utils-BhRmyxT8.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const hasShadowDom = (el) => {
+    return !!el.shadowRoot && !!el.attachShadow;
+};
+const debounceEvent = (event, wait) => {
+    const original = event._original || event;
+    const emit = debounce(original.emit.bind(original), wait);
+    return {
+        _original: original,
+        emit,
+        cancel: emit.cancel,
+        flush: emit.flush,
+    };
+};
+/** Drops an emit still waiting on a `debounceEvent` delay. A no-op on an undebounced emitter. */
+const cancelDebouncedEvent = (event) => {
+    var _a;
+    (_a = event === null || event === void 0 ? void 0 : event.cancel) === null || _a === void 0 ? void 0 : _a.call(event);
+};
+/** Sends an emit still waiting on a `debounceEvent` delay right away. A no-op on an undebounced emitter. */
+const flushDebouncedEvent = (event) => {
+    var _a;
+    (_a = event === null || event === void 0 ? void 0 : event.flush) === null || _a === void 0 ? void 0 : _a.call(event);
+};
+const debounce = (func, wait = 0) => {
+    let timer;
+    let pending;
+    const debounced = (...args) => {
+        clearTimeout(timer);
+        pending = args;
+        timer = setTimeout(() => {
+            pending = undefined;
+            func(...args);
+        }, wait);
+    };
+    debounced.cancel = () => {
+        clearTimeout(timer);
+        pending = undefined;
+    };
+    debounced.flush = () => {
+        const args = pending;
+        debounced.cancel();
+        if (args)
+            func(...args);
+    };
+    return debounced;
+};
+/**
+ * Normalizes color values to ensure consistent CSS variable usage.
+ *
+ * This is the single low-level primitive for color-prop normalization in
+ * Pine. A component with its own semantic-keyword set (e.g. pds-chip's
+ * sentiment-to-dot-color map) should call this directly with its own
+ * `semanticMap` rather than inventing a new normalization helper. Reach for
+ * `setColor` below only when its specific text-role semantic set and
+ * `--color` output key already match what the component needs.
+ *
+ * @param value - Raw token (--token), CSS variable (var(--token)), semantic name, or literal color
+ * @param options.semanticMap - Optional mapping of semantic names to CSS variables
+ * @returns Normalized color value or undefined for invalid inputs
+ */
+const normalizeColorValue = (value, options) => {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    // Treat whitespace-only as undefined to avoid invalid CSS values
+    if (trimmed === '')
+        return undefined;
+    // If a semantic map is provided and the value matches a key, return mapped CSS var
+    if ((options === null || options === void 0 ? void 0 : options.semanticMap) && options.semanticMap[trimmed]) {
+        return options.semanticMap[trimmed];
+    }
+    // If already a CSS var, pass through
+    if (trimmed.startsWith('var('))
+        return trimmed;
+    // If raw token is provided (e.g., --pine-color-foo), wrap in var(...)
+    if (trimmed.startsWith('--'))
+        return `var(${trimmed})`;
+    // Otherwise treat as literal CSS color value
+    return trimmed;
+};
+/**
+ * Convenience wrapper around `normalizeColorValue` for the common text-role
+ * semantic set (primary/secondary/accent/etc.), returned as a `--color`
+ * custom property. If a component needs a different semantic map or a
+ * different custom-property name (e.g. pds-chip's dot/icon-specific tokens),
+ * call `normalizeColorValue` directly instead of extending this function.
+ */
+const setColor = (color, customColors) => {
+    // Return an empty object for empty/whitespace/undefined inputs to avoid invalid CSS styles
+    if (!color)
+        return {};
+    const defaultColors = {
+        primary: 'var(--pine-color-text-primary)',
+        secondary: 'var(--pine-color-text-secondary)',
+        neutral: 'var(--pine-color-text-neutral)',
+        accent: 'var(--pine-color-text-accent)',
+        danger: 'var(--pine-color-text-danger)',
+        info: 'var(--pine-color-text-info)',
+        success: 'var(--pine-color-text-success)',
+        warning: 'var(--pine-color-text-warning)',
+    };
+    // Merge defaults with any custom overrides so defaults are preserved
+    const semanticMap = Object.assign(Object.assign({}, defaultColors), (customColors || {}));
+    // Use the shared normalizer so components accept semantic names, raw tokens, var(...), or literals
+    const resolved = normalizeColorValue(color, { semanticMap });
+    // Ensure we never return an undefined style value; if unresolved, omit the property
+    if (!resolved)
+        return {};
+    return {
+        '--color': resolved
+    };
+};
+
+exports.cancelDebouncedEvent = cancelDebouncedEvent;
+exports.debounceEvent = debounceEvent;
+exports.flushDebouncedEvent = flushDebouncedEvent;
+exports.hasShadowDom = hasShadowDom;
+exports.normalizeColorValue = normalizeColorValue;
+exports.setColor = setColor;

package/dist/collection/collection-manifest.json

@@ -1,20 +1,43 @@
 {
   "entries": [
     "components/pds-accordion/pds-accordion.js",
+    "components/pds-alert/pds-alert.js",
     "components/pds-avatar/pds-avatar.js",
     "components/pds-box/pds-box.js",
     "components/pds-button/pds-button.js",
     "components/pds-checkbox/pds-checkbox.js",
     "components/pds-chip/pds-chip.js",
+    "components/pds-combobox/pds-combobox.js",
+    "components/pds-container/pds-container.js",
     "components/pds-copytext/pds-copytext.js",
+    "components/pds-datepicker/pds-datepicker.js",
     "components/pds-divider/pds-divider.js",
+    "components/pds-drawer/pds-drawer.js",
+    "components/pds-drawer/pds-drawer-content/pds-drawer-content.js",
+    "components/pds-drawer/pds-drawer-footer/pds-drawer-footer.js",
+    "components/pds-drawer/pds-drawer-header/pds-drawer-header.js",
+    "components/pds-dropdown-menu/pds-dropdown-menu.js",
+    "components/pds-dropdown-menu/pds-dropdown-menu-item/pds-dropdown-menu-item.js",
+    "components/pds-dropdown-menu/pds-dropdown-menu-separator/pds-dropdown-menu-separator.js",
+    "components/pds-filters/pds-filters.js",
+    "components/pds-filters/pds-filter/pds-filter.js",
     "components/pds-image/pds-image.js",
     "components/pds-input/pds-input.js",
     "components/pds-link/pds-link.js",
     "components/pds-loader/pds-loader.js",
+    "components/pds-modal/pds-modal.js",
+    "components/pds-modal/pds-modal-content/pds-modal-content.js",
+    "components/pds-modal/pds-modal-footer/pds-modal-footer.js",
+    "components/pds-modal/pds-modal-header/pds-modal-header.js",
+    "components/pds-modal/test/mock-pds-modal.js",
+    "components/pds-multiselect/pds-multiselect.js",
+    "components/pds-popover/pds-popover.js",
     "components/pds-progress/pds-progress.js",
+    "components/pds-property/pds-property.js",
     "components/pds-radio/pds-radio.js",
+    "components/pds-radio-group/pds-radio-group.js",
     "components/pds-row/pds-row.js",
+    "components/pds-select/pds-select.js",
     "components/pds-sortable/pds-sortable.js",
     "components/pds-sortable/pds-sortable-item/pds-sortable-item.js",
     "components/pds-switch/pds-switch.js",
@@ -27,13 +50,16 @@
     "components/pds-tabs/pds-tabs.js",
     "components/pds-tabs/pds-tab/pds-tab.js",
     "components/pds-tabs/pds-tabpanel/pds-tabpanel.js",
+    "components/pds-text/pds-text.js",
     "components/pds-textarea/pds-textarea.js",
+    "components/pds-toast/pds-toast.js",
     "components/pds-tooltip/pds-tooltip.js"
   ],
+  "mixins": [],
   "compiler": {
     "name": "@stencil/core",
-    "version": "4.20.0",
-    "typescriptVersion": "5.5.3"
+    "version": "4.43.5",
+    "typescriptVersion": "5.8.3"
   },
   "collections": [
     {
@@ -43,5 +69,6 @@
       ]
     }
   ],
-  "bundles": []
+  "bundles": [],
+  "global": "global/pine-global.js"
 }

package/dist/collection/components/_internal/pds-label/pds-label.js

@@ -4,4 +4,3 @@ import { h } from "@stencil/core";
  * @internal
  */
 export const PdsLabel = ({ classNames, htmlFor, text }) => (h("label", { class: classNames, htmlFor: htmlFor }, text));
-//# sourceMappingURL=pds-label.js.map