rc-lib-ui 1.1.10 → 1.1.12

package/README.md

@@ -1,9 +1,10 @@
 <h1 align="center">rc-ui-lib</h1>
 
-#### Preloaders
+
+<h3 align="center">Preloaders</h3>
 
 ```tsx
-import { Preloaders } from "rc-lib-ui";
+import { Preloaders } from "rc-lib-ui/preloaders";
 
 export const App = () => {
   //SpinnerGrow | SpinnerBorder | Spinner3D | Ball | Time | Cube | RotateCube
@@ -18,12 +19,13 @@ export const App = () => {
 };
 ```
 
----
 
-#### Dashboard
+
+___
+<h3 align="center">Dashboard</h3>
 
 ```tsx
-import { Dashboard } from "rc-lib-ui";
+import { Dashboard } from "rc-lib-ui/dashboard";
 
 const listMen = [
   {
@@ -137,4 +139,38 @@ export const App = () => {
 }
 ```
 
----
+___
+
+<h3 align="center">Socket Components</h3>
+
+
+```tsx
+import { Socket } from "rc-lib-ui/socket";
+
+<Socket.Initialization
+    onMount={() => {
+      dispatch(InitSocketEvents())
+    }}
+    isNetwork={!!isNetwork}
+    typeNetwork={typeNetwork}
+    init={{
+      url: process.env.REACT_APP_URL_WS as string,
+      timeReConnect: 10000,
+      isReConnectNetworkOnline: true,
+   
+    }}
+  />
+
+// Отображение состояния сокета
+  <Socket.ConnectDetection/> 
+  <Socket.OfflineDetection 
+    isNetwork={!!isNetwork}
+    children={({isDisableConnectSocket}) => {
+      const titleOffline = 'Оффлайн';
+      return isDisableConnectSocket ? `Режим ${titleOffline}` : titleOffline
+    }}
+    />
+  //Воздействие на сокет
+  <Socket.ReConnectButton/>,
+ 
+```

package/dist/Dashboard/Dashboard.d.ts

@@ -1,5 +1,5 @@
-import { default as React, ReactNode } from 'react';
 import { SxProps, Theme } from '@mui/material';
+import { default as React, ReactNode } from 'react';
 import { ListMenuProps } from './components/ListMemu/ListMenu';
 import { MuiHeaderProps } from './components/MuiHeader';
 import { MuiMenuProps } from './components/MuiMenu';

package/dist/Dashboard/components/ContentBox.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 export interface ContentBoxProps {
 }
-export declare const ContentBox: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & ContentBoxProps, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, {}>;
+export declare const ContentBox: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & ContentBoxProps, React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, {}>;

package/dist/Dashboard/components/DrawerToggleMenu.d.ts

@@ -1 +1,2 @@
-export declare const DrawerToggleMenu: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+import { default as React } from 'react';
+export declare const DrawerToggleMenu: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/Dashboard/components/ListMemu/ListMenu.d.ts

@@ -1,5 +1,5 @@
-import { CSSObject, SxProps, Theme } from '@mui/material';
 import { default as React, ReactNode } from 'react';
+import { CSSObject, SxProps, Theme } from '@mui/material';
 import { ListButtonProps } from './ui/ListButton';
 import { ListTextProps } from './ui/ListText';
 import { RenderIconProps } from './ui/RenderIcon';

package/dist/Dashboard/components/ListMemu/ui/ListButtonStyled.d.ts

@@ -3,7 +3,7 @@ export interface ListButtonStyledProps {
 }
 export declare const ListButtonStyled: import('@emotion/styled').StyledComponent<import('@mui/material').ListItemButtonOwnProps & Omit<import('@mui/material').ButtonBaseOwnProps, "classes"> & import('@mui/material/OverridableComponent').CommonProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, "alignItems" | "sx" | "children" | "style" | "autoFocus" | "className" | "tabIndex" | "disabled" | "action" | "selected" | "dense" | "classes" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "disableGutters" | "divider"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & ListButtonStyledProps, {}, {}>;
+}, "className" | "style" | "classes" | "alignItems" | "children" | "sx" | "autoFocus" | "tabIndex" | "dense" | "disabled" | "action" | "selected" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "disableGutters" | "divider"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & ListButtonStyledProps, {}, {}>;
 export declare const defaultState: {
     minHeight: number;
     height: number;

package/dist/Dashboard/components/ListMemu/ui/RenderList.d.ts

@@ -3,4 +3,4 @@ export interface RenderListProps {
 }
 export declare const RenderList: import('@emotion/styled').StyledComponent<import('@mui/material').ListOwnProps & import('@mui/material/OverridableComponent').CommonProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
     ref?: ((instance: HTMLUListElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLUListElement> | null | undefined;
-}, "sx" | "children" | "style" | "className" | "dense" | "classes" | "disablePadding" | "subheader"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & RenderListProps, {}, {}>;
+}, "className" | "style" | "classes" | "children" | "sx" | "dense" | "disablePadding" | "subheader"> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & RenderListProps, {}, {}>;

package/dist/Dashboard/components/MuiFooter.d.ts

@@ -1,5 +1,6 @@
+import { default as React } from 'react';
 export interface MuiFooterProps {
 }
-export declare const MuiFooter: import('@emotion/styled').StyledComponent<import('@mui/system').BoxOwnProps<import('@mui/material').Theme> & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
+export declare const MuiFooter: import('@emotion/styled').StyledComponent<import('@mui/system').BoxOwnProps<import('@mui/material').Theme> & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
 }, keyof import('@mui/system').BoxOwnProps<import('@mui/material').Theme>> & import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & MuiFooterProps, {}, {}>;

package/dist/Dashboard/components/MuiMenuHeader.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 export interface MuiMenuHeaderProps {
 }
-export declare const MuiMenuHeader: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & MuiMenuHeaderProps, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const MuiMenuHeader: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & MuiMenuHeaderProps, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/NetworkAndSocket/Network/components/Detection/CustomDetection.d.ts

@@ -0,0 +1 @@
+export declare const CustomDetection: () => import("react/jsx-runtime").JSX.Element;

package/dist/NetworkAndSocket/Network/components/Detection/Detection.d.ts

@@ -1,8 +1,8 @@
 import { default as React } from 'react';
-import { InitialStateProps } from '../../store/network.types';
+import { InitialStatePropsNetwork } from '../../store/network.types';
 export interface DetectionProps extends Pick<React.HTMLAttributes<HTMLDivElement>, 'className'> {
     profile?: 'min-bottom';
-    getStatus?: (props: InitialStateProps['infoNetwork']) => void;
+    getStatus?: (props: InitialStatePropsNetwork['infoNetwork']) => void;
     children?: React.ReactNode;
 }
 export declare const Detection: React.NamedExoticComponent<DetectionProps>;

package/dist/NetworkAndSocket/Network/components/index.d.ts

@@ -0,0 +1,4 @@
+export declare const Network: {
+    Render: import('react').NamedExoticComponent<import('./Render/Render').NetworkWatcherRenderProps>;
+    Detection: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/NetworkAndSocket/Network/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './store/network.store';
+export * from './store/network.types';

package/dist/NetworkAndSocket/Network/store/network.initial.d.ts

@@ -1,4 +1,4 @@
-import { InitialStateProps } from './network.types';
-declare const initialState: InitialStateProps;
+import { InitialStatePropsNetwork } from './network.types';
+declare const initialState: InitialStatePropsNetwork;
 declare const defaultInitialState: typeof initialState;
 export { defaultInitialState, initialState };

package/dist/NetworkAndSocket/Network/store/network.store.d.ts

@@ -1,16 +1,16 @@
-import { InitialStateProps, NetworkActions } from './network.types';
-export declare const storeNetwork: import('zustand').UseBoundStore<import('zustand').StoreApi<InitialStateProps>>;
+import { InitialStatePropsNetwork, NetworkActions } from './network.types';
+export declare const storeNetwork: import('zustand').UseBoundStore<import('zustand').StoreApi<InitialStatePropsNetwork>>;
 export declare const networkActions: NetworkActions;
 export declare const networkSelectors: {
-    getNetworkStatus: (state: InitialStateProps) => boolean | null;
-    getTypeNetwork: (state: InitialStateProps) => string;
-    getInfoNetworkStatus: (state: InitialStateProps) => {
+    getNetworkStatus: (state: InitialStatePropsNetwork) => boolean | null;
+    getTypeNetwork: (state: InitialStatePropsNetwork) => string;
+    getInfoNetworkStatus: (state: InitialStatePropsNetwork) => {
         online: "" | "active";
         offline: "" | "active";
-        action: "" | "online" | "offline";
+        action: "" | "offline" | "online";
         status: null | boolean;
         titleOnline: string;
         titleOffline: string;
     };
 };
-export declare const useNetworkSelector: <TSelected>(selector: (state: InitialStateProps) => TSelected) => TSelected;
+export declare const useNetworkSelector: <TSelected>(selector: (state: InitialStatePropsNetwork) => TSelected) => TSelected;

package/dist/NetworkAndSocket/Network/store/network.types.d.ts

@@ -1,6 +1,6 @@
 type NetworkActive_OR = '' | 'active';
 type NetworkKey_OR = '' | 'online' | 'offline';
-interface InitialStateProps {
+interface InitialStatePropsNetwork {
     isNetwork: boolean | null;
     typeNetwork: string;
     infoNetwork: {
@@ -14,8 +14,8 @@ interface InitialStateProps {
 }
 interface NetworkActions {
     resetState: () => void;
-    setTypeNetwork: (payload: Pick<InitialStateProps, 'typeNetwork'>) => void;
-    setNetworkStatus: (payload: Pick<InitialStateProps, 'isNetwork'>) => void;
-    setInfoNetworkStatus: (payload: Pick<InitialStateProps, 'infoNetwork'>) => void;
+    setTypeNetwork: (payload: Pick<InitialStatePropsNetwork, 'typeNetwork'>) => void;
+    setNetworkStatus: (payload: Pick<InitialStatePropsNetwork, 'isNetwork'>) => void;
+    setInfoNetworkStatus: (payload: Pick<InitialStatePropsNetwork, 'infoNetwork'>) => void;
 }
-export { type InitialStateProps, type NetworkActions };
+export { type InitialStatePropsNetwork, type NetworkActions };

package/dist/NetworkAndSocket/Socket/api/SocketApi.d.ts

@@ -0,0 +1,57 @@
+import { NetworkInfo } from './deps/NetworkControls';
+import { WsApi_Options_P } from './deps/WsApi';
+import { WsApi_Events } from './deps/WsApi/WsApi.types';
+import { SocketApi_Options_P, SocketApi_StateProps_P, SocketApiOptionsRequest } from './SocketApi.types';
+interface SocketApi_Events {
+    timeOffReConnect(info: {
+        status: boolean;
+        msg: string;
+    }): void;
+    reConnect(status: boolean): void;
+    network(info: NetworkInfo): void;
+}
+type CommonEvents = SocketApi_Events & WsApi_Events;
+export declare class SocketApi {
+    #private;
+    private static state;
+    private static options;
+    private static wsApi;
+    private static delay;
+    private static networkTicker;
+    private static events;
+    private static saveID;
+    private static stateDefault;
+    private static copyState;
+    private static setState;
+    private static resetState;
+    private static setOptions;
+    private static setStatusReConnect;
+    private static setInfoConnect;
+    private static online;
+    private static offline;
+    private static splitOptions;
+    static getState: () => SocketApi_StateProps_P;
+    static on: <K extends keyof CommonEvents>(name: K, cb: CommonEvents[K]) => void;
+    static off: typeof SocketApi.wsApi.events.subscribe & typeof SocketApi.events.subscribe;
+    static getRequestSave: () => {
+        requestAction: string;
+        requestTime: number;
+        payload: {
+            action: string;
+            [key: string]: any;
+        };
+        reqId: string;
+        cb: any;
+    }[];
+    static getStatusSocket: () => import('./deps/WsApi').WsApiE_StatusConnect_OR;
+    static close: () => void;
+    private static setNetworkStatus;
+    static init: (options: WsApi_Options_P & SocketApi_Options_P) => void;
+    static connect(): Promise<void>;
+    static disconnect(): void;
+    static send<P = any, Data = any>(payload: P, cb?: (data: Data) => void): void;
+    static stopReConnect(status?: boolean): void;
+    static socketReConnect: () => void;
+    static request<P = any, Data = any>(keyRequest: string, payload: P, options?: SocketApiOptionsRequest): Promise<Data>;
+}
+export {};

package/dist/NetworkAndSocket/Socket/api/SocketApi.types.d.ts

@@ -0,0 +1,19 @@
+import { WsApiE_StatusConnect_OR } from './deps/WsApi';
+import { WsApi_Response } from './deps/WsApi/WsApi.types';
+export interface SocketApi_Options_P {
+    isReConnectNetworkOnline?: boolean;
+    listUrlsCheckConnectNetwork?: string[];
+}
+type SocketApi_StateProps_OR = 'isDisconnect' | 'isActiveReConnect' | 'isOfflineSocket' | 'isReady' | 'isGotWasFirstConnection' | 'isStartCheckNetwork';
+export type SocketApi_StateProps_P = Record<SocketApi_StateProps_OR, boolean>;
+export type SocketApi_StatusConnect_OR = WsApiE_StatusConnect_OR;
+export interface SocketRequest {
+    action: string;
+    [key: string]: any;
+}
+export type SocketResponse<P = any, Data = any> = WsApi_Response<P, Data>;
+export interface SocketApiOptionsRequest {
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export {};

package/dist/NetworkAndSocket/Socket/api/deps/ConfigInfoConnect/ConfigInfoConnect.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInfoConnectI, OptionsConditionReConnect } from './ConfigInfoConnect.types';
+export declare class ConfigInfoConnect implements ConfigInfoConnectI {
+    options: {
+        stop: boolean;
+    };
+    setConditionReConnect: (options: Partial<OptionsConditionReConnect>) => void;
+}

package/dist/NetworkAndSocket/Socket/api/deps/ConfigInfoConnect/ConfigInfoConnect.types.d.ts

@@ -0,0 +1,7 @@
+export interface OptionsConditionReConnect {
+    stop: boolean;
+}
+export interface ConfigInfoConnectI {
+    options: OptionsConditionReConnect;
+    setConditionReConnect(options: Partial<OptionsConditionReConnect>): void;
+}

package/dist/NetworkAndSocket/Socket/api/deps/DelaysPromise/DelaysPromise.d.ts

@@ -0,0 +1,7 @@
+import { DelaysPromiseProps } from './DelaysPromise.types';
+export declare class DelaysPromise {
+    private defaultProps;
+    startActionEvery: DelaysPromiseProps['startActionEvery'];
+    oneOf: DelaysPromiseProps['oneOf'];
+    oneOfPromise: DelaysPromiseProps['oneOfPromise'];
+}

package/dist/NetworkAndSocket/Socket/api/deps/DelaysPromise/DelaysPromise.types.d.ts

@@ -0,0 +1,31 @@
+export interface ControlAction {
+    stop(status?: boolean): void;
+    getIsActiveEvent(): boolean;
+}
+interface StartActionEveryConfigI {
+    interval: number;
+    cutoffTime?: number;
+    countAction?: number;
+    watchIdInterval?(id: number | null): void;
+    controlAction?(control: ControlAction): void;
+}
+interface OneOfPromiseReject {
+    status: boolean;
+    msg: string;
+}
+export interface DelaysPromiseProps {
+    startActionEvery: (cb: () => boolean, config: StartActionEveryConfigI) => {
+        stop: ControlAction['stop'];
+        promise: Promise<{
+            status: boolean;
+            msg: string;
+        }>;
+    };
+    oneOf: <T = any>(watchPromise: () => Promise<T>, potentialCaseCB: () => void, config: {
+        second: number;
+    }) => void;
+    oneOfPromise: <T = any>(watchPromise: () => Promise<any>, cbPotentialReject: (p: OneOfPromiseReject) => OneOfPromiseReject, config: {
+        second: number;
+    }) => Promise<T>;
+}
+export {};

package/dist/NetworkAndSocket/Socket/api/deps/DelaysPromise/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DelaysPromise';
+export type { DelaysPromiseProps, ControlAction } from './DelaysPromise.types';

package/dist/NetworkAndSocket/Socket/api/deps/EventSubscribers/EventSubscribers.d.ts

@@ -0,0 +1,13 @@
+import { EventSubscribersProps } from './EventSubscribers.types';
+export declare class EventSubscribers<EventsProps extends {
+    [K in keyof EventsProps]: (...args: any[]) => any;
+}> {
+    private subscribersEvents;
+    constructor(eventsRegister: (keyof EventsProps)[]);
+    getListNameEvents: () => string[];
+    getSubscribers: () => { [K in keyof EventsProps]?: EventsProps[K][] | undefined; };
+    subscribe: EventSubscribersProps<EventsProps>['subscribe'];
+    unsubscribe: EventSubscribersProps<EventsProps>['unsubscribe'];
+    publish: EventSubscribersProps<EventsProps>['publish'];
+    resetSubscribers: EventSubscribersProps<EventsProps>['resetSubscribers'];
+}

package/dist/NetworkAndSocket/Socket/api/deps/EventSubscribers/EventSubscribers.types.d.ts

@@ -0,0 +1,9 @@
+export interface EventSubscribersProps<EventsProps> {
+    getSubscribers: () => {
+        [K in keyof EventsProps]?: EventsProps[K][];
+    };
+    subscribe: <K extends keyof EventsProps>(name: K, cb: EventsProps[K]) => void;
+    unsubscribe: <K extends keyof EventsProps>(name: K, cb: EventsProps[K]) => void;
+    publish: <K extends keyof EventsProps>(name: K, data: EventsProps[K] extends (...args: any[]) => any ? Parameters<EventsProps[K]>[0] : any) => void;
+    resetSubscribers: () => void;
+}

package/dist/NetworkAndSocket/Socket/api/deps/EventSubscribers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EventSubscribers';
+export * from './EventSubscribers.types';

package/dist/NetworkAndSocket/Socket/api/deps/NetworkControls/NetworkControls.d.ts

@@ -0,0 +1,14 @@
+import { OnStatusChange } from '../NetworkStatusTracker/NetworkStatusTracker.types';
+import { NetworkControlsConfigProps, NetworkControlsStateProps, NetworkMonitorCallback, NetworkMonitorCallbackInterval } from './NetworkControls.types';
+export declare class NetworkControls {
+    private networkTicker;
+    private state;
+    private config;
+    private setState;
+    getState(): NetworkControlsStateProps;
+    private saveCallback;
+    constructor(listUrlsCheckConnection: string[]);
+    getNetworkStatus(onStatusChange?: OnStatusChange): void;
+    motitorNetwirk(cbInterval: NetworkMonitorCallbackInterval, cb: NetworkMonitorCallback, options?: NetworkControlsConfigProps): Promise<void>;
+    stopMotitorNetwirk(): void;
+}

package/dist/NetworkAndSocket/Socket/api/deps/NetworkControls/NetworkControls.types.d.ts

@@ -0,0 +1,19 @@
+export type NetworkStatus = 'unknown' | 'none' | 'wifi' | '2g' | '3g' | '4g';
+export interface NetworkInfo {
+    isNetwork: boolean;
+    typeNetwork: string;
+}
+export interface NetworkControlsStateProps extends NetworkInfo {
+    isActiveDelay: boolean;
+}
+export interface NetworkControlsConfigProps {
+    interval?: number;
+    isAutoStop?: boolean;
+}
+export type NetworkMonitorCallback = (info: NetworkInfo) => void;
+interface NetworkMonitorCallbackIntervalConfig {
+    reset: () => void;
+    sendNetworkInfo: NetworkMonitorCallback;
+}
+export type NetworkMonitorCallbackInterval = (config: NetworkMonitorCallbackIntervalConfig) => void;
+export {};

package/dist/NetworkAndSocket/Socket/api/deps/NetworkControls/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NetworkControls';
+export * from './NetworkControls.types';

package/dist/NetworkAndSocket/Socket/api/deps/NetworkStatusTracker/NetworkStatusTracker.d.ts

@@ -0,0 +1,31 @@
+import { NetworkStatusInfoTracker, NetworkStatusConfig, OnStatusChange, NetworkConstructorConfig } from './NetworkStatusTracker.types';
+export declare class NetworkStatusTracker {
+    private networkInfo;
+    private listUrls;
+    private state;
+    private setState;
+    private getState;
+    constructor(listUrls: string[]);
+    private getFetchOptions;
+    private getConnection;
+    private getIsNetwork;
+    private getTypeNetwork;
+    private updateState;
+    private controllersEvents;
+    private getControllersEvents;
+    private setControllersEvents;
+    startEvents(onStatusChange: OnStatusChange): void;
+    stopEvents(): void;
+    private requestByUrls;
+    private checkConnection;
+    private controllersFetching;
+    private getControllersMonitoring;
+    private setControllersMonitoring;
+    private startFetching;
+    stopFetching(): void;
+    checkStatus(onStatusChange?: OnStatusChange, config?: NetworkConstructorConfig): Promise<NetworkStatusInfoTracker>;
+    fetchingNetwork(onStatusChange: OnStatusChange, config: Required<NetworkStatusConfig>): {
+        stop: () => void;
+    };
+    getCurrentState(): NetworkStatusInfoTracker;
+}

package/dist/NetworkAndSocket/Socket/api/deps/NetworkStatusTracker/NetworkStatusTracker.types.d.ts

@@ -0,0 +1,22 @@
+export interface NetworkInfoConnection {
+    downlink?: number;
+    effectiveType?: string;
+    rtt?: number;
+    saveData?: boolean;
+    type?: string;
+}
+export interface NetworkStatusInfoTracker {
+    isNetwork: boolean;
+    typeNetwork: string;
+}
+export interface NetworkStatusConfig {
+    interval?: number;
+}
+export interface NetworkConstructorConfig {
+    timeout?: number;
+}
+export type OnStatusChange = (info: NetworkStatusInfoTracker) => void;
+export interface NetworkItemListTracker {
+    keyNameSystem: string;
+    getInfo: () => NetworkStatusInfoTracker;
+}

package/dist/NetworkAndSocket/Socket/api/deps/WsApi/WsApi.d.ts

@@ -0,0 +1,52 @@
+import { EventSubscribers } from '../EventSubscribers/EventSubscribers';
+import { WsApi_Events, WsApi_Options_P, WsApi_StateProps, WsApiE_StatusConnect_OR } from './WsApi.types';
+export declare class WsApi {
+    private options;
+    private state;
+    private initOptions;
+    events: EventSubscribers<WsApi_Events>;
+    private stateDefault;
+    private resetState;
+    private setState;
+    private eventListener;
+    private openHandler;
+    private closeHandler;
+    private msgHandler;
+    private errHandler;
+    private copyState;
+    private filterSaveItemsByResponse;
+    private errorInitSocket;
+    private setStatus;
+    getState: () => WsApi_StateProps;
+    getSocket: () => WebSocket | null;
+    getStatusSocket: () => WsApiE_StatusConnect_OR;
+    getRequestSave: () => {
+        requestAction: string;
+        requestTime: number;
+        payload: {
+            action: string;
+            [key: string]: any;
+        };
+        reqId: string;
+        cb: any;
+    }[];
+    getOptions: () => WsApi_Options_P;
+    init: (options: typeof this.options) => void;
+    getIsInitWS: () => boolean;
+    connect(): void;
+    close(): void;
+    disconnect(): void;
+    send(data: any): void;
+    setRequestSave(reqInfo: (typeof this.state.arrSaveReq)[number]): void;
+    private getItemsRequestSaveByAction;
+    findDataRequestByAction: (action: string) => {
+        requestAction: string;
+        requestTime: number;
+        payload: {
+            action: string;
+            [key: string]: any;
+        };
+        reqId: string;
+        cb: any;
+    };
+}

package/dist/NetworkAndSocket/Socket/api/deps/WsApi/WsApi.types.d.ts

@@ -0,0 +1,40 @@
+export interface WsApi_Options_P {
+    url: string;
+    timeReConnect: number;
+    numberOfRepit?: number;
+}
+export type WsApiE_StatusConnect_OR = "pending" | "ready" | "error" | "close" | "disconnect";
+export interface WsApi_Events {
+    status(status: WsApiE_StatusConnect_OR): void;
+    msg(message: any): void;
+    error(error: {
+        readyState: number;
+        arrSaveReq: WsApi_StateProps['arrSaveReq'];
+    }): void;
+}
+export interface WsApi_RequestMeta<P> {
+    requestAction: string;
+    requestTime: number;
+    payload: P;
+    reqId: string;
+}
+export type WsApi_Response<P, D> = D & {
+    request: WsApi_RequestMeta<P>;
+};
+export interface WsApi_SaveRequest_P<P, D> extends WsApi_RequestMeta<P> {
+    cb: (response: WsApi_Response<P, D>) => void;
+}
+export interface WsApi_StateProps {
+    statusConnect: WsApiE_StatusConnect_OR;
+    ws: null | WebSocket;
+    arrSaveReq: {
+        requestAction: string;
+        requestTime: number;
+        payload: {
+            action: string;
+            [key: string]: any;
+        };
+        reqId: string;
+        cb: any;
+    }[];
+}

package/dist/NetworkAndSocket/Socket/api/deps/WsApi/index.d.ts

@@ -0,0 +1,2 @@
+export * from './WsApi';
+export type { WsApiE_StatusConnect_OR, WsApi_Options_P, } from './WsApi.types';

package/dist/NetworkAndSocket/Socket/api/helpers/createRequestSocket/createRequestSocket.d.ts

@@ -0,0 +1,2 @@
+import { CreateRequestSocketProps } from './createRequestSocket.types';
+export declare const createRequestSocket: <ResponseSocket = any>(cb: (data: ResponseSocket) => void, { payload, socketAction, signal }: CreateRequestSocketProps) => void;

package/dist/NetworkAndSocket/Socket/api/helpers/createRequestSocket/createRequestSocket.types.d.ts

@@ -0,0 +1,5 @@
+export interface CreateRequestSocketProps<D = any> {
+    payload: D;
+    socketAction: string;
+    signal?: AbortSignal;
+}

package/dist/NetworkAndSocket/Socket/api/helpers/createRequestSocket/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createRequestSocket';
+export * from './createRequestSocket.types';

package/dist/NetworkAndSocket/Socket/api/hooks/useRequestSocketApi/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useRequestSocketApi';
+export * from './useRequestSocketApi.types';

package/dist/NetworkAndSocket/Socket/api/hooks/useRequestSocketApi/useRequestSocketApi.d.ts

@@ -0,0 +1,10 @@
+import { UseRequestSocketOptions } from './useRequestSocketApi.types';
+export declare const useRequestSocketApi: <P = any, Data = any>(keyRequest: string, payload: P, options?: UseRequestSocketOptions<Data>) => {
+    data: Data | null;
+    error: Error | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    refetch: () => Promise<void>;
+    abort: () => void;
+};

package/dist/NetworkAndSocket/Socket/api/hooks/useRequestSocketApi/useRequestSocketApi.types.d.ts

@@ -0,0 +1,6 @@
+export interface UseRequestSocketOptions<Data = any> {
+    skip?: boolean;
+    timeout?: number;
+    onSuccess?: (data: Data) => void;
+    onError?: (error: Error) => void;
+}

package/dist/NetworkAndSocket/Socket/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SocketApi';
+export { type SocketApi_StateProps_P, type SocketApi_StatusConnect_OR } from './SocketApi.types';