@arkyn/components 3.0.1-beta.4 → 3.0.1-beta.40

package/dist/providers/drawerProvider.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useState } from "react";
+const drawerContext = createContext({});
+/**
+ * DrawerProvider component - provides drawer context for managing multiple drawers state and data
+ *
+ * @param props - DrawerProvider component properties
+ * @param props.children - React elements that will have access to the drawer context
+ * @param props.enableDrawerAutomation - Optional flag to enable drawer automation features
+ *
+ * @returns DrawerProvider JSX element that wraps children with drawer context
+ *
+ * @example
+ * ```tsx
+ * // Basic drawer provider setup
+ * function App() {
+ *   return (
+ *     <DrawerProvider>
+ *       <NavigationDrawer />
+ *       <FilterDrawer />
+ *       <SettingsDrawer />
+ *       <MainContent />
+ *     </DrawerProvider>
+ *   );
+ * }
+ *
+ * // Drawer provider with automation enabled
+ * function AppWithAutomation() {
+ *   return (
+ *     <DrawerProvider enableDrawerAutomation={true}>
+ *       <Dashboard />
+ *       <SidePanel />
+ *       <NotificationDrawer />
+ *     </DrawerProvider>
+ *   );
+ * }
+ *
+ * // Using with multiple drawers
+ * function MultiDrawerApp() {
+ *   return (
+ *     <DrawerProvider>
+ *       <Header />
+ *       <NavigationDrawer key="navigation" />
+ *       <FilterDrawer key="filters" />
+ *       <CartDrawer key="shopping-cart" />
+ *       <MainContent />
+ *     </DrawerProvider>
+ *   );
+ * }
+ *
+ * // Component using drawer context
+ * function DrawerController() {
+ *   const { openDrawer, closeDrawer } = useDrawer();
+ *
+ *   const handleOpenNavigation = () => {
+ *     openDrawer('navigation', { section: 'main-menu' });
+ *   };
+ *
+ *   const handleOpenFilters = () => {
+ *     openDrawer('filters', { category: 'electronics', priceRange: [0, 1000] });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleOpenNavigation}>
+ *         Open Navigation
+ *       </button>
+ *       <button onClick={handleOpenFilters}>
+ *         Open Filters
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ *
+ * // Drawer component consuming context
+ * function NavigationDrawer() {
+ *   const { drawerIsOpen, drawerData, closeDrawer } = useDrawer('navigation');
+ *
+ *   if (!drawerIsOpen) return null;
+ *
+ *   return (
+ *     <Drawer position="left" onClose={() => closeDrawer('navigation')}>
+ *       <h2>Navigation</h2>
+ *       <p>Current section: {drawerData?.section}</p>
+ *       <nav>
+ *         <a href="/home">Home</a>
+ *         <a href="/products">Products</a>
+ *         <a href="/about">About</a>
+ *       </nav>
+ *     </Drawer>
+ *   );
+ * }
+ * ```
+ */
+function DrawerProvider(args) {
+    const { children = false } = args;
+    const [openedDrawers, setOpenedDrawers] = useState([]);
+    function drawerIsOpen(key) {
+        return !!openedDrawers.some((drawer) => drawer.key === key);
+    }
+    function drawerData(key) {
+        return openedDrawers.find((drawer) => drawer.key === key)?.data;
+    }
+    function openDrawer(key, data) {
+        const alreadyExist = drawerIsOpen(key);
+        if (alreadyExist) {
+            setOpenedDrawers((old) => {
+                const filtered = old.filter((drawer) => drawer.key !== key);
+                return [...filtered, { key, data }];
+            });
+        }
+        else
+            setOpenedDrawers([...openedDrawers, { key, data }]);
+    }
+    function closeDrawer(key) {
+        setOpenedDrawers(openedDrawers.filter((drawer) => drawer.key !== key));
+    }
+    return (_jsx(drawerContext.Provider, { value: { drawerIsOpen, drawerData, openDrawer, closeDrawer }, children: children }));
+}
+export { drawerContext, DrawerProvider };

package/dist/providers/formProvider.d.ts

@@ -0,0 +1,76 @@
+import { ReactNode } from "react";
+type FormContextProps = {
+    fieldErrors: {
+        [x: string]: any;
+    };
+};
+type FormProviderProps = {
+    children: ReactNode;
+    fieldErrors?: any;
+    form?: React.ReactElement;
+};
+declare const formContext: import("react").Context<FormContextProps>;
+/**
+ * FormProvider component - provides form context including field errors to child components
+ *
+ * @param props - FormProvider component properties
+ * @param props.children - React elements that will have access to the form context
+ * @param props.fieldErrors - Object containing validation errors indexed by field name
+ * @param props.form - Optional form element to wrap the children with
+ *
+ * @returns FormProvider JSX element that wraps children with form context
+ *
+ * @example
+ * ```tsx
+ * // Basic form provider with field errors
+ * function App() {
+ *   const errors = {
+ *     email: "Invalid email format",
+ *     password: "Password is required"
+ *   };
+ *
+ *   return (
+ *     <FormProvider fieldErrors={errors}>
+ *       <Input name="email" label="Email" />
+ *       <Input name="password" label="Password" type="password" />
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ * // Form provider with custom form element
+ * function FormWithValidation() {
+ *   const [errors, setErrors] = useState({});
+ *
+ *   const handleSubmit = (e) => {
+ *     e.preventDefault();
+ *     // validation logic
+ *   };
+ *
+ *   return (
+ *     <FormProvider
+ *       fieldErrors={errors}
+ *       form={<form onSubmit={handleSubmit} />}
+ *     >
+ *       <Input name="username" label="Username" />
+ *       <Button type="submit">Submit</Button>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ * // Using with useForm hook
+ * function FormField() {
+ *   const { fieldErrors } = useForm();
+ *
+ *   return (
+ *     <Input
+ *       name="email"
+ *       label="Email"
+ *       errorMessage={fieldErrors?.email}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function FormProvider(props: FormProviderProps): import("react/jsx-runtime").JSX.Element;
+export { formContext, FormProvider };
+//# sourceMappingURL=formProvider.d.ts.map

package/dist/providers/formProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formProvider.d.ts","sourceRoot":"","sources":["../../src/providers/formProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA+C,MAAM,OAAO,CAAC;AAE/E,KAAK,gBAAgB,GAAG;IACtB,WAAW,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;CACnC,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC;CAC3B,CAAC;AAEF,QAAA,MAAM,WAAW,2CAAwC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,iBAAS,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAS7C;AAED,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC"}

package/dist/providers/formProvider.js

@@ -0,0 +1,69 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, cloneElement } from "react";
+const formContext = createContext({});
+/**
+ * FormProvider component - provides form context including field errors to child components
+ *
+ * @param props - FormProvider component properties
+ * @param props.children - React elements that will have access to the form context
+ * @param props.fieldErrors - Object containing validation errors indexed by field name
+ * @param props.form - Optional form element to wrap the children with
+ *
+ * @returns FormProvider JSX element that wraps children with form context
+ *
+ * @example
+ * ```tsx
+ * // Basic form provider with field errors
+ * function App() {
+ *   const errors = {
+ *     email: "Invalid email format",
+ *     password: "Password is required"
+ *   };
+ *
+ *   return (
+ *     <FormProvider fieldErrors={errors}>
+ *       <Input name="email" label="Email" />
+ *       <Input name="password" label="Password" type="password" />
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ * // Form provider with custom form element
+ * function FormWithValidation() {
+ *   const [errors, setErrors] = useState({});
+ *
+ *   const handleSubmit = (e) => {
+ *     e.preventDefault();
+ *     // validation logic
+ *   };
+ *
+ *   return (
+ *     <FormProvider
+ *       fieldErrors={errors}
+ *       form={<form onSubmit={handleSubmit} />}
+ *     >
+ *       <Input name="username" label="Username" />
+ *       <Button type="submit">Submit</Button>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ * // Using with useForm hook
+ * function FormField() {
+ *   const { fieldErrors } = useForm();
+ *
+ *   return (
+ *     <Input
+ *       name="email"
+ *       label="Email"
+ *       errorMessage={fieldErrors?.email}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+function FormProvider(props) {
+    const { children, fieldErrors, form } = props;
+    return (_jsxs(formContext.Provider, { value: { fieldErrors }, children: [!form && children, form && cloneElement(form, form.props, children)] }));
+}
+export { formContext, FormProvider };

package/dist/providers/modalProvider.d.ts

@@ -0,0 +1,103 @@
+import { ReactNode } from "react";
+type ModalContextProps<T = any> = {
+    modalIsOpen(key: string): boolean;
+    modalData(key: string): T;
+    openModal(key: string, data?: T): void;
+    closeModal(key: string): void;
+    closeAll(): void;
+};
+type ModalProviderProps = {
+    children: ReactNode;
+    enableModalAutomation?: boolean;
+};
+declare const modalContext: import("react").Context<ModalContextProps<any>>;
+/**
+ * ModalProvider component - provides modal context for managing multiple modals state and data
+ *
+ * @param props - ModalProvider component properties
+ * @param props.children - React elements that will have access to the modal context
+ * @param props.enableModalAutomation - Optional flag to enable modal automation features
+ *
+ * @returns ModalProvider JSX element that wraps children with modal context
+ *
+ * @example
+ * ```tsx
+ * // Basic modal provider setup
+ * function App() {
+ *   return (
+ *     <ModalProvider>
+ *       <UserModal />
+ *       <ConfirmModal />
+ *       <ImagePreviewModal />
+ *       <MainContent />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Modal provider with automation enabled
+ * function AppWithAutomation() {
+ *   return (
+ *     <ModalProvider enableModalAutomation={true}>
+ *       <Dashboard />
+ *       <SettingsModal />
+ *       <NotificationModal />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Using with multiple modals
+ * function MultiModalApp() {
+ *   return (
+ *     <ModalProvider>
+ *       <Header />
+ *       <Modal key="user-profile" />
+ *       <Modal key="edit-settings" />
+ *       <Modal key="confirm-delete" />
+ *       <MainContent />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Component using modal context
+ * function ModalTrigger() {
+ *   const { openModal, closeAll } = useModal();
+ *
+ *   const handleOpenUserModal = () => {
+ *     openModal('user-details', { userId: 123, mode: 'edit' });
+ *   };
+ *
+ *   const handleCloseAllModals = () => {
+ *     closeAll();
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleOpenUserModal}>
+ *         Open User Modal
+ *       </button>
+ *       <button onClick={handleCloseAllModals}>
+ *         Close All Modals
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ *
+ * // Modal component consuming context
+ * function UserDetailsModal() {
+ *   const { modalIsOpen, modalData, closeModal } = useModal('user-details');
+ *
+ *   if (!modalIsOpen) return null;
+ *
+ *   return (
+ *     <Modal onClose={() => closeModal('user-details')}>
+ *       <h2>User Details</h2>
+ *       <p>User ID: {modalData?.userId}</p>
+ *       <p>Mode: {modalData?.mode}</p>
+ *     </Modal>
+ *   );
+ * }
+ * ```
+ */
+declare function ModalProvider(args: ModalProviderProps): import("react/jsx-runtime").JSX.Element;
+export { modalContext, ModalProvider, type ModalContextProps };
+//# sourceMappingURL=modalProvider.d.ts.map

package/dist/providers/modalProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modalProvider.d.ts","sourceRoot":"","sources":["../../src/providers/modalProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAY,MAAM,OAAO,CAAC;AAE3D,KAAK,iBAAiB,CAAC,CAAC,GAAG,GAAG,IAAI;IAChC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC;IAC1B,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IACvC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,IAAI,IAAI,CAAC;CAClB,CAAC;AAOF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,QAAA,MAAM,YAAY,iDAAyC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAEH,iBAAS,aAAa,CAAC,IAAI,EAAE,kBAAkB,2CAqC9C;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,CAAC"}

package/dist/providers/modalProvider.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useState } from "react";
+const modalContext = createContext({});
+/**
+ * ModalProvider component - provides modal context for managing multiple modals state and data
+ *
+ * @param props - ModalProvider component properties
+ * @param props.children - React elements that will have access to the modal context
+ * @param props.enableModalAutomation - Optional flag to enable modal automation features
+ *
+ * @returns ModalProvider JSX element that wraps children with modal context
+ *
+ * @example
+ * ```tsx
+ * // Basic modal provider setup
+ * function App() {
+ *   return (
+ *     <ModalProvider>
+ *       <UserModal />
+ *       <ConfirmModal />
+ *       <ImagePreviewModal />
+ *       <MainContent />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Modal provider with automation enabled
+ * function AppWithAutomation() {
+ *   return (
+ *     <ModalProvider enableModalAutomation={true}>
+ *       <Dashboard />
+ *       <SettingsModal />
+ *       <NotificationModal />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Using with multiple modals
+ * function MultiModalApp() {
+ *   return (
+ *     <ModalProvider>
+ *       <Header />
+ *       <Modal key="user-profile" />
+ *       <Modal key="edit-settings" />
+ *       <Modal key="confirm-delete" />
+ *       <MainContent />
+ *     </ModalProvider>
+ *   );
+ * }
+ *
+ * // Component using modal context
+ * function ModalTrigger() {
+ *   const { openModal, closeAll } = useModal();
+ *
+ *   const handleOpenUserModal = () => {
+ *     openModal('user-details', { userId: 123, mode: 'edit' });
+ *   };
+ *
+ *   const handleCloseAllModals = () => {
+ *     closeAll();
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleOpenUserModal}>
+ *         Open User Modal
+ *       </button>
+ *       <button onClick={handleCloseAllModals}>
+ *         Close All Modals
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ *
+ * // Modal component consuming context
+ * function UserDetailsModal() {
+ *   const { modalIsOpen, modalData, closeModal } = useModal('user-details');
+ *
+ *   if (!modalIsOpen) return null;
+ *
+ *   return (
+ *     <Modal onClose={() => closeModal('user-details')}>
+ *       <h2>User Details</h2>
+ *       <p>User ID: {modalData?.userId}</p>
+ *       <p>Mode: {modalData?.mode}</p>
+ *     </Modal>
+ *   );
+ * }
+ * ```
+ */
+function ModalProvider(args) {
+    const { children = false } = args;
+    const [openedModals, setOpenedModals] = useState([]);
+    function modalIsOpen(key) {
+        return !!openedModals.some((modal) => modal.key === key);
+    }
+    function modalData(key) {
+        return openedModals.find((modal) => modal.key === key)?.data;
+    }
+    function openModal(key, data) {
+        const alreadyExist = modalIsOpen(key);
+        if (alreadyExist) {
+            setOpenedModals((old) => {
+                const filtered = old.filter((modal) => modal.key !== key);
+                return [...filtered, { key, data }];
+            });
+        }
+        else
+            setOpenedModals([...openedModals, { key, data }]);
+    }
+    function closeModal(key) {
+        setOpenedModals(openedModals.filter((modal) => modal.key !== key));
+    }
+    function closeAll() {
+        setOpenedModals([]);
+    }
+    return (_jsx(modalContext.Provider, { value: { modalIsOpen, modalData, openModal, closeModal, closeAll }, children: children }));
+}
+export { modalContext, ModalProvider };

package/dist/providers/toastProvider.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from "react";
+type ToastProps = {
+    message: string;
+    type: "success" | "danger";
+};
+type ToastContextProps = {
+    showToast(toast: ToastProps): void;
+};
+type ToastProviderProps = {
+    children: ReactNode;
+};
+declare const toastContext: import("react").Context<ToastContextProps>;
+/**
+ * ToastProvider component - provides toast context for managing toast notifications
+ *
+ * @param props - ToastProvider component properties
+ * @param props.children - React elements that will have access to the toast context
+ *
+ * @returns ToastProvider JSX element that wraps children with toast context
+ *
+ * @example
+ * Basic usage:
+ * ```tsx
+ * <ToastProvider>
+ *   <App />
+ * </ToastProvider>
+ * ```
+ *
+ * @example
+ * Using toast in component:
+ * ```tsx
+ * function MyComponent() {
+ *   const { showToast } = useToast();
+ *
+ *   const handleClick = () => {
+ *     showToast({
+ *       message: 'Success!',
+ *       type: 'success'
+ *     });
+ *   };
+ *
+ *   return <button onClick={handleClick}>Show Toast</button>;
+ * }
+ * ```
+ */
+declare function ToastProvider({ children }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
+export { toastContext, ToastProvider };
+//# sourceMappingURL=toastProvider.d.ts.map

package/dist/providers/toastProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toastProvider.d.ts","sourceRoot":"","sources":["../../src/providers/toastProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAGjD,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;CAC5B,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CACpC,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,QAAA,MAAM,YAAY,4CAAyC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,iBAAS,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,kBAAkB,2CA2CtD;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/{provider/ToastProvider.js → providers/toastProvider.js}

@@ -1,6 +1,40 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext } from "react";
 import toast, { Toaster } from "react-hot-toast";
-import { ToastContext } from "../context/ToastContext";
+const toastContext = createContext({});
+/**
+ * ToastProvider component - provides toast context for managing toast notifications
+ *
+ * @param props - ToastProvider component properties
+ * @param props.children - React elements that will have access to the toast context
+ *
+ * @returns ToastProvider JSX element that wraps children with toast context
+ *
+ * @example
+ * Basic usage:
+ * ```tsx
+ * <ToastProvider>
+ *   <App />
+ * </ToastProvider>
+ * ```
+ *
+ * @example
+ * Using toast in component:
+ * ```tsx
+ * function MyComponent() {
+ *   const { showToast } = useToast();
+ *
+ *   const handleClick = () => {
+ *     showToast({
+ *       message: 'Success!',
+ *       type: 'success'
+ *     });
+ *   };
+ *
+ *   return <button onClick={handleClick}>Show Toast</button>;
+ * }
+ * ```
+ */
 function ToastProvider({ children }) {
     function showToast(props) {
         switch (props.type) {
@@ -34,6 +68,6 @@ function ToastProvider({ children }) {
                 });
         }
     }
-    return (_jsxs(ToastContext.Provider, { value: { showToast }, children: [_jsx(Toaster, { position: "top-right", containerStyle: { zIndex: 999999999999999 } }), children] }));
+    return (_jsxs(toastContext.Provider, { value: { showToast }, children: [_jsx(Toaster, { position: "top-right", containerStyle: { zIndex: 999999999999999 } }), children] }));
 }
-export { ToastProvider };
+export { toastContext, ToastProvider };

package/dist/services/iconRenderer.d.ts

@@ -0,0 +1,10 @@
+import { LucideIcon } from "lucide-react";
+type IconRendererProps = {
+    iconSize: number;
+    className?: string;
+    icon?: LucideIcon | string;
+    show?: boolean;
+};
+declare function IconRenderer(props: IconRendererProps): import("react/jsx-runtime").JSX.Element;
+export { IconRenderer };
+//# sourceMappingURL=iconRenderer.d.ts.map

package/dist/services/iconRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iconRenderer.d.ts","sourceRoot":"","sources":["../../src/services/iconRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,iBAAS,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAe7C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/services/iconRenderer.js

@@ -0,0 +1,13 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+function IconRenderer(props) {
+    const { iconSize, icon: Icon, className, show = true } = props;
+    if (!show)
+        return _jsx(_Fragment, {});
+    if (!Icon)
+        return _jsx(_Fragment, {});
+    if (typeof Icon === "string") {
+        return _jsx("p", { className: className, children: Icon });
+    }
+    return (_jsx("p", { className: className, children: _jsx(Icon, { size: iconSize, strokeWidth: 2.5 }) }));
+}
+export { IconRenderer };

package/dist/services/maskCurrencyValues.d.ts

@@ -0,0 +1,4 @@
+type Locale = "USD" | "EUR" | "JPY" | "GBP" | "AUD" | "CAD" | "CHF" | "CNY" | "SEK" | "NZD" | "BRL" | "INR" | "RUB" | "ZAR" | "MXN" | "SGD" | "HKD" | "NOK" | "KRW" | "TRY" | "IDR" | "THB";
+declare function maskCurrencyValues(inputFieldValue: string | number | undefined, locale: Locale): [number, string];
+export { maskCurrencyValues };
+//# sourceMappingURL=maskCurrencyValues.d.ts.map

package/dist/services/maskCurrencyValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maskCurrencyValues.d.ts","sourceRoot":"","sources":["../../src/services/maskCurrencyValues.ts"],"names":[],"mappings":"AAEA,KAAK,MAAM,GACP,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,CAAC;AAiBV,iBAAS,kBAAkB,CACzB,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAC5C,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,EAAE,MAAM,CAAC,CAOlB;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/services/maskCurrencyValues.js

@@ -0,0 +1,23 @@
+import { formatToCurrency, removeNonNumeric } from "@arkyn/shared";
+function normalizeValue(number) {
+    let safeNumber = number;
+    if (typeof number === "string") {
+        safeNumber = +removeNonNumeric(number);
+        if (safeNumber % 1 !== 0)
+            safeNumber = safeNumber.toFixed(2);
+    }
+    else {
+        safeNumber = Number.isInteger(number)
+            ? Number(number) * 10 ** 2
+            : number.toFixed(2);
+    }
+    return +removeNonNumeric(String(safeNumber)) / 10 ** 2;
+}
+function maskCurrencyValues(inputFieldValue, locale) {
+    if (!inputFieldValue)
+        return [0, formatToCurrency(0, locale)];
+    const value = normalizeValue(inputFieldValue);
+    const maskedValue = formatToCurrency(value, locale);
+    return [value, maskedValue];
+}
+export { maskCurrencyValues };

package/dist/services/toHtml.d.ts

@@ -0,0 +1,20 @@
+import { RichTextValue } from "../types/richTextTypes";
+/**
+ * Converts a RichTextValue array to HTML string format.
+ *
+ * @param {RichTextValue} richTextValue - Array of Descendant objects representing rich text content
+ * @returns {string} HTML string representation of the rich text content
+ *
+ * @example
+ * ```typescript
+ * const richTextService = new RichTextService();
+ * const richText = [
+ *   { type: 'paragraph', children: [{ text: 'Hello world', bold: true }] }
+ * ];
+ * const html = richTextService.toHtml(richText);
+ * // Returns: "<p><strong>Hello world</strong></p>"
+ * ```
+ */
+declare function toHtml(richTextValue: RichTextValue): string;
+export { toHtml };
+//# sourceMappingURL=toHtml.d.ts.map