@pine-ds/core 4.0.0-mercury.0 → 4.1.0

package/dist/types/home/runner/work/pine/pine/libs/core/.stencil/scripts/vscode-custom-data-generator.d.ts

@@ -0,0 +1,6 @@
+import { JsonDocs } from '../../../../../../../../../stencil-public-runtime';
+export declare function generateVSCodeCustomData(docs: JsonDocs, outputPath: string): void;
+export default function vscodeCustomDataOutputTarget(outputPath?: string): {
+    type: "docs-custom";
+    generator: (docs: JsonDocs) => void;
+};

package/dist/types/i18n/i18n-format.d.ts

@@ -0,0 +1,38 @@
+export type I18nVars = Record<string, string | number>;
+export type PluralForms = Partial<Record<Intl.LDMLPluralRule, string>>;
+/**
+ * i18n formatting helpers for Pine components.
+ *
+ * Pine stays string-agnostic: user-facing text is supplied by the consumer as
+ * props (English-defaulted). These helpers only handle the two things a prop
+ * value can't express on its own — interpolating live component state into a
+ * translated template, and picking the right plural form. No stored strings, no
+ * locale registry; the locale is read from the DOM (`lang`), the web-standard
+ * signal a consumer already sets.
+ *
+ * Two limitations of DOM-`lang` locale resolution, both inherent to inferring
+ * locale from the DOM rather than being told it:
+ *
+ * 1. Not reactive. `resolveLocale` is read during render; Stencil has no
+ *    reactive dependency on a DOM attribute, so changing `lang` at runtime
+ *    (`document.documentElement.lang = 'pl'`) does NOT re-render mounted
+ *    components — the plural form stays stale until unrelated state forces a
+ *    render. Fine when locale changes via full-page navigation; a consumer that
+ *    switches locale client-side should pass the already-formatted/pluralized
+ *    string as the prop instead.
+ * 2. Does not cross shadow boundaries. `el.closest('[lang]')` stops at the host's
+ *    shadow root. A Pine component nested inside another custom element whose
+ *    `lang` sits on that outer host will not see it and falls back to
+ *    `document.documentElement.lang`. Set `lang` on (or above) the Pine element
+ *    in the same tree, or pass a pre-formatted string, when that matters.
+ */
+/** Replace `{token}` placeholders with `vars`; unknown tokens stay literal. */
+export declare function formatMessage(template: string, vars?: I18nVars): string;
+/** Nearest `[lang]` ancestor, then `<html lang>`, then `'en'`. */
+export declare function resolveLocale(el?: Element | null): string;
+/**
+ * Pick the CLDR plural form for `count` in the element's locale (via the
+ * platform `Intl.PluralRules`) and interpolate `{count}`. `forms` come from the
+ * caller — component props, English-defaulted — and fall back to `other`.
+ */
+export declare function pluralize(el: Element | null, count: number, forms: PluralForms, vars?: I18nVars): string;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { formatMessage, pluralize, resolveLocale } from './i18n-format';
+export type { I18nVars, PluralForms } from './i18n-format';

package/dist/types/index.d.ts

@@ -1 +1,2 @@
+export * from './components';
 import '@pine-ds/icons';

package/dist/types/stencil-public-runtime.d.ts

@@ -1,4 +1,6 @@
-declare type CustomMethodDecorator<T> = (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+type CustomMethodDecorator<T> = (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type MixinInstance<F> = F extends (base: MixedInCtor) => MixedInCtor<infer I> ? I : never;
 export interface ComponentDecorator {
     (opts?: ComponentOptions): ClassDecorator;
 }
@@ -61,6 +63,12 @@ export interface ShadowRootOptions {
      * focusable part is given focus, and the shadow host is given any available `:focus` styling.
      */
     delegatesFocus?: boolean;
+    /**
+     * Sets the slot assignment mode for the shadow root. When set to `'manual'`, enables imperative
+     * slotting using the `HTMLSlotElement.assign()` method. Defaults to `'named'` for standard
+     * declarative slotting behavior.
+     */
+    slotAssignment?: 'manual' | 'named';
 }
 export interface ModeStyles {
     [modeName: string]: string | string[];
@@ -117,12 +125,34 @@ export interface EventOptions {
      */
     composed?: boolean;
 }
+export interface AttachInternalsOptions {
+    /**
+     * Initial custom states to set on the ElementInternals.states CustomStateSet.
+     * Each key is the state name and the value is the initial boolean state.
+     *
+     * These states can be targeted with the CSS `:state()` pseudo-class.
+     *
+     * @example
+     * ```tsx
+     * @AttachInternals({ states: { open: true, active: false } })
+     * internals: ElementInternals;
+     * ```
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+     */
+    states?: {
+        [stateName: string]: boolean;
+    };
+}
 export interface AttachInternalsDecorator {
-    (): PropertyDecorator;
+    (opts?: AttachInternalsOptions): PropertyDecorator;
 }
 export interface ListenDecorator {
     (eventName: string, opts?: ListenOptions): CustomMethodDecorator<any>;
 }
+export interface ResolveVarFunction {
+    <T>(variable: T): string;
+}
 export interface ListenOptions {
     /**
      * Handlers can also be registered for an event other than the host itself.
@@ -151,7 +181,15 @@ export interface StateDecorator {
     (): PropertyDecorator;
 }
 export interface WatchDecorator {
-    (propName: string): CustomMethodDecorator<any>;
+    (propName: any, watchOptions?: {
+        immediate?: boolean;
+    }): CustomMethodDecorator<(newValue?: any, oldValue?: any, propName?: any, ...args: any[]) => any | void>;
+}
+export interface PropSerializeDecorator {
+    (propName: any): CustomMethodDecorator<(newValue?: any, propName?: string, ...args: any[]) => string | null>;
+}
+export interface AttrDeserializeDecorator {
+    (propName: any): CustomMethodDecorator<(newValue?: any, propName?: string, ...args: any[]) => any>;
 }
 export interface UserBuildConditionals {
     isDev: boolean;
@@ -200,6 +238,24 @@ export declare const AttachInternals: AttachInternalsDecorator;
  * https://stenciljs.com/docs/events#listen-decorator
  */
 export declare const Listen: ListenDecorator;
+/**
+ * The `resolveVar()` function is a compile-time utility that resolves const variables
+ * and object properties to their string literal values. This allows variables to be
+ * used in `@Listen` and `@Event` decorators instead of hardcoded strings.
+ *
+ * @example
+ * ```ts
+ * const MY_EVENT = 'myEvent';
+ * @Listen(resolveVar(MY_EVENT))
+ * ```
+ *
+ * @example
+ * ```ts
+ * const EVENTS = { MY_EVENT: 'myEvent' } as const;
+ * @Event({ eventName: resolveVar(EVENTS.MY_EVENT) })
+ * ```
+ */
+export declare const resolveVar: ResolveVarFunction;
 /**
  * The `@Method()` decorator is used to expose methods on the public API.
  * Class methods decorated with the @Method() decorator can be called directly
@@ -233,6 +289,14 @@ export declare const State: StateDecorator;
  * https://stenciljs.com/docs/reactive-data#watch-decorator
  */
 export declare const Watch: WatchDecorator;
+/**
+ * Decorator to serialize a property to an attribute string.
+ */
+export declare const PropSerialize: PropSerializeDecorator;
+/**
+ * Decorator to deserialize an attribute string to a property.
+ */
+export declare const AttrDeserialize: AttrDeserializeDecorator;
 export type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
 export type ErrorHandler = (err: any, element?: HTMLElement) => void;
 /**
@@ -260,6 +324,25 @@ export declare function setPlatformHelpers(helpers: {
  * @returns the base path
  */
 export declare function getAssetPath(path: string): string;
+/**
+ * Method to render a virtual DOM tree to a container element.
+ *
+ * @example
+ * ```tsx
+ * import { render } from '@stencil/core';
+ *
+ * const vnode = (
+ *   <div>
+ *     <h1>Hello, world!</h1>
+ *   </div>
+ * );
+ * render(vnode, document.body);
+ * ```
+ *
+ * @param vnode - The virtual DOM tree to render
+ * @param container - The container element to render the virtual DOM tree to
+ */
+export declare function render(vnode: VNode, container: Element): void;
 /**
  * Used to manually set the base path where assets can be found. For lazy-loaded
  * builds the asset path is automatically set and assets copied to the correct
@@ -330,6 +413,58 @@ export declare function readTask(task: RafCallback): void;
  * Unhandled exception raised while rendering, during event handling, or lifecycles will trigger the custom event handler.
  */
 export declare const setErrorHandler: (handler: ErrorHandler) => void;
+export type TagTransformer = (tag: string) => string;
+/**
+ * Sets a tag transformer to be used when rendering your custom elements.
+ * ```ts
+ * setTagTransformer((tag) => {
+ *  if (tag.startsWith('my-')) return `new-${tag}`
+ *  return tag;
+ * });
+ * ```
+ * Will mean all your components that start with `my-` are defined instead with `new-my-` prefix.
+ *
+ * @param transformer the transformer function to use which must return a string.
+ */
+export declare function setTagTransformer(transformer: TagTransformer): void;
+/**
+ * Transforms a tag name using a transformer set via `setTagTransformer`
+ *
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+export declare function transformTag(tag: string): string;
+/**
+ * @deprecated - Use `MixedInCtor` instead:
+ * ```ts
+ * import { MixedInCtor } from '@stencil/core';
+ *
+ * const AFactoryFn = <B extends MixedInCtor>(Base: B) => {class A extends Base { propA = A }; return A;}
+ * ```
+ */
+export type MixinFactory = (base: MixedInCtor) => MixedInCtor;
+export type MixedInCtor<T = {}> = new (...args: any[]) => T;
+/**
+ * Compose multiple mixin classes into a single constructor.
+ * The resulting class has the combined instance types of all mixed-in classes.
+ *
+ * Example:
+ * ```ts
+ * import { Mixin, MixedInCtor } from '@stencil/core';
+ *
+ * const AWrap = <B extends MixedInCtor>(Base: B) => {class A extends Base { propA = A }; return A;}
+ * const BWrap = <B extends MixedInCtor>(Base: B) => {class B extends Base { propB = B }; return B;}
+ * const CWrap = <B extends MixedInCtor>(Base: B) => {class C extends Base { propC = C }; return C;}
+ *
+ * class X extends Mixin(AWrap, BWrap, CWrap) {
+ *   render() { return <div>{this.propA} {this.propB} {this.propC}</div>; }
+ * }
+ * ```
+ *
+ * @param mixinFactories mixin factory functions that return a class which extends from the provided class.
+ * @returns a class that is composed from extending each of the provided classes in the order they were provided.
+ */
+export declare function Mixin<const TMixins extends readonly MixinFactory[]>(...mixinFactories: TMixins): abstract new (...args: any[]) => UnionToIntersection<MixinInstance<TMixins[number]>>;
 /**
  * This file gets copied to all distributions of stencil component collections.
  * - no imports
@@ -502,7 +637,7 @@ export interface FunctionalUtilities {
     map: (children: VNode[], cb: (vnode: ChildNode, index: number, array: ChildNode[]) => ChildNode) => VNode[];
 }
 export interface FunctionalComponent<T = {}> {
-    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[];
+    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[] | null;
 }
 /**
  * A Child VDOM node
@@ -544,6 +679,7 @@ export declare namespace h {
     function h(sel: any, data: VNodeData | null, text: string): VNode;
     function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
     function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+    function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
     namespace JSX {
         interface IntrinsicElements extends LocalJSX.IntrinsicElements, JSXBase.IntrinsicElements {
             [tagName: string]: any;
@@ -558,6 +694,36 @@ export declare function h(sel: any, children: Array<VNode | undefined | null>):
 export declare function h(sel: any, data: VNodeData | null, text: string): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+export declare function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsx mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsx".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxmode with multiple children.
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsxs(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxdev mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsxdev".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @param isStaticChildren indicates if the children are static
+ * @param source source information
+ * @param self reference to the component instance
+ * @returns a jsx vnode
+ */
+export declare function jsxDEV(type: any, props: any, key?: string | number, isStaticChildren?: boolean, source?: any, self?: any): VNode;
 /**
  * A virtual DOM node
  */
@@ -587,7 +753,7 @@ declare namespace LocalJSX {
 export { LocalJSX as JSX };
 export declare namespace JSXBase {
     interface IntrinsicElements {
-        slot: JSXBase.SlotAttributes;
+        slot: JSXBase.SlotAttributes<HTMLSlotElement>;
         a: JSXBase.AnchorHTMLAttributes<HTMLAnchorElement>;
         abbr: JSXBase.HTMLAttributes;
         address: JSXBase.HTMLAttributes;
@@ -757,7 +923,7 @@ export declare namespace JSXBase {
         use: JSXBase.SVGAttributes;
         view: JSXBase.SVGAttributes;
     }
-    interface SlotAttributes extends JSXAttributes {
+    interface SlotAttributes<T = HTMLSlotElement> extends JSXAttributes<T> {
         name?: string;
         slot?: string;
         onSlotchange?: (event: Event) => void;
@@ -813,6 +979,9 @@ export declare namespace JSXBase {
         popoverTargetAction?: string;
         popoverTargetElement?: Element | null;
         popoverTarget?: string;
+        command?: string;
+        commandFor?: string;
+        commandfor?: string;
     }
     interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
         height?: number | string;
@@ -826,7 +995,8 @@ export declare namespace JSXBase {
     }
     interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
         open?: boolean;
-        onToggle?: (event: Event) => void;
+        name?: string;
+        onToggle?: (event: ToggleEvent) => void;
     }
     interface DelHTMLAttributes<T> extends HTMLAttributes<T> {
         cite?: string;
@@ -900,6 +1070,7 @@ export declare namespace JSXBase {
         importance?: 'low' | 'auto' | 'high';
         height?: number | string;
         loading?: 'lazy' | 'auto' | 'eager';
+        referrerPolicy?: ReferrerPolicy;
         sizes?: string;
         src?: string;
         srcSet?: string;
@@ -1015,6 +1186,8 @@ export declare namespace JSXBase {
         autoPlay?: boolean;
         autoplay?: boolean | string;
         controls?: boolean;
+        controlslist?: 'nodownload' | 'nofullscreen' | 'noremoteplayback';
+        controlsList?: 'nodownload' | 'nofullscreen' | 'noremoteplayback';
         crossOrigin?: string;
         crossorigin?: string;
         loop?: boolean;
@@ -1530,6 +1703,13 @@ export declare namespace JSXBase {
         z?: number | string;
         zoomAndPan?: string;
     }
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent) */
+    interface ToggleEvent extends Event {
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent/newState) */
+        readonly newState: string;
+        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ToggleEvent/oldState) */
+        readonly oldState: string;
+    }
     interface DOMAttributes<T> extends JSXAttributes<T> {
         slot?: string;
         part?: string;
@@ -1546,6 +1726,10 @@ export declare namespace JSXBase {
         onCompositionstartCapture?: (event: CompositionEvent) => void;
         onCompositionupdate?: (event: CompositionEvent) => void;
         onCompositionupdateCapture?: (event: CompositionEvent) => void;
+        onBeforeToggle?: (event: ToggleEvent) => void;
+        onBeforeToggleCapture?: (event: ToggleEvent) => void;
+        onToggle?: (event: ToggleEvent) => void;
+        onToggleCapture?: (event: ToggleEvent) => void;
         onFocus?: (event: FocusEvent) => void;
         onFocusCapture?: (event: FocusEvent) => void;
         onFocusin?: (event: FocusEvent) => void;
@@ -1575,7 +1759,7 @@ export declare namespace JSXBase {
         onKeyUp?: (event: KeyboardEvent) => void;
         onKeyUpCapture?: (event: KeyboardEvent) => void;
         onAuxClick?: (event: MouseEvent) => void;
-        onClick?: (event: MouseEvent) => void;
+        onClick?: (event: PointerEvent) => void;
         onClickCapture?: (event: MouseEvent) => void;
         onContextMenu?: (event: MouseEvent) => void;
         onContextMenuCapture?: (event: MouseEvent) => void;
@@ -1655,6 +1839,8 @@ export declare namespace JSXBase {
         onTransitionRunCapture?: (event: TransitionEvent) => void;
         onTransitionStart?: (event: TransitionEvent) => void;
         onTransitionStartCapture?: (event: TransitionEvent) => void;
+        [key: `aria-${string}`]: string | boolean | undefined;
+        [key: `aria${string}`]: string | boolean | undefined;
     }
 }
 export interface JSXAttributes<T = Element> {
@@ -1665,6 +1851,7 @@ export interface CustomElementsDefineOptions {
     exclude?: string[];
     resourcesUrl?: string;
     syncQueue?: boolean;
+    /** @deprecated in-favour of `setTagTransformer` and `transformTag` */
     transformTagName?: (tagName: string) => string;
     jmp?: (c: Function) => any;
     raf?: (c: FrameRequestCallback) => number;

package/dist/types/utils/attributes.d.ts

@@ -0,0 +1,10 @@
+export type Attributes = {
+    [key: string]: any;
+};
+/**
+ * Inherit attributes from the host element
+ * @param el - Host element
+ * @param attributes - Array of attributes to inherit
+ */
+export declare const inheritAttributes: (el: Element, attributes?: string[]) => Attributes;
+export declare const inheritAriaAttributes: (el: Element, ignoreList?: string[]) => Attributes;

package/dist/types/utils/form.d.ts

@@ -4,9 +4,31 @@
 export declare const messageId: (id: string, messageType: string) => string;
 /**
  * Assign aria-description id to relate messages with form element
+ *
+ * Returns the error message id when invalid, otherwise the helper message id.
+ * Pass only messages the component renders — a described id must exist in the DOM.
  */
-export declare const assignDescription: (id: string, invalid: boolean, helperMessage: string) => string;
+export declare const assignDescription: (id: string, invalid: boolean, helperMessage?: string, errorMessage?: string) => string;
 /**
  * Updates the `invalid` prop of a form element based on it's values validity
  */
 export declare const isRequired: (target: any, component: any) => void;
+/**
+ * Exposes a readonly type property on a custom form element to match native form element behavior.
+ * This makes the type property enumerable and accessible via element.type, matching native HTML elements.
+ * The property is non-configurable, preventing it from being redefined or deleted at runtime.
+ *
+ * @param element - The custom element to add the type property to
+ * @param type - The type value (string literal) or a getter function that returns the type
+ */
+export declare function exposeTypeProperty(element: Element, type: string | (() => string)): void;
+/**
+ * Determines if code is running in Stencil's spec test environment.
+ * Stencil's mock-doc logs console.error on any ElementInternals
+ * property access during spec tests. Use this guard to skip
+ * ElementInternals calls in the mock environment.
+ *
+ * Uses __STENCIL_SPEC_TESTS__ (the same env var Stencil's mock-doc checks)
+ * to avoid false positives in downstream consumer test suites.
+ */
+export declare const isSpecTest: () => boolean;

package/dist/types/utils/interfaces.d.ts

@@ -0,0 +1,6 @@
+export interface BasePdsProps {
+    /**
+    * A unique identifier used for the underlying component `id` attribute.
+    */
+    componentId: string;
+}

package/dist/types/utils/overlay.d.ts

@@ -1,8 +1,8 @@
 interface OverlayArgs {
-    elem: HTMLElement;
+    elem: HTMLElement | null;
     elemPlacement: string;
-    overlay: HTMLElement;
+    overlay: HTMLElement | null;
     offset?: number;
 }
-export declare const positionTooltip: ({ elem, elemPlacement, overlay, offset }: OverlayArgs) => void;
+export declare const positionTooltip: ({ elem, elemPlacement, overlay, offset }: OverlayArgs) => boolean;
 export {};

package/dist/types/utils/reconnected-content.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Unwraps a stale copy of a light-DOM (`shadow: false`) component's own wrapper,
+ * left behind when a page-cache (Turbo, browser bfcache) reconnect nests a
+ * component's previous render inside its freshly rendered one. Call from
+ * `componentDidRender` with the element that directly contains the rendered
+ * `<slot>` and the selector that identifies "another one of me." Unwraps in
+ * place (move-then-remove) so nested content is never lost.
+ *
+ * `contentSelector` is only needed when the wrapper itself further nests a
+ * separate content element (e.g. pds-tab's `<a class="pds-tab">` wrapping a
+ * `.pds-tab__content` div) — omit it when the wrapper's own children are the
+ * slotted content (e.g. pds-tabpanel's `.pds-tabpanel` div).
+ */
+export declare function unwrapReconnectedContent(container: Element | null, selector: string, contentSelector?: string): void;

package/dist/types/utils/scroll.d.ts

@@ -0,0 +1,21 @@
+export type RtlScrollType = 'negative' | 'reverse' | 'default';
+/**
+ * Detects how this browser reports scrollLeft for RTL overflow containers.
+ * @see https://github.com/othree/jquery.rtl-scroll-type
+ */
+export declare function getRtlScrollType(): RtlScrollType;
+/** Reset cached RTL scroll type (for tests). */
+export declare function resetRtlScrollTypeCache(): void;
+/** True when the element's used text direction is RTL (inherits from ancestors). */
+export declare function isRtlDirection(element: Element): boolean;
+/**
+ * RTL scroll offset from inline-start for a known browser scrollLeft model.
+ * @see https://github.com/othree/jquery.rtl-scroll-type#3-types-of-scrollleft-scrollwidth--100
+ */
+export declare function getRtlScrollOffsetFromStart(scrollLeft: number, maxScroll: number, rtlType: RtlScrollType): number;
+/**
+ * Distance scrolled from the inline-start edge (LTR: left, RTL: right).
+ */
+export declare function getScrollOffsetFromStart(container: HTMLElement): number;
+/** True when the container is scrolled away from its inline-start edge. */
+export declare function isScrolledFromInlineStart(container: HTMLElement): boolean;

package/dist/types/utils/test/axe.d.ts

@@ -0,0 +1,81 @@
+import type { E2EPage } from '@stencil/core/testing';
+/** axe-core selector path; nested arrays represent iframe/shadow boundaries. */
+export type AxeTarget = (string | string[])[];
+/**
+ * Subset of an axe-core violation surfaced for test assertions. The shape
+ * mirrors `axe.AxeResults['violations'][number]` without pulling axe-core's
+ * full types into the component test surface.
+ */
+export interface AxeViolation {
+    id: string;
+    impact: 'minor' | 'moderate' | 'serious' | 'critical' | null;
+    description: string;
+    help: string;
+    helpUrl: string;
+    nodes: Array<{
+        target: AxeTarget;
+        html: string;
+        failureSummary?: string;
+    }>;
+}
+export interface RunAxeOptions {
+    /**
+     * Limits the run to rules tagged with one or more of these values.
+     * Defaults to WCAG 2.0 + 2.1 levels A and AA.
+     */
+    tags?: string[];
+    /**
+     * Per-rule overrides (e.g. `{ 'color-contrast': { enabled: false } }`).
+     */
+    rules?: Record<string, {
+        enabled: boolean;
+    }>;
+}
+/**
+ * Default tag filter applied by `runAxe`. Mirrors WCAG 2.0 + 2.1 levels A
+ * and AA. Override with `{ tags: [...] }` to widen or narrow the scope.
+ */
+export declare const DEFAULT_AXE_TAGS: readonly ["wcag2a", "wcag2aa", "wcag21a", "wcag21aa"];
+/**
+ * Page-level axe rules that fire on the bare HTML harness Stencil's E2E
+ * provides (no `<title>`, no `<html lang>`, no landmarks, no `<h1>`, and
+ * often without the full theme/global stylesheet).
+ * They are disabled by default because they describe document chrome or
+ * need themed context — flagging them at component scope yields noise or flakes.
+ *
+ * Tests can opt back in for a specific case:
+ *
+ * ```ts
+ * await runAxe(page, { rules: { 'document-title': { enabled: true } } });
+ * ```
+ */
+export declare const DEFAULT_DISABLED_RULES: readonly ["document-title", "html-has-lang", "landmark-one-main", "page-has-heading-one", "region", "color-contrast"];
+/**
+ * Injects axe-core into an active Stencil E2EPage and returns any
+ * accessibility violations found in the current document.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const page = await newE2EPage();
+ * await page.setContent('<pds-button>Click me</pds-button>');
+ * const violations = await runAxe(page);
+ * expect(violations).toEqual([]);
+ * ```
+ *
+ * Component tests should assert against the returned array directly so
+ * each component can document its own baseline (zero violations is the
+ * goal; suppressions should be deliberate and commented).
+ */
+export declare function runAxe(page: E2EPage, options?: RunAxeOptions): Promise<AxeViolation[]>;
+/**
+ * Formats an axe target selector, including nested arrays for shadow DOM
+ * and iframe boundaries (axe's `UnlabelledFrameSelector` shape).
+ */
+export declare function formatAxeTarget(target: AxeTarget): string;
+/**
+ * Formats an array of axe violations into a readable failure message for
+ * use in test output. Returns an empty string when there are no
+ * violations, so it can be passed directly into `expect(...).toBe('')`.
+ */
+export declare function formatViolations(violations: AxeViolation[]): string;

package/dist/types/utils/test/reconnect-safety.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generic guard against the page-cache (Turbo, browser bfcache) reconnect bug class:
+ * a light-DOM (`shadow: false` or `scoped: true`) component that wraps its slotted
+ * content in a rendered element is reconnected over its own prior render, nesting
+ * (or duplicating, or losing) content.
+ *
+ * Hydrates `html`, re-parses the resulting markup the way a cache restore reconnects
+ * a component over its own output, and asserts no duplicate `id`s and no content
+ * loss or duplication survive the second pass.
+ */
+export declare function expectReconnectSafe(components: unknown[], html: string): Promise<void>;

package/dist/types/utils/truncation-tooltip.d.ts

@@ -0,0 +1,21 @@
+import { PlacementType } from './types';
+export interface TruncationTooltipOptions {
+    /** The host element (for hover/focus listeners and positioning anchor) */
+    hostEl: HTMLElement;
+    /** The inner element where overflow actually occurs (inside shadow root) */
+    contentEl: HTMLElement;
+    /** Function that returns the full text to display in the tooltip */
+    getTooltipText: () => string;
+    /** Tooltip placement preference (default: 'top') */
+    placement?: PlacementType;
+}
+/**
+ * Sets up automatic tooltip behavior for a truncated element.
+ *
+ * When the element's text overflows, hovering or focusing the host element
+ * will display a tooltip showing the full text content. The tooltip is
+ * rendered as a portal on document.body and positioned with Floating UI.
+ *
+ * @returns A cleanup function that removes all listeners, observers, and DOM elements.
+ */
+export declare function setupTruncationTooltip(options: TruncationTooltipOptions): () => void;

package/dist/types/utils/types.d.ts

@@ -1,3 +1,9 @@
-export type TooltipPlacementType = 'top-start' | 'top' | 'top-end' | 'left-start' | 'left' | 'left-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end';
+export type PlacementType = 'top-start' | 'top' | 'top-end' | 'left-start' | 'left' | 'left-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end';
 export type BoxColumnType = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
-export type BoxTShirtSizeType = 'none' | 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type BoxSpacingType = 'none' | 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | '025' | '050' | '100' | '125' | '150' | '200' | '250' | '300' | '350' | '400' | '450' | '500' | '550' | '600' | '650' | '700' | '750' | '800';
+export type BoxShadowSizeType = 'none' | '050' | '100' | '150' | '200' | '300' | '400' | '500';
+export type ChipSentimentType = 'accent' | 'brand' | 'danger' | 'info' | 'neutral' | 'success' | 'warning';
+export type ChipSizeType = 'sm' | 'md' | 'lg';
+export type ChipVariantType = 'text' | 'tag' | 'dropdown';
+export declare const TEXT_SIZES: readonly ["2xl", "xl", "lg", "md", "sm", "xs", "2xs", "h1", "h2", "h3", "h4", "h5", "h6"];
+export type TextSizeType = (typeof TEXT_SIZES)[number];

package/dist/types/utils/utils.d.ts

@@ -1,2 +1,14 @@
-export declare function format(first: string, middle: string, last: string): string;
-export declare const hasShadowDom: (el: HTMLElement) => boolean;
+import type { EventEmitter } from "../stencil-public-runtime";
+export declare const hasShadowDom: (el: Element) => boolean;
+export declare const debounceEvent: (event: EventEmitter, wait: number) => EventEmitter;
+export declare const debounce: (func: (...args: any[]) => void, wait?: number) => (...args: any[]) => any;
+/**
+ * Normalizes color values to ensure consistent CSS variable usage
+ * @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
+ */
+export declare const normalizeColorValue: (value: string | undefined, options?: {
+    semanticMap?: Record<string, string>;
+}) => string | undefined;
+export declare const setColor: (color: string, customColors?: Record<string, string>) => Record<string, string>;