egos-transfer 0.0.8

package/dist/http-transformer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToHttp = void 0;
+const convertToHttp = (peerId, payload) => {
+    const headers = payload.headers || {};
+    headers['x-peer-id'] = peerId;
+    headers['x-request-id'] = payload.requestId;
+    headers['x-message-id'] = payload.id;
+    const url = payload.route;
+    const params = payload.method.toLocaleLowerCase() === 'get' ? payload.body : null;
+    return {
+        url: url,
+        method: payload.method,
+        headers,
+        data: payload.body,
+        params,
+        timeout: payload.timeout,
+    };
+};
+exports.convertToHttp = convertToHttp;

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { DataConnection, Peer, PeerOptions } from 'peerjs';
+import { IDeviceStatus, IMessage, PeerMessage, PeerRequestPayload, RequestCallbackFn, RouteItem } from './interfaces';
+import { InternalApi, PeerAction } from './entity';
+import { PeerRouter } from './router';
+export interface ContentPayload {
+    file: string;
+    parent: string;
+}
+type ResponseCb<T = any> = (args: T) => void;
+export declare abstract class PeerTransfer {
+    protected peer: Peer | undefined;
+    protected peerPool: Map<string, Peer>;
+    protected peerIdMap: Map<string, string>;
+    protected connectPool: Map<string, DataConnection>;
+    static connecting: Map<string, {
+        promise: Promise<any>;
+        resolve: (value: any | PromiseLike<any>) => void;
+        reject: (reason?: any) => void;
+    }>;
+    protected retry: number;
+    protected peerConfig: PeerOptions | undefined;
+    deviceId: string;
+    protected requests: Map<string, ResponseCb>;
+    protected timeout: number;
+    protected router: PeerRouter;
+    protected booted: Promise<string> | undefined;
+    protected reconnectingPromise: Promise<Peer | undefined> | undefined;
+    protected timeoutId: ReturnType<typeof setTimeout>;
+    protected checkerId: ReturnType<typeof setInterval>;
+    isPaused: boolean;
+    peerId: string;
+    constructor(deviceId: string, config: PeerOptions, isRadomPeerId?: boolean);
+    abstract getStore(): any;
+    abstract online(deviceId: string): void;
+    abstract offline(deviceId: string): void;
+    abstract genRequestId(): Promise<string>;
+    abstract getApi(deviceId: string): Promise<InternalApi | undefined>;
+    abstract discoverDeviceById(deviceId: string): Promise<void>;
+    abstract onDestroy(): void;
+    abstract requireAuth(): void;
+    abstract onConnectLimit(): void;
+    initialize(peer: Peer): Promise<string>;
+    handleSocketMessage(message: IMessage): void;
+    onHeartbeat(message: IMessage): void;
+    onError(message: IMessage): void;
+    onOpen(message: IMessage): void;
+    onDeviceOnline(message: IMessage): Promise<void>;
+    onDeviceOffline(message: IMessage): void;
+    removeConnection(peerId: string): void;
+    addConnection(conn: DataConnection): void;
+    checkConnection(): void;
+    getApiHost(): string;
+    getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined>;
+    connectToPeer(deviceId: string): Promise<DataConnection | undefined>;
+    ping(peerId: string): Promise<boolean>;
+    onConnect(conn: DataConnection, positive?: boolean): Promise<DataConnection | undefined>;
+    request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage>;
+    reply(conn: DataConnection, oldMessage: PeerMessage, message: {
+        body?: Record<string, any>;
+        headers?: Record<string, string | number>;
+        error?: string | Record<string, any>;
+    }): Promise<void>;
+    send(conn: DataConnection, message: PeerRequestPayload): Promise<void>;
+    inheritMessage(receiveMsg: PeerMessage): {
+        src: string;
+        id: string;
+        requestId: string;
+        route: string;
+        createdAt: string | number;
+        action: PeerAction;
+    };
+    reconnect(): Promise<Peer | undefined>;
+    private doReconnect;
+    createPeer(force?: boolean): Promise<Peer | undefined>;
+    clearInstance(): void;
+    destroy(): void;
+    onRequest(conn: DataConnection, message: PeerMessage): Promise<void>;
+    onResponse(conn: DataConnection, message: PeerMessage): Promise<void>;
+    responseOk(conn: DataConnection, message: PeerMessage): Promise<void>;
+    responseFail(conn: DataConnection, message: PeerMessage, err: string | Record<string, any>): Promise<void>;
+    addRequest(id: string, cb: ResponseCb): void;
+    use(handler: RequestCallbackFn, prefix?: string): void;
+    addRoute(route: Omit<RouteItem, 'scope'>): void;
+    stop(): void;
+    resume(): Promise<Peer>;
+}
+export * from './interfaces';
+export * from './handler';
+export * from './file-transfer';
+export * from './server';
+export * from './utils';
+export * from './locker';
+export * from './entity';
+export * from './http-transformer';
+export * from './http-transfer';