@pine-ds/core 4.1.0 → 4.2.0

package/dist/collection/components/pds-toast/pds-toast.js

@@ -121,13 +121,13 @@ export class PdsToast {
         return this.icon && h("pds-icon", { name: this.icon, class: "pds-toast__icon" });
     }
     render() {
-        return (h(Host, { key: 'aa1d20ad8b511950338a16cd9277f33a6438bfe5', hidden: !this.isVisible }, h("div", { key: 'b19ddfcdec17bd3339cf6b283cca475ad8dda75b', class: {
+        return (h(Host, { key: 'a1ec97158a6665aa25b58b1954b4b5c622590615', hidden: !this.isVisible }, h("div", { key: 'd9b01164364c76512852a260cede50000b73a563', class: {
                 'pds-toast': true,
                 [`pds-toast--${this.type}`]: this.type !== 'default',
                 'pds-toast--animating-out': this.isAnimatingOut
-            }, role: "alert", "aria-live": "polite" }, this.renderIcon(), h("span", { key: '8f4553ac467032c6e398e1665b41d78eedc56e30', class: "pds-toast__message" }, h("slot", { key: '0a04edffd081298f6cd7f6feb3f50e89276d4e09' })), this.dismissible && (h("button", { key: 'b42a2ab16a011b42e278e77fa4c0698eea3950e0', type: "button", part: "dismiss", class: "pds-toast__button", onClick: () => {
+            }, role: "alert", "aria-live": "polite" }, this.renderIcon(), h("span", { key: '1f581c7c29ea3fc795dfca061d3575c5a9895b3c', class: "pds-toast__message" }, h("slot", { key: '645b31eae3be23de63ab2562234caf0be2510645' })), this.dismissible && (h("button", { key: '44a62b304468c0fca0b8d490ad9c8b5932176ac9', type: "button", part: "dismiss", class: "pds-toast__button", onClick: () => {
                 this.dismiss();
-            }, "aria-label": this.dismissLabel }, h("pds-icon", { key: 'e5ea3485a7d943ba3be144506eecb9a25b55b07d', name: "remove" }))))));
+            }, "aria-label": this.dismissLabel }, h("pds-icon", { key: 'fde63f279f696d9f02875cc1beee3542c97f0c7e', name: "remove" }))))));
     }
     static get is() { return "pds-toast"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/pds-tooltip/pds-tooltip.js

@@ -342,9 +342,9 @@ export class PdsTooltip {
     }
     render() {
         const hostId = this.componentId || undefined;
-        return (h(Host, { key: 'd9fa5c688ba3baeac14334ec9c03e887ef16115e', id: hostId, class: { 'pds-tooltip--is-open': this.opened } }, h("span", { key: '44ee5332139567d3f25070f73c1e73630f00eec4', class: "pds-tooltip__trigger", onMouseEnter: this.handleShow, onMouseLeave: this.handleHide,
+        return (h(Host, { key: 'a4f25d10de27757ab2551af0e5b8a53336bf8cb4', id: hostId, class: { 'pds-tooltip--is-open': this.opened } }, h("span", { key: '5e9f9afbecbb335ad68b02edf999d2ec62f31a8e', class: "pds-tooltip__trigger", onMouseEnter: this.handleShow, onMouseLeave: this.handleHide,
             /* focusin/out bubble; ensure keyboard users see tooltips */
-            onFocusin: this.handleShow, onFocusout: this.handleHide, ref: el => this.triggerEl = el }, h("slot", { key: '4eb9c2f891c8cdb9d7f9d944d99bf423908cbc0f' })), h("div", { key: '985b373be21f07c14cd5c8c3095d5e8d290d3e7f', class: "pds-tooltip__content-slot-wrapper", hidden: true }, h("slot", { key: 'cd8d6c2dca87b7d72fd01f51e5b1d538c2d93531', name: "content" }))));
+            onFocusin: this.handleShow, onFocusout: this.handleHide, ref: el => this.triggerEl = el }, h("slot", { key: 'e142f4f09406b7bd3d1ce9005f624b91cf7ec176' })), h("div", { key: 'ebe0faae0af623477486dbba56c24bc3e0a6bc66', class: "pds-tooltip__content-slot-wrapper", hidden: true }, h("slot", { key: '833d31509ba48f10cd0b5eb2f5e8dc509854c25e', name: "content" }))));
     }
     static get is() { return "pds-tooltip"; }
     static get originalStyleUrls() {

package/dist/collection/index.js

@@ -1,2 +1,3 @@
 export * from './components';
+export { TEXT_SIZES } from './utils/types';
 import "@pine-ds/icons";

package/dist/collection/utils/test/reduced-motion.js

@@ -0,0 +1,78 @@
+/**
+ * Reads a target's computed `transition-duration` from within `hostTag`,
+ * optionally on a pseudo-element (e.g. `::after`). Works whether `hostTag`
+ * renders to a real shadow root (`shadow: true`) or scoped/light DOM
+ * (`shadow: false` / `scoped: true`) — Pine components use both.
+ *
+ * `innerSelector` may be omitted (or `null`) to read the host element itself.
+ *
+ * Embeds the arguments in a string-evaluated IIFE, the same workaround
+ * `runAxe` uses, rather than passing a real function to `page.$eval`: under
+ * Jest's coverage instrumentation, a function reference gets serialized with
+ * injected `cov_*` counter calls that don't exist in the browser's isolated
+ * execution context, throwing a `ReferenceError` there.
+ */
+async function readTransitionDuration(page, hostTag, innerSelector, pseudoElement) {
+    // Normalise to the `::` form. Chrome, which is what these e2e tests drive,
+    // accepts a bare `after` and returns the pseudo-element's style -- verified,
+    // so no assertion is wrong today. The CSSOM spec treats a colonless value as
+    // invalid and returns the originating element's style instead, which would
+    // turn a knob assertion into a silent re-test of its host. Cheap to not
+    // depend on the lenient reading.
+    const normalisedPseudo = pseudoElement
+        ? `::${pseudoElement.replace(/^:{1,2}/, '')}`
+        : null;
+    const argsJson = JSON.stringify({ hostTag, innerSelector, pseudoElement: normalisedPseudo });
+    return page.evaluate(`
+    (() => {
+      const args = ${argsJson};
+      const el = document.querySelector(args.hostTag);
+      const root = el.shadowRoot || el;
+      const target = args.innerSelector ? root.querySelector(args.innerSelector) : el;
+      return getComputedStyle(target, args.pseudoElement || null).transitionDuration;
+    })()
+  `);
+}
+/**
+ * Asserts that an element's `transition-duration` collapses to `0s` once the
+ * page emulates `prefers-reduced-motion: reduce`.
+ *
+ * This is the runtime counterpart to the `pine-design-system/no-hardcoded-motion`
+ * Stylelint rule: the rule can only see a component's *source* — that it
+ * references `var(--pine-motion-duration-*)` somewhere. It can't see whether
+ * that reference actually reaches the declaration that runs at render time
+ * (a `var()` could be shadowed, overridden, or simply never wired up right).
+ * This closes that gap by reading the real computed style before and after
+ * emulating the preference, so a target that *doesn't* zero out fails loudly
+ * here even if it fooled the lint rule.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const page = await newE2EPage();
+ * await page.setContent('<pds-switch></pds-switch>');
+ * await expectRespectsReducedMotion(page, 'pds-switch', 'input', 'after');
+ * ```
+ *
+ * @param page Stencil E2E page.
+ * @param hostTag Custom element tag hosting the shadow root to read from.
+ * @param innerSelector Selector for the element within `hostTag`'s shadow
+ *   root, or `null`/omitted to read `hostTag` itself.
+ * @param pseudoElement Pseudo-element to read from the target (e.g. `'after'`
+ *   for `::after`), or `null`/omitted to read the element's own style.
+ */
+export async function expectRespectsReducedMotion(page, hostTag, innerSelector = null, pseudoElement = null) {
+    const before = await readTransitionDuration(page, hostTag, innerSelector, pseudoElement);
+    await page.emulateMediaFeatures([{ name: 'prefers-reduced-motion', value: 'reduce' }]);
+    await page.waitForChanges();
+    const after = await readTransitionDuration(page, hostTag, innerSelector, pseudoElement);
+    // `transitionDuration` can list one value per transitioned property
+    // (e.g. "0.2s, 0.2s"); every one of them must have zeroed out.
+    const allZero = after.split(',').every((part) => parseFloat(part.trim()) === 0);
+    if (!allZero) {
+        const target = `${hostTag}${innerSelector ? ` >>> ${innerSelector}` : ''}${pseudoElement ? `::${pseudoElement}` : ''}`;
+        throw new Error(`Expected "${target}" to have a zero transition-duration under prefers-reduced-motion, ` +
+            `but got "${after}" (was "${before}" before emulating the preference). Its transition ` +
+            `is not actually routed through a --pine-motion-duration-* token at render time.`);
+    }
+}

package/dist/collection/utils/truncation-tooltip.js

@@ -64,10 +64,12 @@ function isOverflowing(el) {
  * will display a tooltip showing the full text content. The tooltip is
  * rendered as a portal on document.body 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.
  */
 export function setupTruncationTooltip(options) {
-    const { hostEl, contentEl, getTooltipText, placement = 'top' } = options;
+    const { hostEl, contentEl, getTooltipText, placement = 'top', manageTabIndex = true } = options;
     injectStyles();
     let portalEl = null;
     let isHovering = false;
@@ -76,6 +78,34 @@ export function setupTruncationTooltip(options) {
     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') {
@@ -85,6 +115,7 @@ export function setupTruncationTooltip(options) {
             }
             resizeDebounce = setTimeout(() => {
                 resizeDebounce = null;
+                syncTabIndex();
                 // If tooltip is showing but text no longer overflows, hide it
                 if (portalEl && portalEl.isConnected && !isOverflowing(contentEl)) {
                     hideTooltip();
@@ -93,6 +124,18 @@ export function setupTruncationTooltip(options) {
         });
         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;
@@ -224,6 +267,7 @@ export function setupTruncationTooltip(options) {
     hostEl.addEventListener('focusout', handleFocusOut);
     // Return cleanup function
     return () => {
+        disposed = true;
         cancelHideTimeout();
         if (resizeDebounce) {
             clearTimeout(resizeDebounce);
@@ -232,6 +276,12 @@ export function setupTruncationTooltip(options) {
         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);
         hostEl.removeEventListener('focusin', handleFocusIn);

package/dist/docs.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-09-24T21:36:30",
+  "timestamp": "2026-10-06T17:46:04",
   "compiler": {
     "name": "@stencil/core",
     "version": "4.43.5",
@@ -14949,6 +14949,351 @@
       "dependencies": [],
       "dependencyGraph": {}
     },
+    {
+      "filePath": "src/components/pds-drawer/pds-drawer.tsx",
+      "encapsulation": "none",
+      "tag": "pds-drawer",
+      "readme": "# pds-drawer\n\n\n",
+      "docs": "A non-modal side panel composed from `pds-modal`.\n\nUnlike `pds-modal`, the page stays interactive while a drawer is open: no\ndimming, no blur, no scroll lock, no click blocking. `pds-drawer` renders a\n`pds-modal` internally with `disableTopLayer` always on and its backdrop\nsuppressed, and adds the edge, width and dismiss behavior a side panel\nneeds on top. It does not reimplement focus, Escape or dialog semantics —\nthose come from `pds-modal` unchanged.",
+      "docsTags": [],
+      "usage": {},
+      "props": [
+        {
+          "name": "componentId",
+          "type": "string",
+          "complexType": {
+            "original": "string",
+            "resolved": "string",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "component-id",
+          "reflectToAttr": false,
+          "docs": "A unique identifier used for the underlying component `id` attribute.",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "initialFocus",
+          "type": "\"auto\" | \"none\"",
+          "complexType": {
+            "original": "'auto' | 'none'",
+            "resolved": "\"auto\" | \"none\"",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "initial-focus",
+          "reflectToAttr": false,
+          "docs": "Whether to move focus into the drawer when it opens. `auto` is right for\na drawer opened by a direct user action (a click, a deep link the user\njust navigated to). Set to `none` for a drawer that can open from a\nbackground event while the user is mid-task elsewhere on the page —\nmoving focus there would interrupt them, and the page stays live under\na non-modal drawer, so it is a genuine data-entry risk, not just an\nannoyance.",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "'auto'"
+            }
+          ],
+          "default": "'auto'",
+          "values": [
+            {
+              "value": "auto",
+              "type": "string"
+            },
+            {
+              "value": "none",
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "lightDismiss",
+          "type": "boolean",
+          "complexType": {
+            "original": "boolean",
+            "resolved": "boolean",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "light-dismiss",
+          "reflectToAttr": false,
+          "docs": "Whether the drawer can be dismissed with a pointerdown outside it.\nReplaces `pds-modal`'s `backdropDismiss` — there is no backdrop to click.\nThis also gates Escape, matching how `backdropDismiss` gates Escape on\n`pds-modal` today: setting this to `false` means the close button is the\nonly way out.\n\nA trigger outside the drawer should only ever set `open` to `true` and\nleave closing to the drawer itself. A toggle-style trigger (`open =\n!open`) fights light dismiss: clicking it while open closes the drawer\non `pointerdown`, then the trigger's own click handler re-opens it.",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "true"
+            }
+          ],
+          "default": "true",
+          "values": [
+            {
+              "type": "boolean"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "open",
+          "type": "boolean",
+          "complexType": {
+            "original": "boolean",
+            "resolved": "boolean",
+            "references": {}
+          },
+          "mutable": true,
+          "attr": "open",
+          "reflectToAttr": false,
+          "docs": "Whether the drawer is open",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "false"
+            }
+          ],
+          "default": "false",
+          "values": [
+            {
+              "type": "boolean"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "scrollable",
+          "type": "boolean",
+          "complexType": {
+            "original": "boolean",
+            "resolved": "boolean",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "scrollable",
+          "reflectToAttr": false,
+          "docs": "Whether the drawer content should be scrollable",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "true"
+            }
+          ],
+          "default": "true",
+          "values": [
+            {
+              "type": "boolean"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "side",
+          "type": "\"end\" | \"start\"",
+          "complexType": {
+            "original": "'start' | 'end'",
+            "resolved": "\"end\" | \"start\"",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "side",
+          "reflectToAttr": false,
+          "docs": "Which edge of the viewport the drawer is docked to. Logical, so this is\nfree under RTL — `end` is the inline-end edge regardless of direction.",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "'end'"
+            }
+          ],
+          "default": "'end'",
+          "values": [
+            {
+              "value": "end",
+              "type": "string"
+            },
+            {
+              "value": "start",
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "size",
+          "type": "\"md\" | \"sm\"",
+          "complexType": {
+            "original": "'sm' | 'md'",
+            "resolved": "\"md\" | \"sm\"",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "size",
+          "reflectToAttr": false,
+          "docs": "The drawer's width.",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "'md'"
+            }
+          ],
+          "default": "'md'",
+          "values": [
+            {
+              "value": "md",
+              "type": "string"
+            },
+            {
+              "value": "sm",
+              "type": "string"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        }
+      ],
+      "methods": [],
+      "events": [
+        {
+          "event": "pdsDrawerClose",
+          "detail": "void",
+          "bubbles": true,
+          "complexType": {
+            "original": "void",
+            "resolved": "void",
+            "references": {}
+          },
+          "cancelable": true,
+          "composed": true,
+          "docs": "Emitted when the drawer is closed",
+          "docsTags": []
+        },
+        {
+          "event": "pdsDrawerOpen",
+          "detail": "void",
+          "bubbles": true,
+          "complexType": {
+            "original": "void",
+            "resolved": "void",
+            "references": {}
+          },
+          "cancelable": true,
+          "composed": true,
+          "docs": "Emitted when the drawer is opened",
+          "docsTags": []
+        }
+      ],
+      "listeners": [
+        {
+          "event": "pdsModalClose",
+          "capture": false,
+          "passive": false
+        },
+        {
+          "event": "pdsModalOpen",
+          "capture": false,
+          "passive": false
+        },
+        {
+          "event": "pointerdown",
+          "target": "document",
+          "capture": false,
+          "passive": true
+        }
+      ],
+      "styles": [],
+      "slots": [],
+      "parts": [],
+      "states": [],
+      "dependents": [],
+      "dependencies": [
+        "pds-modal"
+      ],
+      "dependencyGraph": {
+        "pds-drawer": [
+          "pds-modal"
+        ]
+      }
+    },
+    {
+      "filePath": "src/components/pds-drawer/pds-drawer-content/pds-drawer-content.tsx",
+      "encapsulation": "none",
+      "tag": "pds-drawer-content",
+      "readme": "# pds-drawer-content\n\n\n",
+      "docs": "Fills the drawer panel's height by default — unlike `pds-modal-content`,\nwhich caps itself against the viewport for a centered, possibly-shorter\nmodal, a drawer panel is already edge-to-edge, so its content can simply\nflex to fill whatever space the header and footer leave.",
+      "docsTags": [],
+      "usage": {},
+      "props": [],
+      "methods": [],
+      "events": [],
+      "listeners": [],
+      "styles": [],
+      "slots": [],
+      "parts": [],
+      "states": [],
+      "dependents": [],
+      "dependencies": [],
+      "dependencyGraph": {}
+    },
+    {
+      "filePath": "src/components/pds-drawer/pds-drawer-footer/pds-drawer-footer.tsx",
+      "encapsulation": "none",
+      "tag": "pds-drawer-footer",
+      "readme": "# pds-drawer-footer\n\n\n",
+      "docs": "",
+      "docsTags": [],
+      "usage": {},
+      "props": [],
+      "methods": [],
+      "events": [],
+      "listeners": [],
+      "styles": [],
+      "slots": [],
+      "parts": [],
+      "states": [],
+      "dependents": [],
+      "dependencies": [],
+      "dependencyGraph": {}
+    },
+    {
+      "filePath": "src/components/pds-drawer/pds-drawer-header/pds-drawer-header.tsx",
+      "encapsulation": "none",
+      "tag": "pds-drawer-header",
+      "readme": "# pds-drawer-header\n\n\n",
+      "docs": "",
+      "docsTags": [],
+      "usage": {},
+      "props": [],
+      "methods": [],
+      "events": [],
+      "listeners": [],
+      "styles": [],
+      "slots": [],
+      "parts": [],
+      "states": [],
+      "dependents": [],
+      "dependencies": [],
+      "dependencyGraph": {}
+    },
     {
       "filePath": "src/components/pds-dropdown-menu/pds-dropdown-menu.tsx",
       "encapsulation": "shadow",
@@ -17596,6 +17941,35 @@
           "getter": false,
           "setter": false
         },
+        {
+          "name": "disableInitialFocus",
+          "type": "boolean",
+          "complexType": {
+            "original": "boolean",
+            "resolved": "boolean",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "disable-initial-focus",
+          "reflectToAttr": false,
+          "docs": "Whether to skip moving focus into the modal when it opens — both our own\n`setInitialFocus()` and the browser's native \"dialog focusing steps\",\nwhich move focus into the dialog as soon as `show()`/`showModal()` is\ncalled regardless of application code. Focus return on close is\nunaffected either way. For a modal opened by something other than a\ndirect user click — a redirect, a deep link, a background event —\nstealing focus on open can interrupt whatever the user was already\ndoing. Default `false` preserves today's behavior for every existing\nconsumer.",
+          "docsTags": [
+            {
+              "name": "default",
+              "text": "false"
+            }
+          ],
+          "default": "false",
+          "values": [
+            {
+              "type": "boolean"
+            }
+          ],
+          "optional": false,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
         {
           "name": "disableTopLayer",
           "type": "boolean",
@@ -17816,9 +18190,15 @@
         }
       ],
       "states": [],
-      "dependents": [],
+      "dependents": [
+        "pds-drawer"
+      ],
       "dependencies": [],
-      "dependencyGraph": {}
+      "dependencyGraph": {
+        "pds-drawer": [
+          "pds-modal"
+        ]
+      }
     },
     {
       "filePath": "src/components/pds-modal/pds-modal-content/pds-modal-content.tsx",
@@ -22993,7 +23373,7 @@
           "mutable": false,
           "attr": "truncate",
           "reflectToAttr": false,
-          "docs": "Truncates content to a max width and adds an ellipsis.\nWhen text overflows, a tooltip showing the full text will appear on hover/focus.\nNote: When truncate is enabled, the element automatically receives tabindex=\"0\" for keyboard accessibility.",
+          "docs": "Truncates content to a max width and adds an ellipsis.\nWhen text overflows, a tooltip showing the full text will appear on hover/focus.\nNote: While the content is overflowing, the cell receives tabindex=\"0\" so the\ntooltip can be reached by keyboard. Content that fits is left out of the tab order.",
           "docsTags": [],
           "values": [
             {
@@ -24118,7 +24498,7 @@
           "mutable": false,
           "attr": "truncate",
           "reflectToAttr": true,
-          "docs": "If set or `true`, the text will be truncated. Must add a `width` to the element.\nWhen text overflows, a tooltip showing the full text will appear on hover/focus.\nNote: When truncate is enabled, the element automatically receives tabindex=\"0\" for keyboard accessibility.",
+          "docs": "If set or `true`, the text will be truncated. Must add a `width` to the element.\nWhen text overflows, a tooltip showing the full text will appear on hover/focus.\nNote: While the text is overflowing, the element receives tabindex=\"0\" so the\ntooltip can be reached by keyboard. Text that fits is left out of the tab order.",
           "docsTags": [],
           "values": [
             {

package/dist/esm/{index-Bu9gFIxM.js → index-DdPaBxPo.js}

@@ -1,4 +1,4 @@
-/* pds-icons v10.4.2, ES Modules */
+/* pds-icons v10.4.3, ES Modules */
 
 const addCircle = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' class='pdsicon'><path fill-rule='evenodd' d='M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18M1 12C1 5.925 5.925 1 12 1s11 4.925 11 11-4.925 11-11 11S1 18.075 1 12m11-5a1 1 0 0 1 1 1v3h3a1 1 0 1 1 0 2h-3v3a1 1 0 1 1-2 0v-3H8a1 1 0 1 1 0-2h3V8a1 1 0 0 1 1-1'/></svg>";
 const caretDown = "data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' class='pdsicon'><path fill-rule='evenodd' d='M5.293 8.293a1 1 0 0 1 1.414 0L12 13.586l5.293-5.293a1 1 0 1 1 1.414 1.414l-6 6a1 1 0 0 1-1.414 0l-6-6a1 1 0 0 1 0-1.414'/></svg>";

package/dist/esm/index.js

@@ -1 +1,20 @@
+// Single source of truth for `pds-text` `size` values. The `as const` tuple is
+// readable at runtime (for validation) and `TextSizeType` is derived from it,
+// so the supported list and the prop type cannot drift apart.
+const TEXT_SIZES = [
+    '2xl',
+    'xl',
+    'lg',
+    'md',
+    'sm',
+    'xs',
+    '2xs',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+];
 
+export { TEXT_SIZES };