@ds-mo/ui 16.1.3 → 16.2.0

package/dist/types/components/Drawer/Drawer.d.ts

@@ -0,0 +1,123 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export type DrawerSide = 'end' | 'start';
+export type DrawerWidth = 'sm' | 'md' | 'lg';
+export type DrawerBodyInset = 'default' | 'none';
+export type DrawerCloseReason = 'close-button' | 'escape' | 'backdrop' | 'replaced';
+export interface DrawerCloseDetail {
+    reason: DrawerCloseReason;
+    originalEvent?: globalThis.Event;
+}
+export interface DrawerAfterCloseDetail {
+    /**
+     * True when the owner should place focus, typically on the record now shown.
+     * False when another drawer replaced this one, or a modal drawer already
+     * returned focus to its trigger.
+     */
+    restoreFocus: boolean;
+}
+export declare class Drawer {
+    el: HTMLElement;
+    open: boolean;
+    /** Generic label for what the drawer shows, such as "Event details". Record identity belongs in the body. */
+    heading: string;
+    /**
+     * Block the page behind a shade and contain focus. The default non-modal
+     * drawer leaves the page interactive beside it.
+     */
+    modal: boolean;
+    /** Edge the panel attaches to. */
+    side: DrawerSide;
+    /** Panel width token (`sm`, `md`, `lg`) or a CSS length. Narrow viewports use the full width. */
+    drawerWidth: DrawerWidth | string;
+    /** `none` removes the body inset for content that owns its own edges. */
+    bodyInset: DrawerBodyInset;
+    /** When set, shows a leading Back action for multi-depth content and emits dsBack. */
+    backLabel: string | undefined;
+    closeAriaLabel: string;
+    /** Shows Previous and Next record actions at the end of the footer. */
+    navigation: boolean;
+    previousAvailable: boolean;
+    nextAvailable: boolean;
+    previousAriaLabel: string;
+    nextAriaLabel: string;
+    navigationAriaLabel: string;
+    /** Suspends Left/Right record paging, for example while a menu in the drawer is open. */
+    navigationShortcutsBlocked: boolean;
+    /** Optional id reference for explanatory content in the body. */
+    ariaDescribedby: string | undefined;
+    private closing;
+    private shown;
+    private hasFooterActions;
+    private hasHeaderActions;
+    /** Emitted when the drawer requests to close; open is already false. */
+    dsClose: EventEmitter<DrawerCloseDetail>;
+    /** Emitted after exit motion completes. */
+    dsAfterClose: EventEmitter<DrawerAfterCloseDetail>;
+    /** Emitted when the leading Back action is activated. The owner swaps heading and body. */
+    dsBack: EventEmitter<MouseEvent>;
+    /** Emitted by the Previous action or ArrowLeft while navigation is shown and available. */
+    dsPrevious: EventEmitter<void>;
+    /** Emitted by the Next action or ArrowRight while navigation is shown and available. */
+    dsNext: EventEmitter<void>;
+    private titleId;
+    private dialogEl;
+    private previousFocus;
+    private closeTimer;
+    private loaded;
+    private openedAsModal;
+    private replaced;
+    private documentListening;
+    private readonly tasks;
+    private slotObserver?;
+    private bodyEl;
+    private headerActionsEl;
+    private footerActionsEl;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    onOpenChange(isOpen: boolean): void;
+    onModalChange(): void;
+    /** Drilling in or out moves focus to the action that now leads the header. */
+    onBackLabelChange(next: string | undefined, previous: string | undefined): void;
+    private present;
+    /** Closes because another non-modal drawer opened; that drawer owns focus. */
+    private replace;
+    private releaseActive;
+    private get isSurfaceOpen();
+    private hideSurface;
+    private focusLeadingAction;
+    private clearCloseTimer;
+    private requestClose;
+    private startDocumentListeners;
+    private stopDocumentListeners;
+    /** A modal surface other than this drawer owns the keyboard. */
+    private get coveredByOtherModal();
+    /** Non-modal Escape works from anywhere in the page, after inner surfaces had their turn. */
+    private readonly handleDocumentKeyDown;
+    /** Captures Left/Right ahead of row and grid handlers so paging works from the page too. */
+    private readonly handleDirectionalKeyDown;
+    private page;
+    private hasAssignedContent;
+    private updateSlotPresence;
+    private namedSlotContainer;
+    /**
+     * Scoped slots only place direct host children, and only during render.
+     * Frameworks insert conditional content after first render, for example an
+     * Angular @if around footer actions, next to an anchor that Stencil already
+     * moved into the body. Move named-slot elements that arrive on the host or
+     * directly in the body into their slot container. Deeper elements belong to
+     * nested components and are left alone.
+     */
+    private placeSlottedContent;
+    private observeSlottedContent;
+    private handleCancel;
+    private handleBackdropPointerDown;
+    private handleDialogKeyDown;
+    private get resolvedWidth();
+    private get closeAnimationMs();
+    private finishClose;
+    private renderIconAction;
+    render(): any;
+}
+//# sourceMappingURL=Drawer.d.ts.map

package/dist/types/components/Popover/Popover.d.ts

@@ -0,0 +1,64 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { AnchoredAlign, AnchoredSide } from '../../utils/anchored-position';
+export type PopoverSide = AnchoredSide;
+export type PopoverAlign = AnchoredAlign;
+export type PopoverWidth = 'xs' | 'sm' | 'md' | 'lg';
+export type PopoverCloseReason = 'escape' | 'outside' | 'tab';
+export interface PopoverCloseDetail {
+    reason: PopoverCloseReason;
+    /** The triggering event; absent for outside activation, which the shared controller observes. */
+    originalEvent?: Event;
+}
+export declare class Popover {
+    el: HTMLElement;
+    open: boolean;
+    /** External trigger element to position against. Set via JS: popoverEl.anchor = buttonEl */
+    anchor: HTMLElement | undefined;
+    /** ID of the external trigger element for positioning. */
+    anchorId: string | undefined;
+    /** Preferred side; placement flips to the opposite side when that offers a better fit. */
+    side: PopoverSide;
+    align: PopoverAlign;
+    /** Gap between anchor and popover — number (px) or TokoMo length. */
+    sideOffset: number | string;
+    /** Explicit collision owner; otherwise the nearest data-ds-overlay-boundary ancestor is used. */
+    boundary: HTMLElement | undefined;
+    /**
+     * Menu width token (`xs`, `sm`, `md`, `lg`) or a CSS length. Unset, the surface
+     * follows its content between the menu-width-xs and panel-width-lg bounds.
+     */
+    popoverWidth: PopoverWidth | string | undefined;
+    /** Accessible name for the dialog surface. */
+    popoverLabel: string;
+    private shouldRender;
+    private closing;
+    private positionReady;
+    private pos;
+    private availableHeight;
+    /** Emitted when the user dismisses the popover. The component sets open to false. */
+    dsClose: EventEmitter<PopoverCloseDetail>;
+    /** Emitted after exit motion completes. */
+    dsAfterClose: EventEmitter<void>;
+    private readonly popupId;
+    private closeTimer;
+    private loaded;
+    private readonly tasks;
+    private readonly position;
+    private readonly interaction;
+    componentDidLoad(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onOpenChange(isOpen: boolean): void;
+    onPlacementChange(): void;
+    private get resolvedAnchor();
+    private get popupEl();
+    private get viewportPadPx();
+    private get resolvedWidth();
+    private teardown;
+    private focusInitial;
+    private close;
+    private finishClose;
+    private handleKeyDown;
+    render(): any;
+}
+//# sourceMappingURL=Popover.d.ts.map