epic-modals 0.0.10 → 1.0.0

package/dist/core/modal/Interactions.d.ts

@@ -0,0 +1,67 @@
+import { ResizeDirection } from '../behaviors/resize';
+import { ModalFeatures } from '../types';
+
+export interface InteractionConfigHelper {
+    isFeatureEnabled: (feature: keyof ModalFeatures) => boolean;
+}
+
+export interface InteractionDragBehavior {
+    onPointerDown: (e: PointerEvent, element: HTMLElement) => void;
+    onPointerMove: (e: PointerEvent, modalSize: {
+        width: number;
+        height: number;
+    }) => void;
+    onPointerUp: (e: PointerEvent, element: HTMLElement) => void;
+    isDragging: () => boolean;
+    getPosition: () => {
+        x: number;
+        y: number;
+    };
+    hasBeenDragged: () => boolean;
+}
+
+export interface InteractionResizeBehavior {
+    startResize: (e: PointerEvent, direction: ResizeDirection) => void;
+    hasBeenResized: () => boolean;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    justFinishedResizing: () => boolean;
+}
+
+export interface InteractionState {
+    hasChild: boolean;
+}
+export interface ModalInteractionsOptions {
+    id: string;
+    configHelper: InteractionConfigHelper;
+    getDragBehavior: () => InteractionDragBehavior;
+    getResizeBehavior: () => InteractionResizeBehavior;
+    getElement: () => HTMLElement | null;
+    getState: () => InteractionState;
+    onDragMove: () => void;
+    onDragEnd: () => void;
+    onClose?: () => void;
+    closeOnEscape?: boolean;
+    isTopModal: () => boolean;
+}
+export declare class ModalInteractions {
+    private options;
+    constructor(options: ModalInteractionsOptions);
+    
+    startDrag(e: PointerEvent): void;
+    
+    startResize(e: PointerEvent, direction: ResizeDirection): void;
+    
+    handlePointerMove(e: PointerEvent): void;
+    
+    handlePointerUp(e: PointerEvent): void;
+    
+    handleKeyDown(e: KeyboardEvent): void;
+    
+    handleTabKey(e: KeyboardEvent): void;
+    
+    focusFirst(): void;
+}
+//# sourceMappingURL=Interactions.d.ts.map

package/dist/core/modal/Lifecycle.d.ts

@@ -0,0 +1,20 @@
+export interface ModalLifecycleOptions {
+    onMount?: () => void;
+    onDestroy?: () => void;
+    onWindowResize?: () => void;
+}
+export declare class ModalLifecycle {
+    private element;
+    private resizeHandler;
+    private options;
+    constructor(options?: ModalLifecycleOptions);
+    
+    mount(element: HTMLElement): void;
+    
+    destroy(): void;
+    
+    getElement(): HTMLElement | null;
+    
+    isMounted(): boolean;
+}
+//# sourceMappingURL=Lifecycle.d.ts.map

package/dist/core/modal/Positioning.d.ts

@@ -0,0 +1,40 @@
+import { ModalId, Dimensions } from '../types';
+import { DragBehavior } from '../behaviors/drag';
+import { PositioningConfig } from '../config';
+
+export interface PositioningConfigHelper {
+    getPositioning: <K extends keyof PositioningConfig>(key: K) => PositioningConfig[K];
+}
+export interface ModalPositioningOptions {
+    
+    id: ModalId;
+    
+    dataId: string;
+    
+    configHelper: PositioningConfigHelper;
+    
+    getDragBehavior: () => DragBehavior;
+    
+    getElement: () => HTMLElement | null;
+}
+export declare class ModalPositioning {
+    private id;
+    private dataId;
+    private configHelper;
+    private getDragBehavior;
+    private getElement;
+    constructor(options: ModalPositioningOptions);
+    
+    constrainToViewport(size: Dimensions): void;
+    
+    shouldApplySmartPositioning(): boolean;
+    
+    applySmartPositioning(): boolean;
+    
+    scheduleSmartPositioning(): void;
+    
+    centerChildOnParent(parentId: ModalId): boolean;
+    
+    scheduleCenterChildOnParent(parentId: ModalId): void;
+}
+//# sourceMappingURL=Positioning.d.ts.map

package/dist/core/modal/StateManager.d.ts

@@ -0,0 +1,91 @@
+import { ModalId, Position } from '../types';
+import { DragBehavior } from '../behaviors/drag';
+import { ResizeBehavior } from '../behaviors/resize';
+import { AnimationController } from '../animation/controller';
+
+export interface StateManagerPositioning {
+    centerChildOnParent: (parentId: ModalId) => boolean;
+    scheduleCenterChildOnParent: (parentId: ModalId) => void;
+    applySmartPositioning: () => void;
+    scheduleSmartPositioning: () => void;
+}
+export interface ModalStateManagerOptions {
+    
+    id: ModalId;
+    
+    options: {
+        glow?: unknown;
+        openSourcePosition?: Position | null;
+        onClose?: () => void;
+    };
+    
+    getDragBehavior: () => DragBehavior;
+    
+    getResizeBehavior: () => ResizeBehavior;
+    
+    getAnimationController: () => AnimationController;
+    
+    getElement: () => HTMLElement | null;
+    
+    getPositioning: () => StateManagerPositioning;
+    
+    onStateChange: () => void;
+    
+    focusFirst: () => void;
+}
+export declare class ModalStateManager {
+    private id;
+    private options;
+    private _isHandlingMinimize;
+    private _isAttentionAnimating;
+    private _wasRestored;
+    private _glowStabilizing;
+    private _restoreHold;
+    private _isAnimatingToCenter;
+    private _cancelParentAnimationCleanup;
+    private _parentFlipInFlight;
+    private _deferredParentTarget;
+    private _parentFlipStartTime;
+    constructor(options: ModalStateManagerOptions);
+    
+    handlePendingStates(): void;
+    
+    private handlePendingForceClose;
+    
+    private handlePendingMinimize;
+    
+    private handlePendingMinimizeWithParent;
+    
+    private handlePendingRestore;
+    
+    private handlePendingChildRestore;
+    
+    private handlePendingClose;
+    
+    private handlePendingParentLink;
+    
+    private handlePendingOpen;
+    
+    private openChildModalWithAnimation;
+    
+    private openStandaloneModalWithAnimation;
+    
+    private handlePendingAttention;
+    
+    private handlePendingParentAnimation;
+    
+    private startParentFlip;
+    
+    private handleChildCentering;
+    get wasRestored(): boolean;
+    set wasRestored(value: boolean);
+    get isAttentionAnimating(): boolean;
+    get glowStabilizing(): boolean;
+    set glowStabilizing(value: boolean);
+    get restoreHold(): boolean;
+    set restoreHold(value: boolean);
+    get isAnimatingToCenter(): boolean;
+    set isAnimatingToCenter(value: boolean);
+    get isHandlingMinimize(): boolean;
+}
+//# sourceMappingURL=StateManager.d.ts.map

package/dist/core/modal/Styling.d.ts

@@ -0,0 +1,42 @@
+import { Position, Dimensions, ModalGlow, AnimationTransform } from '../types';
+export interface ComputeStyleInput {
+    position: Position;
+    hasBeenDragged: boolean;
+    hasBeenResized: boolean;
+    size: Dimensions;
+    animationTransform: AnimationTransform | null;
+    zIndex: number;
+    glowEnabled: boolean;
+    glow: ModalGlow | null;
+    maxWidth: string | undefined;
+    preferredHeight: string | undefined;
+    
+    isAnimatingPosition?: boolean;
+}
+export interface ComputeCssClassesInput {
+    isDragging: boolean;
+    isResizing: boolean;
+    hasBeenDragged: boolean;
+    isMinimizing: boolean;
+    isRestoring: boolean;
+    isOpening: boolean;
+    isClosing: boolean;
+    showCentered: boolean;
+    isTransparent: boolean;
+    glowEnabled: boolean;
+    hasChild: boolean;
+    isChildModal: boolean;
+    wasRestored: boolean;
+    isVisibleByAnimation: boolean;
+    isAwaitingRestore: boolean;
+    isAwaitingChildOpen: boolean;
+    isAnimatingToCenter: boolean;
+    isAnimatingPosition: boolean;
+    isAttentionAnimating: boolean;
+    glowStabilizing: boolean;
+}
+
+export declare function computeStyle(input: ComputeStyleInput): Record<string, string | number>;
+
+export declare function computeCssClasses(input: ComputeCssClassesInput): string[];
+//# sourceMappingURL=Styling.d.ts.map

package/dist/core/modal/index.d.ts

@@ -0,0 +1,8 @@
+
+export * from './Controller';
+export * from './Lifecycle';
+export * from './Styling';
+export * from './Positioning';
+export * from './Interactions';
+export * from './StateManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/state/effects.d.ts

@@ -0,0 +1,16 @@
+import { ModalId } from '../types';
+
+export declare function toggleModalTransparency(id: ModalId): void;
+
+export declare function triggerAttention(id: ModalId): void;
+
+export declare function shakeElement(element: HTMLElement): void;
+
+export declare function triggerRejection(id: ModalId): void;
+
+export declare function resetModalTransparency(id: ModalId): void;
+
+export declare function startAttentionAnimation(_id: ModalId): void;
+
+export declare function endAttentionAnimation(_id: ModalId): void;
+//# sourceMappingURL=effects.d.ts.map

package/dist/core/state/events.d.ts

@@ -0,0 +1,15 @@
+
+export type EventCallback<T = void> = (data: T) => void;
+
+export declare function createEventEmitter<T>(): {
+    
+    on<K extends keyof T>(event: K, callback: EventCallback<T[K]>): () => void;
+    
+    emit<K extends keyof T>(event: K, data: T[K]): void;
+    
+    off<K extends keyof T>(event?: K): void;
+    
+    listenerCount<K extends keyof T>(event: K): number;
+};
+export type EventEmitter<T> = ReturnType<typeof createEventEmitter<T>>;
+//# sourceMappingURL=events.d.ts.map

package/dist/core/state/getters.d.ts

@@ -0,0 +1,37 @@
+import { ModalState, ModalId, Position } from '../types';
+import { ModalLayoutInfo, ModalBounds } from '../utils/viewport';
+import { getStateVersion, subscribe } from './internal';
+export { getStateVersion, subscribe };
+
+export declare function getModalState(id: ModalId): ModalState | undefined;
+
+export declare function isModalOpen(id: ModalId): boolean;
+
+export declare function isModalRegistered(id: ModalId): boolean;
+
+export declare function isModalAnimating(id: ModalId): boolean;
+
+export declare function setModalAnimating(id: ModalId, animating: boolean): void;
+
+export declare function getModalsStore(): Map<ModalId, ModalState>;
+
+export declare function getDockOrder(): ModalId[];
+
+export declare function getDockItemElement(id: ModalId): HTMLElement | null;
+
+export declare function getModalLayoutInfos(): ModalLayoutInfo[];
+
+export declare function getOpenModalBounds(excludeId?: ModalId): ModalBounds[];
+
+export declare function getMinimizedModals(): ModalState[];
+
+export declare function getOpenSourcePositionFromState(id: ModalId): Position | null;
+
+export declare function getOpenModalBoundsWithIds(excludeId?: ModalId): Array<{
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+//# sourceMappingURL=getters.d.ts.map

package/dist/core/state/index.d.ts

@@ -0,0 +1,17 @@
+
+export { batchUpdates, getStateVersion, subscribe, setDockPositionGetterInternal, setRegistryCallbacksInternal, setURLCallbacks, _resetInternalState, _getInternalState, type URLStateCallbacks, type RegistryCallbacks, type DockPositionGetter, } from './internal';
+export { registerModal, unregisterModal, createModalRegistration, type CreateModalRegistrationProps, } from './registration';
+export { minimizeModal, restoreModal, restoreAllMinimizedModals, restoreChildModal, unhideChildModal, finalizeChildMinimize, hideChildWithParent, clearPendingParentAnimation, } from './minimize';
+export { bringToFront, isTopModal, reorderDock, } from './zindex';
+export { updateModalPosition, clearPositionAnimation, updateModalSize, updateModal, } from './position';
+export { openModal, openChildModal, createModal, closeModal, closeAllModals, finalizeModalClose, getModalsToClose, type OpenModalOptions, } from './open-close';
+export { hasPendingMinimize, consumePendingMinimize, hasPendingMinimizeWithParent, consumePendingMinimizeWithParent, hasPendingOpen, consumePendingOpen, hasPendingClose, consumePendingClose, hasPendingForceClose, consumePendingForceClose, hasPendingRestore, consumePendingRestore, hasPendingChildRestore, consumePendingChildRestore, hasPendingAttention, consumePendingAttention, clearActiveAttention, hasPendingParentLinkFor, hasPendingParentAnimation, consumePendingParentAnimation, storeOpenSourcePosition, getOpenSourcePosition, consumeOpenSourcePosition, consumePendingMinimizeTarget, consumePendingParentLink, } from './pending';
+export { getModalState, isModalOpen, isModalRegistered, isModalAnimating, setModalAnimating, getModalsStore, getDockOrder, getDockItemElement, getModalLayoutInfos, getOpenModalBounds, getOpenModalBoundsWithIds, getMinimizedModals, } from './getters';
+export { toggleModalTransparency, triggerAttention, shakeElement, triggerRejection, resetModalTransparency, startAttentionAnimation, endAttentionAnimation, } from './effects';
+export { triggerRearrangement, applyLayoutPositions, animateModalsToPositions, handleWindowResize, initializeResizeListener, cleanupResizeListener, } from './layout';
+export { linkModals, getPendingParentLink, triggerCascadingParentAnimations, getPendingParentAnimation, calculateChildCenterPosition, } from './parent-child';
+export * from './stacking';
+export * from './events';
+export { setURLCallbacks as setURLStateCallbacks } from './internal';
+export { setRegistryCallbacksInternal as setRegistryFunctions } from './internal';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/state/internal.d.ts

@@ -0,0 +1,105 @@
+import { ModalState, ModalId, Position, Dimensions, AnimationTransform } from '../types';
+
+export interface URLStateCallbacks {
+    push: (id: ModalId) => void;
+    replace: (id: ModalId) => void;
+    pop: () => void;
+}
+
+export type DockPositionGetter = () => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+export interface RegistryCallbacks {
+    mountModal: (id: ModalId) => void;
+    isRegisteredInRegistry: (id: ModalId) => boolean;
+    unmountModal: (id: ModalId) => void;
+}
+
+export declare const modals: Map<ModalId, ModalState>;
+
+export declare let rearrangementTimeout: ReturnType<typeof setTimeout> | null;
+export declare function setRearrangementTimeout(timeout: ReturnType<typeof setTimeout> | null): void;
+
+export declare let resizeTimeout: ReturnType<typeof setTimeout> | null;
+export declare function setResizeTimeout(timeout: ReturnType<typeof setTimeout> | null): void;
+export declare let pendingMinimize: ModalId[];
+export declare let pendingOpen: ModalId[];
+export declare let pendingClose: ModalId[];
+export declare let pendingForceClose: ModalId[];
+export declare let pendingRestore: ModalId[];
+export declare let pendingChildRestore: ModalId[];
+export declare let pendingMinimizeWithParent: ModalId[];
+export declare let pendingAttention: ModalId[];
+export declare let activeAttention: ModalId[];
+
+export declare let pendingMinimizeTarget: AnimationTransform | null;
+export declare function setPendingMinimizeTarget(target: AnimationTransform | null): void;
+
+export declare const openSourcePositions: Map<ModalId, Position>;
+
+export declare let pendingParentLink: {
+    parentId: ModalId;
+    childId: ModalId;
+} | null;
+export declare function setPendingParentLink(link: {
+    parentId: ModalId;
+    childId: ModalId;
+} | null): void;
+
+export declare const pendingParentAnimations: Map<ModalId, Position>;
+
+export declare const animatingModals: Set<ModalId>;
+
+export declare const closingModals: Set<ModalId>;
+
+export declare const transparentModals: Set<ModalId>;
+
+export declare let dockOrder: ModalId[];
+export declare function setDockOrder(order: ModalId[]): void;
+export declare let urlCallbacks: URLStateCallbacks | null;
+export declare function setURLCallbacks(callbacks: URLStateCallbacks | null): void;
+export declare let dockPositionGetter: DockPositionGetter | null;
+export declare function setDockPositionGetterInternal(getter: DockPositionGetter | null): void;
+export declare let registryCallbacks: RegistryCallbacks | null;
+export declare function setRegistryCallbacksInternal(callbacks: RegistryCallbacks | null): void;
+export declare function setPendingMinimize(arr: ModalId[]): void;
+export declare function setPendingOpen(arr: ModalId[]): void;
+export declare function setPendingClose(arr: ModalId[]): void;
+export declare function setPendingForceClose(arr: ModalId[]): void;
+export declare function setPendingRestore(arr: ModalId[]): void;
+export declare function setPendingChildRestore(arr: ModalId[]): void;
+export declare function setPendingMinimizeWithParent(arr: ModalId[]): void;
+export declare function setPendingAttention(arr: ModalId[]): void;
+export declare function setActiveAttention(arr: ModalId[]): void;
+
+export declare function incrementVersion(): void;
+
+export declare function getStateVersion(): number;
+
+export declare function subscribe(callback: () => void): () => void;
+
+export declare function batchUpdates(callback: () => void): void;
+
+export declare function validatePosition(position: Position, context: string): void;
+
+export declare function validateDimensions(size: Dimensions, context: string): void;
+
+export declare function warnIfUnregistered(id: ModalId, method: string): boolean;
+
+export declare function _resetInternalState(): void;
+
+export declare function _getInternalState(): {
+    modals: Map<string, ModalState>;
+    pendingMinimize: string[];
+    pendingOpen: string[];
+    pendingClose: string[];
+    pendingRestore: string[];
+    dockOrder: string[];
+    animatingModals: Set<string>;
+    transparentModals: Set<string>;
+};
+//# sourceMappingURL=internal.d.ts.map

package/dist/core/state/layout.d.ts

@@ -0,0 +1,17 @@
+import { Position } from '../types';
+
+export declare function triggerRearrangement(newModal: {
+    id: string;
+    width: number;
+    height: number;
+} | null): void;
+
+export declare function applyLayoutPositions(positions: Map<string, Position>): void;
+
+export declare function handleWindowResize(): void;
+export declare function initializeResizeListener(): void;
+
+export declare function cleanupResizeListener(): void;
+
+export declare function animateModalsToPositions(moves: Map<string, Position>): void;
+//# sourceMappingURL=layout.d.ts.map

package/dist/core/state/minimize.d.ts

@@ -0,0 +1,18 @@
+import { ModalId } from '../types';
+
+export declare function clearPendingParentAnimation(parentId: ModalId): void;
+
+export declare function minimizeModal(id: ModalId): void;
+
+export declare function restoreModal(id: ModalId): void;
+
+export declare function restoreAllMinimizedModals(): void;
+
+export declare function restoreChildModal(id: ModalId): void;
+
+export declare function unhideChildModal(id: ModalId): void;
+
+export declare function finalizeChildMinimize(id: ModalId): void;
+
+export declare function hideChildWithParent(parentId: ModalId): void;
+//# sourceMappingURL=minimize.d.ts.map

package/dist/core/state/open-close.d.ts

@@ -0,0 +1,21 @@
+import { ModalId, ModalState, Position } from '../types';
+
+export interface OpenModalOptions {
+    
+    parentId?: ModalId;
+}
+
+export declare function openChildModal(childId: ModalId, parentId: ModalId, source: HTMLElement | Position): void;
+
+export declare function openModal(id: ModalId, source: HTMLElement | Position, options?: OpenModalOptions): void;
+
+export declare function createModal(modal: Omit<ModalState, 'zIndex' | 'isAnimating'>): void;
+
+export declare function closeModal(id: ModalId, force?: boolean): void;
+
+export declare function closeAllModals(exclude?: ModalId[]): void;
+
+export declare function finalizeModalClose(id: ModalId): void;
+
+export declare function getModalsToClose(fromIdOrExclude: ModalId | ModalId[]): ModalId[];
+//# sourceMappingURL=open-close.d.ts.map

package/dist/core/state/parent-child.d.ts

@@ -0,0 +1,17 @@
+import { ModalId, Position } from '../types';
+
+export declare function linkModals(parentId: ModalId, childId: ModalId, offset: Position): void;
+
+export declare function getPendingParentLink(): {
+    parentId: ModalId;
+    childId: ModalId;
+} | null;
+
+export declare function triggerCascadingParentAnimations(childId: ModalId): void;
+
+export declare function getPendingParentAnimation(id: ModalId): Position | null;
+
+export declare function clearPendingParentAnimation(id: ModalId): void;
+
+export declare function calculateChildCenterPosition(parentId: ModalId, childWidth: number, childHeight: number): Position | null;
+//# sourceMappingURL=parent-child.d.ts.map

package/dist/core/state/pending.d.ts

@@ -0,0 +1,55 @@
+import { ModalId, AnimationTransform, Position } from '../types';
+
+export declare function hasPendingMinimize(id: ModalId): boolean;
+
+export declare function consumePendingMinimize(id: ModalId): AnimationTransform | null;
+
+export declare function hasPendingMinimizeWithParent(id: ModalId): boolean;
+
+export declare function consumePendingMinimizeWithParent(id: ModalId): void;
+
+export declare function hasPendingOpen(id: ModalId): boolean;
+
+export declare function consumePendingOpen(id: ModalId): void;
+
+export declare function hasPendingClose(id: ModalId): boolean;
+
+export declare function consumePendingClose(id: ModalId): void;
+
+export declare function hasPendingForceClose(id: ModalId): boolean;
+
+export declare function consumePendingForceClose(id: ModalId): void;
+
+export declare function hasPendingRestore(id: ModalId): boolean;
+
+export declare function consumePendingRestore(id: ModalId): void;
+
+export declare function hasPendingChildRestore(id: ModalId): boolean;
+
+export declare function consumePendingChildRestore(id: ModalId): void;
+
+export declare function hasPendingAttention(id: ModalId): boolean;
+
+export declare function consumePendingAttention(id: ModalId): void;
+
+export declare function clearActiveAttention(id: ModalId): void;
+
+export declare function hasPendingParentLinkFor(id: ModalId): boolean;
+
+export declare function hasPendingParentAnimation(id: ModalId): boolean;
+
+export declare function consumePendingParentAnimation(id: ModalId): Position | null;
+
+export declare function storeOpenSourcePosition(id: ModalId, position: Position): void;
+
+export declare function getOpenSourcePosition(id: ModalId): Position | null;
+
+export declare function consumeOpenSourcePosition(id: ModalId): Position | null;
+
+export declare function consumePendingMinimizeTarget(): AnimationTransform | null;
+
+export declare function consumePendingParentLink(modalId?: ModalId): {
+    parentId: ModalId;
+    childId: ModalId;
+} | null;
+//# sourceMappingURL=pending.d.ts.map

package/dist/core/state/position.d.ts

@@ -0,0 +1,15 @@
+import { ModalId, ModalState, Position, Dimensions } from '../types';
+
+export declare function updateModalPosition(id: ModalId, position: Position, options?: {
+    constrain?: boolean;
+    drag?: boolean;
+    size?: Dimensions;
+    realtime?: boolean;
+}): void;
+
+export declare function clearPositionAnimation(id: ModalId): void;
+
+export declare function updateModalSize(id: ModalId, size: Dimensions): void;
+
+export declare function updateModal(id: ModalId, updates: Partial<ModalState>): void;
+//# sourceMappingURL=position.d.ts.map

package/dist/core/state/registration.d.ts

@@ -0,0 +1,15 @@
+import { ModalState, ModalId, ModalGlow } from '../types';
+
+export interface CreateModalRegistrationProps {
+    id: ModalId;
+    title: string;
+    icon?: string;
+    autoOpen?: boolean;
+    glow?: ModalGlow | null;
+}
+export declare function createModalRegistration(props: CreateModalRegistrationProps): Omit<ModalState, 'zIndex' | 'isAnimating'>;
+
+export declare function registerModal(modal: Omit<ModalState, 'zIndex' | 'isAnimating'>): void;
+
+export declare function unregisterModal(id: ModalId): void;
+//# sourceMappingURL=registration.d.ts.map

package/dist/core/state/stacking.d.ts

@@ -0,0 +1,10 @@
+import { StackingLayerName } from '../types';
+
+export declare function initializeStacking(): void;
+
+export declare function acquireModalZIndex(): number;
+
+export declare function getLayerZIndex(layer: StackingLayerName): number;
+
+export declare function resetStacking(): void;
+//# sourceMappingURL=stacking.d.ts.map

package/dist/core/state/zindex.d.ts

@@ -0,0 +1,8 @@
+import { ModalId } from '../types';
+
+export declare function bringToFront(id: ModalId): void;
+
+export declare function isTopModal(id: ModalId): boolean;
+
+export declare function reorderDock(newOrderOrFromIndex: ModalId[] | number, toIndex?: number): void;
+//# sourceMappingURL=zindex.d.ts.map