@inertiaui/modal-react 1.0.0-beta-5 → 2.0.2

package/dist/CloseButton.d.ts

@@ -0,0 +1,5 @@
+interface CloseButtonProps {
+    onClick: () => void;
+}
+export default function CloseButton({ onClick }: CloseButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Deferred.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+interface DeferredProps {
+    children: ReactNode;
+    data: string | string[];
+    fallback?: ReactNode;
+}
+declare const Deferred: {
+    ({ children, data, fallback }: DeferredProps): ReactNode;
+    displayName: string;
+};
+export default Deferred;

package/dist/HeadlessModal.d.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react';
+import { Modal, ModalConfig, ReloadOptions } from './types';
+interface HeadlessModalConfig {
+    slideover: boolean;
+    closeButton: boolean;
+    closeExplicitly: boolean;
+    closeOnClickOutside: boolean;
+    maxWidth: string;
+    paddingClasses: string;
+    panelClasses: string;
+    position: string;
+}
+interface HeadlessModalRenderProps {
+    afterLeave: () => void;
+    close: () => void;
+    config: HeadlessModalConfig;
+    emit: (event: string, ...args: unknown[]) => void;
+    getChildModal: () => Modal | null;
+    getParentModal: () => Modal | null;
+    id: string;
+    index: number;
+    isOpen: boolean;
+    modalContext: Modal;
+    onTopOfStack: boolean;
+    reload: (options?: ReloadOptions) => void;
+    setOpen: (open: boolean) => void;
+    shouldRender: boolean;
+    [key: string]: unknown;
+}
+interface HeadlessModalBaseProps {
+    name?: string;
+    children: ReactNode | ((props: HeadlessModalRenderProps) => ReactNode);
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onClose?: () => void;
+    onSuccess?: () => void;
+    slideover?: boolean;
+    closeButton?: boolean;
+    closeExplicitly?: boolean;
+    closeOnClickOutside?: boolean;
+    maxWidth?: string;
+    paddingClasses?: string;
+    panelClasses?: string;
+    position?: string;
+}
+type HeadlessModalProps = HeadlessModalBaseProps & Record<string, unknown>;
+export interface HeadlessModalRef {
+    afterLeave: () => void;
+    close: () => void;
+    emit: (event: string, ...args: unknown[]) => void;
+    getChildModal: () => Modal | null | undefined;
+    getParentModal: () => Modal | null | undefined;
+    reload: (options?: ReloadOptions) => void;
+    setOpen: (open: boolean) => void;
+    readonly id: string | undefined;
+    readonly index: number | undefined;
+    readonly isOpen: boolean | undefined;
+    readonly config: ModalConfig | undefined;
+    readonly modalContext: Modal | null;
+    readonly onTopOfStack: boolean | undefined;
+    readonly shouldRender: boolean | undefined;
+}
+declare const HeadlessModal: import('react').ForwardRefExoticComponent<Omit<HeadlessModalProps, "ref"> & import('react').RefAttributes<HeadlessModalRef>>;
+export default HeadlessModal;

package/dist/Modal.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from 'react';
+import { HeadlessModalRef } from './HeadlessModal';
+import { Modal as ModalType, ReloadOptions } from './types';
+interface ModalConfig {
+    slideover: boolean;
+    closeButton: boolean;
+    closeExplicitly: boolean;
+    maxWidth: string;
+    paddingClasses: string;
+    panelClasses: string;
+    position: string;
+}
+interface ModalRenderProps {
+    afterLeave: () => void;
+    close: () => void;
+    config: ModalConfig;
+    emit: (event: string, ...args: unknown[]) => void;
+    getChildModal: () => ModalType | null;
+    getParentModal: () => ModalType | null;
+    id: string;
+    index: number;
+    isOpen: boolean;
+    modalContext: ModalType;
+    onTopOfStack: boolean;
+    reload: (options?: ReloadOptions) => void;
+    setOpen: (open: boolean) => void;
+    shouldRender: boolean;
+    [key: string]: unknown;
+}
+interface ModalBaseProps {
+    name?: string;
+    children: ReactNode | ((props: ModalRenderProps) => ReactNode);
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onClose?: () => void;
+    onSuccess?: () => void;
+    onAfterLeave?: () => void;
+    slideover?: boolean;
+    closeButton?: boolean;
+    closeExplicitly?: boolean;
+    maxWidth?: string;
+    paddingClasses?: string;
+    panelClasses?: string;
+    position?: string;
+}
+type ModalProps = ModalBaseProps & Record<string, unknown>;
+declare const Modal: import('react').ForwardRefExoticComponent<Omit<ModalProps, "ref"> & import('react').RefAttributes<HeadlessModalRef>>;
+export default Modal;

package/dist/ModalContent.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { Modal } from './types';
+interface ModalContentConfig {
+    maxWidth: string;
+    paddingClasses: string;
+    panelClasses: string;
+    position: string;
+    closeButton: boolean;
+    closeExplicitly?: boolean;
+    closeOnClickOutside?: boolean;
+}
+interface ModalContentProps {
+    modalContext: Modal;
+    config: ModalContentConfig;
+    useNativeDialog: boolean;
+    isFirstModal: boolean;
+    onAfterLeave?: () => void;
+    children: ReactNode | ((props: {
+        modalContext: Modal;
+        config: ModalContentConfig;
+    }) => ReactNode);
+}
+declare const ModalContent: ({ modalContext, config, useNativeDialog, isFirstModal, onAfterLeave, children }: ModalContentProps) => import("react/jsx-runtime").JSX.Element;
+export default ModalContent;

package/dist/ModalLink.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode, ElementType } from 'react';
+import { PrefetchOption } from './types';
+import { RequestPayload } from '@inertiajs/core';
+interface ModalLinkProps {
+    href: string;
+    method?: string;
+    data?: RequestPayload;
+    as?: ElementType;
+    headers?: Record<string, string>;
+    queryStringArrayFormat?: 'brackets' | 'indices';
+    onAfterLeave?: () => void;
+    onBlur?: () => void;
+    onClose?: () => void;
+    onError?: (error: unknown) => void;
+    onFocus?: () => void;
+    onStart?: () => void;
+    onSuccess?: () => void;
+    onPrefetching?: () => void;
+    onPrefetched?: () => void;
+    navigate?: boolean;
+    prefetch?: PrefetchOption;
+    cacheFor?: number;
+    children: ReactNode | ((props: {
+        loading: boolean;
+    }) => ReactNode);
+    [key: string]: unknown;
+}
+declare const ModalLink: ({ href, method, data, as: Component, headers, queryStringArrayFormat, onAfterLeave, onBlur, onClose, onError, onFocus, onStart, onSuccess, onPrefetching, onPrefetched, navigate, prefetch, cacheFor, children, ...props }: ModalLinkProps) => import("react/jsx-runtime").JSX.Element;
+export default ModalLink;

package/dist/ModalRenderer.d.ts

@@ -0,0 +1,4 @@
+import { ModalRendererProps } from './types';
+export declare const useModalIndex: () => number | null;
+declare const ModalRenderer: ({ index }: ModalRendererProps) => import("react/jsx-runtime").JSX.Element;
+export default ModalRenderer;

package/dist/ModalRoot.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode, ComponentType } from 'react';
+import { ModalStackContextValue, PageProps, ModalRootProps, PrefetchOptions } from './types';
+export declare function prefetch(href: string, options?: PrefetchOptions): Promise<void>;
+interface ModalStackProviderProps {
+    children: ReactNode;
+}
+export declare const ModalStackProvider: ({ children }: ModalStackProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useModalStack: () => ModalStackContextValue;
+export declare const modalPropNames: string[];
+export declare const initFromPageProps: (pageProps: PageProps) => void;
+interface RenderInertiaAppProps {
+    Component: ComponentType & {
+        layout?: ((page: ReactNode) => ReactNode) | ComponentType[];
+    };
+    props: Record<string, unknown>;
+    key: string;
+}
+export declare const renderApp: (App: ComponentType<{
+    children: (props: RenderInertiaAppProps) => ReactNode;
+}>, pageProps: PageProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ModalRoot: ({ children }: ModalRootProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/SlideoverContent.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { Modal } from './types';
+interface SlideoverContentConfig {
+    maxWidth: string;
+    paddingClasses: string;
+    panelClasses: string;
+    position: string;
+    closeButton: boolean;
+    closeExplicitly?: boolean;
+    closeOnClickOutside?: boolean;
+}
+interface SlideoverContentProps {
+    modalContext: Modal;
+    config: SlideoverContentConfig;
+    useNativeDialog: boolean;
+    isFirstModal: boolean;
+    onAfterLeave?: () => void;
+    children: ReactNode | ((props: {
+        modalContext: Modal;
+        config: SlideoverContentConfig;
+    }) => ReactNode);
+}
+declare const SlideoverContent: ({ modalContext, config, useNativeDialog, isFirstModal, onAfterLeave, children }: SlideoverContentProps) => import("react/jsx-runtime").JSX.Element;
+export default SlideoverContent;

package/dist/WhenVisible.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode, ElementType } from 'react';
+import { ReloadOptions } from './types';
+interface WhenVisibleProps {
+    children: ReactNode;
+    data?: string | string[];
+    params?: ReloadOptions;
+    buffer?: number;
+    as?: ElementType;
+    always?: boolean;
+    fallback?: ReactNode;
+}
+declare const WhenVisible: {
+    ({ children, data, params, buffer, as, always, fallback }: WhenVisibleProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode>> | import('react').ReactElement<any, string | import('react').JSXElementConstructor<any>>;
+    displayName: string;
+};
+export default WhenVisible;

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+export interface ModalTypeConfig {
+    closeButton: boolean;
+    closeExplicitly: boolean;
+    closeOnClickOutside: boolean;
+    maxWidth: string;
+    paddingClasses: string;
+    panelClasses: string;
+    position: string;
+}
+export interface ModalConfig {
+    type: 'modal' | 'slideover';
+    navigate: boolean;
+    useNativeDialog: boolean;
+    appElement: string | null;
+    modal: ModalTypeConfig;
+    slideover: ModalTypeConfig;
+}
+export declare const resetConfig: () => void;
+export declare const putConfig: (key: string | Partial<ModalConfig>, value?: unknown) => void;
+export declare const getConfig: (key?: string) => unknown;
+export declare const getConfigByType: (isSlideover: boolean, key: string) => unknown;

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Max width classes for modals and slideovers.
+ * Uses a map lookup for Tailwind 4 compatibility (scanner picks up full class strings).
+ */
+export declare const maxWidthClasses: Record<string, string>;
+export declare const defaultMaxWidth = "2xl";
+export declare function getMaxWidthClass(maxWidth: string): string;

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+export { sameUrlPath, except, only, rejectNullValues, kebabCase, isStandardDomEvent } from '@inertiaui/vanilla';
+export declare function generateIdUsing(callback: (() => string) | null): void;
+export declare function generateId(prefix?: string): string;

package/dist/inertiaui-modal.d.ts

@@ -0,0 +1,2 @@
+export * from './inertiauiModal'
+export {}