@x-oasis/async-call-rpc-misc 0.1.38

package/dist/channel-protocol/AbstractChannelProtocol.d.ts

@@ -0,0 +1,51 @@
+import { Disposable } from '@x-oasis/disposable';
+import { Deferred } from '@x-oasis/deferred';
+import { SendingProps, IMessageChannel, ClientMiddleware, SenderMiddleware, AbstractChannelProtocolProps, PendingSendEntry } from '../types';
+import RPCServiceHost from '../rpc-service/RPCServiceHost';
+import { WriteBuffer, ReadBuffer } from '../buffer';
+import { Channel } from './Channel';
+declare abstract class AbstractChannelProtocol extends Disposable implements IMessageChannel {
+    private readonly _masterProcessName;
+    private _key;
+    channel: Channel;
+    private _serviceHost;
+    private readonly _description;
+    private _seqId;
+    protected _onMessageMiddleware: ClientMiddleware[];
+    private _senderMiddleware;
+    private _readBuffer;
+    private _writeBuffer;
+    private _isConnected;
+    ongoingRequests: Map<string, Deferred>;
+    pendingSendEntries: Set<PendingSendEntry>;
+    requestEvents: Map<string, any>;
+    private onDidConnectedEvent;
+    onDidConnected: (listener: Function) => import("@x-oasis/disposable").IDisposable;
+    private onDidDisconnectedEvent;
+    onDidDisconnected: (listener: Function) => import("@x-oasis/disposable").IDisposable;
+    constructor(props: AbstractChannelProtocolProps);
+    get serviceHost(): RPCServiceHost;
+    setServiceHost(serviceHost: RPCServiceHost): void;
+    get senderMiddleware(): SenderMiddleware[];
+    get readBuffer(): ReadBuffer;
+    get writeBuffer(): WriteBuffer;
+    get seqId(): string;
+    get description(): string;
+    get masterProcessName(): string;
+    addPendingSendEntry(entry: PendingSendEntry): void;
+    applyOnMessageMiddleware(fns: Function | Function[]): void;
+    applySendMiddleware(fns: Function | Function[]): void;
+    isConnected(): boolean;
+    resumePendingEntry(): void;
+    didConnected(): void;
+    protected bindChannel(channel: Channel): void;
+    connect(channel: Channel): void;
+    activate(): void;
+    disconnect(): void;
+    send(props: SendingProps, transfer?: MessagePort[]): Deferred | void;
+    send(requestPath: string, fnName: string, ...args: any[]): Deferred | void;
+    sendReply(...args: any[]): void;
+    onMessage(...args: any[]): void;
+    runWithMiddlewares(middlewares: ClientMiddleware[], ...args: any[]): void;
+}
+export default AbstractChannelProtocol;

package/dist/channel-protocol/Channel.d.ts

@@ -0,0 +1,16 @@
+import { Emitter } from '@x-oasis/emitter';
+import { Disposable } from '@x-oasis/disposable';
+declare type ChannelSend = (...args: any[]) => void;
+declare type ChannelInitListener = (emitter: Emitter) => void;
+declare type ChannelProps = {
+    send: ChannelSend;
+    initListener: ChannelInitListener;
+};
+export declare class Channel extends Disposable {
+    private _send;
+    emitter: Emitter;
+    constructor(props: ChannelProps);
+    send(...args: any[]): void;
+    on(eventName: string, listener: Function): void;
+}
+export {};

package/dist/channel-protocol/DeferredMessageChannelProtocol.d.ts

@@ -0,0 +1,8 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, DeferredMessageChannelProtocolProps } from '../types';
+export default class DeferredMessageChannelProtocol extends AbstractChannelProtocol {
+    private port;
+    constructor(props: DeferredMessageChannelProtocolProps);
+    bindPort(port: MainPort): void;
+    disconnect(): void;
+}

package/dist/channel-protocol/IPCMainChannelProtocol.d.ts

@@ -0,0 +1,7 @@
+import { IPCMainChannelProtocolProps } from '../types';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+export default class IPCMainChannelProtocol extends AbstractChannelProtocol {
+    private channelName;
+    constructor(props: IPCMainChannelProtocolProps);
+    disconnect(): void;
+}

package/dist/channel-protocol/IPCMainGlobalChannelProtocol.d.ts

@@ -0,0 +1,7 @@
+import { IPCMainGlobalChannelProtocolProps } from '../types';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+export default class IPCMainGlobalChannelProtocol extends AbstractChannelProtocol {
+    private channelName;
+    constructor(props: IPCMainGlobalChannelProtocolProps);
+    disconnect(): void;
+}

package/dist/channel-protocol/IPCRendererChannelProtocol.d.ts

@@ -0,0 +1,8 @@
+import { IPCRendererChannelProtocolProps } from '../types';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+declare class IPCRendererChannelProtocol extends AbstractChannelProtocol {
+    private channelName;
+    constructor(props: IPCRendererChannelProtocolProps);
+    disconnect(): void;
+}
+export default IPCRendererChannelProtocol;

package/dist/channel-protocol/IPCRendererMessageChannelProtocol.d.ts

@@ -0,0 +1,8 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MainPort, MessageChannelProtocolProps } from '../types';
+export default class IPCRendererMessageChannelProtocol extends AbstractChannelProtocol {
+    private readonly port;
+    constructor(props: MessageChannelProtocolProps);
+    bindPort(port: MainPort): void;
+    disconnect(): void;
+}

package/dist/channel-protocol/MessageChannelProtocol.d.ts

@@ -0,0 +1,7 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MessageChannelProtocolProps } from '../types';
+export default class MessageChannelProtocol extends AbstractChannelProtocol {
+    private readonly port;
+    constructor(props: MessageChannelProtocolProps);
+    disconnect(): void;
+}

package/dist/channel-protocol/ProcessChannelProtocol.d.ts

@@ -0,0 +1,7 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { ProcessChannelProtocolProps } from '../types';
+export default class ProcessChannelProtocol extends AbstractChannelProtocol {
+    private readonly process;
+    constructor(props: ProcessChannelProtocolProps);
+    disconnect(): void;
+}

package/dist/channel-protocol/ProcessClientChannelProtocol.d.ts

@@ -0,0 +1,7 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { MessageChannelProtocolProps } from '../types';
+export default class ProcessClientChannelProtocol extends AbstractChannelProtocol {
+    private readonly port;
+    constructor(props: MessageChannelProtocolProps);
+    disconnect(): void;
+}

package/dist/channel-protocol/middlewares/buffer.d.ts

@@ -0,0 +1,18 @@
+import { NormalizedRawMessageOutput, SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const serialize: (channel: AbstractChannelProtocol) => {
+    (value: SenderMiddlewareOutput): {
+        data: string;
+        transfer: any;
+        seqId: number;
+        returnValue: import("@x-oasis/deferred").Deferred<any>;
+        isOptionsRequest: boolean;
+        middlewareContext: import("../../types").MiddlewareContext;
+    };
+    lifecycle: SendMiddlewareLifecycle;
+};
+export declare const deserialize: (channel: AbstractChannelProtocol) => (value: NormalizedRawMessageOutput) => {
+    data: string;
+    event: any;
+    ports: any;
+};

package/dist/channel-protocol/middlewares/handleDisconnectedRequest.d.ts

@@ -0,0 +1,7 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const handleDisconnectedRequest: (protocol: AbstractChannelProtocol) => {
+    (value: SenderMiddlewareOutput): SenderMiddlewareOutput;
+    displayName: string;
+    lifecycle: SendMiddlewareLifecycle;
+};

package/dist/channel-protocol/middlewares/handlePortRequest.d.ts

@@ -0,0 +1,3 @@
+import { DeserializedMessageOutput } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const handlePortRequest: (protocol: AbstractChannelProtocol) => (message: DeserializedMessageOutput) => DeserializedMessageOutput;

package/dist/channel-protocol/middlewares/handleRequest.d.ts

@@ -0,0 +1,3 @@
+import { DeserializedMessageOutput } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const handleRequest: (protocol: AbstractChannelProtocol) => (message: DeserializedMessageOutput) => DeserializedMessageOutput;

package/dist/channel-protocol/middlewares/handleRequestUtils.d.ts

@@ -0,0 +1,10 @@
+import RPCServiceHost from '../../rpc-service/RPCServiceHost';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const handleAcquirePort: (props: {
+    protocol: AbstractChannelProtocol;
+    serviceHost: RPCServiceHost;
+    requestPath: string;
+    fnName: string;
+    seqId: string;
+    args: any[];
+}) => any[];

package/dist/channel-protocol/middlewares/handleResponse.d.ts

@@ -0,0 +1,3 @@
+import { DeserializedMessageOutput } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const handleResponse: (protocol: AbstractChannelProtocol) => (message: DeserializedMessageOutput) => DeserializedMessageOutput;

package/dist/channel-protocol/middlewares/index.d.ts

@@ -0,0 +1,10 @@
+export * from './buffer';
+export * from './handleRequest';
+export * from './normalize';
+export * from './handleResponse';
+export * from './prepareRequestData';
+export * from './updateSeqInfo';
+export * from './handlePortRequest';
+export * from './sendRequest';
+export * from './handleDisconnectedRequest';
+export { runMiddlewares } from './utils';

package/dist/channel-protocol/middlewares/logger.d.ts

@@ -0,0 +1,4 @@
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import { NormalizedRawMessageOutput } from '../../types';
+export declare const createSenderLogger: (logService: any) => (channel: AbstractChannelProtocol) => (value: NormalizedRawMessageOutput) => NormalizedRawMessageOutput;
+export declare const createClientLogger: (logService: any) => (channel: AbstractChannelProtocol) => (value: NormalizedRawMessageOutput) => NormalizedRawMessageOutput;

package/dist/channel-protocol/middlewares/normalize.d.ts

@@ -0,0 +1,12 @@
+import { NormalizedRawMessageOutput } from '../../types';
+export declare const normalizeMessageChannelRawMessage: () => (event: MessageEvent) => NormalizedRawMessageOutput;
+export declare const normalizeIPCChannelRawMessage: () => (event: MessageEvent, data: string) => {
+    event: MessageEvent;
+    data: string;
+    ports: readonly MessagePort[];
+};
+export declare const processClientRawMessage: () => (data: string) => {
+    event: any;
+    data: string;
+    ports: any[];
+};

package/dist/channel-protocol/middlewares/prepareRequestData.d.ts

@@ -0,0 +1,28 @@
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+import { SendingProps, SendMiddlewareLifecycle } from '../../types';
+export declare const preparePortData: (channel: AbstractChannelProtocol) => {
+    (props: string | SendingProps, ...args: any[]): {
+        seqId: string;
+        transfer: any[];
+        isOptionsRequest: boolean;
+        data: any[][];
+    };
+    lifecycle: SendMiddlewareLifecycle;
+};
+export declare const prepareHostPortData: (channel: AbstractChannelProtocol) => {
+    (props: string | SendingProps, ...args: any[]): {
+        seqId: string;
+        transfer: any[];
+        isOptionsRequest: boolean;
+        data: any[][];
+    };
+    lifecycle: SendMiddlewareLifecycle;
+};
+export declare const prepareNormalData: (channel: AbstractChannelProtocol) => {
+    (props: string | SendingProps, ...args: any[]): {
+        seqId: string;
+        isOptionsRequest: boolean;
+        data: any[][];
+    };
+    lifecycle: SendMiddlewareLifecycle;
+};

package/dist/channel-protocol/middlewares/sendRequest.d.ts

@@ -0,0 +1,6 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const sendRequest: (channelProtocol: AbstractChannelProtocol) => {
+    (value: SenderMiddlewareOutput): SenderMiddlewareOutput;
+    lifecycle: SendMiddlewareLifecycle;
+};

package/dist/channel-protocol/middlewares/updateSeqInfo.d.ts

@@ -0,0 +1,6 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../../types';
+import AbstractChannelProtocol from '../AbstractChannelProtocol';
+export declare const updateSeqInfo: (channelProtocol: AbstractChannelProtocol) => {
+    (value: SenderMiddlewareOutput): SenderMiddlewareOutput;
+    lifecycle: SendMiddlewareLifecycle;
+};

package/dist/channel-protocol/middlewares/utils.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareContext, PendingSendEntry } from '../../types';
+export declare const resumeMiddlewares: (middlewares: any, entry: PendingSendEntry) => any;
+export declare const runMiddlewares: (middlewares: any, args: any[], _context?: MiddlewareContext) => any;

package/dist/common.d.ts

@@ -0,0 +1,4 @@
+export declare const isEventMethod: (name: string) => boolean;
+export declare const isAssignPassingPortMethod: (name: string) => boolean;
+export declare const isAcquirePortMethod: (name: string) => boolean;
+export declare const isOptionsMethod: (name: string) => boolean;

package/dist/error.d.ts

@@ -0,0 +1,12 @@
+export interface ErrorResponseDetail<Error = unknown> {
+    readonly code: number;
+    readonly message: string;
+    readonly data?: Error;
+}
+export declare type ID = string | number | null | undefined;
+export interface ErrorResponse<Error = unknown> {
+    readonly jsonrpc: '2.0';
+    readonly id?: ID;
+    readonly error: ErrorResponseDetail<Error>;
+}
+export declare const makeErrorResponse: <T>(id: ID, code: number, message: string, data?: T) => ErrorResponse<T>;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { default as RPCServiceHost } from './rpc-service/RPCServiceHost';
+export { default as rpcServiceProvider } from './rpc-service/RPCServiceProvider';
+export { default as ProxyRPCClient } from './rpc-service/ProxyRPCClient';
+export * from './types';
+export { isEventMethod } from './common';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./async-call-rpc-misc.cjs.production.min.js')
+} else {
+  module.exports = require('./async-call-rpc-misc.cjs.development.js')
+}

package/dist/rpc-service/ProxyRPCClient.d.ts

@@ -0,0 +1,9 @@
+import { ProxyRPCClientProps } from '../types';
+declare class ProxyRPCClient {
+    private requestPath;
+    private _channelProtocol;
+    constructor(props: ProxyRPCClientProps);
+    get channelProtocol(): import("../channel-protocol/AbstractChannelProtocol").default;
+    createProxy<T = object>(): T;
+}
+export default ProxyRPCClient;

package/dist/rpc-service/RPCServiceHost.d.ts

@@ -0,0 +1,11 @@
+import { IService, ServiceHandlerPath } from '../types';
+declare class RPCServiceHost {
+    protected readonly hostPath: string;
+    handlersMap: Map<string, any>;
+    constructor(hostPath: string);
+    registerServiceHandler(handlerPath: ServiceHandlerPath, service: IService): void;
+    getHandlers(handlerPath: ServiceHandlerPath): any;
+    getHandler(handlerPath: ServiceHandlerPath, fnName: string): any;
+    merge(serviceHost: RPCServiceHost): void;
+}
+export default RPCServiceHost;

package/dist/rpc-service/RPCServiceProvider.d.ts

@@ -0,0 +1,9 @@
+import RPCServiceHandler from './RPCServiceHost';
+declare class RPCServiceProvider {
+    private hostMap;
+    getHost(hostPath: string): RPCServiceHandler;
+    registerHost(hostPath: string): RPCServiceHandler;
+    resetHost(hostPath: string): void;
+}
+declare const _default: RPCServiceProvider;
+export default _default;

package/dist/types/buffer.d.ts

@@ -0,0 +1,4 @@
+export declare type DataBuffer = {
+    flush: () => void;
+    drain: () => void;
+};

package/dist/types/channel.d.ts

@@ -0,0 +1,12 @@
+export declare type IMessageChannelOnClose = () => void;
+export declare type IMessageChannelOnError = () => void;
+export declare type IMessageChannelOnMessage = (message: any) => void;
+export declare type IMessageChannelSend = (requestPath: string, fnName: string, ...args: any[]) => void;
+export declare type IMessageChannelDisconnect = () => void;
+export declare type IMessageChannel = {
+    onClose?: IMessageChannelOnClose;
+    onError?: IMessageChannelOnError;
+    onMessage: IMessageChannelOnMessage;
+    send: IMessageChannelSend;
+    disconnect: IMessageChannelDisconnect;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './channel';
+export * from './messageChannel';
+export * from './rpc';
+export * from './proxyChannel';
+export * from './proxyService';
+export * from './middleware';

package/dist/types/messageChannel.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import { IpcRenderer, UtilityProcess, WebContents } from 'electron';
+import MessageChannelProtocol from '../channel-protocol/MessageChannelProtocol';
+import RPCServiceHost from '../rpc-service/RPCServiceHost';
+export interface ChannelPort {
+    on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    removeListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    postMessage(message: any, transfer?: MainPort[]): void;
+}
+export declare type UtilityMessageChannelPortStoreProps = {
+    name: string;
+    port: ParentPort;
+    masterProcessName: string;
+    clientMiddlewares?: ClientMiddleware[];
+    senderMiddlewares?: SenderMiddleware[];
+};
+export declare type OnMessageEntry = {
+    data: any;
+    ports: any;
+};
+export declare type SenderEntry = any;
+export declare type ClientMiddleware = (channel?: MessageChannelProtocol) => (v: OnMessageEntry) => OnMessageEntry;
+export declare type SenderMiddleware = (channel?: MessageChannelProtocol) => (data: SenderEntry) => SenderEntry;
+export declare type AbstractChannelProtocolProps = {
+    serviceHost?: RPCServiceHost;
+    connected?: boolean;
+    description?: string;
+    masterProcessName?: string;
+    clientMiddlewares?: ClientMiddleware[];
+    senderMiddlewares?: SenderMiddleware[];
+};
+export declare type DeferredMessageChannelProtocolProps = AbstractChannelProtocolProps & {
+    port?: MainPort;
+};
+export declare type MessageChannelProtocolProps = AbstractChannelProtocolProps & {
+    port?: MainPort;
+};
+export declare type ProcessChannelProtocolProps = {
+    process: UtilityProcess;
+} & AbstractChannelProtocolProps;
+export declare type IPCMainGlobalChannelProtocolProps = AbstractChannelProtocolProps & {
+    channelName: string;
+};
+export declare type IPCMainChannelProtocolProps = {
+    channelName: string;
+    webContents: WebContents;
+} & AbstractChannelProtocolProps;
+export declare type IPCRendererChannelProtocolProps = {
+    channelName: string;
+    ipcRenderer: IpcRenderer;
+    projectName: string;
+} & AbstractChannelProtocolProps;
+export interface ParentPort extends NodeJS.EventEmitter {
+    on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    addListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    removeListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    postMessage(message: any): void;
+}
+export declare type UtilityNodeJSProcess = NodeJS.Process;
+export interface MainPort extends NodeJS.EventEmitter {
+    on(event: 'close', listener: Function): this;
+    on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    off(event: 'close', listener: Function): this;
+    off(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    once(event: 'close', listener: Function): this;
+    once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    addListener(event: 'close', listener: Function): this;
+    addListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    removeListener(event: 'close', listener: Function): this;
+    removeListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+    close(): void;
+    postMessage(message: any, transfer?: MainPort[]): void;
+    start(): void;
+}
+export declare function isUtilityProcess(process: NodeJS.Process): process is UtilityNodeJSProcess;

package/dist/types/middleware.d.ts

@@ -0,0 +1,44 @@
+import { Deferred } from '@x-oasis/deferred';
+import { HostRequestEntry, RequestEntry } from './rpc';
+export declare type MiddlewareFunction = {
+    (...args: any[]): any;
+    displayName?: string;
+    lifecycle?: SendMiddlewareLifecycle;
+};
+export declare type MessageOutput = {
+    event: any;
+    ports: any;
+};
+export declare type NormalizedRawMessageOutput = MessageOutput & {
+    data: string;
+};
+export declare type DeserializedMessageOutput = MessageOutput & {
+    data: HostRequestEntry | RequestEntry;
+};
+export declare type SenderMiddlewareOutput = {
+    data: any;
+    transfer: any;
+    seqId: number;
+    returnValue: Deferred;
+    isOptionsRequest: boolean;
+    middlewareContext: MiddlewareContext;
+};
+export declare type PendingSendEntry = SenderMiddlewareOutput & {
+    fnName: string;
+    lifecycle: SendMiddlewareLifecycle;
+    middlewareContext: MiddlewareContext;
+};
+export declare type MiddlewareContext = {
+    isResumed?: boolean;
+    startLifecycle: SendMiddlewareLifecycle;
+    minLifecycle: SendMiddlewareLifecycle;
+    reserved: PendingSendEntry;
+};
+export declare enum SendMiddlewareLifecycle {
+    Initial = 0,
+    Prepare = 10,
+    Transfrom = 20,
+    DataOperation = 30,
+    Send = 40,
+    Aborted = 100
+}

package/dist/types/proxyChannel.d.ts

@@ -0,0 +1,3 @@
+export declare type ProxyChannelProps = {
+    name: string;
+};

package/dist/types/proxyService.d.ts

@@ -0,0 +1,10 @@
+import AbstractChannelProtocol from '../channel-protocol/AbstractChannelProtocol';
+export declare type IService = any;
+export declare type ServiceHandlerPath = string;
+export declare type ProxyRPCClientChannel = AbstractChannelProtocol | {
+    (): AbstractChannelProtocol;
+};
+export declare type ProxyRPCClientProps = {
+    requestPath: string;
+    channel: ProxyRPCClientChannel;
+};

package/dist/types/rpc.d.ts

@@ -0,0 +1,31 @@
+export declare enum RequestType {
+    PromiseRequest = "pr",
+    PromiseAbort = "pa",
+    SignalRequest = "sr",
+    SignalAbort = "sa"
+}
+export declare type RequestRawSequenceId = number;
+export declare type RequestSequenceId = string;
+export declare type RequestServicePath = string;
+export declare type RequestFnName = string;
+export declare type RequestEntryHeader = [RequestType, RequestSequenceId, RequestServicePath, RequestFnName];
+export declare type RequestEntryBody = any;
+export declare type RequestEntry = [RequestEntryHeader, RequestEntryBody];
+export declare enum ResponseType {
+    ReturnSuccess = "rs",
+    ReturnFail = "rf",
+    PortSuccess = "ps",
+    PortFail = "pf"
+}
+export declare type ResponseEntryHeader = [ResponseType, RequestSequenceId];
+export declare type ResponseEntryBody = any;
+export declare type HostName = string;
+export declare type HostRequestEntryHeader = [RequestType, RequestSequenceId, RequestServicePath, RequestFnName, HostName];
+export declare type HostRequestEntryBody = any;
+export declare type HostRequestEntry = [HostRequestEntryHeader, HostRequestEntryBody];
+export declare type SendingProps = {
+    requestPath?: string;
+    fnName?: string;
+    args?: any;
+    isOptionsRequest?: boolean;
+};

package/dist/types/rpcProtocol.d.ts

@@ -0,0 +1,22 @@
+export declare type IRPCProtocolServer = {
+    source: any;
+    encoder: null;
+    decoder: null;
+    onRequest: () => {};
+    handleRequest: () => {};
+    sendReply: () => {};
+};
+export declare type IRPCProtocolClient = {
+    source: any;
+    encode: () => {};
+    decode: () => {};
+    sendRequest: () => {};
+    onReply: () => {};
+    handleReply: () => {};
+};
+export declare type IRPCProtocol = {
+    encode: Function;
+    decode: Function;
+    onMessage: Function;
+    send: Function;
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@x-oasis/async-call-rpc-misc",
+  "version": "0.1.38",
+  "description": "async-call-rpc-misc function",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "module": "dist/async-call-rpc-misc.esm.js",
+  "files": [
+    "dist",
+    "index.ts",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsdx": "^0.14.1"
+  },
+  "dependencies": {
+    "@x-oasis/is-promise": "0.1.38",
+    "@x-oasis/emitter": "0.1.38",
+    "@x-oasis/deferred": "0.1.38",
+    "@x-oasis/disposable": "0.1.38",
+    "@x-oasis/id": "0.1.38",
+    "@x-oasis/is-ascii": "0.1.38"
+  },
+  "peerDependencies": {
+    "electron": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsdx build --tsconfig tsconfig.build.json",
+    "clean": "rimraf ./dist",
+    "test": "vitest",
+    "compile": "tsc -p tsconfig.build.json"
+  }
+}

package/src/buffer/DataBuffer.ts

@@ -0,0 +1 @@
+export default class DataBuffer {}