@edifice.io/react 2.0.0-develop-rc.3

package/dist/components/Input/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Input } from './Input';
+export * from './Input';

package/dist/components/Label/Label.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+export type OmitLabelProps = 'htmlFor';
+export interface LabelProps extends Omit<React.ComponentPropsWithRef<'label'>, OmitLabelProps> {
+    /**
+     * Display Icon to the left
+     */
+    leftIcon?: ReactNode;
+    /**
+     * Translated Optional Text
+     */
+    optionalText?: string;
+    /**
+     * Required Indicator or Text
+     */
+    requiredText?: string;
+    /**
+     * Label Text
+     */
+    children: ReactNode;
+    /**
+     * Optional class for styling purpose
+     */
+    className?: string;
+}
+declare const Label: import('react').ForwardRefExoticComponent<Omit<LabelProps, "ref"> & import('react').RefAttributes<HTMLLabelElement>>;
+export default Label;

package/dist/components/Label/Label.js

@@ -0,0 +1,37 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect } from "react";
+import clsx from "clsx";
+import { useTranslation } from "react-i18next";
+import { useFormControl } from "../Form/FormContext.js";
+const Label = /* @__PURE__ */ forwardRef(({
+  leftIcon,
+  optionalText,
+  requiredText = "*",
+  children,
+  className
+}, ref) => {
+  const {
+    id,
+    isOptional,
+    isRequired
+  } = useFormControl(), {
+    t
+  } = useTranslation(), classes = clsx("form-label", {
+    "has-icon": leftIcon
+  }, className), optionalState = isOptional && !isRequired, requiredState = isRequired && !isOptional;
+  return useEffect(() => {
+    if (isOptional && isRequired)
+      throw new Error("Cannot be optional and required at the same time");
+  }, [isOptional, isRequired]), /* @__PURE__ */ jsxs("label", { ref, htmlFor: id, className: classes, children: [
+    leftIcon,
+    children,
+    optionalState && /* @__PURE__ */ jsxs("em", { className: "optional", children: [
+      "- ",
+      optionalText ?? t("explorer.optional")
+    ] }),
+    requiredState && /* @__PURE__ */ jsx("em", { className: "required", children: requiredText })
+  ] });
+}), Label$1 = Label;
+export {
+  Label$1 as default
+};

package/dist/components/Label/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Label } from './Label';
+export * from './Label';

package/dist/components/Loading/Loading.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+export type LoadingPosition = 'left' | 'right' | undefined;
+export type LoadingIcon = JSX.Element | undefined;
+export interface LoadingProps {
+    /**
+     * Is it loading ?
+     */
+    isLoading: boolean;
+    /**
+     * Override default loading icon
+     */
+    loadingIcon?: LoadingIcon;
+    /**
+     * Default position to left. When using with another component, position can be switched
+     */
+    loadingPosition?: LoadingPosition;
+    /** When using with another component, we can pass a children */
+    children?: ReactNode;
+    /**
+     * Optional class for styling purpose
+     */
+    className?: string;
+    color?: string;
+}
+/**
+ * Inform user about loading status
+ */
+declare const Loading: import('react').ForwardRefExoticComponent<LoadingProps & import('react').RefAttributes<HTMLDivElement>>;
+export default Loading;

package/dist/components/Loading/Loading.js

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import clsx from "clsx";
+import { Icon } from "../Icon/Icon.js";
+const Loading = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    isLoading,
+    loadingIcon,
+    loadingPosition = "left",
+    children,
+    className,
+    ...restProps
+  } = props, getLoadingIcon = () => {
+    let icon;
+    return loadingIcon ? icon = loadingIcon : icon = /* @__PURE__ */ jsx(Icon, { name: "loader", ...restProps, "aria-label": "Loading" }), icon;
+  }, classes = clsx("loading d-flex align-items-center gap-8", {
+    "is-loading": isLoading
+  }, className);
+  return /* @__PURE__ */ jsxs("div", { className: classes, role: "status", ref, children: [
+    (!loadingPosition || loadingPosition === "left") && getLoadingIcon(),
+    children,
+    loadingPosition === "right" && getLoadingIcon()
+  ] });
+}), Loading$1 = Loading;
+export {
+  Loading$1 as default
+};

package/dist/components/Loading/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Loading } from './Loading';
+export * from './Loading';

package/dist/components/LoadingScreen/LoadingScreen.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface LoadingScreenProps {
+    position?: boolean;
+    caption?: string;
+}
+declare const LoadingScreen: import('react').ForwardRefExoticComponent<LoadingScreenProps & import('react').RefAttributes<HTMLDivElement>>;
+export default LoadingScreen;

package/dist/components/LoadingScreen/LoadingScreen.js

@@ -0,0 +1,25 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import clsx from "clsx";
+import usePaths from "../../core/usePaths/usePaths.js";
+const LoadingScreen = /* @__PURE__ */ forwardRef(({
+  position = !0,
+  caption
+}, ref) => {
+  const [imagePath] = usePaths(), image = `${imagePath}/loading/screen-loading.gif`, containerClasses = clsx("top-0 end-0 start-0 bottom-0 d-grid justify-content-center align-content-center align-items-center z-2000", {
+    "position-fixed": !position,
+    "position-static": position
+  }), captionClasses = clsx("text-center pt-12", {
+    "text-white": !position
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { ref, className: containerClasses, children: [
+      /* @__PURE__ */ jsx("div", { className: "bg-white rounded-circle mx-auto w-25", children: /* @__PURE__ */ jsx("img", { src: image, alt: "loading" }) }),
+      caption && /* @__PURE__ */ jsx("div", { className: captionClasses, children: caption })
+    ] }),
+    !position && /* @__PURE__ */ jsx("div", { className: "modal-backdrop fade show" })
+  ] });
+}), LoadingScreen$1 = LoadingScreen;
+export {
+  LoadingScreen$1 as default
+};

package/dist/components/LoadingScreen/index.d.ts

@@ -0,0 +1 @@
+export { default as LoadingScreen } from './LoadingScreen';

package/dist/components/Logo/Logo.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export interface LogoProps {
+    src: string;
+    is1d?: boolean;
+    translate?: string;
+}
+declare const Logo: import('react').ForwardRefExoticComponent<LogoProps & import('react').RefAttributes<HTMLAnchorElement>>;
+export default Logo;

package/dist/components/Logo/Logo.js

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import clsx from "clsx";
+const Logo = /* @__PURE__ */ forwardRef(({
+  src,
+  is1d,
+  translate = "Retour accueil"
+}, ref) => {
+  const classes = clsx("navbar-brand d-none d-md-block");
+  return /* @__PURE__ */ jsx("a", { ref, className: classes, href: "/timeline/timeline", "aria-label": translate, children: /* @__PURE__ */ jsx("img", { className: "logo", src, alt: `logo ${is1d ? "ONE" : "NEO"}`, width: "300", height: "52" }) });
+}), Logo$1 = Logo;
+export {
+  Logo$1 as default
+};

package/dist/components/Logo/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Logo } from './Logo';
+export * from './Logo';

package/dist/components/Menu/Menu.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+/**
+ * Menu Component to navigate between routes with react-router-dom
+ */
+export declare const Menu: {
+    ({ label, children, }: {
+        label: string;
+        children: ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    Item: ({ children }: {
+        children: ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Button: (props: Partial<import('./MenuButton').MenuButtonProps>) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/Menu/Menu.js

@@ -0,0 +1,58 @@
+import { jsx } from "react/jsx-runtime";
+import { usePrevious } from "@uidotdev/usehooks";
+import { useRef, useState, useEffect, useMemo } from "react";
+import { MenuButton } from "./MenuButton.js";
+import { MenuContext } from "./MenuContext.js";
+import { MenuItem } from "./MenuItem.js";
+const Menu = ({
+  label,
+  children
+}) => {
+  const menuRef = useRef(null), menuItems = useRef(/* @__PURE__ */ new Set()).current, [currentIndex, setCurrentIndex] = useState(0), previousIndex = usePrevious(currentIndex) ?? 0;
+  useEffect(() => {
+    var _a, _b;
+    if (currentIndex !== previousIndex) {
+      const items = Array.from(menuItems), currentNode = (_a = items[currentIndex]) == null ? void 0 : _a.firstChild, previousNode = (_b = items[previousIndex]) == null ? void 0 : _b.firstChild;
+      previousNode == null || previousNode.setAttribute("tabindex", "-1"), currentNode == null || currentNode.setAttribute("tabindex", "0"), currentNode == null || currentNode.focus({
+        preventScroll: !0
+      });
+    }
+  }, [currentIndex, previousIndex, menuItems]);
+  const first = () => setCurrentIndex(0), last = () => setCurrentIndex(menuItems.size - 1), next = () => {
+    const index = currentIndex === menuItems.size - 1 ? 0 : currentIndex + 1;
+    setCurrentIndex(index);
+  }, previous = () => {
+    const index = currentIndex === 0 ? menuItems.size - 1 : currentIndex - 1;
+    setCurrentIndex(index);
+  }, onKeyDown = (event) => {
+    switch (event.stopPropagation(), event.code) {
+      case "ArrowUp":
+        event.preventDefault(), previous();
+        break;
+      case "ArrowDown":
+        event.preventDefault(), next();
+        break;
+    }
+    switch (event.code) {
+      case "End":
+        event.preventDefault(), last();
+        break;
+      case "Home":
+        event.preventDefault(), first();
+        break;
+    }
+  }, childProps = useMemo(() => ({
+    "data-menubar-menuitem": "",
+    role: "menuitem"
+  }), []), values = useMemo(() => ({
+    menuRef,
+    menuItems,
+    childProps
+  }), [childProps, menuItems]);
+  return /* @__PURE__ */ jsx(MenuContext.Provider, { value: values, children: /* @__PURE__ */ jsx("nav", { "aria-label": label, className: "menu", children: /* @__PURE__ */ jsx("ul", { ref: menuRef, role: "menubar", "aria-label": label, onKeyDown, "data-menubar-list": !0, className: "list-unstyled d-flex flex-column gap-4", children }) }) });
+};
+Menu.Item = MenuItem;
+Menu.Button = MenuButton;
+export {
+  Menu
+};

package/dist/components/Menu/MenuButton.d.ts

@@ -0,0 +1,5 @@
+import { ButtonProps } from '../Button';
+export type MenuButtonProps = Pick<ButtonProps, 'children' | 'leftIcon' | 'rightIcon' | 'onClick'> & {
+    selected: boolean;
+};
+export declare const MenuButton: (props: Partial<MenuButtonProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Menu/MenuButton.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { useMenuContext } from "./MenuContext.js";
+import Button from "../Button/Button.js";
+const MenuButton = (props) => {
+  const {
+    selected,
+    leftIcon,
+    rightIcon,
+    onClick,
+    children
+  } = props, {
+    childProps
+  } = useMenuContext();
+  return /* @__PURE__ */ jsx(Button, { variant: "ghost", color: "tertiary", className: clsx("stack w-100", {
+    selected
+  }), leftIcon, rightIcon, onClick, ...childProps, children });
+};
+export {
+  MenuButton
+};

package/dist/components/Menu/MenuContext.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'react';
+export interface MenuContextProps {
+    menuRef: Ref<HTMLUListElement | null>;
+    menuItems: Set<HTMLLIElement>;
+    childProps: {
+        [key: string]: string;
+    };
+}
+export declare const MenuContext: import('react').Context<MenuContextProps | null>;
+export declare function useMenuContext(): MenuContextProps;

package/dist/components/Menu/MenuContext.js

@@ -0,0 +1,12 @@
+import { createContext, useContext } from "react";
+const MenuContext = /* @__PURE__ */ createContext(null);
+function useMenuContext() {
+  const context = useContext(MenuContext);
+  if (!context)
+    throw new Error("Cannot be rendered outside the Menu component");
+  return context;
+}
+export {
+  MenuContext,
+  useMenuContext
+};

package/dist/components/Menu/MenuItem.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare const MenuItem: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Menu/MenuItem.js

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { useRef, useId, useEffect } from "react";
+import { useMenuContext } from "./MenuContext.js";
+const MenuItem = ({
+  children
+}) => {
+  const itemRef = useRef(null), id = useId(), {
+    menuItems
+  } = useMenuContext();
+  return useEffect(() => {
+    const itemNode = itemRef.current;
+    return itemNode && menuItems.add(itemNode), () => {
+      itemNode && menuItems.delete(itemNode);
+    };
+  }, [menuItems]), /* @__PURE__ */ jsx("li", { ref: itemRef, id, role: "none", "data-menubar-listitem": !0, children });
+};
+export {
+  MenuItem
+};

package/dist/components/Menu/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Menu';
+export { type MenuButtonProps } from './MenuButton';

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+export type ModalElement = HTMLDivElement;
+export type ModalSize = 'md' | 'lg';
+export interface ModalProps {
+    /**
+     * Modal id (useful when multiple modal on the same page)
+     */
+    id: string;
+    /**
+     * Is Modal Open
+     */
+    isOpen: boolean;
+    /**
+     * Function to call when closing modal
+     */
+    onModalClose: () => void;
+    /**
+     * Size of the modal (width)
+     */
+    size?: ModalSize;
+    /**
+     * Is modal scrollable (see https://getbootstrap.com/docs/5.0/components/modal/#scrolling-long-content)
+     */
+    scrollable?: boolean;
+    /**
+     * ID of the HTML element to receive focus when modal is active.
+     */
+    focusId?: string;
+    /**
+     * Modal takes the full height of the window
+     */
+    viewport?: boolean;
+    /**
+     * Children
+     */
+    children: React.ReactNode;
+}
+declare const Modal: import('react').ForwardRefExoticComponent<ModalProps & import('react').RefAttributes<HTMLDivElement>> & {
+    Header: {
+        (props: import('./ModalHeader').ModalHeaderProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Subtitle: {
+        (props: import('./ModalSubtitle').ModalSubtitleProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        (props: import('./ModalBody').ModalBodyProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        (props: import('./ModalFooter').ModalFooterProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export default Modal;

package/dist/components/Modal/Modal.js

@@ -0,0 +1,72 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { forwardRef, useEffect } from "react";
+import { useTransition, animated } from "@react-spring/web";
+import clsx from "clsx";
+import ModalBody from "./ModalBody.js";
+import { ModalContext } from "./ModalContext.js";
+import ModalFooter from "./ModalFooter.js";
+import ModalHeader from "./ModalHeader.js";
+import ModalSubtitle from "./ModalSubtitle.js";
+import useClickOutside from "../../hooks/useClickOutside/useClickOutside.js";
+import useTrapFocus from "../../hooks/useTrapFocus/useTrapFocus.js";
+import useKeyPress from "../../hooks/useKeyPress/useKeyPress.js";
+const Root = /* @__PURE__ */ forwardRef((props, ref) => {
+  const {
+    id,
+    isOpen,
+    onModalClose,
+    size = "md",
+    viewport = !1,
+    scrollable = !1,
+    focusId,
+    children
+  } = props, ariaLabelId = `aria_label_${id}`, ariaDescriptionId = `aria_desc_${id}`, modalRef = useClickOutside(onModalClose), trapRef = useTrapFocus();
+  useKeyPress(onModalClose, ["Escape"]), useEffect(() => {
+    if (isOpen && (document.body.style.overflow = "hidden", focusId)) {
+      const elem = document.getElementById(focusId);
+      elem == null || elem.focus();
+    }
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, [focusId, isOpen]);
+  const modalClasses = clsx("modal fade", {
+    "show d-block": isOpen,
+    "modal-scrollable": scrollable,
+    viewport,
+    [`modal-${size}`]: size
+  }), dialogClasses = clsx("modal-dialog"), modalContextValue = {
+    ariaLabelId,
+    ariaDescriptionId,
+    focusId
+  }, transition = useTransition(isOpen, {
+    from: {
+      x: -50,
+      opacity: 0
+    },
+    enter: {
+      x: 0,
+      opacity: 1
+    },
+    leave: {
+      x: 50,
+      opacity: 0
+    }
+  });
+  return /* @__PURE__ */ jsx(ModalContext.Provider, { value: modalContextValue, children: transition((style, isOpen2) => /* @__PURE__ */ jsxs(Fragment, { children: [
+    isOpen2 && /* @__PURE__ */ jsx(animated.div, { id, ref, role: "dialog", "aria-modal": "true", "aria-labelledby": ariaLabelId, "aria-describedby": ariaDescriptionId, className: modalClasses, style, tabIndex: -1, children: /* @__PURE__ */ jsx("div", { id: `${id}_ref`, ref: (node) => {
+      modalRef.current = node, isOpen2 && (trapRef.current = node);
+    }, className: dialogClasses, children: /* @__PURE__ */ jsx("div", { className: "modal-content", children }) }) }),
+    isOpen2 && /* @__PURE__ */ jsx(animated.div, { className: "modal-backdrop fade show", style: {
+      opacity: 0.65
+    } })
+  ] })) });
+}), Modal = /* @__PURE__ */ Object.assign(Root, {
+  Header: ModalHeader,
+  Subtitle: ModalSubtitle,
+  Body: ModalBody,
+  Footer: ModalFooter
+}), Modal$1 = Modal;
+export {
+  Modal$1 as default
+};

package/dist/components/Modal/ModalBody.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+export interface ModalBodyProps {
+    /**
+     *Children
+     */
+    children: ReactNode;
+    /**
+     * Optional class for styling purpose
+     */
+    className?: string | null;
+}
+/**
+ * Modal Body
+ */
+declare const ModalBody: {
+    (props: ModalBodyProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ModalBody;

package/dist/components/Modal/ModalBody.js

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { useModalContext } from "./ModalContext.js";
+const ModalBody = (props) => {
+  const {
+    ariaDescriptionId
+  } = useModalContext(), {
+    children,
+    className
+  } = props, classes = clsx("modal-body", className);
+  return /* @__PURE__ */ jsx("div", { id: ariaDescriptionId, className: classes, children });
+};
+export {
+  ModalBody as default
+};

package/dist/components/Modal/ModalContext.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export interface ModalContextProps {
+    ariaLabelId: string;
+    ariaDescriptionId: string;
+    focusId: string | undefined;
+}
+export declare const ModalContext: import('react').Context<ModalContextProps>;
+export declare const useModalContext: () => ModalContextProps;

package/dist/components/Modal/ModalContext.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from "react";
+const ModalContext = /* @__PURE__ */ createContext({
+  ariaLabelId: "",
+  ariaDescriptionId: "",
+  focusId: ""
+}), useModalContext = () => {
+  const context = useContext(ModalContext);
+  if (!context)
+    throw new Error("Cannot be rendered outside the Modal component");
+  return context;
+};
+export {
+  ModalContext,
+  useModalContext
+};

package/dist/components/Modal/ModalFooter.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface ModalFooterProps {
+    children: ReactNode;
+}
+/**
+ * Modal Footer
+ */
+declare const ModalFooter: {
+    (props: ModalFooterProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ModalFooter;

package/dist/components/Modal/ModalFooter.js

@@ -0,0 +1,5 @@
+import { jsx } from "react/jsx-runtime";
+const ModalFooter = (props) => /* @__PURE__ */ jsx("div", { className: "modal-footer", children: props.children });
+export {
+  ModalFooter as default
+};

package/dist/components/Modal/ModalHeader.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+export interface ModalHeaderProps {
+    /**
+     * Method called on modal close
+     */
+    onModalClose: () => void;
+    /**
+     * ReactNode
+     */
+    children: ReactNode;
+}
+/**
+ * Modal Header
+ */
+declare const ModalHeader: {
+    (props: ModalHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ModalHeader;

package/dist/components/Modal/ModalHeader.js

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useRef, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import IconButton from "../Button/IconButton.js";
+import { useModalContext } from "./ModalContext.js";
+import { Icon } from "../Icon/Icon.js";
+const ModalHeader = (props) => {
+  const {
+    onModalClose,
+    children
+  } = props, {
+    ariaLabelId,
+    focusId
+  } = useModalContext(), closeButtonRef = useRef(null), {
+    t
+  } = useTranslation();
+  return useEffect(() => {
+    var _a;
+    focusId || (_a = closeButtonRef.current) == null || _a.focus();
+  }, [focusId]), /* @__PURE__ */ jsxs("div", { className: "modal-header", children: [
+    /* @__PURE__ */ jsx("h2", { id: ariaLabelId, className: "modal-title", tabIndex: -1, children }),
+    /* @__PURE__ */ jsx(IconButton, { ref: closeButtonRef, "aria-label": t("close"), color: "tertiary", icon: /* @__PURE__ */ jsx(Icon, { name: "close" }), type: "button", variant: "ghost", title: t("close"), onClick: onModalClose, className: "btn-close" })
+  ] });
+};
+export {
+  ModalHeader as default
+};

package/dist/components/Modal/ModalSubtitle.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface ModalSubtitleProps {
+    children: ReactNode;
+}
+/**
+ * Modal Subtitle
+ */
+declare const ModalSubtitle: {
+    (props: ModalSubtitleProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ModalSubtitle;

package/dist/components/Modal/ModalSubtitle.js

@@ -0,0 +1,5 @@
+import { jsx } from "react/jsx-runtime";
+const ModalSubtitle = (props) => /* @__PURE__ */ jsx("p", { className: "modal-subtitle", children: props.children });
+export {
+  ModalSubtitle as default
+};

package/dist/components/Modal/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Modal } from './Modal';
+export * from './Modal';