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

package/dist/types/mixins/anchored.mixin.d.ts

@@ -2,6 +2,7 @@ import { IFloatingAdapter, PositioningEngine } from "../services/floating/positi
 import { MixedInCtor } from '../stencil-public-runtime';
 import { Logger } from "../services/logger/Logger";
 import { FloatingMixinOptions } from "../services/floating/interfaces/Floating";
+import { AnchoredHooks } from "../services/floating/interfaces/Anchored";
 /**
  * Positioning and trigger mixin for anchor-based floating elements.
  *
@@ -109,6 +110,8 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * either via slot change handler or `componentDidLoad`.
          */
         triggerSlot: HTMLElement;
+        el: HTMLElement;
+        readonly hooks: AnchoredHooks;
         /**
          * Shows the floating element using the Popover API
          * and starts position auto-update relative to `triggerSlot`.
@@ -125,6 +128,11 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * @returns `false` if `triggerSlot` is not set, otherwise delegates to super
          */
         onBeforeShow(target?: HTMLElement): boolean;
+        /**
+         * Hides the focus from the floating element.
+         * This is necessary to prevent the focus from being trapped inside the floating element.
+         */
+        hideFocus(): void;
         /**
          * Hides the floating element using the Popover API
          * and stops position auto-update.
@@ -160,7 +168,7 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * @param options - Positioning options (placement, offset, flip, shift, arrow)
          * @param onPositionUpdate - Optional callback invoked after each position update
          */
-        updatePosition(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void): Promise<import("../services/floating/interfaces/Positioning").PositioningResult>;
+        updatePosition(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void): Promise<import("../services").PositioningResult>;
         /**
          * Starts automatic position synchronization between the trigger
          * and the floating element. Runs `updatePosition` once immediately,
@@ -171,7 +179,7 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * @param options - Positioning options
          * @param onPositionUpdate - Optional callback after each position update
          */
-        startAutoUpdate(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: Parameters<(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void) => Promise<import("../services/floating/interfaces/Positioning").PositioningResult>>[3]): void;
+        startAutoUpdate(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: Parameters<(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void) => Promise<import("../services").PositioningResult>>[3]): void;
         /**
          * Stops automatic position synchronization and clears the cleanup reference.
          */
@@ -200,6 +208,9 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * @param hideFn - Bound hide function to remove
          */
         floatingDisconnect(showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        subscribeToTrigger(trigger?: HTMLElement): void;
+        onBeforeLoad(): void;
+        componentDidLoad(): void;
         /**
          * Initializes the positioning engine, logger, and binds lifecycle methods
          * so they can be safely passed as event listener callbacks.
@@ -213,10 +224,9 @@ export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
          * when the component is removed from the DOM.
          */
         disconnectedCallback(): void;
-        floatingOptions: import("../services/floating/interfaces/Props").FloatingAnchoredProp;
+        floatingOptions: import("../services").FloatingProp;
         floatingContent: HTMLElement;
         isVisible: boolean;
-        readonly hooks: import("@/services/floating/interfaces/Floating").FloatingHooks;
         onBeforeHide(target?: HTMLElement): boolean;
         show(target?: HTMLElement): void;
         hide(target?: HTMLElement): void;

package/dist/types/mixins/backdrop.mixin.d.ts

@@ -0,0 +1,103 @@
+import { MixedInCtor } from '../stencil-public-runtime';
+import { BackdropHooks } from "../services/floating/interfaces/Backdrop";
+export declare const backdropMixin: <B extends MixedInCtor>(Base: B) => {
+    new (...args: any[]): {
+        /**
+         * The dialog element associated with this backdrop.
+         */
+        dialogElement: HTMLDialogElement;
+        /**
+         * Determines whether clicking on the backdrop closes the dialog.
+         */
+        backdropClose: boolean;
+        /**
+         * Determines whether pressing the Escape key closes the dialog.
+         */
+        escapeClose: boolean;
+        /**
+         * Determines whether pressing the Escape key closes the dialog.
+         */
+        preventClose: boolean;
+        /**
+         * Indicates whether the dialog is currently in the process of closing.
+         */
+        isClosing: boolean;
+        /**
+         * Scroll lock is handled per dialog instance.
+         * This assumes dialogs are opened in a nested manner.
+         */
+        previousOverflow: string;
+        /**
+         * Override in component to provide custom hooks.
+         * @returns {BackdropHooks} The custom hooks object.
+         */
+        readonly hooks: BackdropHooks;
+        /**
+         * Shows the dialog element by calling showModal and setting isVisible to true.
+         * Overrides floating mixin showElement()
+         */
+        showElement(): void;
+        /**
+         * Hides the dialog element by calling close and setting isVisible to false, and resets isClosing.
+         * Overrides floating mixin hideElement()
+         */
+        hideElement(): void;
+        /**
+         * Closes the dialog element, preventing multiple close attempts and calling hooks if available.
+         * * If the onBEforeClose() hook is passed, the implementation SHOULD call the hide() function.
+         */
+        closeElement(): void;
+        /**
+         * Toggles the visibility of the dialog: closes if visible, shows if hidden.
+         */
+        toggle(): void;
+        /**
+         * Overrides the hooks inherited from floating mixin.
+         * Hook called after the dialog is shown. Locks the scroll and calls custom hooks.
+         * @param target The target HTMLElement
+         */
+        onAfterShow(target?: HTMLElement): void;
+        /**
+         * Hook called after the dialog is hidden. Restores the previous overflow style and calls custom hooks.
+         * @param target The target HTMLElement
+         */
+        onAfterHide(target?: HTMLElement): void;
+        /**
+         * A lifecycle hook that is invoked just before the dialog begins to close.
+         * This provides an opportunity to perform custom actions, such as triggering closing animations,
+         * before the dialog is actually hidden from view.
+         * * If the onBeforeClose() hook is passed, the implementation SHOULD call the hide() function.
+         * @param target The target HTMLElement, typically the dialog element.
+         */
+        onBeforeClose(target?: HTMLElement): void;
+        /**
+         * Handle backdrop click to close the dialog.
+         * @param e Mouse Event at click
+         */
+        handleBackdropClick(e: MouseEvent): void;
+        /**
+         * Handle Escape keydown to close the dialog.
+         * @param ev KeyboardEvent
+         */
+        handleKeydown(ev: KeyboardEvent): void;
+        /**
+         * Adds a transition class to the dialog element.
+         * Cleanup and closing logic must be handled by the caller.
+         */
+        addTransitionAnimation(animationClassName: string): void;
+        /**
+         * Removes a transition class to the dialog element.
+         * Calling must be handled by the caller.
+         */
+        removeTransitionAnimation(animationClassName: string): void;
+        floatingOptions: import("../services").FloatingProp;
+        floatingContent: HTMLElement;
+        isVisible: boolean;
+        readonly options: import("../services").FloatingMixinOptions;
+        onBeforeShow(target?: HTMLElement): boolean;
+        onBeforeHide(target?: HTMLElement): boolean;
+        show(target?: HTMLElement): void;
+        hide(target?: HTMLElement): void;
+    };
+} & B;
+//# sourceMappingURL=backdrop.mixin.d.ts.map

package/dist/types/mixins/floating.mixin.d.ts

@@ -1,5 +1,5 @@
-import { FloatingHooks } from "../services/floating/interfaces/Floating";
-import { FloatingAnchoredProp } from "../services/floating/interfaces/Props";
+import { FloatingHooks, FloatingMixinOptions } from "../services/floating/interfaces/Floating";
+import { FloatingProp } from "../services/floating/interfaces/Props";
 import { MixedInCtor } from '../stencil-public-runtime';
 /**
  * Core lifecycle mixin for all floating elements in the design system.
@@ -66,7 +66,7 @@ export declare const floatingMixin: <B extends MixedInCtor>(Base: B) => {
          * Configuration prop passed by the consumer component.
          * Allows external control over lifecycle hooks and floating behavior.
          */
-        floatingOptions: FloatingAnchoredProp;
+        floatingOptions: FloatingProp;
         /**
          * Reference to the floating element in the DOM.
          * Must be assigned via `ref` in the component's render method.
@@ -90,6 +90,14 @@ export declare const floatingMixin: <B extends MixedInCtor>(Base: B) => {
          * @returns FloatingHooks — an object with optional lifecycle callbacks
          */
         readonly hooks: FloatingHooks;
+        /**
+         * Default options for the floating mixin.
+         * Override this getter in the component to customize placement,
+         * offset, strategy, flip, shift, and arrow.
+         *
+         * @returns FloatingMixinOptions — default options for the mixin
+         */
+        readonly options: FloatingMixinOptions;
         /**
          * Called before the element is shown.
          * Aggregates both the component `hooks` and `floatingOptions` controls.

package/dist/types/mixins/form-associated.mixin.d.ts

@@ -9,7 +9,7 @@ import { type EventEmitter, type MixedInCtor } from '../stencil-public-runtime';
  *
  * @example
  * ```typescript
- * import { AttachInternals, Component, Event, EventEmitter, Mixin, Prop } from '../stencil-public-runtime';
+ * import { AttachInternals, Component, Event, EventEmitter, Mixin, Prop, State, Watch } from '../stencil-public-runtime';
  *
  * import { setFormValue } from '@/utils/form';
  * import { formAssociatedMixin, type IFormControl } from '@/mixins/form-associated.mixin';
@@ -18,6 +18,12 @@ import { type EventEmitter, type MixedInCtor } from '../stencil-public-runtime';
  * export class BdsTextField extends Mixin(formAssociatedMixin) implements ITextField, IFormControl<string> {
  *   @AttachInternals() internals!: ElementInternals;
  *
+ *   @Prop({ reflect: true }) readonly disabled: boolean = false;
+ *   @State() private isDisabled: boolean = false;
+ *
+ *   @Watch('disabled')
+ *   onDisabledChange(next: boolean) { this.isDisabled = next; }
+ *
  *   @Prop({ mutable: true, reflect: true }) value: string = '';
  *
  *   @Event() valueChange!: EventEmitter<string>;
@@ -99,28 +105,26 @@ export interface IFormControl<T> extends IFormAssociatedCallbacks, IFormValueEmi
 /**
  * Shared base mixin for Form-Associated Custom Elements in Boreal DS.
  *
- * Provides:
- * - `name`, `disabled`, and `required` form props
- * - `formDisabledCallback` with universal disabled sync behavior
+ * Provides `formDisabledCallback` — the only behavior that is identical across
+ * all FACE components. It writes to the component's `isDisabled` state, which
+ * each component must declare as `@State() private isDisabled: boolean = false`.
+ *
+ * Each component must declare directly on its class body:
+ * - `@AttachInternals() internals!: ElementInternals`
+ * - `@Prop({ reflect: true }) readonly name!: string`
+ * - `@Prop({ reflect: true }) readonly disabled: boolean = false`
+ * - `@Prop({ reflect: true }) readonly required: boolean = false`
+ * - `@State() private isDisabled: boolean = false`
+ * - `@Watch('disabled') onDisabledChange(next: boolean) { this.isDisabled = next; }`
  *
- * Each component must declare `@AttachInternals() internals!: ElementInternals`
- * directly on its class body — Stencil's compiler requires this decorator to be
- * statically visible on the component class, not inside a mixin factory.
+ * Stencil's compiler requires `@Prop` and `@State` decorators to be statically
+ * visible on the component class — they cannot be inherited from a mixin.
  *
  * Components must also implement `IFormControl<T>` for value registration,
  * reset, state restoration, and 2-way binding event emission.
  */
 export declare const formAssociatedMixin: <B extends MixedInCtor>(Base: B) => {
     new (...args: any[]): {
-        /** Name of the form control, submitted as a key in the form data. */
-        readonly name: string;
-        /** Disables the control. Synced automatically from a parent `<fieldset>` or `<form>` via `formDisabledCallback`. */
-        readonly disabled: boolean;
-        /** Marks the control as required for form submission. */
-        readonly required: boolean;
-        /**
-         * Sync component disabled state with parent form disabled state.
-         */
         formDisabledCallback(disabled: boolean): void;
     };
 } & B;

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

@@ -1,4 +1,7 @@
 export * from './form-associated.mixin';
 export * from './floating.mixin';
 export * from './anchored.mixin';
+export * from './backdrop.mixin';
+export * from './menu-behavior.mixin';
+export * from './links.mixin';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/mixins/links.mixin.d.ts

@@ -0,0 +1,85 @@
+import { LinksAttrs } from "../types/links";
+import { MixedInCtor } from '../stencil-public-runtime';
+/**
+ * Creates a mixin that adds link-related properties and behaviors to a base class.
+ * It provides computed attributes for links, handles keyboard interactions, and sanitizes URLs to ensure security.
+ * It allows components to easily handle link attributes and execute link events.
+ *
+ * This mixin includes:
+ *  - `href`: The URL the link points to.
+ *  - `newTab`: Whether the link should open in a new tab.
+ *  - `downloadable`: Whether the link should be treated as a download.
+ *  - `filename`: The filename to use when downloading.
+ *  - `getLinkAttributes`: A computed property that returns the appropriate attributes for the link based on its state and props.
+ *  - `handleLinkKeyDown`: A method to handle keyboard interactions for accessibility.
+ *  - `handleLinkClick`: A method to manage click behavior, including external links and downloads.
+ *  - `sanitizeUrl`: A utility method to sanitize URLs and prevent XSS vulnerabilities.
+ *
+ * @typeParam T - The base constructor type to extend.
+ * @param {T} Base - The base component class to be extended.
+ * @returns {WithLinks} - A class with injected link behaviors.
+ *
+ * @example
+ * ```tsx
+ *  import { Component, h } from '../stencil-public-runtime';
+ *  import { WithLinks } from '@/mixins/links.mixin';
+ *
+ * @Component({
+ *  tag: 'my-link',
+ *  styleUrl: 'my-link.scss',
+ *  })
+ *  class MyLink extends Mixin(WithLinks) {
+ *    @Element() el!: HTMLElement;
+ *    @Prop() href: string = '';
+ *    @Prop() newTab: boolean = false;
+ *    @Prop() downloadable: boolean = false;
+ *    @Prop() filename: string = '';
+ *    @Prop() disabled: boolean = false;
+ *
+ *    private handleKeyDown = (e: KeyboardEvent) => {
+ *      if (this.disabled) return;
+ *      this.handleLinkKeyDown(e);
+ *    };
+ *
+ *   render() {
+ *    return (
+ *      <Host
+ *      {...this.getLinkAttributes}
+ *      onKeyDown={this.handleKeyDown} >
+ *      <slot />
+ *      </Host>
+ *    );
+ *    }
+ * } ```
+ *
+ */
+export declare const WithLinks: <T extends MixedInCtor>(Base: T) => {
+    new (...args: any[]): {
+        /** Props should be declared in the component using the Mixin */
+        el: HTMLElement;
+        href: string;
+        newTab: boolean;
+        download: string;
+        readonly isLink: boolean;
+        /**
+         * Computes the appropriate link attributes based on the component's props and state.
+         * It handles external links, new tab behavior, and download attributes while ensuring accessibility.
+         * @returns {LinksAttrs} - The computed link attributes.
+         * */
+        readonly linkAttributes: LinksAttrs;
+        _isExternalLink(url: string): boolean;
+        /** Keydown handler to allow keyboard interaction with the link */
+        handleLinkKeyDown(event: KeyboardEvent): void;
+        /** Click handler to manage link behavior, including external links and downloads */
+        handleLinkClick(event: MouseEvent): void;
+        /** Sanitizes the URL to prevent XSS vulnerabilities. It removes dangerous protocols and ensures valid URLs.
+         * @param {string} url - The URL to sanitize.
+         * @returns {string} - The sanitized URL, or an empty string if the URL is deemed unsafe.
+         * @example
+         * const safeUrl = sanitizeUrl('https://example.com'); // returns 'https://example.com'
+         * const unsafeUrl = sanitizeUrl('javascript:alert(1)'); // returns ''
+         */
+        sanitizeUrl(url: string): string;
+    };
+} & T;
+//# sourceMappingURL=links.mixin.d.ts.map

package/dist/types/mixins/menu-behavior.mixin.d.ts

@@ -0,0 +1,91 @@
+import { MenuRole, MenuItemRole } from "../types/index";
+import { MixedInCtor } from '../stencil-public-runtime';
+/**
+ * A Mixin that provides menu item behaviors, including ARIA roles,
+ * focus management, and keyboard navigation logic.
+ * This mixin is designed to be used with Stencil components that represent items within a menu or listbox,
+ * allowing them to automatically adapt their behavior based on the context of their parent container.
+ *
+ * The mixin includes:
+ * - Dynamic ARIA role resolution based on the nearest parent menu or listbox.
+ * - Computation of aria-selected and tabIndex attributes for accessibility.
+ * - A method to handle keyboard navigation (Arrow keys, Enter, Space) within the menu context.
+ *
+ *
+ * @typeParam B - The base constructor type.
+ * @param {B} Base - The base component class to be extended.
+ * @returns {MenuBehaviorMixin} - A class with injected menu behaviors.
+ *
+ * @example
+ * ```tsx
+ * import { Component, h } from '../stencil-public-runtime';
+ * import { MenuItemBehavior } from '@/mixins/menu-behavior.mixin';
+ *
+ * @Component({
+ *  tag: 'my-menu-item',
+ *  styleUrl: 'my-menu-item.scss',
+ * })
+ * export class MyMenuItem extends Mixin(MenuItemBehavior) {
+ *   @Element() el!: HTMLElement;
+ *   @Prop() disabled: boolean = false;
+ *   @Prop() selected: boolean = false;
+ *
+ *   private handleKeyDown = (e: KeyboardEvent) => {
+ *     if (this.disabled) return;
+ *     this.handleKeyDownLogic(e, () => this.handleSelection());
+ *   };
+ *
+ *  render() {
+ *   return (
+ *    <Host
+ *      role={this.menuItemRole}
+ *      aria-selected={this.ariaSelected}
+ *      tabIndex={ this.itemTabIndex}
+ *      onKeyDown={this.handleKeyDown} >
+ *      <slot />
+ *    </Host>
+ *   );
+ *  }
+ * } ```
+ *
+ *
+ */
+export declare const MenuItemBehavior: <B extends MixedInCtor>(Base: B) => {
+    new (...args: any[]): {
+        el: HTMLElement;
+        disabled: boolean;
+        selected: boolean;
+        activeItem: boolean;
+        /**
+         * Detects the ARIA role of the nearest parent menu or listbox.
+         * @returns {MenuRole | null} - 'menu', 'listbox', or null if not found.
+         */
+        readonly parentRole: MenuRole | null;
+        /**
+         * Resolves the specific item role ('menuitem' or 'option').
+         * Defaults to 'menuitem' if no parent is detected.
+         * @returns {MenuItemRole}
+         */
+        readonly menuItemRole: MenuItemRole;
+        /**
+         * Returns the 'aria-selected' value as a string for listbox options.
+         * @returns {string | null}
+         */
+        readonly ariaSelected: string | null;
+        /**
+         * Calculates the tabIndex for the item.
+         * @returns {number} 0 for focusable menu items, -1 otherwise.
+         */
+        readonly itemTabIndex: number;
+        /**
+         * Processes keyboard events for arrow navigation and activation.
+         * @param {KeyboardEvent} e - The native keyboard event.
+         * @param {() => void} onActivate - Function to execute when Enter or Space is pressed.
+         * @example
+         * // Inside a component's keydown listener:
+         * this.handleKeyDownLogic(event, () => this.emitSelection());
+         */
+        handleKeyDownLogic(e: KeyboardEvent, onActivate: () => void): void;
+    };
+} & B;
+//# sourceMappingURL=menu-behavior.mixin.d.ts.map

package/dist/types/services/floating/index.d.ts

@@ -0,0 +1,4 @@
+export * from './positioning.service';
+export * from './interfaces';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/services/floating/interfaces/Anchored.d.ts

@@ -0,0 +1,7 @@
+import { FloatingHooks } from './Floating';
+export interface AnchoredHooks extends FloatingHooks {
+    onBeforeLoad?: (el?: HTMLElement) => void;
+    onAfterLoad?: (el?: HTMLElement) => void;
+    subscribeToTrigger?: (el?: HTMLElement) => void;
+}
+//# sourceMappingURL=Anchored.d.ts.map

package/dist/types/services/floating/interfaces/Backdrop.d.ts

@@ -0,0 +1,5 @@
+import { FloatingHooks } from './Floating';
+export interface BackdropHooks extends FloatingHooks {
+    onBeforeClose?: (el?: HTMLElement) => void;
+}
+//# sourceMappingURL=Backdrop.d.ts.map

package/dist/types/services/floating/interfaces/Floating.d.ts

@@ -1,6 +1,6 @@
 import { Placement, Strategy } from '@floating-ui/dom';
 import { PositioningResult } from './Positioning';
-import { FloatingAnchoredProp } from './Props';
+import { FloatingProp } from './Props';
 /**
  * Add methods to the `onBeforeShow`, `onAfterShow`, `onBeforeHide`, and `onAfterHide` to add custom logic.
  * Pass the element to the method to get the reference to the floating element.
@@ -31,7 +31,7 @@ export interface FloatingMixinOptions {
  * The mixin could provide a getter to able the developer override values.
  */
 export interface IFloatingMixin extends FloatingHooks {
-    floatingOptions: FloatingAnchoredProp;
+    floatingOptions?: FloatingProp;
     get options(): FloatingMixinOptions;
     get hooks(): FloatingHooks;
 }

package/dist/types/services/floating/interfaces/Props.d.ts

@@ -1,4 +1,4 @@
-import { Position } from "../../../types/position";
+import { PopoverPosition, Position } from "../../../types/position";
 import { Arrow } from '../types/Arrow';
 import { FloatingHooks, FloatingMixinOptions } from './Floating';
 /**
@@ -28,8 +28,9 @@ export interface FloatingTooltipProp extends FloatingAnchoredProp {
  * add closeOnClick prop to close the popover when the trigger element is clicked.
  * add clickOutside prop to close the popover when the user click outside the popover.
  */
-export interface FloatingPopoverProp extends FloatingAnchoredProp {
+export interface FloatingPopoverProp extends Omit<FloatingAnchoredProp, 'placement'> {
     closeOnClick?: boolean;
-    clickOutside?: boolean;
+    closeOnClickOutside?: boolean;
+    placement?: PopoverPosition;
 }
 //# sourceMappingURL=Props.d.ts.map

package/dist/types/services/floating/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Floating';
+export * from './Props';
+export * from './Anchored';
+export * from './Positioning';
+export * from './Backdrop';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/services/floating/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Arrow';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './floating';
+export * from './logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/services/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/IFormProps.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Interface that define and centralize some props to the form components.
+ * In this way we standardize the props and avoid repetition.
+ * @public
+ * @interface IFormProps
+ * @augments {IFormProps}
+ * @property {string} name - Name of the form control, submitted as a key in the form data.
+ * @property {boolean} disabled - Disables the control. Defaults to `false`.
+ * @property {boolean} required - Marks the control as required for form submission. Defaults to `false`.
+ * @property {string} info - Tooltip content attached to the label. Rendered via `bds-typography` `tooltipText` prop.
+ * @property {boolean} error - When `true`, applies the error visual state.
+ * @property {string} errorMessage - Message shown below the input when `error` is `true`. Replaces `helperText`.
+ * @property {string} label - Label displayed next to the input. Defaults to `""`.
+ * @property {string} helperText - Help text displayed below the input. Defaults to `""`.
+ * @example
+ * export interface IToggle extends IFormProps {}
+ */
+export interface IFormProps {
+    info?: string;
+    error?: boolean;
+    errorMessage?: string;
+    label?: string;
+    helperText?: string;
+}
+//# sourceMappingURL=IFormProps.d.ts.map

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

@@ -1,4 +1,3 @@
-export type ValidationTiming = 'blur' | 'input' | 'submit';
 export interface IFormValidator {
     key: keyof ValidityStateFlags;
     isValid: (el: HTMLElement) => boolean;

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

@@ -3,4 +3,7 @@ export * from './form';
 export * from './size';
 export * from './states';
 export * from './stylesMap';
+export * from './IFormProps';
+export * from './menu';
+export * from './links';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/types/links.d.ts

@@ -0,0 +1,14 @@
+export type LinksAttrs = {
+    href?: string;
+    target?: string;
+    rel?: string;
+    download?: string;
+    role?: string;
+    tabindex?: string;
+};
+export interface IWithLinks {
+    href: string;
+    newTab: boolean;
+    download: string;
+}
+//# sourceMappingURL=links.d.ts.map

package/dist/types/types/menu.d.ts

@@ -0,0 +1,16 @@
+export declare const MENU_ROLES: {
+    readonly MENU: "menu";
+    readonly LISTBOX: "listbox";
+};
+export type MenuRole = (typeof MENU_ROLES)[keyof typeof MENU_ROLES];
+export declare const MENU_ITEM_ROLES: {
+    readonly MENUITEM: "menuitem";
+    readonly OPTION: "option";
+};
+export type MenuItemRole = (typeof MENU_ITEM_ROLES)[keyof typeof MENU_ITEM_ROLES];
+export interface IMenuBehavior {
+    disabled: boolean;
+    selected: boolean;
+    activeItem: boolean;
+}
+//# sourceMappingURL=menu.d.ts.map

package/dist/types/types/position.d.ts

@@ -9,5 +9,16 @@ export declare const POSITION: {
     readonly LEFT: "left";
     readonly RIGHT: "right";
 };
+export declare const POPOVER_POSITION: {
+    readonly TOP_START: "top-start";
+    readonly BOTTOM_START: "bottom-start";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+    readonly TOP_END: "top-end";
+    readonly BOTTOM_END: "bottom-end";
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+};
 export type Position = (typeof POSITION)[keyof typeof POSITION];
+export type PopoverPosition = (typeof POPOVER_POSITION)[keyof typeof POPOVER_POSITION];
 //# sourceMappingURL=position.d.ts.map

package/dist/types/utils/constants/common/Aria.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type for aria-label values used across components.
+ */
+type AriaLabels = {
+    [key: string]: string;
+};
+/**
+ * Centralized list of `aria-label` values used by interactive elements.
+ * Add new entries to the `ARIA_LABELS` object to keep labels consistent
+ * and prevent typos across the design system.
+ */
+export declare const ARIA_LABELS: AriaLabels;
+export {};
+//# sourceMappingURL=Aria.d.ts.map

package/dist/types/utils/constants/common/Icons.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type for icon font-class names used across components.
+ */
+type Icons = {
+    [key: string]: string;
+};
+/**
+ * Centralized list of icon font-class names used by design-system components.
+ * Add new entries to the `ICONS` object to keep class names consistent
+ * and prevent typos across the design system.
+ */
+export declare const ICONS: Icons;
+export {};
+//# sourceMappingURL=Icons.d.ts.map