dev-classes 1.3.35 → 1.4.10

package/dist/classes/NetworkStatusTracker/NetworkStatusTracker.js

@@ -0,0 +1,158 @@
+var v = Object.defineProperty;
+var d = (r, t, e) => t in r ? v(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var s = (r, t, e) => (d(r, typeof t != "symbol" ? t + "" : t, e), e);
+class p {
+  constructor(t) {
+    s(this, "networkInfo");
+    s(this, "listUrls", []);
+    s(this, "state", {
+      isActiveEvents: !1,
+      isMonitoring: !1,
+      checkIntervalId: null
+    });
+    s(this, "getFetchOptions", (t) => ({
+      method: "HEAD",
+      cache: "no-store",
+      signal: t.signal,
+      headers: {
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0"
+      }
+    }));
+    s(this, "getIsNetwork", (t) => !["unknown", "none"].includes(t));
+    s(this, "getTypeNetwork", ({ effectiveType: t, type: e }, n) => (n || n === null) && (t || e) || "none");
+    /*-----------------------------------------------------------------------------*/
+    s(this, "controllersEvents", {
+      online: null,
+      offline: null,
+      change: null
+    });
+    s(this, "controllersFetching", {
+      online: null,
+      offline: null,
+      change: null
+    });
+    this.listUrls = t;
+    const e = typeof navigator < "u" ? navigator.onLine : !1;
+    this.networkInfo = {
+      isNetwork: e,
+      typeNetwork: this.getTypeNetwork(this.getConnection(), e)
+    };
+  }
+  setState(t) {
+    this.state = { ...this.state, ...t };
+  }
+  getState() {
+    return this.state;
+  }
+  getConnection() {
+    var t;
+    return (t = window == null ? void 0 : window.navigator) == null ? void 0 : t.connection;
+  }
+  updateState(t, e) {
+    const n = {
+      isNetwork: t,
+      typeNetwork: this.getTypeNetwork(this.getConnection(), t)
+    };
+    this.networkInfo = n, typeof e == "function" && e(n);
+  }
+  getControllersEvents() {
+    return this.controllersEvents;
+  }
+  setControllersEvents(t) {
+    this.controllersEvents = { ...this.controllersEvents, ...t };
+  }
+  startEvents(t) {
+    var l, c, a, h;
+    const { isActiveEvents: e } = this.getState();
+    if (e)
+      return;
+    this.setState({ isActiveEvents: !0 });
+    const n = {
+      online: new AbortController(),
+      offline: new AbortController(),
+      change: new AbortController()
+    };
+    this.setControllersEvents(n);
+    const o = this.getConnection(), i = this.getTypeNetwork(o, window.navigator.onLine), g = this.getIsNetwork(i);
+    this.updateState(g, t), window.addEventListener("online", () => {
+      this.updateState(!0, t);
+    }, { signal: (l = n.online) == null ? void 0 : l.signal }), window.addEventListener("offline", () => {
+      this.updateState(!1, t);
+    }, { signal: (c = n.offline) == null ? void 0 : c.signal }), (a = this.getConnection()) != null && a.addEventListener && this.getConnection().addEventListener("change", () => {
+      const u = this.getConnection(), w = this.getTypeNetwork(u, null), f = this.getIsNetwork(w);
+      this.updateState(f, t);
+    }, { signal: (h = n.change) == null ? void 0 : h.signal });
+  }
+  stopEvents() {
+    const { isActiveEvents: t } = this.getState();
+    if (t) {
+      this.setState({ isActiveEvents: !1 });
+      const e = this.getControllersEvents();
+      for (const n of Object.values(e))
+        n == null || n.abort();
+    }
+  }
+  /*-----------------------------------------------------------------------------*/
+  async requestByUrls(t, e) {
+    const n = await this.checkConnection(e);
+    this.updateState(n, t);
+  }
+  async checkConnection(t = {}) {
+    for (const e of this.listUrls)
+      try {
+        const n = new AbortController(), o = setTimeout(() => n.abort(), (t == null ? void 0 : t.timeout) || 5e3), i = await window.fetch(e);
+        if (clearTimeout(o), i.status >= 200 && i.status < 400)
+          return !0;
+      } catch {
+        continue;
+      }
+    return !1;
+  }
+  getControllersMonitoring() {
+    return this.controllersFetching;
+  }
+  setControllersMonitoring(t) {
+    this.controllersFetching = { ...this.controllersFetching, ...t };
+  }
+  startFetching(t, { interval: e = 5e3 }) {
+    const { isMonitoring: n } = this.getState();
+    if (n)
+      return;
+    this.setState({ isMonitoring: !0 });
+    const o = {
+      online: new AbortController(),
+      offline: new AbortController(),
+      change: new AbortController()
+    };
+    this.setControllersMonitoring(o), this.requestByUrls(t, { timeout: 2e3 });
+    const i = window.setInterval(() => this.requestByUrls(t), e);
+    this.setState({ checkIntervalId: i });
+  }
+  stopFetching() {
+    const { isMonitoring: t, checkIntervalId: e } = this.getState();
+    if (!t)
+      return;
+    const n = this.getControllersMonitoring();
+    for (const o of Object.values(n))
+      o == null || o.abort();
+    e && clearInterval(e), this.setState({ isMonitoring: !1, checkIntervalId: null });
+  }
+  /*--------------------------------------------------------------------------------------------------*/
+  /*--------------------------------------------------------------------------------------------------*/
+  async checkStatus(t, e) {
+    return await this.requestByUrls(t), this.getCurrentState();
+  }
+  fetchingNetwork(t, e) {
+    return this.startFetching(t, e), {
+      stop: () => this.stopFetching()
+    };
+  }
+  getCurrentState() {
+    return this.networkInfo;
+  }
+}
+export {
+  p as NetworkStatusTracker
+};

package/dist/classes/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/index.d.ts

@@ -4,7 +4,7 @@ export * from './classes/DelaysPromise';
 export * from './classes/File';
 export * from './classes/HTTPSApi';
 export * from './classes/Numbers';
-export * from './classes/SocketApi';
 export * from './classes/Utils/Utils';
-export * from './classes/Utils/EventSubscribers';
+export * from './classes/EventSubscribers';
+export * from './classes/NetworkStatusTracker/NetworkStatusTracker';
 export * from './classes/Utils/NetworkInformation';

package/dist/index.js

@@ -1,28 +1,28 @@
 import { Color as t } from "./classes/Color/Color.js";
 import { DateProcessing as m } from "./classes/DateProcessing/DateProcessing.js";
 import { DelaysPromise as p } from "./classes/DelaysPromise/DelaysPromise.js";
-import { File as i } from "./classes/File/File.js";
-import { HTTPSApi as s } from "./classes/HTTPSApi/HTTPSApi.js";
+import { File as a } from "./classes/File/File.js";
+import { HTTPSApi as n } from "./classes/HTTPSApi/HTTPSApi.js";
 import { Numbers as k } from "./classes/Numbers/Numbers.js";
-import { SocketApi as b } from "./classes/SocketApi/SocketApi.js";
-import { Utils as l } from "./classes/Utils/Utils.js";
-import { EventSubscribers as I } from "./classes/Utils/EventSubscribers/EventSubscribers.js";
-import { NetworkInformation as A } from "./classes/Utils/NetworkInformation/NetworkInformation.js";
+import { Utils as w } from "./classes/Utils/Utils.js";
+import { EventSubscribers as c } from "./classes/EventSubscribers/EventSubscribers.js";
+import { NetworkStatusTracker as I } from "./classes/NetworkStatusTracker/NetworkStatusTracker.js";
+import { NetworkInformation as u } from "./classes/Utils/NetworkInformation/NetworkInformation.js";
 import { NetworkInformationPC as S } from "./classes/Utils/NetworkInformation/classes/NetworkInformationPC.js";
 import { NetworkInformationAbstract as v } from "./classes/Utils/NetworkInformation/classes/types/types.abscruct.js";
-import { NetworkInformationCordova as T } from "./classes/Utils/NetworkInformation/classes/NetworkInformationCordova.js";
+import { NetworkInformationCordova as D } from "./classes/Utils/NetworkInformation/classes/NetworkInformationCordova.js";
 export {
   t as Color,
   m as DateProcessing,
   p as DelaysPromise,
-  I as EventSubscribers,
-  i as File,
-  s as HTTPSApi,
-  A as NetworkInformation,
+  c as EventSubscribers,
+  a as File,
+  n as HTTPSApi,
+  u as NetworkInformation,
   v as NetworkInformationAbstract,
-  T as NetworkInformationCordova,
+  D as NetworkInformationCordova,
   S as NetworkInformationPC,
+  I as NetworkStatusTracker,
   k as Numbers,
-  b as SocketApi,
-  l as Utils
+  w as Utils
 };

package/package.json

@@ -11,7 +11,7 @@
     "url": "git+https://github.com/SinGlEBW/dev-classes.git"
   },
   "license": "MIT",
-  "version": "1.3.35",
+  "version": "1.4.10",
   "type": "module",
   "module": "./dist/index.js",
   "main": "./dist/index.js",
@@ -24,7 +24,6 @@
   },
   "keywords": [
     "dev-classes",
-    "SocketApi",
     "EventSubscribers",
     "NetworkInformation",
     "HTTPSApi",
@@ -44,6 +43,7 @@
   "devDependencies": {
     "@types/js-cookie": "^3.0.6",
     "@types/node": "^20.12.7",
+    "@types/react": "^18.3.23",
     "glob": "^10.3.12",
     "typescript": "^5.2.2",
     "vite": "^5.1.6",
@@ -54,5 +54,13 @@
     "axios": "^1.7.7",
     "js-cookie": "^3.0.5",
     "uuid4": "^2.0.3"
+  },
+  "peerDependencies": {
+    "@emotion/react": "^11.11.4",
+    "@emotion/styled": "^11.11.0",
+    "@mui/icons-material": "^5.15.14",
+    "@mui/material": "^5.15.14",
+    "classnames": "^2.5.1",
+    "react": "^18.2.0"
   }
 }

package/dist/classes/ControlAppBySocket/ControlAppBySocket.d.ts

@@ -1,3 +0,0 @@
-export declare class ControlAppBySocket {
-    static reloadPage(): void;
-}

package/dist/classes/ControlAppBySocket/ControlAppBySocket.js

@@ -1,8 +0,0 @@
-class a {
-  static reloadPage() {
-    window.location.reload();
-  }
-}
-export {
-  a as ControlAppBySocket
-};

package/dist/classes/SocketApi/SocketApi.d.ts

@@ -1,52 +0,0 @@
-import { WsApi_Events } from './deps/WsApi/WsApi.types';
-import { WsApi_Options_P } from './deps/WsApi';
-import { SocketApi_Options_P, SocketApi_StateProps_P } from './SocketApi.types';
-
-interface SocketApi_Events {
-    timeOffReConnect(info: {
-        status: boolean;
-        msg: string;
-    }): void;
-    reConnect(status: boolean): 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 internet;
-    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.on & typeof SocketApi.events.subscribe;
-    static getRequestSave: () => {
-        payload: {
-            [key: string]: any;
-            action: string;
-        };
-        reqId: string;
-        cb: any;
-    }[];
-    static getStatusSocket: () => import('./deps/WsApi').WsApiE_StatusConnect_OR;
-    static close: () => void;
-    static init: (options: WsApi_Options_P & SocketApi_Options_P) => void;
-    static connect(): void;
-    static disconnect(): void;
-    static send<ResType>(data: object, cb?: (data: ResType) => void): void;
-    static stopReConnect(status?: boolean): void;
-    static socketReConnect: () => void;
-}
-export {};

package/dist/classes/SocketApi/SocketApi.js

@@ -1,127 +0,0 @@
-var w = Object.defineProperty;
-var C = (o, e, s) => e in o ? w(o, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : o[e] = s;
-var n = (o, e, s) => (C(o, typeof e != "symbol" ? e + "" : e, s), s);
-var f = (o, e, s) => {
-  if (e.has(o))
-    throw TypeError("Cannot add the same private member more than once");
-  e instanceof WeakSet ? e.add(o) : e.set(o, s);
-};
-import { DelaysPromise as R } from "../DelaysPromise/DelaysPromise.js";
-import { NetworkInformationCordova as v } from "../Utils/NetworkInformation/classes/NetworkInformationCordova.js";
-import { NetworkInformationPC as d } from "../Utils/NetworkInformation/classes/NetworkInformationPC.js";
-import { EventSubscribers as g } from "../Utils/EventSubscribers/EventSubscribers.js";
-import { NetworkInformation as O } from "../Utils/NetworkInformation/NetworkInformation.js";
-import { WsApi as S } from "./deps/WsApi/WsApi.js";
-const I = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function m(o) {
-  return I.test(o);
-}
-function u() {
-  var o = URL.createObjectURL(new Blob()), e = o.toString();
-  return URL.revokeObjectURL(o), e.split(/[:\/]/g).pop().toLowerCase();
-}
-u.valid = m;
-var r, A;
-const t = class t {
-  static copyState(e) {
-    return JSON.parse(JSON.stringify(e));
-  }
-  static setState(e) {
-    t.state = { ...t.state, ...e };
-  }
-  static resetState() {
-    t.state = t.copyState(t.stateDefault);
-  }
-  static setOptions(e) {
-    t.options = { ...t.options, ...e };
-  }
-  static setStatusReConnect(e) {
-    t.setState({ isActiveReConnect: e }), t.events.publish("reConnect", e);
-  }
-  static connect() {
-    t.wsApi.getIsInitWS() && (console.log("CONNECT WS"), t.setState({ isDisconnect: !1 }), t.wsApi.connect());
-  }
-  static disconnect() {
-    t.state.isDisconnect || (t.setState({ isDisconnect: !0 }), console.log("DISCONNECT WS"), t.wsApi.disconnect(), t.resetState());
-  }
-  static send(e, s) {
-    const { action: i, ...c } = e, a = u();
-    t.wsApi.setRequestSave({
-      reqId: a,
-      payload: { action: i, ...c },
-      cb: s
-    });
-    const l = t.wsApi.getSocket();
-    if (!l || l.readyState !== 1) {
-      console.log("Нет подключения к сокету");
-      return;
-    }
-    t.wsApi.send(e);
-  }
-  static stopReConnect(e) {
-    console.dir("функция stop не присвоена к stopReConnect");
-  }
-};
-r = new WeakSet(), A = function() {
-}, f(t, r), n(t, "state", {
-  isDisconnect: !0,
-  isActiveReConnect: !1,
-  isOfflineSocket: !0,
-  isReady: !1,
-  isNetworkStatus: navigator.onLine
-}), n(t, "options", {
-  isReConnectNetworkOnline: !1
-}), n(t, "wsApi", new S()), n(t, "delay", new R()), n(t, "internet", new O([new d(), new v()])), n(t, "events", new g(["timeOffReConnect", "reConnect"])), n(t, "saveID", {
-  idReConnect: null,
-  checkConnect: null
-}), n(t, "stateDefault", t.copyState(t.state)), n(t, "setInfoConnect", (e) => {
-  e.status || t.close(), t.setState({ isOfflineSocket: !e.status }), t.events.publish("timeOffReConnect", e), t.setStatusReConnect(!1);
-}), n(t, "online", () => {
-  t.setState({ isNetworkStatus: !0 }), !t.state.isActiveReConnect && t.options.isReConnectNetworkOnline && t.socketReConnect();
-}), n(t, "offline", () => {
-  t.setState({ isNetworkStatus: !1 }), t.state.isActiveReConnect && t.stopReConnect(!1);
-}), n(t, "splitOptions", (e) => Object.entries(e).reduce(
-  (s, [i, c]) => {
-    const a = t.wsApi.getOptions();
-    return i in a ? { ...s, WsOptions: { ...s.WsOptions, [i]: c } } : { ...s, SocketApiOptions: { ...s.SocketApiOptions, [i]: c } };
-  },
-  { WsOptions: {}, SocketApiOptions: {} }
-)), /*---------------------------------------------------------------------------------------------------------------------------*/
-n(t, "getState", () => t.state), n(t, "on", (e, s) => {
-  t.wsApi.getRegisteredEvents().includes(e) ? t.wsApi.on(e, s) : t.events.subscribe(e, s);
-}), n(t, "off", (e, s) => {
-  t.wsApi.getRegisteredEvents().includes(e) ? t.wsApi.off(e, s) : t.events.unsubscribe(e, s);
-}), n(t, "getRequestSave", t.wsApi.getRequestSave), n(t, "getStatusSocket", t.wsApi.getStatusSocket), n(t, "close", () => {
-  t.state.isActiveReConnect ? t.stopReConnect(!1) : t.wsApi.close();
-}), n(t, "init", (e) => {
-  const { WsOptions: s, SocketApiOptions: i } = t.splitOptions(e);
-  t.internet.run((c) => {
-    c ? t.online() : t.offline();
-  }), t.setOptions(i), t.wsApi.init(s);
-}), /*------------------------------------------------------------------------------------------------------*/
-n(t, "socketReConnect", () => {
-  if (t.wsApi.getIsInitWS())
-    if (console.log("reconnect"), t.saveID.idReConnect)
-      console.groupCollapsed("Процесс socketReConnect уже запущен"), console.log("SocketApi.saveID: ", t.saveID), console.groupEnd();
-    else {
-      t.setStatusReConnect(!0), t.connect();
-      const { timeReConnect: e, numberOfRepit: s } = t.wsApi.getOptions();
-      t.delay.startActionEvery(
-        () => (console.log("reconnect:>>delay"), t.wsApi.getStatusSocket() === "ready" ? (console.dir("Подключение установлено"), !0) : (t.connect(), !1)),
-        {
-          interval: e,
-          countAction: s,
-          watchIdInterval: (c) => {
-            t.saveID.idReConnect = c;
-          },
-          controlAction: ({ stop: c, getIsActiveEvent: a }) => {
-            t.stopReConnect = c;
-          }
-        }
-      ).promise.then(t.setInfoConnect).catch(t.setInfoConnect);
-    }
-});
-let p = t;
-export {
-  p as SocketApi
-};

package/dist/classes/SocketApi/SocketApi.types.d.ts

@@ -1,9 +0,0 @@
-import { WsApiE_StatusConnect_OR } from './deps/WsApi';
-
-export interface SocketApi_Options_P {
-    isReConnectNetworkOnline?: boolean;
-}
-type SocketApi_StateProps_OR = 'isDisconnect' | 'isActiveReConnect' | 'isOfflineSocket' | 'isReady' | 'isNetworkStatus';
-export type SocketApi_StateProps_P = Record<SocketApi_StateProps_OR, boolean>;
-export type SocketApi_StatusConnect_OR = WsApiE_StatusConnect_OR;
-export {};

package/dist/classes/SocketApi/deps/ConfigInfoConnect/ConfigInfoConnect.d.ts

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

package/dist/classes/SocketApi/deps/ConfigInfoConnect/ConfigInfoConnect.js

@@ -1,16 +0,0 @@
-var i = Object.defineProperty;
-var e = (n, o, t) => o in n ? i(n, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[o] = t;
-var s = (n, o, t) => (e(n, typeof o != "symbol" ? o + "" : o, t), t);
-class C {
-  constructor() {
-    s(this, "options", {
-      stop: !1
-    });
-    s(this, "setConditionReConnect", (o) => {
-      this.options = { ...this.options, ...o };
-    });
-  }
-}
-export {
-  C as ConfigInfoConnect
-};

package/dist/classes/SocketApi/deps/ConfigInfoConnect/ConfigInfoConnect.types.d.ts

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

package/dist/classes/SocketApi/deps/ConfigInfoConnect/ConfigInfoConnect.types.js

@@ -1 +0,0 @@
-

package/dist/classes/SocketApi/deps/WsApi/WsApi.d.ts

@@ -1,41 +0,0 @@
-import { WsApi_Events, WsApi_Options_P, WsApiE_StatusConnect_OR } from './WsApi.types';
-
-export declare class WsApi {
-    private options;
-    private state;
-    private initOptions;
-    private 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;
-    getSocket: () => WebSocket | null;
-    getStatusSocket: () => WsApiE_StatusConnect_OR;
-    getRequestSave: () => {
-        payload: {
-            [key: string]: any;
-            action: string;
-        };
-        reqId: string;
-        cb: any;
-    }[];
-    getOptions: () => WsApi_Options_P;
-    getRegisteredEvents: () => string[];
-    on: <K extends keyof WsApi_Events>(name: K, cb: WsApi_Events[K]) => void;
-    off: <K extends keyof WsApi_Events>(name: K, cb: WsApi_Events[K]) => void;
-    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;
-}

package/dist/classes/SocketApi/deps/WsApi/WsApi.js

@@ -1,116 +0,0 @@
-var c = Object.defineProperty;
-var l = (a, t, s) => t in a ? c(a, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : a[t] = s;
-var e = (a, t, s) => (l(a, typeof t != "symbol" ? t + "" : t, s), s);
-import { EventSubscribers as S } from "../../../Utils/EventSubscribers/EventSubscribers.js";
-class d {
-  constructor() {
-    e(this, "options", {
-      timeReConnect: 5e3,
-      numberOfRepit: 5,
-      url: ""
-    });
-    e(this, "state", {
-      statusConnect: "disconnect",
-      ws: null,
-      arrSaveReq: []
-    });
-    e(this, "initOptions", !1);
-    e(this, "events", new S(["status", "msg"]));
-    e(this, "stateDefault", this.copyState(this.state));
-    e(this, "eventListener", (t) => {
-      var i, r;
-      const s = [
-        ["open", this.openHandler],
-        ["close", this.closeHandler],
-        ["message", this.msgHandler],
-        ["error", this.errHandler]
-      ];
-      for (let n = 0; n < s.length; n++) {
-        const [o, h] = s[n];
-        t === "add" ? (i = this.state.ws) == null || i.addEventListener(o, h) : (r = this.state.ws) == null || r.removeEventListener(o, h);
-      }
-    });
-    e(this, "openHandler", () => {
-      this.setStatus("ready");
-    });
-    e(this, "closeHandler", () => {
-      this.setStatus("close");
-    });
-    e(this, "msgHandler", (t) => {
-      const s = JSON.parse(t.data ? t.data : "{}");
-      try {
-        const { action: i } = s;
-        i && this.filterSaveItemsByResponse(s), this.events.publish("msg", s);
-      } catch {
-        this.events.publish("msg", JSON.parse("{}"));
-      }
-    });
-    e(this, "errHandler", (t) => {
-      console.log("errHandler", t), this.setStatus("error");
-    });
-    e(this, "errorInitSocket", () => {
-      console.error("Вы не установили опции");
-    });
-    e(this, "setStatus", (t) => {
-      this.events.publish("status", t), this.setState({ statusConnect: t });
-    });
-    /*----------------------------------------------------------------------------------------------------------*/
-    e(this, "getSocket", () => this.state.ws);
-    e(this, "getStatusSocket", () => this.state.statusConnect);
-    e(this, "getRequestSave", () => this.state.arrSaveReq);
-    e(this, "getOptions", () => this.options);
-    e(this, "getRegisteredEvents", this.events.getListNameEvents);
-    e(this, "on", this.events.subscribe);
-    e(this, "off", this.events.unsubscribe);
-    e(this, "init", (t) => {
-      this.initOptions = !0, this.options = { ...this.options, ...t };
-    });
-    e(this, "getIsInitWS", () => {
-      const t = this.initOptions;
-      return t || this.errorInitSocket(), t;
-    });
-  }
-  resetState() {
-    this.state = this.copyState(this.stateDefault);
-  }
-  setState(t) {
-    this.state = { ...this.state, ...t };
-  }
-  copyState(t) {
-    return JSON.parse(JSON.stringify(t));
-  }
-  filterSaveItemsByResponse(t) {
-    const s = this.getRequestSave(), i = [];
-    for (let r = 0; r < s.length; r++) {
-      const n = s[r];
-      n.payload.action !== t.action ? i.push(n) : n.cb && n.cb(t);
-    }
-    this.state.arrSaveReq = i;
-  }
-  connect() {
-    this.initOptions && (this.close(), this.setState({
-      ws: new WebSocket(this.options.url)
-    }), this.setStatus("pending"), this.eventListener("add"));
-  }
-  close() {
-    var t;
-    (t = this.state.ws) == null || t.close(), this.eventListener("remove"), this.setStatus("close");
-  }
-  disconnect() {
-    this.close(), this.resetState();
-  }
-  send(t) {
-    var i;
-    const s = JSON.stringify(t);
-    (i = this.state.ws) == null || i.send(s);
-  }
-  setRequestSave(t) {
-    if ("action" in t.payload) {
-      const s = this.state.arrSaveReq.findIndex((i) => i.payload.action === t.payload.action);
-      ~s ? this.state.arrSaveReq[s] = t : this.state.arrSaveReq.push(t);
-    }
-  }
-}
-export {
-  d as WsApi
-};