modalio 0.9.0

package/dist/index.js

@@ -0,0 +1,874 @@
+import { createContext, useEffect, useContext, useRef, useCallback, useMemo, useReducer } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/adapters.ts
+var radixUiDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  }
+});
+var radixUiDialogContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var radixUiAlertDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  }
+});
+var radixUiAlertDialogContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var shadcnUiDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  onClose: () => {
+    if (!options?.disableClose) {
+      modal.dismiss();
+    }
+  },
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  }
+});
+var shadcnUiDialogContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var shadcnUiAlertDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  onClose: () => {
+    if (!options?.disableClose) {
+      modal.dismiss();
+    }
+  },
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  }
+});
+var shadcnUiAlertDialogContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var shadcnUiSheet = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  onClose: () => {
+    if (!options?.disableClose) {
+      modal.dismiss();
+    }
+  },
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  }
+});
+var shadcnUiSheetContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var shadcnUiPopover = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+      modal.onAnimationEnd();
+    }
+  }
+});
+var shadcnUiDrawer = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  dismissible: !options?.disableClose
+});
+var shadcnUiDrawerContent = (modal) => ({
+  onAnimationEnd: () => {
+    modal.onAnimationEnd();
+  }
+});
+var radixUiSheet = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  }
+});
+var radixUiSheetContent = (modal, options) => ({
+  onAnimationEndCapture: () => {
+    modal.onAnimationEnd();
+  },
+  onEscapeKeyDown: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  },
+  onPointerDownOutside: (e) => {
+    if (options?.disableClose) {
+      e?.preventDefault();
+    } else {
+      modal.dismiss();
+    }
+  }
+});
+var radixUiPopover = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+      modal.onAnimationEnd();
+    }
+  }
+});
+var baseUiDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  dismissible: !options?.disableClose
+});
+var baseUiDialogPortal = (modal) => ({
+  keepMounted: modal.keepMounted
+});
+var baseUiDialogPopup = (modal) => ({
+  onAnimationEnd: () => {
+    modal.onAnimationEnd();
+  }
+});
+var baseUiAlertDialog = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  dismissible: !options?.disableClose
+});
+var baseUiAlertDialogPortal = (modal) => ({
+  keepMounted: modal.keepMounted
+});
+var baseUiAlertDialogPopup = (modal) => ({
+  onAnimationEnd: () => {
+    modal.onAnimationEnd();
+  }
+});
+var baseUiPopover = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  }
+});
+var baseUiPopoverPortal = (modal) => ({
+  keepMounted: modal.keepMounted
+});
+var baseUiPopoverPopup = (modal) => ({
+  onAnimationEnd: () => {
+    modal.onAnimationEnd();
+  }
+});
+var baseUiSheet = (modal, options) => ({
+  open: modal.isOpen,
+  onOpenChange: (open) => {
+    if (!(open || options?.disableClose)) {
+      modal.dismiss();
+    }
+  },
+  dismissible: !options?.disableClose
+});
+var baseUiSheetPortal = (modal) => ({
+  keepMounted: modal.keepMounted
+});
+var baseUiSheetPopup = (modal) => ({
+  onAnimationEnd: () => {
+    modal.onAnimationEnd();
+  }
+});
+
+// src/core.ts
+var symModalId = /* @__PURE__ */ Symbol("ModalManagerId");
+var initialState = {};
+var MODAL_REGISTRY = {};
+var ALREADY_MOUNTED = {};
+var modalCallbacks = {};
+var hideModalCallbacks = {};
+var uidSeed = 0;
+var dispatchFn = () => {
+  throw new Error(
+    "No dispatch method detected. Did you wrap your app with ModalManager.Provider?"
+  );
+};
+var getUid = () => `_modal_${uidSeed++}`;
+var getModalId = (modal) => {
+  if (typeof modal === "string") {
+    return modal;
+  }
+  const modalWithId = modal;
+  if (!modalWithId[symModalId]) {
+    modalWithId[symModalId] = getUid();
+  }
+  return modalWithId[symModalId];
+};
+var setDispatch = (fn) => {
+  dispatchFn = fn;
+};
+var getDispatch = () => dispatchFn;
+var actions = {
+  open: (modalId, data) => ({
+    type: "modalio/show",
+    payload: { modalId, data }
+  }),
+  close: (modalId) => ({
+    type: "modalio/hide",
+    payload: { modalId }
+  }),
+  remove: (modalId) => ({
+    type: "modalio/remove",
+    payload: { modalId }
+  }),
+  setFlags: (modalId, flags) => ({
+    type: "modalio/set-flags",
+    payload: { modalId, flags }
+  })
+};
+var reducer = (state, action) => {
+  switch (action.type) {
+    case "modalio/show": {
+      const { modalId, data } = action.payload;
+      return {
+        ...state,
+        [modalId]: {
+          ...state[modalId],
+          modalId,
+          data,
+          // If already mounted, show immediately; otherwise delay
+          isOpen: !!ALREADY_MOUNTED[modalId],
+          delayOpen: !ALREADY_MOUNTED[modalId]
+        }
+      };
+    }
+    case "modalio/hide": {
+      const { modalId } = action.payload;
+      const modalState = state[modalId];
+      if (!modalState) {
+        return state;
+      }
+      return {
+        ...state,
+        [modalId]: {
+          ...modalState,
+          isOpen: false
+        }
+      };
+    }
+    case "modalio/remove": {
+      const { modalId } = action.payload;
+      const newState = { ...state };
+      delete newState[modalId];
+      return newState;
+    }
+    case "modalio/set-flags": {
+      const { modalId, flags } = action.payload;
+      const existingState = state[modalId];
+      if (!existingState) {
+        return state;
+      }
+      return {
+        ...state,
+        [modalId]: {
+          ...existingState,
+          ...flags
+        }
+      };
+    }
+    default:
+      return state;
+  }
+};
+var register = (id, comp, props) => {
+  if (MODAL_REGISTRY[id]) {
+    MODAL_REGISTRY[id].props = props;
+  } else {
+    MODAL_REGISTRY[id] = {
+      comp,
+      props
+    };
+  }
+};
+var unregister = (id) => {
+  delete MODAL_REGISTRY[id];
+};
+
+// src/types.ts
+var MODAL_CONFIG_KEY = "__modalConfig";
+
+// src/api.ts
+var CLEANUP_DELAY_MS = 5e3;
+function createDeferredPromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { resolve, reject, promise };
+}
+var openedCallbacks = {};
+var beforeClosedCallbacks = {};
+var modalStates = {};
+var closedPromises = {};
+var cleanupModal = (modalId) => {
+  delete modalCallbacks[modalId];
+  delete hideModalCallbacks[modalId];
+  delete openedCallbacks[modalId];
+  delete beforeClosedCallbacks[modalId];
+  delete modalStates[modalId];
+  delete closedPromises[modalId];
+};
+var cleanupAllModals = () => {
+  const allIds = /* @__PURE__ */ new Set([
+    ...Object.keys(modalCallbacks),
+    ...Object.keys(hideModalCallbacks),
+    ...Object.keys(openedCallbacks),
+    ...Object.keys(beforeClosedCallbacks),
+    ...Object.keys(modalStates),
+    ...Object.keys(closedPromises)
+  ]);
+  for (const id of allIds) {
+    cleanupModal(id);
+  }
+};
+function closeModal(modal) {
+  const modalId = getModalId(modal);
+  modalStates[modalId] = "closing";
+  getDispatch()(actions.close(modalId));
+  if (modalCallbacks[modalId]) {
+    modalCallbacks[modalId].resolve(void 0);
+    delete modalCallbacks[modalId];
+  }
+  if (!hideModalCallbacks[modalId]) {
+    hideModalCallbacks[modalId] = createDeferredPromise();
+  }
+  return hideModalCallbacks[modalId].promise;
+}
+var removeModal = (modal) => {
+  const modalId = getModalId(modal);
+  getDispatch()(actions.remove(modalId));
+  modalCallbacks[modalId]?.resolve(void 0);
+  hideModalCallbacks[modalId]?.resolve(void 0);
+  beforeClosedCallbacks[modalId]?.resolve(void 0);
+  openedCallbacks[modalId]?.resolve();
+  cleanupModal(modalId);
+};
+var setFlags = (modalId, flags) => {
+  getDispatch()(actions.setFlags(modalId, flags));
+};
+function openModal(modal, config = {}) {
+  const modalId = config.modalId ?? getModalId(modal);
+  if (typeof modal !== "string" && !MODAL_REGISTRY[modalId]) {
+    register(modalId, modal);
+  }
+  let disableClose = config.disableClose ?? false;
+  const modalConfig = {
+    disableClose,
+    keepMounted: config.keepMounted
+  };
+  const data = {
+    ...config.data,
+    [MODAL_CONFIG_KEY]: modalConfig
+  };
+  modalStates[modalId] = "open";
+  getDispatch()(actions.open(modalId, data));
+  if (config.keepMounted) {
+    getDispatch()(actions.setFlags(modalId, { keepMounted: true }));
+  }
+  const mainCallbacks = createDeferredPromise();
+  modalCallbacks[modalId] = mainCallbacks;
+  closedPromises[modalId] = mainCallbacks.promise;
+  const openedDeferred = createDeferredPromise();
+  openedCallbacks[modalId] = {
+    resolve: openedDeferred.resolve,
+    promise: openedDeferred.promise
+  };
+  const beforeClosedDeferred = createDeferredPromise();
+  beforeClosedCallbacks[modalId] = {
+    resolve: beforeClosedDeferred.resolve,
+    promise: beforeClosedDeferred.promise
+  };
+  const modalRef = {
+    modalId,
+    data: config.data,
+    get disableClose() {
+      return disableClose;
+    },
+    set disableClose(value) {
+      disableClose = value;
+      const currentConfig = data[MODAL_CONFIG_KEY] ?? {};
+      const updatedData = {
+        ...data,
+        [MODAL_CONFIG_KEY]: {
+          ...currentConfig,
+          disableClose: value
+        }
+      };
+      getDispatch()(actions.setFlags(modalId, { data: updatedData }));
+    },
+    close: (result) => {
+      if (modalStates[modalId] === "closed") {
+        return;
+      }
+      modalStates[modalId] = "closing";
+      beforeClosedCallbacks[modalId]?.resolve(result);
+      delete beforeClosedCallbacks[modalId];
+      modalCallbacks[modalId]?.resolve(result);
+      delete modalCallbacks[modalId];
+      closeModal(modalId);
+    },
+    afterOpened: () => {
+      return openedCallbacks[modalId]?.promise ?? Promise.resolve();
+    },
+    afterClosed: () => {
+      return closedPromises[modalId] ?? Promise.resolve(void 0);
+    },
+    beforeClosed: () => {
+      return beforeClosedCallbacks[modalId]?.promise ?? Promise.resolve(void 0);
+    },
+    updateData: (newData) => {
+      Object.assign(data, newData);
+      getDispatch()(actions.open(modalId, data));
+    },
+    getState: () => {
+      return modalStates[modalId] ?? "closed";
+    }
+  };
+  return modalRef;
+}
+var markClosed = (modalId) => {
+  modalStates[modalId] = "closed";
+  setTimeout(() => {
+    if (modalStates[modalId] === "closed") {
+      delete modalStates[modalId];
+      delete closedPromises[modalId];
+    }
+  }, CLEANUP_DELAY_MS);
+};
+var getOpenModals = () => {
+  return Object.entries(modalStates).filter(([_, state]) => state === "open" || state === "closing").map(([id]) => id);
+};
+var closeAllModals = async () => {
+  const openModals = getOpenModals();
+  const closePromises = [];
+  for (const modalId of openModals) {
+    modalStates[modalId] = "closing";
+    beforeClosedCallbacks[modalId]?.resolve(void 0);
+    delete beforeClosedCallbacks[modalId];
+    modalCallbacks[modalId]?.resolve(void 0);
+    delete modalCallbacks[modalId];
+    closePromises.push(closeModal(modalId));
+  }
+  await Promise.all(closePromises);
+};
+var hasOpenModals = () => {
+  return getOpenModals().length > 0;
+};
+var notifyOpened = (modalId) => {
+  openedCallbacks[modalId]?.resolve();
+  delete openedCallbacks[modalId];
+};
+var ModalContext = createContext(initialState);
+var ModalIdContext = createContext(null);
+function ModalPlaceholder() {
+  const modals = useContext(ModalContext);
+  const visibleModalIds = Object.keys(modals).filter(
+    (id) => modals[id] !== void 0
+  );
+  const toRender = [];
+  for (const id of visibleModalIds) {
+    const entry = MODAL_REGISTRY[id];
+    if (entry) {
+      toRender.push({ id, comp: entry.comp, props: entry.props });
+    } else if (!ALREADY_MOUNTED[id]) {
+      console.warn(
+        `[ModalManager] No modal found for id: ${id}. Please check if it is registered or declared via JSX.`
+      );
+    }
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: toRender.map(({ id, comp: Comp, props }) => /* @__PURE__ */ jsx(Comp, { modalId: id, ...props }, id)) });
+}
+function InnerContextProvider({
+  children
+}) {
+  const [modals, dispatch] = useReducer(reducer, initialState);
+  setDispatch(dispatch);
+  return /* @__PURE__ */ jsxs(ModalContext.Provider, { value: modals, children: [
+    children,
+    /* @__PURE__ */ jsx(ModalPlaceholder, {})
+  ] });
+}
+function ModalProvider({
+  children,
+  dispatch: givenDispatch,
+  modals: givenModals
+}) {
+  if (givenDispatch && givenModals) {
+    setDispatch(givenDispatch);
+    return /* @__PURE__ */ jsxs(ModalContext.Provider, { value: givenModals, children: [
+      children,
+      /* @__PURE__ */ jsx(ModalPlaceholder, {})
+    ] });
+  }
+  return /* @__PURE__ */ jsx(InnerContextProvider, { children });
+}
+function ModalDef({
+  id,
+  component
+}) {
+  useEffect(() => {
+    register(id, component);
+    return () => {
+      unregister(id);
+    };
+  }, [id, component]);
+  return null;
+}
+function useModal(modal, initialData) {
+  const modals = useContext(ModalContext);
+  const contextModalId = useContext(ModalIdContext);
+  const modalId = modal ? getModalId(modal) : contextModalId;
+  if (!modalId) {
+    throw new Error(
+      "[ModalManager] No modal id found in useModal. Either pass a modal component/id or use inside a modal component."
+    );
+  }
+  const isComponentRef = modal !== void 0 && typeof modal !== "string";
+  useEffect(() => {
+    if (isComponentRef && !MODAL_REGISTRY[modalId]) {
+      register(
+        modalId,
+        modal,
+        initialData
+      );
+    }
+  }, [isComponentRef, modalId, modal, initialData]);
+  const modalInfo = modals[modalId];
+  const modalInfoRef = useRef(modalInfo);
+  useEffect(() => {
+    modalInfoRef.current = modalInfo;
+  }, [modalInfo]);
+  const openCallback = useCallback(
+    (data) => {
+      const ref = openModal(modalId, { data });
+      return ref.afterClosed();
+    },
+    [modalId]
+  );
+  const closeCallback = useCallback(
+    (result) => {
+      modalCallbacks[modalId]?.resolve(result);
+      delete modalCallbacks[modalId];
+      closeModal(modalId);
+    },
+    [modalId]
+  );
+  const dismissCallback = useCallback(() => {
+    modalCallbacks[modalId]?.resolve(void 0);
+    delete modalCallbacks[modalId];
+    closeModal(modalId);
+  }, [modalId]);
+  const removeCallback = useCallback(() => removeModal(modalId), [modalId]);
+  const onAnimationEnd = useCallback(() => {
+    const current = modalInfoRef.current;
+    if (current?.isOpen) {
+      notifyOpened(modalId);
+    } else {
+      markClosed(modalId);
+      hideModalCallbacks[modalId]?.resolve(void 0);
+      delete hideModalCallbacks[modalId];
+      if (!current?.keepMounted) {
+        removeModal(modalId);
+      }
+    }
+  }, [modalId]);
+  return useMemo(
+    () => ({
+      // State
+      modalId,
+      data: modalInfo?.data,
+      isOpen: !!modalInfo?.isOpen,
+      keepMounted: !!modalInfo?.keepMounted,
+      // Controls
+      open: openCallback,
+      close: closeCallback,
+      dismiss: dismissCallback,
+      remove: removeCallback,
+      // Animation handler
+      onAnimationEnd
+    }),
+    [
+      modalId,
+      modalInfo?.data,
+      modalInfo?.isOpen,
+      modalInfo?.keepMounted,
+      openCallback,
+      closeCallback,
+      dismissCallback,
+      removeCallback,
+      onAnimationEnd
+    ]
+  );
+}
+function useModalData() {
+  const modals = useContext(ModalContext);
+  const modalId = useContext(ModalIdContext);
+  if (!modalId) {
+    throw new Error(
+      "[ModalManager] useModalData must be used inside a modal component. Make sure you're using createModal() to wrap your modal."
+    );
+  }
+  const modalInfo = modals[modalId];
+  const data = modalInfo?.data;
+  if (!data) {
+    return void 0;
+  }
+  const { [MODAL_CONFIG_KEY]: _, ...userData } = data;
+  return userData;
+}
+function useModalConfig() {
+  const modals = useContext(ModalContext);
+  const modalId = useContext(ModalIdContext);
+  if (!modalId) {
+    throw new Error(
+      "[ModalManager] useModalConfig must be used inside a modal component."
+    );
+  }
+  const modalInfo = modals[modalId];
+  const config = modalInfo?.data?.[MODAL_CONFIG_KEY];
+  return config ?? {};
+}
+var createModal = (Comp) => {
+  function WrappedComponent(allProps) {
+    const { defaultOpen, keepMounted, modalId, ref, ...restProps } = allProps;
+    const componentProps = restProps;
+    const { data, open: openModal2 } = useModal(modalId);
+    const modals = useContext(ModalContext);
+    const shouldMount = modalId in modals;
+    useEffect(() => {
+      if (defaultOpen) {
+        openModal2();
+      }
+      ALREADY_MOUNTED[modalId] = true;
+      return () => {
+        delete ALREADY_MOUNTED[modalId];
+      };
+    }, [modalId, openModal2, defaultOpen]);
+    useEffect(() => {
+      if (keepMounted) {
+        setFlags(modalId, { keepMounted: true });
+      }
+    }, [modalId, keepMounted]);
+    const delayOpen = modals[modalId]?.delayOpen;
+    useEffect(() => {
+      if (delayOpen) {
+        openModal2(data);
+      }
+    }, [delayOpen, data, openModal2]);
+    if (!shouldMount) {
+      return null;
+    }
+    const mergedProps = {
+      ...componentProps,
+      ...data,
+      ref
+    };
+    return /* @__PURE__ */ jsx(ModalIdContext.Provider, { value: modalId, children: /* @__PURE__ */ jsx(Comp, { ...mergedProps }) });
+  }
+  WrappedComponent.displayName = `ModalManager(${Comp.displayName || Comp.name || "Component"})`;
+  return WrappedComponent;
+};
+
+// src/modal-manager.ts
+var ModalManager = {
+  /**
+   * Create a modal component with lifecycle management.
+   * Wraps your component with automatic registration and state handling.
+   */
+  create: createModal,
+  /**
+   * Open a modal and return a ModalRef for controlling it.
+   * @returns ModalRef with afterOpened(), afterClosed(), beforeClosed() promises
+   */
+  open: openModal,
+  /**
+   * Close a specific modal by component or ID.
+   * @returns Promise that resolves when the close animation completes
+   */
+  close: closeModal,
+  /**
+   * Close all open modals.
+   * @returns Promise that resolves when all close animations complete
+   */
+  closeAll: closeAllModals,
+  /**
+   * Remove a modal from the DOM completely.
+   */
+  remove: removeModal,
+  /**
+   * Check if any modals are currently open.
+   */
+  hasOpen: hasOpenModals,
+  /**
+   * Get array of currently open modal IDs.
+   */
+  getOpen: getOpenModals,
+  /**
+   * Register a modal component with an ID for later use.
+   */
+  register,
+  /**
+   * Unregister a previously registered modal.
+   */
+  unregister,
+  /**
+   * Clean up all internal state for a specific modal.
+   */
+  cleanup: cleanupModal,
+  /**
+   * Clean up all modal state (useful for testing).
+   */
+  cleanupAll: cleanupAllModals,
+  /**
+   * Context provider for modal management.
+   * Must wrap your application.
+   *
+   * @example
+   * ```tsx
+   * function App() {
+   *   return (
+   *     <ModalManager.Provider>
+   *       <YourApp />
+   *     </ModalManager.Provider>
+   *   );
+   * }
+   * ```
+   */
+  Provider: ModalProvider,
+  /**
+   * Declaratively define a modal in JSX.
+   *
+   * @example
+   * ```tsx
+   * <ModalManager.Def component={MyModal} id="my-modal" />
+   *
+   * // Later: open by ID
+   * ModalManager.open("my-modal");
+   * ```
+   */
+  Def: ModalDef
+};
+
+export { MODAL_CONFIG_KEY, ModalContext, ModalIdContext, ModalManager, baseUiAlertDialog, baseUiAlertDialogPopup, baseUiAlertDialogPortal, baseUiDialog, baseUiDialogPopup, baseUiDialogPortal, baseUiPopover, baseUiPopoverPopup, baseUiPopoverPortal, baseUiSheet, baseUiSheetPopup, baseUiSheetPortal, getModalId, radixUiAlertDialog, radixUiAlertDialogContent, radixUiDialog, radixUiDialogContent, radixUiPopover, radixUiSheet, radixUiSheetContent, reducer, shadcnUiAlertDialog, shadcnUiAlertDialogContent, shadcnUiDialog, shadcnUiDialogContent, shadcnUiDrawer, shadcnUiDrawerContent, shadcnUiPopover, shadcnUiSheet, shadcnUiSheetContent, useModal, useModalConfig, useModalData };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map