jinbi-utils 1.0.19 → 1.0.21

package/test/date/index.test.ts

@@ -0,0 +1,107 @@
+import { compatibleDate, newDate, formatTime, fromNow, addDays } from '../../src';
+
+describe('compatibleDate', () => {
+  test(`compatibleDate('2020-03-04') 返回 2020/03/04`, () => {
+    expect(compatibleDate('2020-03-04')).toBe('2020/03/04');
+  })
+  test(`compatibleDate(Date.now()) 返回 Date.now()`, () => {
+    const now = Date.now();
+    expect(compatibleDate(now)).toBe(now);
+  })
+  test(`compatibleDate(new Date()) 返回 new Date()`, () => {
+    const newDate = new Date();
+    expect(compatibleDate(newDate)).toBe(newDate);
+  })
+});
+
+describe('newDate', () => {
+  const date = new Date();
+  test(`newDate() 返回 new Date()`, () => {
+    expect(new Date(date)).toEqual(date);
+  })
+  test(`newDate('2020-03-04') 返回 new Date(2020/03/04)`, () => {
+    expect(newDate('2020-03-04')).toEqual(new Date('2020/03/04'));
+  })
+  test(`newDate(date) 返回 date`, () => { 
+    const date = new Date();
+    expect(newDate(date)).toEqual(date);
+  })
+});
+
+describe('formatTime', () => {
+  test(`formatTime() 返回 ${formatTime()}`, () => {
+    expect(formatTime()).toBe(formatTime());
+  })
+  test(`formatTime('2018-02-02 00:00:00') 返回 2018-02-02 00:00:00`, () => {
+    expect(formatTime('2018-02-02 00:00:00')).toBe('2018-02-02 00:00:00');
+  })
+  test(`formatTime('2018-02-02', 'yyyy/MM/dd') 返回 2018/02/02`, () => {
+    expect(formatTime('2018-02-02', 'yyyy/MM/dd')).toBe('2018/02/02');
+  })
+  test(`formatTime('2018-02-02 23:50:50', 'yyyy/MM/dd HH:mm:ss') 返回 2018/02/02 23:50:50`, () => {
+    expect(formatTime('2018-02-02 23:50:50', 'yyyy/MM/dd HH:mm:ss')).toBe('2018/02/02 23:50:50');
+  })
+  test(`formatTime('2018-02-02 23:50:50', 'MM/dd HH:mm:ss') 返回 02/02 23:50:50`, () => {
+    expect(formatTime('2018-02-02 23:50:50', 'MM/dd HH:mm:ss')).toBe('02/02 23:50:50');
+  })
+  test(`formatTime(new Date('2018-02-02 23:50:50') + 200, 'yyyy/MM/dd HH:mm:ss S') 返回 2018/02/02 23:50:50 200`, () => {
+    const date = new Date('2018-02-02 23:50:50').getTime() + 200;
+    expect(formatTime(date, 'yyyy/MM/dd HH:mm:ss S')).toBe('2018/02/02 23:50:50 200');
+  })
+});
+
+describe('fromNow', () => {
+  const date = new Date();
+  const now = Date.now();
+  test(`fromNow('') 返回 -`, () => {
+    expect(fromNow('')).toBe('-');
+  })
+  test(`fromNow(Date.now() + 2000) 返回 Date.now() + 2000`, () => {
+    expect(fromNow(now + 2000)).toBe(now + 2000);
+  })
+  test(`fromNow(Date.now()) 返回 刚刚`, () => {
+    expect(fromNow(now)).toBe('刚刚');
+  })
+  test(`fromNow(new Date().getTime()) 返回 刚刚`, () => {
+    expect(fromNow(date.getTime())).toBe('刚刚');
+  })
+  // 之所返回的是 58 是因为 Date.now() 获取的时机在调用之后
+  test(`fromNow(now - 3420 * 1000) 返回 58分钟前面`, () => {
+    expect(fromNow(now - 3420 * 1000)).toBe('58分钟前');
+  })
+  test(`fromNow(now - 3600 * 1000 * 3) 返回 3小时前`, () => {
+    expect(fromNow(now - 3600 * 1000 * 3)).toBe('3小时前');
+  })
+  test(`fromNow(now - 3600 * 1000 * 24 * 1.5) 返回 1天前`, () => {
+    expect(fromNow(now - 3600 * 1000 * 24 * 1.5)).toBe('1天前');
+  })
+  const day5 = 3600 * 1000 * 24 * 5;
+  test(`fromNow(now - day5) 返回 formatTime(now - day5, 'yyyy年MM月dd日 HH时mm分ss秒')`, () => {
+    expect(fromNow(now - day5, 'yyyy年MM月dd日 HH时mm分ss秒')).toBe(formatTime(now - day5, 'yyyy年MM月dd日 HH时mm分ss秒'));
+  })
+  test(`fromNow('', '', 'defaultValue') 等于 defaultValue`, () => {
+    expect(fromNow('', '', 'defaultValue')).toBe('defaultValue');
+  })
+});
+
+describe('addDays', () => {
+  test(`addDays('') 返回 -`, () => {
+    expect(addDays('')).toBe('-');
+  })
+  test(`addDays('2018-02-02') 返回 2018-02-02`, () => {
+    expect(addDays('2018-02-02')).toBe('2018-02-02');
+  })
+  test(`addDays('2018-02-02', 2) 返回 2018-02-04`, () => {
+    expect(addDays('2018-02-02', 2)).toBe('2018-02-04');
+  })
+  test(`addDays('2018-02-02', 2, 'yyyy/MM/dd') 返回 2018/02/04`, () => {
+    expect(addDays('2018-02-02', 2, 'yyyy/MM/dd')).toBe('2018/02/04');
+  })
+  test(`addDays(new Date('2020-03-04'), 2, 'yyyy/MM/dd') 返回 2020/03/06`, () => {
+    expect(addDays(new Date('2020-03-04'), 2, 'yyyy/MM/dd')).toBe('2020/03/06');
+  })
+  test(`addDays(Date.now(), 2, 'yyyy/MM/dd') 返回 今天 + 2天`, () => {
+    const now = Date.now();
+    expect(addDays(now, 2, 'yyyy/MM/dd')).toBe(formatTime(now + 2 * 24 * 60 * 60 * 1000, 'yyyy/MM/dd'));
+  })
+});

package/test/file/index.test.ts

@@ -0,0 +1,104 @@
+import axios from 'axios';
+import { 
+  calcFileSize, 
+  fileSizeFormat, 
+  ceil, 
+  blobToDataURL, 
+  dataURLtoBlob, 
+  genExportByBlob,
+} from '../../src';
+
+describe('calcFileSize', () => {
+  test(`calcFileSize(100) 返回 { size: 100, unit: 'B' }`, () => {
+    expect(calcFileSize(100)).toEqual({
+      size: 100, 
+      unit: 'B',
+    });
+  })
+  test(`calcFileSize(1024) 返回 { size: 1, unit: 'KB' }`, () => {
+    expect(calcFileSize(1024)).toEqual({
+      size: 1,
+      unit: 'KB',
+    });
+  })
+  test(`calcFileSize(1024, 'KB') 返回 { size: 1, unit: 'MB' }`, () => {
+    expect(calcFileSize(1024, 'KB')).toEqual({
+      size: 1, 
+      unit: 'MB'
+    });
+  })
+  test(`calcFileSize(1126.4, 'mb') 返回 { size: 1.1, unit: 'GB' }`, () => {
+    expect(calcFileSize(1126.4, 'mb' as any)).toEqual({
+      size: 1.1, 
+      unit: 'GB'
+    });
+  })
+  test(`calcFileSize(Math.pow(1024, 2), 'kb') 返回 { size: 1, unit: 'GB' }`, () => {
+    expect(calcFileSize(Math.pow(1024, 2), 'kb' as any)).toEqual({
+      size: 1, 
+      unit: 'GB'
+    });
+  })
+});
+
+describe('fileSizeFormat', () => {
+  test(`fileSizeFormat('') 返回 -`, () => {
+    expect(fileSizeFormat('')).toBe('-');
+  })
+  test(`fileSizeFormat('1024') 返回 1KB`, () => {
+    expect(fileSizeFormat('1024')).toBe('1KB');
+  })
+  test(`fileSizeFormat('1024', 'KB') 返回 1MB`, () => {
+    expect(fileSizeFormat('1024', 'KB')).toBe('1MB');
+  })
+  test(`fileSizeFormat('2645', 'B') 返回 ceil(2645 / 1024, 2)MB`, () => {
+    expect(fileSizeFormat('2645', 'KB')).toBe(`${ceil(2645 / 1024, 2)}MB`);
+  })
+});
+
+describe('blobToDataURL', () => {
+  test(`blobToDataURL(Blob) 返回 base64`, async () => {
+    const res = await axios.get('https://img.baibu.la/baibu_520ac52acfaa48ddbaa55b8f7f1b8a13.png', {
+      responseType: 'blob',
+    });
+    const base64 = await blobToDataURL(res.data);
+    expect(base64.includes('base64')).toBe(true);
+  })
+});
+
+describe('dataURLtoBlob', () => {
+  test(`dataURLtoBlob(base64) 返回 Blob`, async () => {
+    const res = await axios.get('https://img.baibu.la/baibu_520ac52acfaa48ddbaa55b8f7f1b8a13.png', {
+      responseType: 'blob',
+    });
+    const base64 = await blobToDataURL(res.data);
+    const blob = dataURLtoBlob(base64);
+    expect(blob instanceof Blob).toBe(true);
+  })
+});
+
+// describe('compressImg', () => {
+//   test(`compressImg(File) 返回 Blob`, async () => {
+//     const res = await axios.get('https://img.baibu.la/baibu_520ac52acfaa48ddbaa55b8f7f1b8a13.png', {
+//       responseType: 'blob',
+//     });
+    
+//     const blob = await compressImg(res.data);
+//     expect(blob instanceof Blob).toBe(true);
+//   })
+// });
+
+describe('exportByBlob', () => {
+  test(`exportByBlob(File) 返回 Blob`, async () => {
+    const exportByBlob = genExportByBlob({
+      axiosRequest: axios,
+    })
+    const res = await exportByBlob({
+      filename: '测试.png',
+      url: 'https://img.baibu.la/baibu_520ac52acfaa48ddbaa55b8f7f1b8a13.png',
+      method: 'GET',
+    });
+    const data = (res as any).data;
+    expect(data instanceof Blob).toBe(true);
+  })
+});

package/test/number/index.test.ts

@@ -0,0 +1,108 @@
+import { toThousands, convertCurrency, formatFloat, ceil, floor } from '../../src';
+
+describe('toThousands', () => {
+  test(`toThousands('') 返回 '-'`, () => {
+    expect(toThousands('')).toBe('-');
+  })
+
+  test(`toThousands('', '|') 返回 '|'`, () => {
+    expect(toThousands('', '|')).toBe('|');
+  })
+
+  test(`toThousands(123) 返回 '123'`, () => {
+    expect(toThousands(123)).toBe('123');
+  })
+
+  test(`toThousands(12323) 返回 '12,323'`, () => {
+    expect(toThousands(12323)).toBe('12,323');
+  })
+
+  test(`toThousands('12323.12') 返回 '12,323.12'`, () => {
+    expect(toThousands('12323.12')).toBe('12,323.12');
+  })
+});
+
+describe('convertCurrency', () => {
+  test(`convertCurrency() 返回 ''`, () => {
+    expect(convertCurrency()).toBe('');
+  })
+
+  test(`convertCurrency('') 返回 ''`, () => {
+    expect(convertCurrency('-')).toBe('零元整');
+  })
+
+  test(`convertCurrency(1999999999999999) 返回 ''`, () => {
+    const value = '1999999999999999';
+    expect(convertCurrency(value)).toBe(value);
+  })
+
+  test(`convertCurrency(0.012) 返回 '壹分贰毫'`, () => {
+    expect(convertCurrency('0.012')).toBe('壹分贰毫');
+  })
+
+  test(`convertCurrency(0) 返回 '零元整'`, () => {
+    expect(convertCurrency('0')).toBe('零元整');
+  })
+
+  test(`convertCurrency(12.12) 返回 '壹拾贰元壹角贰分'`, () => {
+    expect(convertCurrency('12.12')).toBe('壹拾贰元壹角贰分');
+  })
+
+  test(`convertCurrency(1234567809) 返回 '壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰零玖元整'`, () => {
+    expect(convertCurrency('1234567809')).toBe('壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰零玖元整');
+  })
+});
+
+describe('formatFloat', () => {
+  test(`formatFloat('NaN') 返回 ''`, () => {
+    expect(formatFloat('NaN')).toBe('');
+  })
+
+  test(`formatFloat('1.2345') 返回 '1.23'`, () => {
+    expect(formatFloat('1.2345')).toBe('1.23');
+  })
+
+  test(`formatFloat('1.2345') 返回 '1.235'`, () => {
+    expect(formatFloat('1.2345', 3)).toBe('1.235');
+  })
+
+  test(`formatFloat('1', 3) 返回 '1.000'`, () => {
+    expect(formatFloat('1', 3)).toBe('1.000');
+  })
+});
+
+describe('ceil', () => {
+  test(`ceil('') 返回 ''`, () => {
+    expect(ceil('')).toBe('');
+  })
+
+  test(`ceil('1.23') 返回 2`, () => {
+    expect(ceil('1.23')).toBe(2);
+  })
+
+  test(`ceil('1.234', 2) 返回 1.24`, () => {
+    expect(ceil('1.234', 2)).toBe(1.24);
+  })
+
+  test(`ceil('1.230', 2) 返回 1.23`, () => {
+    expect(ceil('1.230', 2)).toBe(1.23);
+  })
+});
+
+describe('floor', () => {
+  test(`floor('') 返回 ''`, () => {
+    expect(floor('')).toBe('');
+  })
+
+  test(`floor('1.23') 返回 1`, () => {
+    expect(floor('1.23')).toBe(1);
+  })
+
+  test(`floor('1.234', 2) 返回 1.23`, () => {
+    expect(floor('1.234', 2)).toBe(1.23);
+  })
+
+  test(`floor('1.230', 2) 返回 1.23`, () => {
+    expect(floor('1.230', 2)).toBe(1.23);
+  })
+});

package/test/object/index.test.ts

@@ -0,0 +1,20 @@
+import { deepEqual } from '../../src';
+
+
+describe('deepEqual', () => {
+  test(`deepEqual(null, null) 返回 true`, () => {
+    expect(deepEqual(null, null)).toBe(true);
+  })
+
+  test(`deepEqual({}, null) 返回 false`, () => {
+    expect(deepEqual({}, null)).toBe(false);
+  })
+
+  test(`deepEqual({a: 10}, {a: 10}) 返回 true`, () => {
+    expect(deepEqual({a: 10}, {a: 10})).toBe(true);
+  })
+
+  test(`deepEqual({a: 10}, {a: 10, b: 20}) 返回 false`, () => {
+    expect(deepEqual({a: 10}, {a: 10, b: 20})).toBe(false);
+  })
+});

package/test/string/index.test.ts

@@ -0,0 +1,82 @@
+import { formatEmptyValue, formatPhone, formatPhoneHide, formatBank, generateEnglishLetters } from '../../src';
+
+describe('formatEmptyValue', () => {
+  test(`formatEmptyValue('') 返回 `, () => {
+    expect(formatEmptyValue('')).toBe('-');
+  })
+
+  test(`formatEmptyValue('123') 返回  123`, () => {
+    expect(formatEmptyValue('123')).toBe('123');
+  })
+
+  test(`formatEmptyValue(null) 返回 '-'`, () => {
+    expect(formatEmptyValue(null)).toBe('-');
+  })
+
+  test(`formatEmptyValue(null, ' ') 返回 ' '`, () => {
+    expect(formatEmptyValue(null, ' ')).toBe(' ');
+  })
+});
+
+describe('formatPhone', () => {
+  test(`formatPhone('') 返回 `, () => {
+    expect(formatPhone('')).toBe('-');
+  })
+
+  test(`formatPhone('', '-', ' ') 返回 ' '`, () => {
+    expect(formatPhone('', '-', ' ')).toBe(' ');
+  })
+
+  test('formatPhone(123) 返回 123', () => {
+    expect(formatPhone('123')).toBe('123');
+  })
+
+  test(`formatPhone(18211572781)  返回 '182 1157 2781'`, () => {
+    expect(formatPhone(18211572781)).toBe('182 1157 2781');
+  })
+
+  test(`formatPhone('18211572781', '-') 放回 '182-1157-2781'`, () => {
+    expect(formatPhone('18211572781', '-')).toBe('182-1157-2781');
+  })
+});
+
+describe('formatPhoneHide', () => {
+  test(`formatPhoneHide('') 返回 ''`, () => {
+    expect(formatPhoneHide('')).toBe('');
+  })
+
+  test('formatPhoneHide(123) 返回 123', () => {
+    expect(formatPhoneHide('123')).toBe('123');
+  })
+
+  test(`formatPhoneHide(18211572781)  返回 '182****2781'`, () => {
+    expect(formatPhoneHide(18211572781)).toBe('182****2781');
+  })
+
+  test(`formatPhoneHide('18211572781', '-') 放回 '182****2781'`, () => {
+    expect(formatPhoneHide('18211572781', '-')).toBe('182****2781');
+  })
+});
+
+describe('formatBank', () => {
+  test(`formatBank('') 返回 ''`, () => {
+    expect(formatBank('')).toBe('');
+  })
+
+  test(`formatBank('', '-') 返回 '-'`, () => {
+    expect(formatBank('', '-')).toBe('-');
+  })
+
+  test(`formatBank(6282356862823568123) 返回 '6282 3568 6282 3568 123'`, () => {
+    expect(formatBank('6282356862823568123')).toBe('6282 3568 6282 3568 123');
+  })
+});
+
+
+describe('generateEnglishLetters', () => {
+  test(`generateEnglishLetters() 返回 ['A', ..., 'Z']`, () => {
+    expect(generateEnglishLetters()).toContain('A');
+    expect(generateEnglishLetters()).toContain('Z');
+    expect(generateEnglishLetters()).toHaveLength(26);
+  })
+});

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "es6",
+    "lib": ["ESNext", "dom", "es2015.collection"],
+    "removeComments": false,
+    "preserveConstEnums": true,
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "noImplicitAny": false,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationDir": "./types",
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strictNullChecks": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "rootDir": "./src/",
+    "jsx": "preserve",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "typeRoots": [
+      "node_modules/@types",
+      "global.d.ts"
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compileOnSave": true
+}

package/typedoc.json

@@ -0,0 +1,12 @@
+{
+  "excludeNotExported": true,
+  "mode": "modules",
+  "out": "docs",
+  "inputFiles": ["./src"],
+  "exclude": [
+    "src/index.ts",
+    "src/build/chunk-optimizer/**",
+    "**/node_modules/**"
+  ],
+  "excludeExternals": true
+}

package/types/file/index.d.ts

@@ -94,3 +94,10 @@ export declare function genExportByBlob({ axiosRequest, notWithCredentials, }: {
     axiosRequest: any;
     notWithCredentials?: never[] | undefined;
 }): (config: ExportByBlobParams) => Promise<unknown>;
+/**
+ * 将 base64 字符串转换为 File 或 Blob
+ * @param {string} base64 - 带有 data URI 的 base64 字符串
+ * @param {string} [filename] - 如果提供了，则返回 File；否则返回 Blob
+ * @returns {File|Blob}
+ */
+export declare function base64ToFileOrBlob(base64: any, filename: any): Promise<Blob>;

package/types/index.d.ts

@@ -14,3 +14,4 @@ export * from './iam';
 export * from './color';
 export * from './array';
 export * from './dom';
+export * from './websocket';

package/types/websocket/emitter.d.ts

@@ -0,0 +1,16 @@
+import type { WebSocketMessageType } from './types';
+export declare type WebSocketEmitterEvents = {
+    'websocket-connected': boolean;
+    'websocket-message': WebSocketMessageType;
+    'websocket-error': {
+        message: string;
+    };
+    'websocket-closed': void;
+};
+export declare class Emitter<E extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => boolean;
+    off<K extends keyof E>(event: K, handler: (payload: E[K]) => void): void;
+    emit<K extends keyof E>(event: K, payload: E[K]): void;
+}
+export declare const emitter: Emitter<WebSocketEmitterEvents>;

package/types/websocket/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export { WebsocketManager } from './manager';
+export type { WebSocketOptions } from './manager';
+export { websocketService } from './service';
+export { emitter } from './emitter';
+export { createWebSocketStore } from './pinia-store';

package/types/websocket/manager.d.ts

@@ -0,0 +1,36 @@
+import type { WebSocketMessageType } from './types';
+declare type EventMap = {
+    connected: boolean;
+    message: WebSocketMessageType;
+    error: {
+        message: string;
+    };
+    closed: void;
+};
+export interface WebSocketOptions {
+    url: string;
+    reconnectAttemptsLimit?: number;
+    reconnectInterval?: number;
+    heartbeatInterval?: number;
+    registerMessage?: unknown;
+}
+export declare class WebsocketManager {
+    private ws;
+    private reconnectAttempts;
+    private heartbeatTimer;
+    private listeners;
+    private readonly opts;
+    constructor(options: WebSocketOptions);
+    get url(): string;
+    on<E extends keyof EventMap>(event: E, handler: (payload: EventMap[E]) => void): () => boolean;
+    private emit;
+    connect(): void;
+    private setupEventListeners;
+    send(data: unknown): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private reconnect;
+    disconnect(): void;
+    get isConnected(): boolean;
+}
+export {};

package/types/websocket/pinia-store.d.ts

@@ -0,0 +1,25 @@
+import { WebsocketManager } from './manager';
+import type { WebSocketMessageType } from './types';
+import type { WebSocketOptions } from './manager';
+declare type MessageWithMeta = WebSocketMessageType & {
+    timestamp?: number;
+    id?: string;
+};
+export declare const createWebSocketStore: (storeId?: string) => import("pinia").StoreDefinition<string, {
+    isConnected: boolean;
+    wsManager: WebsocketManager | null;
+    messages: MessageWithMeta[];
+    connectionError: string | null;
+}, {
+    connectionStatus: (state: any) => "已连接" | "未连接";
+    lastMessage: (state: any) => any;
+}, {
+    connect(options: WebSocketOptions): Promise<void>;
+    setupEventListeners(): void;
+    sendMessage(data: WebSocketMessageType): void;
+    addMessage(message: WebSocketMessageType): void;
+    clearMessages(): void;
+    disconnect(): void;
+    reset(): void;
+}>;
+export {};

package/types/websocket/service.d.ts

@@ -0,0 +1,13 @@
+import { WebsocketManager } from './manager';
+import type { WebSocketOptions } from './manager';
+declare class WebSocketService {
+    private static instance;
+    private initialized;
+    private manager;
+    static getInstance(): WebSocketService;
+    init(options: WebSocketOptions): Promise<void>;
+    destroy(): void;
+    getManager(): WebsocketManager | null;
+}
+export declare const websocketService: WebSocketService;
+export {};

package/types/websocket/types.d.ts

@@ -0,0 +1,34 @@
+export interface WebSocketMessage<T = unknown> {
+    type: string;
+    data?: T;
+    timestamp?: number;
+    messageId?: string;
+}
+export interface WebSocketHeartbeat {
+    type: 'ping' | 'pong';
+}
+export interface WebSocketNotification {
+    type: 'notification';
+    data: {
+        title: string;
+        message: string;
+        level?: 'info' | 'success' | 'warning' | 'error';
+    };
+}
+export interface WebSocketDataUpdate<T = unknown> {
+    type: 'data-update';
+    data: {
+        entity: string;
+        action: 'create' | 'update' | 'delete';
+        payload: T;
+    };
+}
+export interface WebSocketSystemMessage {
+    type: 'system';
+    data: {
+        code: string;
+        message: string;
+    };
+}
+export declare type WebSocketMessageType = WebSocketHeartbeat | WebSocketNotification | WebSocketDataUpdate | WebSocketSystemMessage | WebSocketMessage;
+export declare type WebSocketStatus = 'connected' | 'disconnected' | 'connecting' | 'error';