crx-rpc 1.0.0

package/src/content.ts

@@ -0,0 +1,71 @@
+import { BaseObservable, RPCClient } from './client';
+import { OBSERVABLE_EVENT, RPC_EVENT_NAME, RPC_RESPONSE_EVENT_NAME, SUBSCRIBABLE_OBSERVABLE, UNSUBSCRIBE_OBSERVABLE } from './const';
+import { Disposable } from './disposable';
+import { Identifier } from './id';
+import type { IMessageAdapter, RpcRequest, RpcResponse, } from './types';
+
+const WEB_TO_BACKGROUND = [RPC_EVENT_NAME, SUBSCRIBABLE_OBSERVABLE, UNSUBSCRIBE_OBSERVABLE]
+const BACKGROUND_TO_WEB = [RPC_RESPONSE_EVENT_NAME, OBSERVABLE_EVENT]
+
+export class ContentRPC extends Disposable {
+    constructor() {
+        super();
+        WEB_TO_BACKGROUND.forEach(eventName => {
+            const handler = (event: any) => {
+                chrome.runtime.sendMessage({ ...event.detail, type: eventName });
+            }
+            window.addEventListener(eventName, handler);
+
+            this.disposeWithMe(() => {
+                window.removeEventListener(eventName, handler);
+            });
+        });
+
+        const handler = (msg: { type: string } & (RpcRequest | RpcResponse)) => {
+            if (!BACKGROUND_TO_WEB.includes(msg.type)) return;
+            const { type, ...detail } = msg
+            window.dispatchEvent(new CustomEvent(type, { detail }));
+        }
+        chrome.runtime.onMessage.addListener(handler);
+
+        this.disposeWithMe(() => {
+            chrome.runtime.onMessage.removeListener(handler);
+        });
+    }
+}
+
+
+export const contentMessageAdapter: IMessageAdapter = {
+    onMessage<T>(type: string, callback: (message: T) => void) {
+        const handler = (msg: { type: string } & T) => {
+            if (msg.type === type) {
+                callback(msg);
+            }
+        }
+
+        chrome.runtime.onMessage.addListener(handler);
+        return () => {
+            chrome.runtime.onMessage.removeListener(handler);
+        }
+    },
+    sendMessage<T>(type: string, message: T): void {
+        chrome.runtime.sendMessage({ ...message, type });
+    },
+};
+
+export class ContentRPCClient extends RPCClient {
+    constructor() {
+        super(contentMessageAdapter);
+    }
+}
+
+export class ContentObservable<T> extends BaseObservable<T> {
+    constructor(
+        identifier: Identifier<T>,
+        key: string,
+        callback: (value: T) => void,
+    ) {
+        super(identifier, key, callback, contentMessageAdapter);
+    }
+}
+

package/src/disposable.ts

@@ -0,0 +1,18 @@
+export class Disposable {
+    private _isDisposed = false;
+    private _disposeCallbacks: Set<() => void> = new Set();
+
+    dispose(): void {
+        if (this._isDisposed) return;
+        this._isDisposed = true;
+        this._disposeCallbacks.forEach(callback => callback());
+    }
+
+    isDisposed(): boolean {
+        return this._isDisposed;
+    }
+
+    protected disposeWithMe(disposeLike: () => void) {
+        this._disposeCallbacks.add(disposeLike);
+    }
+}

package/src/id.ts

@@ -0,0 +1,17 @@
+// shared/utils/identifier.ts
+
+/**
+ * Identifier 类型，既携带类型信息，又在运行时能唯一标识。
+ */
+export interface Identifier<T> {
+    key: string;
+    __type?: T; // 用于 TS 类型推导，不会出现在运行时
+}
+
+  /**
+   * 创建一个 Identifier。
+   * @param key 唯一字符串标识
+   */
+export function createIdentifier<T>(key: string): Identifier<T> {
+    return { key } as Identifier<T>;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './background';
+export * from './content';
+export * from './types';
+export * from './id';
+export * from './web';
+export * from './content';

package/src/types.ts

@@ -0,0 +1,49 @@
+export interface RpcRequest {
+    id: string;
+    method: string;
+    service: string;
+    args: any[];
+}
+
+export interface RpcResponse {
+    id: string;
+    result?: any;
+    error?: { message: string; stack?: string; name?: string };
+    service: string;
+    method: string;
+}
+
+export type RpcHandler = (...args: any[]) => Promise<any> | any;
+
+export type RpcService = Record<string, RpcHandler>;
+
+export interface ObservableLike<T> {
+    subscribe(next: (value: T) => void): () => void;
+}
+
+export interface SubjectLike<T> extends ObservableLike<T> {
+    next(value: T): void;
+    complete(): void;
+}
+
+export interface RpcObservableUpdateMessage<T> {
+    type: string;
+    operation: 'next' | 'complete';
+    key: string;
+    value?: T;
+}
+
+export interface RpcObservableSubscribeMessage {
+    type: string;
+    key: string;
+}
+
+export interface IMessageAdapter {
+    onMessage<T>(type: string, callback: (message: T) => void): () => void;
+
+    sendMessage<T>(type: string, message: T): void;
+}
+
+export interface IDisposable {
+    dispose(): void;
+}

package/src/web.ts

@@ -0,0 +1,34 @@
+import { BaseObservable, RPCClient } from "./client";
+import { Identifier } from "./id";
+import { IMessageAdapter } from "./types";
+
+export const webMessageAdapter: IMessageAdapter = {
+    onMessage<T>(type: string, callback: (message: T) => void) {
+        const handler = (event: any) => {
+            callback(event.detail);
+        }
+        window.addEventListener(type, handler);
+        return () => {
+            window.removeEventListener(type, handler);
+        };
+    },
+    sendMessage<T>(type: string, message: T): void {
+        window.dispatchEvent(new CustomEvent(type, { detail: message }));
+    },
+};
+
+export class WebRPCClient extends RPCClient {
+    constructor() {
+        super(webMessageAdapter);
+    }
+}
+
+export class WebObservable<T> extends BaseObservable<T> {
+    constructor(
+        identifier: Identifier<T>,
+        key: string,
+        callback: (value: T) => void,
+    ) {
+        super(identifier, key, callback, webMessageAdapter);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "lib": ["DOM", "ES2022"],
+        "module": "ESNext",
+        "moduleResolution": "node",
+        "types": ["node", "chrome"],
+        "strict": true,
+        "declaration": true,
+        "outDir": "dist",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "skipLibCheck": true
+    },
+    "include": ["src"]
+}