@dashadmin/dash-utils 1.3.73 → 1.3.74-srcfree.2

package/dist/components/LazyAppLoader.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface LazyAppLoaderConfig {
+    importFn: () => Promise<{
+        default: React.ComponentType<any>;
+    }>;
+    initDelay?: number;
+    fallbackComponent?: React.ComponentType<any>;
+    onError?: (error: Error) => void;
+}
+export declare const DefaultLoadFailedComponent: React.FC<{
+    message?: string;
+}>;
+export declare const createLazyAppComponent: (config: LazyAppLoaderConfig) => React.LazyExoticComponent<React.ComponentType<any>>;
+export declare const createSimpleLazyApp: (importFn: () => Promise<{
+    default: React.ComponentType<any>;
+}>, initDelay?: number) => React.LazyExoticComponent<React.ComponentType<any>>;
+export default createLazyAppComponent;

package/dist/components/MinimalLayout.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface MinimalLayoutProps {
+    children?: React.ReactNode;
+}
+export declare const MinimalLayout: React.FC<MinimalLayoutProps>;
+export default MinimalLayout;

package/dist/components/RouterComponent.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+export interface DashRouterComponentProps {
+    children?: React.ReactNode;
+    forceType?: 'hash' | 'browser';
+    basename?: string;
+    platformType?: string;
+    platform?: string;
+    loader?: React.ReactNode;
+    publicRoutes?: React.ReactNode | (() => React.ReactNode);
+    className?: string;
+}
+export type RouterComponentProps = DashRouterComponentProps;
+export declare const shouldUseHashRouter: (platformType?: string, platform?: string) => boolean;
+export declare const DashRouterComponent: React.FC<DashRouterComponentProps>;
+export declare const createRouterComponent: (envVars: {
+    PLATFORM_TYPE?: string;
+    PLATFORM?: string;
+}) => React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const RouterComponent: React.FC<DashRouterComponentProps>;
+export default DashRouterComponent;

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export { MinimalLayout, type MinimalLayoutProps } from './MinimalLayout';
+export { DashRouterComponent, RouterComponent, shouldUseHashRouter, createRouterComponent, type DashRouterComponentProps, type RouterComponentProps } from './RouterComponent';

package/dist/contexts/IPCMessageBrokerContext.d.ts

@@ -0,0 +1,42 @@
+import { DashIPCServiceType } from "../utils/dashIPCService";
+export interface LogMessage {
+    level: string;
+    message: string;
+    timestamp: string;
+}
+export interface SubprocessOutput {
+    type: string;
+    message: string;
+    timestamp: string;
+    pid?: number;
+    exitCode?: number;
+    error?: string;
+}
+export interface IPCMessageBrokerContextType {
+    lastMessage: string | undefined;
+    idleStatus: boolean;
+    logMessages: LogMessage[];
+    subprocessOutputs: SubprocessOutput[];
+    isElectronAvailable: boolean;
+}
+export interface IPCMessageBrokerConfig {
+    idleTime?: number;
+    resuscitationTime?: number;
+    maxLogMessages?: number;
+    maxSubprocessOutputs?: number;
+    maxInitAttempts?: number;
+    initRetryDelay?: number;
+}
+export declare const IPCMessageBrokerContext: import("react").Context<IPCMessageBrokerContextType>;
+export declare const useIPCMessageBroker: () => IPCMessageBrokerContextType;
+declare global {
+    interface Window {
+        DashIPCService?: DashIPCServiceType;
+    }
+}
+interface IPCMessageBrokerProviderProps {
+    children: React.ReactNode;
+    config?: IPCMessageBrokerConfig;
+}
+export declare const IPCMessageBrokerProvider: ({ children, config: userConfig }: IPCMessageBrokerProviderProps) => import("react").JSX.Element;
+export default IPCMessageBrokerProvider;

package/dist/hooks/useCapacitorAppStateRefresh.d.ts

@@ -0,0 +1,2 @@
+export declare const useCapacitorAppStateRefresh: (onResume?: () => void) => void;
+export default useCapacitorAppStateRefresh;

package/dist/hooks/useCapacitorKeyboard.d.ts

@@ -0,0 +1,19 @@
+export interface KeyboardState {
+    isKeyboardOpen: boolean;
+    keyboardHeight: number;
+}
+export interface UseCapacitorKeyboardOptions {
+    disableAccessoryBar?: boolean;
+    resizeMode?: 'body' | 'ionic' | 'native' | 'none';
+    debug?: boolean;
+}
+export declare const isCapacitorKeyboardAvailable: () => boolean;
+export declare const getCapacitorKeyboard: () => any;
+export declare const useCapacitorKeyboard: (options?: UseCapacitorKeyboardOptions) => {
+    hideKeyboard: () => Promise<void>;
+    showKeyboard: () => Promise<void>;
+    isCapacitorAvailable: boolean;
+    isKeyboardOpen: boolean;
+    keyboardHeight: number;
+};
+export default useCapacitorKeyboard;

package/dist/hooks/useDeviceStorageSync.d.ts

@@ -0,0 +1,4 @@
+export declare const useDeviceStorageSync: () => void;
+export declare const syncDeviceStoreToLocalStorage: () => Promise<void>;
+export declare const syncLocalStorageToDeviceStore: () => Promise<void>;
+export default useDeviceStorageSync;

package/dist/hooks/useDraggable.d.ts

@@ -0,0 +1,24 @@
+export interface DraggablePosition {
+    x: number;
+    y: number;
+}
+export interface UseDraggableOptions {
+    initialPosition?: DraggablePosition;
+    minX?: number;
+    minY?: number;
+    maxX?: number;
+    maxY?: number;
+    elementWidth?: number;
+    elementHeight?: number;
+    onPositionChange?: (position: DraggablePosition) => void;
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+}
+export interface UseDraggableReturn {
+    position: DraggablePosition;
+    isDragging: boolean;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    setPosition: (position: DraggablePosition) => void;
+}
+export declare const useDraggable: (options?: UseDraggableOptions) => UseDraggableReturn;
+export default useDraggable;

package/dist/hooks/useMenuStateInit.d.ts

@@ -0,0 +1,10 @@
+export interface UseMenuStateInitOptions {
+    navExpandedKey?: string;
+    navSizeKey?: string;
+    setNavExpandedAction?: (isExpanded: boolean) => any;
+    setNavSizeAction?: (size: string) => any;
+}
+export declare const useMenuStateInit: (options?: UseMenuStateInitOptions) => void;
+export declare const getInitialMenuState: (navExpandedKey?: string) => boolean;
+export declare const getInitialNavSize: (navSizeKey?: string) => any;
+export default useMenuStateInit;

package/dist/hooks/useMobileDetection.d.ts

@@ -0,0 +1,20 @@
+export interface MobileDetectionState {
+    isMobile: boolean;
+    isAndroid: boolean;
+    isIOS: boolean;
+    isWebView: boolean;
+    screenWidth: number;
+}
+export interface UseMobileDetectionOptions {
+    mobileBreakpoint?: number;
+    debug?: boolean;
+}
+export declare const checkMobileDevice: (mobileBreakpoint?: number) => boolean;
+export declare const isWebView: () => boolean;
+export declare const isAndroid: () => boolean;
+export declare const isIOS: () => boolean;
+export declare const isWindows: () => boolean;
+export declare const isMacOS: () => boolean;
+export declare const isLinux: () => boolean;
+export declare const useMobileDetection: (options?: UseMobileDetectionOptions) => MobileDetectionState;
+export default useMobileDetection;

package/dist/hooks/useNotifications.d.ts

@@ -0,0 +1,51 @@
+export interface ProcessedNotification {
+    id: string;
+    title: string;
+    message: string;
+    customer?: string;
+    store?: string;
+    timestamp: string;
+    isRead: boolean;
+    data?: any;
+    severity?: 'info' | 'warning' | 'error' | 'success';
+}
+export interface ToastNotification {
+    id: string;
+    title: string;
+    message: string;
+    severity: 'info' | 'warning' | 'error' | 'success';
+}
+export interface DialogNotification extends ProcessedNotification {
+    position: {
+        x: number;
+        y: number;
+    };
+    zIndex: number;
+}
+export interface UseNotificationsOptions {
+    maxNotifications?: number;
+    initialZIndex?: number;
+    toastAutoDismiss?: number;
+}
+export interface UseNotificationsReturn {
+    notifications: ProcessedNotification[];
+    toastNotifications: ToastNotification[];
+    dialogNotifications: DialogNotification[];
+    unreadCount: number;
+    addNotification: (notification: Omit<ProcessedNotification, 'id' | 'timestamp' | 'isRead'>) => ProcessedNotification;
+    addToast: (toast: Omit<ToastNotification, 'id'>) => string;
+    addDialogNotification: (notification: Omit<ProcessedNotification, 'id' | 'timestamp' | 'isRead'>) => DialogNotification;
+    markAsRead: (notificationId: string) => void;
+    markAllAsRead: () => void;
+    removeNotification: (notificationId: string) => void;
+    clearAllNotifications: () => void;
+    removeToast: (toastId: string) => void;
+    removeDialogNotification: (notificationId: string) => void;
+    bringDialogToFront: (notificationId: string) => void;
+    updateDialogPosition: (notificationId: string, position: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export declare const useNotifications: (options?: UseNotificationsOptions) => UseNotificationsReturn;
+export default useNotifications;

package/dist/hooks/useQuickSearch.d.ts

@@ -0,0 +1,6 @@
+export interface UseQuickSearchReturn {
+    quickSearchUseState: [string | null, React.Dispatch<React.SetStateAction<string | null>>];
+    sendQuickSearchEvent: (quickSearchString: string) => void;
+}
+export declare const useQuickSearch: () => UseQuickSearchReturn;
+export default useQuickSearch;

package/dist/hooks/useWindowSize.d.ts

@@ -0,0 +1,6 @@
+interface IWindowSize {
+    width: number | undefined;
+    height: number | undefined;
+}
+export declare const useWindowSize: () => IWindowSize;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export { useWindowSize } from './hooks/useWindowSize';
+export { useCapacitorAppStateRefresh } from './hooks/useCapacitorAppStateRefresh';
+export { useDeviceStorageSync } from './hooks/useDeviceStorageSync';
+export { useCapacitorKeyboard, isCapacitorKeyboardAvailable, getCapacitorKeyboard, type KeyboardState, type UseCapacitorKeyboardOptions } from './hooks/useCapacitorKeyboard';
+export { useMobileDetection, checkMobileDevice, isWebView, isAndroid, isIOS, isWindows, isMacOS, isLinux, type MobileDetectionState, type UseMobileDetectionOptions } from './hooks/useMobileDetection';
+export { useDraggable, type DraggablePosition, type UseDraggableOptions, type UseDraggableReturn } from './hooks/useDraggable';
+export { useNotifications, type ProcessedNotification, type ToastNotification, type DialogNotification, type UseNotificationsOptions, type UseNotificationsReturn } from './hooks/useNotifications';
+export { useQuickSearch, type UseQuickSearchReturn } from './hooks/useQuickSearch';
+export { useMenuStateInit, getInitialMenuState, getInitialNavSize, type UseMenuStateInitOptions } from './hooks/useMenuStateInit';
+export { updateDomCssVariables } from './utils/updateDomCssVariables';
+export { getEnv } from './utils/envUtils';
+export { dashStorage } from './utils/dashDtorage';
+export { EMAIL_REGEX, PHONE_REGEX, URL_REGEX, validateEmail, validatePhone, validateUrl, validateRequired, validateMinLength, validateMaxLength, validateRut, checkPasswordStrength, type PasswordStrength } from './utils/validation';
+export { isDashIPCServiceAvailable, isElectron, getDashIPCService, windowControl, startWindowDrag, executeIPCAction, onIPCStdout, useDashIPCService, type DashIPCServiceType } from './utils/dashIPCService';
+export { speak, speakAsync } from './utils/speechService';
+export { getStoredTheme, setStoredTheme, initializeStoredTheme, clearStoredTheme } from './utils/storedTheme';
+export { isDev, isProd, isTest, getEnvironment } from './utils/isDev';
+export { setupEnvironmentBodyClasses, useEnvironmentBodyClasses, type EnvironmentVars } from './utils/environmentBodyClasses';
+export { isWebView as isWebViewPlatform, isAndroid as isAndroidPlatform, isIOS as isIOSPlatform, isWindows as isWindowsPlatform, applyPlatformBodyClasses } from './utils/platformDetection';
+export { syncElectronStore, hasElectronStore } from './utils/electronStoreSync';
+export { requestNotificationPermission, isNotificationSupported, hasNotificationPermission, isNotificationDenied, getNotificationPermission } from './utils/notificationPermission';
+export { dashInitializeApp, dashBootstrapApp, type DashInitializeAppConfig } from './utils/dashBootstrapApp';
+export { createResourceLoader, createSimpleResourceLoader } from './utils/resourceLoader';
+export { createLogoutFromStorage, isUserAuthenticated, getCurrentUser, getAuthToken, getTenantId, getUserRoles, setAuthData, type LogoutConfig } from './utils/authProviderUtils';
+export { getResourceConfigManager, setResourceConfigs, getResourceConfig, processPostData, processFormData, buildQueryString, isFormDataResource, type IResourceConfig } from './utils/dataProviderUtils';
+export { MinimalLayout, type MinimalLayoutProps } from './components/MinimalLayout';
+export { DashRouterComponent, RouterComponent, shouldUseHashRouter, createRouterComponent, type DashRouterComponentProps, type RouterComponentProps } from './components/RouterComponent';
+export { IPCMessageBrokerContext, IPCMessageBrokerProvider, useIPCMessageBroker, type LogMessage, type SubprocessOutput, type IPCMessageBrokerContextType, type IPCMessageBrokerConfig } from './contexts/IPCMessageBrokerContext';
+export { createLazyAppComponent, createSimpleLazyApp, DefaultLoadFailedComponent, type LazyAppLoaderConfig } from './components/LazyAppLoader';
+export { priceFormatter } from "./utils/priceFormatter";

package/dist/utils/authProviderUtils.d.ts

@@ -0,0 +1,37 @@
+export interface LogoutConfig {
+    clearAuthPersistence?: () => void;
+    syncToDeviceStore?: () => Promise<void>;
+    removeCookies?: (names: string[]) => void;
+    additionalKeys?: string[];
+}
+export declare const createLogoutFromStorage: (config?: LogoutConfig) => (reason?: string) => Promise<void>;
+export declare const isUserAuthenticated: () => boolean;
+export declare const getCurrentUser: <T = any>() => T | null;
+export declare const getAuthToken: () => string | null;
+export declare const getTenantId: () => string | null;
+export declare const getUserRoles: <T = any>() => T[];
+export declare const setAuthData: (data: {
+    token?: string;
+    user?: any;
+    roles?: any[];
+    authenticated?: boolean;
+    tenant_id?: string;
+    user_id?: string;
+}) => void;
+declare const _default: {
+    createLogoutFromStorage: (config?: LogoutConfig) => (reason?: string) => Promise<void>;
+    isUserAuthenticated: () => boolean;
+    getCurrentUser: <T = any>() => T | null;
+    getAuthToken: () => string | null;
+    getTenantId: () => string | null;
+    getUserRoles: <T = any>() => T[];
+    setAuthData: (data: {
+        token?: string;
+        user?: any;
+        roles?: any[];
+        authenticated?: boolean;
+        tenant_id?: string;
+        user_id?: string;
+    }) => void;
+};
+export default _default;

package/dist/utils/dashBootstrapApp.d.ts

@@ -0,0 +1,9 @@
+export interface DashInitializeAppConfig {
+    defaultTheme?: string;
+    requestNotifications?: boolean;
+    syncElectron?: boolean;
+    applyPlatformClasses?: boolean;
+}
+export declare const dashInitializeApp: (config?: DashInitializeAppConfig) => Promise<void>;
+export declare const dashBootstrapApp: () => void;
+export default dashBootstrapApp;

package/dist/utils/dashDtorage.d.ts

@@ -0,0 +1,8 @@
+export declare class dashStorage {
+    private static localLayer;
+    private static get layer();
+    static getItem<T = any>(key: string): T | null;
+    static setItem<T = any>(key: string, value: T): void;
+    static removeItem(key: string): void;
+    static clear(): void;
+}

package/dist/utils/dashIPCService.d.ts

@@ -0,0 +1,93 @@
+export interface SpeechPayload {
+    message: string;
+    lang?: string;
+}
+export interface SubprocessOutput {
+    type: 'stdout' | 'stderr' | 'exit' | 'error' | 'print-stdout' | 'print-stderr';
+    message: string;
+    timestamp: string;
+    pid?: number;
+    exitCode?: number;
+    error?: string;
+    code?: string;
+}
+export interface ElectronLogData {
+    level: 'info' | 'error' | 'warn' | 'debug' | 'verbose';
+    message: string;
+    timestamp: string;
+}
+export interface DashIPCServiceType {
+    runPythonScript: (filePath: string, scriptPath: string, args: string[]) => void;
+    action: (action: string, payload: any) => void;
+    speak: (payload: string | SpeechPayload) => void;
+    playSound: (soundName: string) => void;
+    stopSound: () => void;
+    notify: (title: string, message: string) => void;
+    onPythonOutput: (callback: (data: any) => void) => void;
+    onServiceMessage: (callback: (data: any) => void) => void;
+    onStdout: (callback: (data: string) => void) => void;
+    onElectronLog: (callback: (logData: ElectronLogData) => void) => void;
+    onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => void;
+    windowControls: (action: 'minimize' | 'maximize' | 'close') => void;
+    startDrag: () => void;
+    print: (urlOrTest: string) => Promise<any>;
+    send?: (channel: string, data?: any) => void;
+    invoke?: (channel: string, data?: any) => Promise<any>;
+}
+export interface ElectronStoreType {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    getAll: () => Promise<Record<string, any>>;
+    syncToLocalStorage: () => Promise<Record<string, any>>;
+}
+declare global {
+    interface Window {
+        DashIPCService?: DashIPCServiceType;
+        electronStore?: ElectronStoreType;
+    }
+}
+export declare const isDashIPCServiceAvailable: () => boolean;
+export declare const isElectron: () => boolean;
+export declare const getDashIPCService: () => DashIPCServiceType | undefined;
+export declare const windowControl: (action: "minimize" | "maximize" | "close") => boolean;
+export declare const startWindowDrag: () => boolean;
+export declare const executeIPCAction: (action: string, payload: any) => boolean;
+export declare const onIPCStdout: (callback: (data: string) => void) => boolean;
+export declare const onElectronLog: (callback: (logData: ElectronLogData) => void) => boolean;
+export declare const onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => boolean;
+export declare const useDashIPCService: () => {
+    isAvailable: boolean;
+    isElectron: boolean;
+    service: DashIPCServiceType;
+    windowControl: (action: "minimize" | "maximize" | "close") => boolean;
+    startWindowDrag: () => boolean;
+    executeAction: (action: string, payload: any) => boolean;
+    onStdout: (callback: (data: string) => void) => boolean;
+    onElectronLog: (callback: (logData: ElectronLogData) => void) => boolean;
+    onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => boolean;
+};
+declare const _default: {
+    isDashIPCServiceAvailable: () => boolean;
+    isElectron: () => boolean;
+    getDashIPCService: () => DashIPCServiceType | undefined;
+    windowControl: (action: "minimize" | "maximize" | "close") => boolean;
+    startWindowDrag: () => boolean;
+    executeIPCAction: (action: string, payload: any) => boolean;
+    onIPCStdout: (callback: (data: string) => void) => boolean;
+    onElectronLog: (callback: (logData: ElectronLogData) => void) => boolean;
+    onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => boolean;
+    useDashIPCService: () => {
+        isAvailable: boolean;
+        isElectron: boolean;
+        service: DashIPCServiceType;
+        windowControl: (action: "minimize" | "maximize" | "close") => boolean;
+        startWindowDrag: () => boolean;
+        executeAction: (action: string, payload: any) => boolean;
+        onStdout: (callback: (data: string) => void) => boolean;
+        onElectronLog: (callback: (logData: ElectronLogData) => void) => boolean;
+        onSubprocessOutput: (callback: (data: SubprocessOutput) => void) => boolean;
+    };
+};
+export default _default;

package/dist/utils/dataProviderUtils.d.ts

@@ -0,0 +1,44 @@
+export interface IResourceConfig {
+    model?: string;
+    isFormData?: boolean;
+    dataTransform?: (data: Record<string, any>, operation: string) => Record<string, any>;
+    [key: string]: any;
+}
+declare class ResourceConfigManager<T extends IResourceConfig = IResourceConfig> {
+    private configs;
+    setConfigs(configs: T[]): void;
+    getConfigs(): T[];
+    getConfig(resource: string): T | undefined;
+    clear(): void;
+}
+export declare const getResourceConfigManager: <T extends IResourceConfig = IResourceConfig>() => ResourceConfigManager<T>;
+export declare const setResourceConfigs: <T extends IResourceConfig = IResourceConfig>(configs: T[]) => void;
+export declare const getResourceConfig: <T extends IResourceConfig = IResourceConfig>(resource: string) => T | undefined;
+export declare const processPostData: <T extends IResourceConfig = IResourceConfig>(resource: string, data: Record<string, any>, operation: "create" | "update" | "getList" | "import" | string) => Record<string, any>;
+export declare const processFormData: (resource: string, data: Record<string, any>) => FormData;
+export declare const buildQueryString: (params: Record<string, any>) => string;
+export declare const isFormDataResource: <T extends IResourceConfig = IResourceConfig>(resource: string, params?: {
+    data?: {
+        isFormData?: boolean;
+    };
+    meta?: {
+        isFormData?: boolean;
+    };
+}) => boolean;
+declare const _default: {
+    getResourceConfigManager: <T extends IResourceConfig = IResourceConfig>() => ResourceConfigManager<T>;
+    setResourceConfigs: <T extends IResourceConfig = IResourceConfig>(configs: T[]) => void;
+    getResourceConfig: <T extends IResourceConfig = IResourceConfig>(resource: string) => T | undefined;
+    processPostData: <T extends IResourceConfig = IResourceConfig>(resource: string, data: Record<string, any>, operation: "create" | "update" | "getList" | "import" | string) => Record<string, any>;
+    processFormData: (resource: string, data: Record<string, any>) => FormData;
+    buildQueryString: (params: Record<string, any>) => string;
+    isFormDataResource: <T extends IResourceConfig = IResourceConfig>(resource: string, params?: {
+        data?: {
+            isFormData?: boolean;
+        };
+        meta?: {
+            isFormData?: boolean;
+        };
+    }) => boolean;
+};
+export default _default;

package/dist/utils/electronStoreSync.d.ts

@@ -0,0 +1,3 @@
+export declare const syncElectronStore: () => Promise<void>;
+export declare const hasElectronStore: () => boolean;
+export default syncElectronStore;

package/dist/utils/envUtils.d.ts

@@ -0,0 +1 @@
+export declare const getEnv: (key: string) => any;

package/dist/utils/environmentBodyClasses.d.ts

@@ -0,0 +1,11 @@
+export interface EnvironmentVars {
+    PLATFORM_TYPE?: string;
+    IS_ELECTRON?: boolean;
+    IS_MAC?: boolean;
+    IS_WINDOWS?: boolean;
+    IS_LINUX?: boolean;
+    PLATFORM?: string;
+}
+export declare const setupEnvironmentBodyClasses: (envVars: EnvironmentVars) => (() => void);
+export declare const useEnvironmentBodyClasses: (envVars: EnvironmentVars) => void;
+export default setupEnvironmentBodyClasses;

package/dist/utils/isDev.d.ts

@@ -0,0 +1,5 @@
+export declare const isDev: () => boolean;
+export declare const isProd: () => boolean;
+export declare const isTest: () => boolean;
+export declare const getEnvironment: () => "development" | "production" | "test";
+export default isDev;

package/dist/utils/notificationPermission.d.ts

@@ -0,0 +1,5 @@
+export declare const requestNotificationPermission: () => Promise<NotificationPermission | null>;
+export declare const isNotificationSupported: () => boolean;
+export declare const hasNotificationPermission: () => boolean;
+export declare const isNotificationDenied: () => boolean;
+export declare const getNotificationPermission: () => NotificationPermission | null;

package/dist/utils/platformDetection.d.ts

@@ -0,0 +1,13 @@
+export declare const isWebView: () => boolean;
+export declare const isAndroid: () => boolean;
+export declare const isIOS: () => boolean;
+export declare const isWindows: () => boolean;
+export declare const applyPlatformBodyClasses: () => void;
+declare const _default: {
+    isWebView: () => boolean;
+    isAndroid: () => boolean;
+    isIOS: () => boolean;
+    isWindows: () => boolean;
+    applyPlatformBodyClasses: () => void;
+};
+export default _default;

package/dist/utils/priceFormatter.d.ts

@@ -0,0 +1,2 @@
+export declare const priceFormatter: (price: number, currencyCode?: string) => string;
+export default priceFormatter;

package/dist/utils/resourceLoader.d.ts

@@ -0,0 +1,8 @@
+export declare const createResourceLoader: <T>(loadFn: () => Promise<T[]>) => {
+    getResources: () => Promise<T[]>;
+    resources: T[];
+    clearCache: () => void;
+    isLoaded: () => boolean;
+};
+export declare const createSimpleResourceLoader: <T>(loadFn: () => Promise<T[]>) => (() => Promise<T[]>);
+export default createResourceLoader;

package/dist/utils/speechService.d.ts

@@ -0,0 +1,7 @@
+export declare const speak: (text: string, lang?: string) => void;
+export declare const speakAsync: (text: string, lang?: string) => Promise<void>;
+declare const _default: {
+    speak: (text: string, lang?: string) => void;
+    speakAsync: (text: string, lang?: string) => Promise<void>;
+};
+export default _default;

package/dist/utils/storedTheme.d.ts

@@ -0,0 +1,11 @@
+export declare const getStoredTheme: () => string | null;
+export declare const setStoredTheme: (theme: string) => void;
+export declare const initializeStoredTheme: (defaultTheme: string) => string;
+export declare const clearStoredTheme: () => void;
+declare const _default: {
+    getStoredTheme: () => string | null;
+    setStoredTheme: (theme: string) => void;
+    initializeStoredTheme: (defaultTheme: string) => string;
+    clearStoredTheme: () => void;
+};
+export default _default;

package/dist/utils/updateDomCssVariables.d.ts

@@ -0,0 +1,6 @@
+export declare const updateDomCssVariables: (theme: string, colors?: {
+    [x: string]: string;
+}, values?: {
+    [x: string]: string;
+}) => void;
+export default updateDomCssVariables;

package/dist/utils/validation.d.ts

@@ -0,0 +1,12 @@
+export declare const EMAIL_REGEX: RegExp;
+export declare const validateEmail: (email: string) => boolean;
+export declare const PHONE_REGEX: RegExp;
+export declare const validatePhone: (phone: string) => boolean;
+export declare const URL_REGEX: RegExp;
+export declare const validateUrl: (url: string) => boolean;
+export type PasswordStrength = 'weak' | 'fair' | 'good' | 'strong';
+export declare const checkPasswordStrength: (password: string) => PasswordStrength;
+export declare const validateRequired: (value: any) => boolean;
+export declare const validateMinLength: (value: string, minLength: number) => boolean;
+export declare const validateMaxLength: (value: string, maxLength: number) => boolean;
+export declare const validateRut: (rut: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dashadmin/dash-utils",
-	"version": "1.3.73",
+	"version": "1.3.74-srcfree.2",
 	"license": "MIT",
 	"main": "dist/index.js",
 	"devDependencies": {
@@ -26,10 +26,10 @@
 	},
 	"dependencies": {
 		"@mui/material": "^9.3.0",
-		"@dashadmin/dash-constants": "1.3.73"
+		"@dashadmin/dash-constants": "1.3.74-srcfree.2"
 	},
 	"module": "dist/index.js",
-	"types": "./src/index.ts",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": "./dist/index.js",
 		"./components": "./dist/components/index.js",
@@ -42,22 +42,25 @@
 		"registry": "https://registry.npmjs.org"
 	},
 	"scripts": {
-		"build": "tsup"
+		"build": "tsup && pnpm run build:types",
+		"build:types": "../../node_modules/.bin/tsc -p tsconfig.json --declaration --emitDeclarationOnly --noEmit false --outDir dist --rootDir src --skipLibCheck; test -f dist/index.d.ts"
 	},
 	"type": "module",
 	"files": [
-		"dist",
-		"src"
+		"dist"
 	],
 	"typesVersions": {
 		"*": {
+			"dist/*": [
+				"dist/*"
+			],
 			"src/*": [
-				"src/*",
-				"src/*/index"
+				"dist/*",
+				"dist/*/index"
 			],
 			"*": [
-				"src/*",
-				"src/*/index"
+				"dist/*",
+				"dist/*/index"
 			]
 		}
 	}