@event-chat/rpc 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 快乐的小萌新
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# Rslib project
+
+## Setup
+
+Install the dependencies:
+
+```bash
+npm install
+```
+
+## Get started
+
+Build the library:
+
+```bash
+npm run build
+```
+
+Build the library in watch mode:
+
+```bash
+npm run dev
+```

package/dist/RPCAction.d.ts

@@ -0,0 +1,42 @@
+import RPCFactory, { IframeSerializeOptions } from './RPCFactory';
+declare class RPCAction {
+    private _target;
+    private _brodcastListeners;
+    private _handlers;
+    private _heartbeatTimer;
+    private _isConnected;
+    private _lastHeartbeat;
+    private _options;
+    private _pending;
+    private _boundMessageHandler;
+    constructor(_target: RPCFactory, options?: RPCOptionsType);
+    destroy(): void;
+    broadcast<T>(options?: Omit<RequestOptions<T>, 'retry'>): void;
+    config(options: Omit<RPCOptionsType, 'onConnect' | 'onDisconnect'>): void;
+    on<T extends ActionFunType>(type: PropertyKey, handler: T): void;
+    onBrodcast(listener: BrodcastItem): void;
+    request<T = unknown>(type: PropertyKey, options?: RequestOptions<T>): Promise<unknown>;
+    private _abort;
+    private _createRequestId;
+    private _isOriginAllowed;
+    private _messageHandler;
+    private _startHeartbeat;
+}
+export default RPCAction;
+export type RPCOptionsType = {
+    allowedOrigins?: string[];
+    channel?: string;
+    heartbeatInterval?: number;
+    heartbeatTimeout?: number;
+    retryTimeout?: number;
+    retryTimes?: number;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+};
+export type ActionFunType = (payload?: any) => any;
+export type BrodcastItem = (value: unknown, origin?: string) => void;
+export type RequestOptions<T = unknown> = IframeSerializeOptions & {
+    payload?: T;
+    retry?: number;
+};
+//# sourceMappingURL=RPCAction.d.ts.map

package/dist/RPCAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCAction.d.ts","sourceRoot":"","sources":["../src/RPCAction.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,EAAE,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAejE,cAAM,SAAS;IAWX,OAAO,CAAC,OAAO;IAVjB,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,oBAAoB,CAAkC;gBAGpD,OAAO,EAAE,UAAU,EAC3B,OAAO,CAAC,EAAE,cAAc;IAc1B,OAAO;IAUP,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IASvD,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,cAAc,CAAC;IAIlE,EAAE,CAAC,CAAC,SAAS,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAIzD,UAAU,CAAC,QAAQ,EAAE,YAAY;IAIjC,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;IA6CnE,OAAO,CAAC,MAAM;IAWd,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,eAAe;IAuEvB,OAAO,CAAC,eAAe;CAsBxB;AAED,eAAe,SAAS,CAAA;AAExB,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAA;CAC1B,CAAA;AAID,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,GAAG,CAAA;AAElD,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;AAEpE,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,sBAAsB,GAAG;IACjE,OAAO,CAAC,EAAE,CAAC,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA"}

package/dist/RPCAction.js

@@ -0,0 +1,189 @@
+import { isKey } from "./utils.js";
+const RPC_SIGN = 'RPCActionSign';
+const defaultOptions = {
+    allowedOrigins: [],
+    heartbeatInterval: 3000,
+    heartbeatTimeout: 8000,
+    retryTimeout: 5000,
+    retryTimes: 2
+};
+const getOrigin = (url)=>new URL(url, window.location.origin).origin;
+class RPCAction {
+    _target;
+    _brodcastListeners = [];
+    _handlers = {};
+    _heartbeatTimer = null;
+    _isConnected = false;
+    _lastHeartbeat = Date.now();
+    _options = {};
+    _pending = new Map();
+    _boundMessageHandler = this._messageHandler.bind(this);
+    constructor(_target, options){
+        this._target = _target;
+        this._options = {
+            ...defaultOptions,
+            ...options,
+            allowedOrigins: options?.allowedOrigins?.map((item)=>'*' === item ? item : getOrigin(item))
+        };
+        this._target.onmessage(this._boundMessageHandler);
+        this._startHeartbeat();
+    }
+    destroy() {
+        clearInterval(this._heartbeatTimer ?? void 0);
+        this._target.onremove(this._boundMessageHandler);
+        this._abort();
+        this._brodcastListeners = [];
+        this._handlers = {};
+        this._heartbeatTimer = null;
+    }
+    broadcast(options) {
+        const { payload, ...ops } = options ?? {};
+        const { channel } = this._options;
+        this._target.postMessage({
+            __RPC__: RPC_SIGN,
+            broadcast: true,
+            kind: 'request',
+            channel,
+            payload
+        }, {
+            ...ops,
+            targetOrigin: ops.targetOrigin ?? window.location.origin
+        });
+    }
+    config(options) {
+        this._options = {
+            ...this._options,
+            ...options
+        };
+    }
+    on(type, handler) {
+        this._handlers[type] = handler;
+    }
+    onBrodcast(listener) {
+        this._brodcastListeners.push(listener);
+    }
+    request(type, options) {
+        const { payload, retry = 0, ...ops } = options ?? {};
+        const { channel, retryTimeout = defaultOptions.retryTimeout, retryTimes = defaultOptions.retryTimes } = this._options;
+        return new Promise((resolve, reject)=>{
+            if (!this._isConnected) return void reject(new Error(`[RPC] 连接未建立，无法请求：${type.toString()}`));
+            const requestId = this._createRequestId();
+            const timer = window.setTimeout(()=>{
+                this._pending.delete(requestId);
+                if (retry < retryTimes) resolve(this.request(type, {
+                    ...options,
+                    retry: retry + 1
+                }));
+                else reject(new Error(`[RPC] 请求超时：${type.toString()}`));
+            }, retryTimeout);
+            this._pending.set(requestId, {
+                resolve: (res)=>{
+                    clearTimeout(timer);
+                    resolve(res);
+                },
+                reject: (err)=>{
+                    const message = err instanceof Error ? err.message : '[RPC] 处理消息时发生错误';
+                    clearTimeout(timer);
+                    reject(new Error(message));
+                },
+                timer
+            });
+            this._target.postMessage({
+                __RPC__: RPC_SIGN,
+                kind: 'request',
+                channel,
+                payload,
+                requestId,
+                type
+            }, {
+                ...ops,
+                targetOrigin: ops.targetOrigin ?? window.location.origin
+            });
+        });
+    }
+    _abort() {
+        this._isConnected = false;
+        this._options?.onDisconnect?.();
+        this._pending.forEach(({ reject, timer })=>{
+            clearTimeout(timer);
+            reject(new Error('[RPC] 连接已断开，请求已取消'));
+        });
+        this._pending.clear();
+    }
+    _createRequestId() {
+        const requestId = Math.random().toString(36).slice(2, 10);
+        return this._pending.has(requestId) ? this._createRequestId() : requestId;
+    }
+    _isOriginAllowed(origin) {
+        return this._options?.allowedOrigins?.some((item)=>'*' === item || getOrigin(item) === getOrigin(origin)) ?? false;
+    }
+    _messageHandler(event) {
+        const { data, origin, source } = event;
+        const { __RPC__, broadcast, channel, error, heartbeat, kind, payload, requestId, type } = data ?? {};
+        if (__RPC__ !== RPC_SIGN) return;
+        if (this._options?.channel !== channel) return;
+        if (!this._target.is(source)) return;
+        if (this._target.getType() === window.toString() && !this._isOriginAllowed(origin)) return;
+        if (heartbeat) {
+            this._lastHeartbeat = Date.now();
+            if (!this._isConnected) {
+                this._isConnected = true;
+                this._options?.onConnect?.();
+            }
+            return;
+        }
+        if (broadcast) return void this._brodcastListeners.forEach((listener)=>listener(payload, origin));
+        const pending = requestId ? this._pending.get(requestId) : void 0;
+        if (requestId && pending) {
+            const { resolve, reject } = pending;
+            this._pending.delete(requestId);
+            if (void 0 !== error) reject(new Error(error));
+            else resolve(payload);
+            return;
+        }
+        if ('request' !== kind) return;
+        const handler = type && isKey(type, this._handlers) ? this._handlers[type] : void 0;
+        if (handler) Promise.resolve().then(()=>handler(payload)).then((result)=>{
+            this._target.postMessage({
+                __RPC__: RPC_SIGN,
+                kind: 'response',
+                payload: result,
+                channel,
+                requestId,
+                type
+            }, {
+                targetOrigin: origin
+            });
+        }).catch((err)=>{
+            const message = err instanceof Error ? err.message : '[RPC] 处理消息时发生错误';
+            this._target.postMessage({
+                __RPC__: RPC_SIGN,
+                error: message,
+                kind: 'response',
+                payload: '',
+                channel,
+                requestId
+            }, {
+                targetOrigin: origin
+            });
+        });
+    }
+    _startHeartbeat() {
+        const { channel, heartbeatInterval = defaultOptions.heartbeatInterval, heartbeatTimeout = defaultOptions.heartbeatTimeout } = this._options;
+        const intervalLoops = ()=>{
+            this._target.postMessage({
+                __RPC__: RPC_SIGN,
+                heartbeat: true,
+                kind: 'request',
+                channel
+            });
+            if (!this._isConnected) return;
+            if (Date.now() - this._lastHeartbeat > heartbeatTimeout) this._abort();
+        };
+        intervalLoops();
+        clearInterval(this._heartbeatTimer ?? void 0);
+        this._heartbeatTimer = window.setInterval(intervalLoops, heartbeatInterval);
+    }
+}
+const src_RPCAction = RPCAction;
+export { src_RPCAction as default };

package/dist/RPCDecorator.d.ts

@@ -0,0 +1,21 @@
+import RPCAction, { ActionFunType, BrodcastItem, RPCOptionsType, RequestOptions } from './RPCAction';
+import RPCFactory, { FactoryOptions, TargetType } from './RPCFactory';
+declare const factoryKey: readonly ["getType", "upset"];
+declare function RPCDecorator<EVENT extends ActionRecord, CONSUME extends ActionRecord>(target: TargetType | null, context?: DecoratorContext<EVENT, CONSUME>): Readonly<Omit<RPCAction, "on" | "request"> & Pick<RPCFactory, (typeof factoryKey)[number]> & {
+    request: <K extends keyof CONSUME>(...args: Parameters<CONSUME[K]> extends [] ? [keyname: K, reqops?: RequestOptionsByAction<CONSUME[K]>] : [keyname: K, reqops: RequestOptionsByAction<CONSUME[K]>]) => Promise<ReturnType<CONSUME[K]>>;
+}>;
+export default RPCDecorator;
+export interface DecoratorContext<EVENT extends ActionRecord, CONSUME extends ActionRecord> {
+    brodcast?: Record<string, BrodcastItem>;
+    config?: RPCOptionsType;
+    consume?: CONSUME;
+    event?: EVENT;
+    options?: FactoryOptions;
+}
+export type ActionRecord = Record<string, ActionFunType>;
+type RequestOptionsByAction<F extends ActionFunType> = Parameters<F> extends [] ? Omit<RequestOptions, 'payload'> & {
+    payload?: never;
+} : RequestOptions<Parameters<F>[0]> & {
+    payload: Parameters<F>[0];
+};
+//# sourceMappingURL=RPCDecorator.d.ts.map

package/dist/RPCDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCDecorator.d.ts","sourceRoot":"","sources":["../src/RPCDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACpG,OAAO,UAAU,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAErE,QAAA,MAAM,UAAU,+BAAgC,CAAA;AAUhD,iBAAS,YAAY,CAAC,KAAK,SAAS,YAAY,EAAE,OAAO,SAAS,YAAY,EAC5E,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,OAAO,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAwDrC,QAAQ,CACX,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,SAAS,CAAC,GAC/B,IAAI,CAAC,UAAU,EAAE,CAAC,OAAO,UAAU,EAAE,MAAM,CAAC,CAAC,GAAG;IAC9C,OAAO,GArDI,CAAC,SAAS,MAAM,OAAO,WAC7B,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,GACtC,CAAC,OAAO,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GACzD,CAAC,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,KAGjB,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CA+C/C;CACxB,CACJ,CACF;AAED,eAAe,YAAY,CAAA;AAE3B,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,YAAY,EAAE,OAAO,SAAS,YAAY;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;IACvC,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAExD,KAAK,sBAAsB,CAAC,CAAC,SAAS,aAAa,IACjD,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,GACpB,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GACrD,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,CAAA"}

package/dist/RPCDecorator.js

@@ -0,0 +1,57 @@
+import RPCAction from "./RPCAction.js";
+import RPCFactory from "./RPCFactory.js";
+const factoryKey = [
+    'getType',
+    'upset'
+];
+function isAction(action, key) {
+    return key in action;
+}
+function isFactory(action, key) {
+    return null !== action && key in action && factoryKey.map(String).includes(key);
+}
+function RPCDecorator(target, context) {
+    const { brodcast, config, event, options } = context ?? {};
+    const factory = target ? new RPCFactory(target, options) : null;
+    const action = factory ? new RPCAction(factory, config) : null;
+    const request = (...args)=>{
+        const [keyname, reqops] = args;
+        return action?.request(keyname, reqops);
+    };
+    Object.entries(event ?? {}).forEach(([keyname, handle])=>action?.on(keyname, handle));
+    Object.values(brodcast ?? {}).forEach((handle)=>action?.onBrodcast(handle));
+    return new Proxy({}, {
+        get (_, key) {
+            const keyname = key.toString();
+            if (!action || 'on' === keyname || !(keyname in action) && !isFactory(factory, keyname)) return;
+            switch(key){
+                case 'destroy':
+                    return ()=>{
+                        action.destroy();
+                        factory?.destory();
+                    };
+                case 'request':
+                    return request;
+                default:
+                    if (isAction(action, keyname)) {
+                        const value = action[keyname];
+                        return 'function' == typeof value ? value.bind(action) : value;
+                    }
+                    if (factory && isFactory(factory, keyname)) {
+                        const value = factory[keyname];
+                        return 'function' == typeof value ? value.bind(factory) : value;
+                    }
+                    throw new Error('outof decorator');
+            }
+        },
+        has (_, key) {
+            const keyname = key.toString();
+            return null !== action && 'on' !== keyname && (keyname in action || isFactory(factory, keyname));
+        },
+        set () {
+            throw new Error('decorator is readonly');
+        }
+    });
+}
+const src_RPCDecorator = RPCDecorator;
+export { src_RPCDecorator as default };

package/dist/RPCFactory.d.ts

@@ -0,0 +1,22 @@
+declare class RPCFactory<T extends TargetType = TargetType> {
+    private _target;
+    private _options;
+    private _onconnect;
+    constructor(_target: T, _options?: FactoryOptions);
+    destory(): void;
+    getType(): string;
+    is(source: MessageEventSource | null): boolean;
+    onmessage(listener: (ev: MessageEvent) => unknown): void;
+    onremove(listener: (ev: MessageEvent) => unknown): void;
+    postMessage(message: unknown, options?: IframeSerializeOptions): void;
+    upset(options: FactoryOptions): void;
+}
+export default RPCFactory;
+export interface FactoryOptions {
+    message?: boolean | AddEventListenerOptions;
+}
+export type IframeSerializeOptions = StructuredSerializeOptions & {
+    targetOrigin?: string;
+};
+export type TargetType = BroadcastChannel | WebSocket | Window | ServiceWorkerRegistration | ServiceWorkerGlobalScope | SharedWorker | SharedWorkerGlobalScope | Worker | DedicatedWorkerGlobalScope;
+//# sourceMappingURL=RPCFactory.d.ts.map

package/dist/RPCFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCFactory.d.ts","sourceRoot":"","sources":["../src/RPCFactory.ts"],"names":[],"mappings":"AAQA,cAAM,UAAU,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IAI9C,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IAJlB,OAAO,CAAC,UAAU,CAAwB;gBAGhC,OAAO,EAAE,CAAC,EACV,QAAQ,GAAE,cAAmB;IAqBvC,OAAO;IA4CP,OAAO;IAIP,EAAE,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAIpC,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO;IAoFjD,QAAQ,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO;IA0DhD,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAqE9D,KAAK,CAAC,OAAO,EAAE,cAAc;CAG9B;AAED,eAAe,UAAU,CAAA;AAEzB,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAA;CAC5C;AAED,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,GAAG;IAChE,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAID,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,SAAS,GACT,MAAM,GAEN,yBAAyB,GACzB,wBAAwB,GACxB,YAAY,GACZ,uBAAuB,GACvB,MAAM,GACN,0BAA0B,CAAA"}

package/dist/RPCFactory.js

@@ -0,0 +1,141 @@
+import { TARGET_TYPE_STRINGS } from "./fields.js";
+function isSafeBufferSource(data) {
+    return data instanceof ArrayBuffer || ArrayBuffer.isView(data) && data.buffer instanceof ArrayBuffer;
+}
+class RPCFactory {
+    _target;
+    _options;
+    _onconnect = {};
+    constructor(_target, _options = {}){
+        this._target = _target;
+        this._options = _options;
+        this._onconnect = {
+            WebSocketPort: new Promise((resolve)=>{
+                if (this._target instanceof WebSocket) {
+                    this._target.onopen = ()=>{
+                        resolve(true);
+                    };
+                    this._target.onclose = ()=>{
+                        resolve(false);
+                    };
+                } else resolve(false);
+            })
+        };
+    }
+    destory() {
+        if (this._target instanceof BroadcastChannel) this._target.close();
+        if (this._target instanceof WebSocket) {
+            this._target.onclose = null;
+            this._target.onopen = null;
+            if (this._target.readyState === WebSocket.OPEN) this._target.close();
+        }
+        this._target, ServiceWorkerContainer;
+        if (this._target instanceof SharedWorker) this._target.port.close();
+        if ('undefined' != typeof SharedWorkerGlobalScope && this._target instanceof SharedWorkerGlobalScope) {
+            this._onconnect.SharedWorkerGlobalPort?.then((messagePort)=>messagePort.close()).catch(()=>{});
+            if (this._onconnect.SharedWorkerGlobalScope) this._target.removeEventListener('connect', this._onconnect.SharedWorkerGlobalScope);
+        }
+        if (this._target instanceof Worker) this._target.terminate();
+        this._onconnect = {};
+    }
+    getType() {
+        return `${Object.prototype.toString.call(this._target)}`;
+    }
+    is(source) {
+        return this._target === source;
+    }
+    onmessage(listener) {
+        if (this._target instanceof BroadcastChannel) this._target.addEventListener('message', listener, this._options.message);
+        if (this._target instanceof WebSocket) this._target.onmessage = listener;
+        if (this.getType() === TARGET_TYPE_STRINGS.Window) window.addEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof ServiceWorkerRegistration && this._target instanceof ServiceWorkerRegistration) navigator.serviceWorker.addEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof ServiceWorkerGlobalScope && this._target instanceof ServiceWorkerGlobalScope) {
+            this._onconnect.ServiceWorkerGlobalScope = (event)=>{
+                const ports = event.ports.map((i)=>i);
+                const source = event.source instanceof Client ? null : event.source;
+                const messageEvent = new MessageEvent('serverWork', {
+                    ...event,
+                    ports,
+                    source
+                });
+                listener(messageEvent);
+            };
+            this._target.addEventListener('message', this._onconnect.ServiceWorkerGlobalScope, this._options.message);
+        }
+        if (this._target instanceof SharedWorker) {
+            this._target.port.addEventListener('message', listener, this._options.message);
+            this._target.port.start();
+        }
+        if ('undefined' != typeof SharedWorkerGlobalScope && this._target instanceof SharedWorkerGlobalScope) {
+            const SharedWorker1 = this._target;
+            this._onconnect.SharedWorkerGlobalPort = new Promise((resolve)=>{
+                this._onconnect.SharedWorkerGlobalScope = (event)=>{
+                    const port = event.ports[0];
+                    resolve(port);
+                    port.addEventListener('message', listener, this._options.message);
+                    port.start();
+                };
+                SharedWorker1.addEventListener('connect', this._onconnect.SharedWorkerGlobalScope);
+            });
+        }
+        if (this._target instanceof Worker) this._target.addEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof DedicatedWorkerGlobalScope && this._target instanceof DedicatedWorkerGlobalScope) this._target.addEventListener('message', listener, this._options.message);
+    }
+    onremove(listener) {
+        if (this._target instanceof BroadcastChannel) this._target.removeEventListener('message', listener, this._options.message);
+        if (this._target instanceof WebSocket) this._target.onmessage = null;
+        if (this.getType() === TARGET_TYPE_STRINGS.Window) window.removeEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof ServiceWorkerRegistration && this._target instanceof ServiceWorkerRegistration) navigator.serviceWorker.removeEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof ServiceWorkerGlobalScope && this._target instanceof ServiceWorkerGlobalScope && this._onconnect.ServiceWorkerGlobalScope) this._target.removeEventListener('message', this._onconnect.ServiceWorkerGlobalScope, this._options.message);
+        if (this._target instanceof SharedWorker) this._target.port.removeEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof SharedWorkerGlobalScope && this._target instanceof SharedWorkerGlobalScope) this._onconnect.SharedWorkerGlobalPort?.then((messagePort)=>{
+            messagePort.removeEventListener('message', listener, this._options.message);
+        }).catch(()=>{});
+        if (this._target instanceof Worker) this._target.removeEventListener('message', listener, this._options.message);
+        if ('undefined' != typeof DedicatedWorkerGlobalScope && this._target instanceof DedicatedWorkerGlobalScope) this._target.removeEventListener('message', listener, this._options.message);
+    }
+    postMessage(message, options) {
+        const { transfer, targetOrigin = '*' } = options ?? {};
+        if (this._target instanceof BroadcastChannel) this._target.postMessage(message);
+        if (this._target instanceof WebSocket) {
+            const target = this._target;
+            this._onconnect.WebSocketPort?.then((open)=>{
+                if (open) target.send(isSafeBufferSource(message) || message instanceof Blob ? message : String(message));
+            }).catch(()=>{});
+        }
+        if (this.getType() === TARGET_TYPE_STRINGS.Window && 'postMessage' in this._target) this._target.postMessage(message, {
+            targetOrigin,
+            transfer
+        });
+        if ('undefined' != typeof ServiceWorkerRegistration && this._target instanceof ServiceWorkerRegistration) this._target.active?.postMessage(message, {
+            transfer
+        });
+        if ('undefined' != typeof ServiceWorkerGlobalScope && this._target instanceof ServiceWorkerGlobalScope) this._target.clients.matchAll().then((clients)=>{
+            clients.forEach((client)=>client.postMessage(message, {
+                    transfer
+                }));
+        }).catch(()=>{});
+        if (this._target instanceof SharedWorker) this._target.port.postMessage(message, {
+            transfer
+        });
+        if ('undefined' != typeof SharedWorkerGlobalScope && this._target instanceof SharedWorkerGlobalScope) this._onconnect.SharedWorkerGlobalPort?.then((messagePort)=>{
+            messagePort.postMessage(message, {
+                transfer
+            });
+        }).catch(()=>{});
+        if (this._target instanceof Worker) this._target.postMessage(message, {
+            transfer
+        });
+        if ('undefined' != typeof DedicatedWorkerGlobalScope && this._target instanceof DedicatedWorkerGlobalScope) this._target.postMessage(message, {
+            transfer
+        });
+    }
+    upset(options) {
+        this._options = {
+            ...this._options,
+            ...options
+        };
+    }
+}
+const src_RPCFactory = RPCFactory;
+export { src_RPCFactory as default };

package/dist/RPCProvider.d.ts

@@ -0,0 +1,4 @@
+import { FC, PropsWithChildren } from 'react';
+declare const RPCProvider: FC<PropsWithChildren>;
+export default RPCProvider;
+//# sourceMappingURL=RPCProvider.d.ts.map

package/dist/RPCProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCProvider.d.ts","sourceRoot":"","sources":["../src/RPCProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,iBAAiB,EAAkC,MAAM,OAAO,CAAA;AAW7E,QAAA,MAAM,WAAW,EAAE,EAAE,CAAC,iBAAiB,CA4CtC,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/RPCProvider.js

@@ -0,0 +1,34 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef } from "react";
+import { RPCInstanceContext, TARGET_TYPE_STRINGS } from "./fields.js";
+import { objectValues } from "./utils.js";
+const RPCProvider = ({ children })=>{
+    const list = useRef(new Map());
+    const brodcastScope = useCallback((data, options)=>{
+        const { exclude, include, typein, typeout } = options ?? {};
+        if (list.current.size > 0) {
+            const scope = objectValues(TARGET_TYPE_STRINGS).filter((item)=>!exclude?.includes(item)).filter((item)=>!include || include.includes(item)).map(String);
+            list.current.forEach((group, item)=>{
+                if (scope.includes(item.getType()) && !typeout?.includes(group) && (!typein || typein.includes(group))) item.broadcast(data);
+            });
+        }
+    }, []);
+    const mount = useCallback((data, name)=>{
+        const newMap = new Map(list.current);
+        if (void 0 !== name) newMap.set(data, name);
+        else newMap.delete(data);
+        list.current = newMap;
+    }, []);
+    useEffect(()=>()=>{
+            list.current = new Map();
+        }, []);
+    return /*#__PURE__*/ jsx(RPCInstanceContext.Provider, {
+        value: {
+            brodcastScope,
+            mount
+        },
+        children: children
+    });
+};
+const src_RPCProvider = RPCProvider;
+export { src_RPCProvider as default };

package/dist/createCtx.d.ts

@@ -0,0 +1,13 @@
+import { ActionFunType, BrodcastItem } from './RPCAction';
+declare function createCtx<CTX extends Record<string, unknown>, ACTIONS extends Record<string, ActionFunType>, BRODCATS extends Record<string, BrodcastItem>>(factory: (ctx: Partial<CTX>) => ACTIONS, brodcast?: (ctx: Partial<CTX>) => BRODCATS): Readonly<{
+    actions: ACTIONS;
+    brodcasts: BRODCATS | undefined;
+    provider: (next: Partial<CTX>) => () => void;
+}>;
+declare function createService<CTX extends Record<string, unknown>>(): <ACTIONS extends Record<string, ActionFunType>, BRODCATS extends Record<string, BrodcastItem>>(factory: (ctx: Partial<CTX>) => ACTIONS, brodcast?: (ctx: Partial<CTX>) => BRODCATS) => Readonly<{
+    actions: ACTIONS;
+    brodcasts: BRODCATS | undefined;
+    provider: (next: Partial<CTX>) => () => void;
+}>;
+export { createCtx, createService };
+//# sourceMappingURL=createCtx.d.ts.map

package/dist/createCtx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCtx.d.ts","sourceRoot":"","sources":["../src/createCtx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAEzD,iBAAS,SAAS,CAChB,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EAC7C,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC7C,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,QAAQ;;;qBAiB3D,OAAO,CAAC,GAAG,CAAC;GAYrC;AAED,iBAAS,aAAa,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAEtD,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EAC7C,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAE7C,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,OAAO,EACvC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,QAAQ;;;;GAE7C;AAED,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA"}

package/dist/createCtx.js

@@ -0,0 +1,33 @@
+function createCtx(factory, brodcast) {
+    const ctx = {
+        current: null
+    };
+    const proxyCtx = new Proxy({}, {
+        get (_, key) {
+            return ctx.current ? Reflect.get(ctx.current, key) : void 0;
+        },
+        set () {
+            throw new Error('ctx is readonly');
+        }
+    });
+    const actions = factory(proxyCtx);
+    const brodcasts = brodcast?.(proxyCtx);
+    const provider = (next)=>{
+        ctx.current = {
+            ...ctx.current ?? {},
+            ...next
+        };
+        return ()=>{
+            ctx.current = null;
+        };
+    };
+    return Object.freeze({
+        actions,
+        brodcasts,
+        provider
+    });
+}
+function createService() {
+    return (factory, brodcast)=>createCtx(factory, brodcast);
+}
+export { createCtx, createService };

package/dist/fields.d.ts

@@ -0,0 +1,27 @@
+import RPCAction, { RequestOptions } from './RPCAction';
+import RPCFactory from './RPCFactory';
+import { ValueOf } from './utils';
+export declare const RPCInstanceContext: import("react").Context<RPCInstanceContextIns>;
+export declare const TARGET_TYPE_STRINGS: Readonly<{
+    BroadcastChannel: "[object BroadcastChannel]";
+    WebSocket: "[object WebSocket]";
+    Window: "[object Window]";
+    ServiceWorkerRegistration: "[object ServiceWorkerRegistration]";
+    ServiceWorkerGlobalScope: "[object ServiceWorkerGlobalScope]";
+    SharedWorker: "[object SharedWorker]";
+    SharedWorkerGlobalScope: "[object SharedWorkerGlobalScope]";
+    Worker: "[object Worker]";
+    DedicatedWorkerGlobalScope: "[object DedicatedWorkerGlobalScope]";
+}>;
+export interface RPCInstanceContextIns {
+    brodcastScope?: <T>(data: RequestOptions<T>, options?: ScopeProps) => void;
+    mount?: (item: RPCItem, name?: string) => void;
+}
+export type RPCItem = Pick<RPCAction, 'broadcast'> & Pick<RPCFactory, 'getType'>;
+export type ScopeProps = {
+    exclude?: Array<ValueOf<typeof TARGET_TYPE_STRINGS>>;
+    include?: Array<ValueOf<typeof TARGET_TYPE_STRINGS>>;
+    typein?: string[];
+    typeout?: string[];
+};
+//# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,EAAE,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,UAAU,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEjC,eAAO,MAAM,kBAAkB,gDAA2C,CAAA;AAC1E,eAAO,MAAM,mBAAmB;;;;;;;;;;EAU9B,CAAA;AAEF,MAAM,WAAW,qBAAqB;IACpC,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,UAAU,KAAK,IAAI,CAAA;IAC1E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/C;AAED,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;AAEhF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAA;IACpD,OAAO,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAA;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA"}

package/dist/fields.js

@@ -0,0 +1,14 @@
+import { createContext } from "react";
+const RPCInstanceContext = createContext({});
+const TARGET_TYPE_STRINGS = Object.freeze({
+    BroadcastChannel: '[object BroadcastChannel]',
+    WebSocket: '[object WebSocket]',
+    Window: '[object Window]',
+    ServiceWorkerRegistration: '[object ServiceWorkerRegistration]',
+    ServiceWorkerGlobalScope: '[object ServiceWorkerGlobalScope]',
+    SharedWorker: '[object SharedWorker]',
+    SharedWorkerGlobalScope: '[object SharedWorkerGlobalScope]',
+    Worker: '[object Worker]',
+    DedicatedWorkerGlobalScope: '[object DedicatedWorkerGlobalScope]'
+});
+export { RPCInstanceContext, TARGET_TYPE_STRINGS };

package/dist/hooks.d.ts

@@ -0,0 +1,34 @@
+import { ActionRecord, DecoratorContext } from './RPCDecorator';
+declare const useRPC: <EVENT extends ActionRecord, CONSUME extends ActionRecord>({ init, ...ops }: RPCHooksOptions<EVENT, CONSUME>) => Readonly<{
+    rpc: Readonly<Omit<Readonly<Omit<import("./RPCAction").default, "on" | "request"> & Pick<import("./RPCFactory").default<import("./RPCFactory").TargetType>, "getType" | "upset"> & {
+        request: <K extends keyof CONSUME>(...args: Parameters<CONSUME[K]> extends [] ? [keyname: K, reqops?: (Parameters<CONSUME[K]> extends [] ? Omit<import("./RPCAction").RequestOptions, "payload"> & {
+            payload?: never;
+        } : StructuredSerializeOptions & {
+            targetOrigin?: string;
+        } & {
+            payload?: Parameters<CONSUME[K]>[0] | undefined;
+            retry?: number;
+        } & {
+            payload: Parameters<CONSUME[K]>[0];
+        }) | undefined] : [keyname: K, reqops: Parameters<CONSUME[K]> extends [] ? Omit<import("./RPCAction").RequestOptions, "payload"> & {
+            payload?: never;
+        } : StructuredSerializeOptions & {
+            targetOrigin?: string;
+        } & {
+            payload?: Parameters<CONSUME[K]>[0] | undefined;
+            retry?: number;
+        } & {
+            payload: Parameters<CONSUME[K]>[0];
+        }]) => Promise<ReturnType<CONSUME[K]>>;
+    }>, "destroy">>;
+    mount: (name: string) => void;
+    connected: boolean;
+    brodcastScope: <T>(data: import("./RPCAction").RequestOptions<T>, options?: import("./fields").ScopeProps) => void;
+}>;
+export default useRPC;
+interface RPCHooksOptions<EVENT extends ActionRecord, CONSUME extends ActionRecord> extends DecoratorContext<EVENT, CONSUME> {
+    init: () => TargetInit | Promise<TargetInit>;
+    name?: string;
+}
+type TargetInit = BroadcastChannel | ServiceWorkerRegistration | SharedWorker | WebSocket | Window | Worker | HTMLIFrameElement | null;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AACA,OAAqB,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAI7E,QAAA,MAAM,MAAM,GAAI,KAAK,SAAS,YAAY,EAAE,OAAO,SAAS,YAAY,EAAE,kBAGvE,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;kBAoDvB,MAAM;;;EAkDhB,CAAA;AAED,eAAe,MAAM,CAAA;AAErB,UAAU,eAAe,CACvB,KAAK,SAAS,YAAY,EAC1B,OAAO,SAAS,YAAY,CAC5B,SAAQ,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC;IACxC,IAAI,EAAE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAOD,KAAK,UAAU,GACX,gBAAgB,GAChB,yBAAyB,GACzB,YAAY,GACZ,SAAS,GACT,MAAM,GACN,MAAM,GACN,iBAAiB,GACjB,IAAI,CAAA"}

package/dist/hooks.js

@@ -0,0 +1,82 @@
+import { useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import RPCDecorator from "./RPCDecorator.js";
+import { RPCInstanceContext } from "./fields.js";
+const disableKey = [
+    'destroy'
+];
+const useRPC = ({ init, ...ops })=>{
+    const { mount, brodcastScope = ()=>{} } = useContext(RPCInstanceContext);
+    const [connected, setConnected] = useState(false);
+    const initRef = useRef(init);
+    const opsRef = useRef(ops);
+    const decoratorRef = useRef(null);
+    const processRef = useRef(Promise.resolve(null));
+    const isRPCResult = useCallback((data, key)=>null !== data && key in data, []);
+    const rpcIns = useMemo(()=>new Proxy({}, {
+            get (_, key) {
+                const decorator = decoratorRef.current;
+                const keyname = key.toString();
+                if (decorator && !disableKey.map(String).includes(keyname) && isRPCResult(decorator, keyname)) return decorator[keyname];
+                throw new Error(`outof decorator: ${key.toString()}`);
+            },
+            has (_, key) {
+                const decorator = decoratorRef.current;
+                const keyname = key.toString();
+                return null !== decorator && !disableKey.map(String).includes(keyname) && isRPCResult(decorator, keyname);
+            },
+            set () {
+                throw new Error('decorator is readonly');
+            }
+        }), [
+        decoratorRef,
+        isRPCResult
+    ]);
+    const mounHandle = useCallback((name)=>{
+        if (decoratorRef.current) mount?.(decoratorRef.current, name);
+    }, [
+        mount
+    ]);
+    useEffect(()=>{
+        const { config, name = '', ...opConfig } = opsRef.current;
+        processRef.current = processRef.current.then(initRef.current).then((tar)=>{
+            const result = RPCDecorator(tar instanceof HTMLIFrameElement ? tar.contentWindow : tar, {
+                ...opConfig,
+                config: {
+                    ...config,
+                    onConnect () {
+                        config?.onConnect?.();
+                        setConnected(true);
+                    },
+                    onDisconnect () {
+                        config?.onDisconnect?.();
+                        setConnected(false);
+                    }
+                }
+            });
+            decoratorRef.current = result;
+            mount?.(result, name);
+            return result;
+        });
+        return ()=>{
+            processRef.current = processRef.current.then((result)=>{
+                setConnected(false);
+                if (result) {
+                    mount?.(result);
+                    result.destroy();
+                }
+                decoratorRef.current = null;
+                return null;
+            });
+        };
+    }, [
+        mount
+    ]);
+    return Object.freeze({
+        rpc: rpcIns,
+        mount: mounHandle,
+        connected,
+        brodcastScope
+    });
+};
+const hooks = useRPC;
+export { hooks as default };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createCtx';
+export { TARGET_TYPE_STRINGS } from './fields';
+export { default as useRPC } from './hooks';
+export { default as RPCDecorator } from './RPCDecorator';
+export { default as RPCProvider } from './RPCProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import { TARGET_TYPE_STRINGS } from "./fields.js";
+import hooks from "./hooks.js";
+import RPCDecorator from "./RPCDecorator.js";
+import RPCProvider from "./RPCProvider.js";
+export * from "./createCtx.js";
+export { RPCDecorator, RPCProvider, TARGET_TYPE_STRINGS, hooks as useRPC };

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const isKey: <T extends Record<string, unknown>>(key: unknown, data: T) => key is keyof T;
+export declare const isPropertyKey: (value: unknown) => value is PropertyKey;
+export declare const objectValues: <T extends object, V = ValueOf<T>>(obj: T) => V[];
+export type ValueOf<T> = T[keyof T];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,OAAO,EAAE,MAAM,CAAC,KAAG,GAAG,IAAI,MAAM,CAC3D,CAAA;AAEnC,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WACD,CAAA;AAEvD,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAA2B,CAAC,EAAE,CAAA;AAEnG,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA"}

package/dist/utils.js

@@ -0,0 +1,8 @@
+const isKey = (key, data)=>isPropertyKey(key) && key in data;
+const isPropertyKey = (value)=>[
+        'number',
+        'string',
+        'symbol'
+    ].includes(typeof value);
+const objectValues = (obj)=>Object.values(obj);
+export { isKey, isPropertyKey, objectValues };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@event-chat/rpc",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "license": "MIT",
+  "devDependencies": {
+    "@rslib/core": "^0.18.4",
+    "@rstest/core": "^0.7.1",
+    "@rstest/coverage-istanbul": "^0.1.3",
+    "@storybook/addon-docs": "^10.1.4",
+    "@storybook/addon-onboarding": "^10.1.4",
+    "@storybook/react": "^10.1.4",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "jsdom": "^26.1.0",
+    "storybook": "^10.1.4",
+    "storybook-addon-rslib": "^3.1.0",
+    "storybook-react-rsbuild": "^3.1.0",
+    "tsd": "^0.33.0",
+    "typescript-eslint": "^8.48.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "build:storybook": "storybook build",
+    "dev": "rslib build --watch",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx}\"",
+    "lint": "eslint \"src/**/*.{ts,tsx,js,jsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx,js,jsx}\" --fix",
+    "storybook": "storybook dev",
+    "test": "rstest",
+    "test:all": "tsd && rstest --coverage",
+    "test:coverage": "rstest --coverage",
+    "test:type": "tsd"
+  }
+}