osra 0.1.2 → 0.2.1

package/build/index.d.ts

@@ -1,8 +1,155 @@
-import type { RemoteTarget, LocalTarget, OsraMessage, StructuredCloneTransferableProxiableType } from './types';
-export * from './utils';
-export declare const expose: <T extends StructuredCloneTransferableProxiableType>(value: StructuredCloneTransferableProxiableType, { remote: _remote, local: _local, key, origin }: {
-    remote: RemoteTarget | ((osraMessage: OsraMessage, transferables: Transferable[]) => void);
-    local: LocalTarget | ((listener: (event: MessageEvent<OsraMessage>) => void) => void);
-    key?: string;
-    origin?: string;
-}) => Promise<T>;
+declare type BidirectionalConnectionMessage = {
+    type: 'init';
+    remoteUuid: Uuid;
+    data: Capable;
+}
+/** message not needed if transferring MessagePort is supported */
+| {
+    type: 'message';
+    remoteUuid: Uuid;
+    data: Capable;
+    /** uuid of the messagePort that the message was sent through */
+    portId: Uuid;
+}
+/** message not needed if transferring MessagePort is supported */
+| {
+    type: 'message-port-close';
+    remoteUuid: Uuid;
+    /** uuid of the messagePort that closed */
+    portId: string;
+};
+
+declare type Capable = Structurable | TransferBox | Transferable | Revivable | {
+    [key: string]: Capable;
+} | Array<Capable> | Map<Capable, Capable> | Set<Capable>;
+
+declare type ConnectionMessage = BidirectionalConnectionMessage | UnidirectionalConnectionMessage;
+
+declare type CustomTransport = {
+    isJson?: boolean;
+} & ({
+    receive: ReceivePlatformTransport | ((listener: (event: Message, messageContext: MessageContext) => void) => void);
+    emit: EmitPlatformTransport | ((message: Message, transferables?: Transferable[]) => void);
+} | {
+    receive: ReceivePlatformTransport | ((listener: (event: Message, messageContext: MessageContext) => void) => void);
+} | {
+    emit: EmitPlatformTransport | ((message: Message, transferables?: Transferable[]) => void);
+});
+
+declare type EmitJsonPlatformTransport = WebSocket | WebExtPort;
+
+declare type EmitPlatformTransport = EmitJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
+
+/**
+ * Protocol mode:
+ * - Bidirectional mode
+ * - Unidirectional mode
+ *
+ * Transport modes:
+ * - Capable mode
+ * - Jsonable mode
+ */
+export declare const expose: <T extends Capable>(value: Capable, { transport: _transport, name, remoteName, key, origin, unregisterSignal, platformCapabilities: _platformCapabilities, transferAll, logger }: {
+    transport: Transport;
+    name?: string;
+    remoteName?: string;
+    key?: string;
+    origin?: string;
+    unregisterSignal?: AbortSignal;
+    platformCapabilities?: PlatformCapabilities;
+    transferAll?: boolean;
+    logger?: {};
+}) => Promise<T>;
+
+declare type Jsonable = boolean | null | number | string | {
+    [key: string]: Jsonable;
+} | Array<Jsonable>;
+
+declare type Message = MessageBase & MessageVariant;
+
+declare type MessageBase = {
+    [OSRA_KEY]: string;
+    /** UUID of the client that sent the message */
+    uuid: Uuid;
+    name?: string;
+};
+
+declare type MessageContext = {
+    port?: MessagePort | WebExtPort;
+    sender?: WebExtSender;
+    receiveTransport?: ReceivePlatformTransport;
+    source?: MessageEventSource | null;
+};
+
+declare type MessageVariant = ProtocolMessage | ConnectionMessage;
+
+declare const OSRA_BOX: "__OSRA_BOX__";
+
+declare const OSRA_KEY: "__OSRA_KEY__";
+
+declare type PlatformCapabilities = {
+    jsonOnly: boolean;
+    messagePort: boolean;
+    arrayBuffer: boolean;
+    transferable: boolean;
+    transferableStream: boolean;
+};
+
+declare type PlatformTransport = EmitPlatformTransport | ReceivePlatformTransport;
+
+declare type ProtocolMessage = {
+    type: 'announce';
+    /** Only set when acknowledging a remote announcement */
+    remoteUuid?: Uuid;
+} | {
+    /** uuid already taken, try announcing with another one */
+    type: 'reject-uuid-taken';
+    remoteUuid: Uuid;
+} | {
+    type: 'close';
+    remoteUuid: Uuid;
+};
+
+declare type ReceiveJsonPlatformTransport = WebSocket | WebExtPort | WebExtOnConnect | WebExtOnMessage;
+
+declare type ReceivePlatformTransport = ReceiveJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
+
+declare type Revivable = MessagePort | Promise<Capable> | TypedArray | ArrayBuffer | ReadableStream | Date | Error | ((...args: Capable[]) => Promise<Capable>);
+
+declare type Structurable = Jsonable
+/** not really structureable but here for convenience */
+| void | undefined | BigInt | Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | {
+    [key: string]: Structurable;
+} | Array<Structurable> | Map<Structurable, Structurable> | Set<Structurable>;
+
+declare type TransferBox<T extends Transferable = Transferable> = {
+    [OSRA_BOX]: 'transferable';
+    value: T;
+};
+
+declare type Transport = PlatformTransport | CustomTransport;
+
+declare type TypedArray = typeof typedArrays[number];
+
+declare const typedArrays: (BigInt64Array<ArrayBuffer> | BigUint64Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Float64Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float16Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Uint8Array<ArrayBuffer>)[];
+
+declare type UnidirectionalConnectionMessage = {
+    type: 'message';
+    remoteUuid: Uuid;
+    data: Capable;
+    portId: Uuid;
+};
+
+declare type Uuid = `${string}-${string}-${string}-${string}-${string}`;
+
+declare type WebExtOnConnect = WebExtRuntime['onConnect'];
+
+declare type WebExtOnMessage = WebExtRuntime['onMessage'];
+
+declare type WebExtPort = ReturnType<WebExtRuntime['connect']>;
+
+declare type WebExtRuntime = typeof browser.runtime;
+
+declare type WebExtSender = NonNullable<WebExtPort['sender']>;
+
+export { }