osra 0.2.0 → 0.2.2

package/build/index.d.ts

@@ -1,3 +1,23 @@
+import { Runtime } from 'webextension-polyfill';
+import { TypedEventTarget } from 'typescript-event-target';
+
+declare type AllocatedMessageChannel<T extends StructurableTransferable = StructurableTransferable, T2 extends StructurableTransferable = StructurableTransferable> = {
+    uuid: Uuid;
+    /** Local port */
+    port1: StrictMessagePort<T>;
+    /** Remote port that gets transferred, might be undefined if a remote context created the channel */
+    port2?: StrictMessagePort<T2>;
+};
+
+declare namespace arrayBuffer {
+    export {
+        type,
+        isType,
+        box,
+        revive
+    }
+}
+
 declare type BidirectionalConnectionMessage = {
     type: 'init';
     remoteUuid: Uuid;
@@ -19,12 +39,135 @@ declare type BidirectionalConnectionMessage = {
     portId: string;
 };
 
-declare type Capable = Structurable | TransferBox | Transferable | Revivable | {
+declare const box: <T extends ArrayBuffer, T2 extends RevivableContext>(value: T, _context: T2) => {
+    type: "arrayBuffer";
+    __OSRA_BOX__: "revivable";
+} & (IsJsonOnlyTransport<T2["transport"]> extends true ? {
+    base64Buffer: string;
+} : IsJsonOnlyTransport<T2["transport"]> extends false ? {
+    arrayBuffer: ArrayBuffer;
+} : {
+    base64Buffer: string;
+} | {
+    arrayBuffer: ArrayBuffer;
+});
+
+declare const box_2: <T extends Date, T2 extends RevivableContext>(value: T, _context: T2) => {
+    type: "date";
+    ISOString: string;
+    __OSRA_BOX__: "revivable";
+};
+
+declare const box_3: <T extends Error, T2 extends RevivableContext>(value: T, _context: T2) => {
+    type: "error";
+    message: string;
+    stack: string;
+    __OSRA_BOX__: "revivable";
+};
+
+declare const box_4: <T extends TypedArray, T2 extends RevivableContext>(value: T, context: T2) => {
+    type: "typedArray";
+    typedArrayType: string;
+    __OSRA_BOX__: "revivable";
+} & (IsJsonOnlyTransport<T2["transport"]> extends true ? {
+    base64Buffer: string;
+} : IsJsonOnlyTransport<T2["transport"]> extends false ? {
+    arrayBuffer: ArrayBuffer;
+} : {
+    base64Buffer: string;
+} | {
+    arrayBuffer: ArrayBuffer;
+}) & {
+    [UnderlyingType]: T;
+};
+
+declare const box_5: <T, T2 extends RevivableContext = RevivableContext>(value: StructurableTransferablePort<T>, context: T2) => ({
+    type: "messagePort";
+    portId: `${string}-${string}-${string}-${string}-${string}`;
+    __OSRA_BOX__: "revivable";
+} & {
+    [UnderlyingType]: StrictMessagePort<ExtractStructurableTransferable<T>>;
+}) | ({
+    type: "messagePort";
+    port: StructurableTransferablePort<T>;
+    __OSRA_BOX__: "revivable";
+} & {
+    [UnderlyingType]: StrictMessagePort<ExtractStructurableTransferable<T>>;
+});
+
+declare const box_6: <T, T2 extends RevivableContext>(value: CapablePromise<T>, context: T2) => BoxedPromise<ExtractCapable<T>>;
+
+declare const box_7: <T extends (...args: any[]) => any, T2 extends RevivableContext>(value: T & CapableFunction<T>, context: T2) => BoxedFunction<T>;
+
+declare const box_8: <T extends ReadableStream, T2 extends RevivableContext>(value: T, context: T2) => BoxedReadableStream<T>;
+
+export declare const BoxBase: {
+    readonly __OSRA_BOX__: "revivable";
+    readonly type: string;
+};
+
+export declare type BoxBase<T extends string = string> = typeof BoxBase & {
+    type: T;
+};
+
+declare type BoxedFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = BoxBase<typeof type_6> & {
+    port: BoxedMessagePort;
+} & {
+    [UnderlyingType]: (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+};
+
+declare type BoxedMessagePort<T extends StructurableTransferable = StructurableTransferable> = BoxBase<typeof type_7> & ({
+    portId: string;
+} | {
+    port: StrictMessagePort<T>;
+}) & {
+    [UnderlyingType]: StrictMessagePort<T>;
+};
+
+declare type BoxedPromise<T extends Capable = Capable> = {
+    __OSRA_BOX__: 'revivable';
+    type: typeof type_5;
+    port: ReturnType<typeof box_5>;
+    [UnderlyingType]: T;
+};
+
+declare type BoxedReadableStream<T extends ReadableStream = ReadableStream> = {
+    __OSRA_BOX__: 'revivable';
+    type: typeof type_8;
+    port: BoxedMessagePort;
+    [UnderlyingType]: T;
+};
+
+declare type CallContext = [
+/** MessagePort or portId that will be used to send the result of the function call */
+MessagePort | string,
+/** Arguments that will be passed to the function call */
+Capable[]
+];
+
+declare type Capable<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = StructurableTransferable | InferRevivables<TModules> | {
     [key: string]: Capable;
 } | Array<Capable> | Map<Capable, Capable> | Set<Capable>;
 
+declare const CapableError: unique symbol;
+
+declare type CapableFunction<T> = T extends (...args: infer P) => infer R ? P extends Capable[] ? R extends Capable ? T : never : never : never;
+
+declare type CapablePromise<T> = T extends Capable ? Promise<T> : {
+    [CapableError]: 'Message type must extend Capable';
+    __badType__: T;
+};
+
 declare type ConnectionMessage = BidirectionalConnectionMessage | UnidirectionalConnectionMessage;
 
+declare type Context = {
+    type: 'resolve';
+    data: Capable;
+} | {
+    type: 'reject';
+    error: string;
+};
+
 declare type CustomTransport = {
     isJson?: boolean;
 } & ({
@@ -36,10 +179,32 @@ declare type CustomTransport = {
     emit: EmitPlatformTransport | ((message: Message, transferables?: Transferable[]) => void);
 });
 
+declare namespace date {
+    export {
+        type_2 as type,
+        isType_2 as isType,
+        box_2 as box,
+        revive_2 as revive
+    }
+}
+
+declare type DefaultRevivableModules = typeof defaultRevivableModules;
+
+declare const defaultRevivableModules: readonly [typeof arrayBuffer, typeof date, typeof error, typeof typedArray, typeof promise, typeof func, typeof messagePort, typeof readableStream];
+
 declare type EmitJsonPlatformTransport = WebSocket | WebExtPort;
 
 declare type EmitPlatformTransport = EmitJsonPlatformTransport | Window | ServiceWorker | Worker | SharedWorker | MessagePort;
 
+declare namespace error {
+    export {
+        type_3 as type,
+        isType_3 as isType,
+        box_3 as box,
+        revive_3 as revive
+    }
+}
+
 /**
  * Protocol mode:
  * - Bidirectional mode
@@ -61,10 +226,76 @@ export declare const expose: <T extends Capable>(value: Capable, { transport: _t
     logger?: {};
 }) => Promise<T>;
 
+declare type ExtractCapable<T> = T extends Capable ? T : never;
+
+declare type ExtractStructurableTransferable<T> = T extends StructurableTransferable ? T : never;
+
+declare type ExtractType<T> = T extends {
+    isType: (value: unknown) => value is infer S;
+} ? S : never;
+
+declare namespace func {
+    export {
+        type_6 as type,
+        CallContext,
+        BoxedFunction,
+        isType_6 as isType,
+        box_7 as box,
+        revive_6 as revive
+    }
+}
+
+declare type InferRevivables<TModules extends readonly unknown[]> = ExtractType<TModules[number]>;
+
+declare type IsJsonOnlyTransport<T extends Transport> = T extends JsonPlatformTransport ? true : false;
+
+declare const isType: (value: unknown) => value is ArrayBuffer;
+
+declare const isType_2: (value: unknown) => value is Date;
+
+declare const isType_3: (value: unknown) => value is Error;
+
+declare const isType_4: (value: unknown) => value is TypedArray;
+
+declare const isType_5: (value: unknown) => value is Promise<any>;
+
+declare const isType_6: (value: unknown) => value is (...args: any[]) => any;
+
+declare const isType_7: (value: unknown) => value is MessagePort;
+
+declare const isType_8: (value: unknown) => value is ReadableStream;
+
 declare type Jsonable = boolean | null | number | string | {
     [key: string]: Jsonable;
 } | Array<Jsonable>;
 
+declare type JsonPlatformTransport = {
+    isJson: true;
+} | EmitJsonPlatformTransport | ReceiveJsonPlatformTransport;
+
+declare const makeMessageChannelAllocator: () => {
+    getUniqueUuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    set: (uuid: Uuid, messagePorts: {
+        port1: StrictMessagePort;
+        port2?: StrictMessagePort;
+    }) => void;
+    alloc: (uuid?: Uuid | undefined, messagePorts?: {
+        port1: StrictMessagePort;
+        port2?: StrictMessagePort;
+    }) => {
+        port1: StrictMessagePort;
+        port2?: StrictMessagePort;
+        uuid: `${string}-${string}-${string}-${string}-${string}`;
+    };
+    has: (uuid: string) => boolean;
+    get: (uuid: string) => AllocatedMessageChannel<StructurableTransferable, StructurableTransferable> | undefined;
+    free: (uuid: string) => boolean;
+    getOrAlloc: (uuid?: Uuid | undefined, messagePorts?: {
+        port1: StrictMessagePort;
+        port2?: StrictMessagePort;
+    }) => AllocatedMessageChannel<StructurableTransferable, StructurableTransferable>;
+};
+
 declare type Message = MessageBase & MessageVariant;
 
 declare type MessageBase = {
@@ -74,6 +305,8 @@ declare type MessageBase = {
     name?: string;
 };
 
+declare type MessageChannelAllocator = ReturnType<typeof makeMessageChannelAllocator>;
+
 declare type MessageContext = {
     port?: MessagePort | WebExtPort;
     sender?: WebExtSender;
@@ -81,9 +314,23 @@ declare type MessageContext = {
     source?: MessageEventSource | null;
 };
 
-declare type MessageVariant = ProtocolMessage | ConnectionMessage;
+declare type MessageEventMap = {
+    message: CustomEvent<Message>;
+};
 
-declare const OSRA_BOX: "__OSRA_BOX__";
+declare type MessageEventTarget_2 = TypedEventTarget<MessageEventMap>;
+
+declare namespace messagePort {
+    export {
+        type_7 as type,
+        BoxedMessagePort,
+        isType_7 as isType,
+        box_5 as box,
+        revive_7 as revive
+    }
+}
+
+declare type MessageVariant = ProtocolMessage | ConnectionMessage;
 
 declare const OSRA_KEY: "__OSRA_KEY__";
 
@@ -97,6 +344,17 @@ declare type PlatformCapabilities = {
 
 declare type PlatformTransport = EmitPlatformTransport | ReceivePlatformTransport;
 
+declare namespace promise {
+    export {
+        type_5 as type,
+        Context,
+        BoxedPromise,
+        isType_5 as isType,
+        box_6 as box,
+        revive_5 as revive
+    }
+}
+
 declare type ProtocolMessage = {
     type: 'announce';
     /** Only set when acknowledging a remote announcement */
@@ -110,11 +368,77 @@ declare type ProtocolMessage = {
     remoteUuid: Uuid;
 };
 
+declare type PullContext = {
+    type: 'pull' | 'cancel';
+};
+
+declare namespace readableStream {
+    export {
+        type_8 as type,
+        PullContext,
+        BoxedReadableStream,
+        isType_8 as isType,
+        box_8 as box,
+        revive_8 as revive
+    }
+}
+
 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 RevivableContext<TModules extends readonly RevivableModule[] = DefaultRevivableModules> = {
+    platformCapabilities: PlatformCapabilities;
+    transport: Transport;
+    remoteUuid: Uuid;
+    messagePorts: Set<MessagePort>;
+    messageChannels: MessageChannelAllocator;
+    sendMessage: (message: ConnectionMessage) => void;
+    revivableModules: TModules;
+    eventTarget: MessageEventTarget_2;
+};
+
+declare type RevivableModule<T extends string = string, T2 = any, T3 extends BoxBase<T> = any> = {
+    readonly type: T;
+    readonly isType: (value: unknown) => value is T2;
+    readonly box: ((value: T2, context: RevivableContext) => T3) | ((...args: any[]) => any);
+    readonly revive: (value: T3, context: RevivableContext) => T2;
+};
+
+declare const revive: <T extends ReturnType<typeof box>, T2 extends RevivableContext>(value: T, _context: T2) => ArrayBuffer;
+
+declare const revive_2: <T extends ReturnType<typeof box_2>, T2 extends RevivableContext>(value: T, _context: T2) => Date;
+
+declare const revive_3: <T extends ReturnType<typeof box_3>, T2 extends RevivableContext>(value: T, _context: T2) => Error;
+
+declare const revive_4: <T extends ReturnType<typeof box_4>, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+
+declare const revive_5: <T extends BoxedPromise, T2 extends RevivableContext>(value: T, context: T2) => Promise<T[typeof UnderlyingType]>;
+
+declare const revive_6: <T extends BoxedFunction, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+
+declare const revive_7: <T extends StructurableTransferable, T2 extends RevivableContext>(value: BoxedMessagePort<T>, context: T2) => StrictMessagePort<T>;
+
+declare const revive_8: <T extends BoxedReadableStream, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+
+declare interface StrictMessagePort<T = StructurableTransferable> extends EventTarget {
+    [UnderlyingType]: T;
+    onmessage: ((this: MessagePort, ev: MessageEvent<T>) => any) | null;
+    onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
+    close(): void;
+    postMessage(message: T, transfer: Transferable[]): void;
+    postMessage(message: T, options?: StructuredSerializeOptions): void;
+    start(): void;
+    addEventListener<K extends keyof StrictMessagePortEventMap<T>>(type: K, listener: (this: MessagePort, ev: StrictMessagePortEventMap<T>[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof StrictMessagePortEventMap<T>>(type: K, listener: (this: MessagePort, ev: StrictMessagePortEventMap<T>[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+
+declare type StrictMessagePortEventMap<T = any> = {
+    'message': MessageEvent<T>;
+    'messageerror': MessageEvent;
+};
 
 declare type Structurable = Jsonable
 /** not really structureable but here for convenience */
@@ -122,16 +446,66 @@ declare type Structurable = Jsonable
     [key: string]: Structurable;
 } | Array<Structurable> | Map<Structurable, Structurable> | Set<Structurable>;
 
-declare type TransferBox<T extends Transferable = Transferable> = {
-    [OSRA_BOX]: 'transferable';
-    value: T;
+declare type StructurableTransferable = Structurable | Transferable | {
+    [key: string]: StructurableTransferable;
+} | Array<StructurableTransferable> | Map<StructurableTransferable, StructurableTransferable> | Set<StructurableTransferable>;
+
+declare const StructurableTransferableError: unique symbol;
+
+declare type StructurableTransferablePort<T> = T extends StructurableTransferable ? StrictMessagePort<T> : {
+    [StructurableTransferableError]: 'Message type must extend StructurableTransferable';
+    __badType__: T;
 };
 
 declare type Transport = PlatformTransport | CustomTransport;
 
+declare const type: "arrayBuffer";
+
+declare const type_2: "date";
+
+declare const type_3: "error";
+
+declare const type_4: "typedArray";
+
+declare const type_5: "promise";
+
+declare const type_6: "function";
+
+declare const type_7: "messagePort";
+
+declare const type_8: "readableStream";
+
 declare type TypedArray = typeof typedArrays[number];
 
-declare const typedArrays: (BigInt64Array<ArrayBuffer> | BigUint64Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Float64Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float16Array<ArrayBuffer> | Float32Array<ArrayBuffer>)[];
+declare namespace typedArray {
+    export {
+        type_4 as type,
+        TypedArrayConstructor,
+        TypedArray,
+        typedArrayToType,
+        TypedArrayType,
+        typedArrayTypeToTypedArrayConstructor,
+        isType_4 as isType,
+        box_4 as box,
+        revive_4 as revive
+    }
+}
+
+declare type TypedArrayConstructor = typeof typedArrayConstructors[number];
+
+declare const typedArrayConstructors: (Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float16ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor)[];
+
+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 const typedArrayToType: <T extends TypedArray>(value: T) => "BigUint64Array" | "BigInt64Array" | "Float64Array" | "Int8Array" | "Uint8ClampedArray" | "Int16Array" | "Uint16Array" | "Int32Array" | "Uint32Array" | "Float16Array" | "Float32Array" | "Uint8Array";
+
+declare type TypedArrayType = ReturnType<typeof typedArrayToType>;
+
+declare const typedArrayTypeToTypedArrayConstructor: (value: TypedArrayType) => TypedArrayConstructor;
+
+export declare const UnderlyingType: unique symbol;
+
+export declare type UnderlyingType = typeof UnderlyingType;
 
 declare type UnidirectionalConnectionMessage = {
     type: 'message';
@@ -146,7 +520,7 @@ declare type WebExtOnConnect = WebExtRuntime['onConnect'];
 
 declare type WebExtOnMessage = WebExtRuntime['onMessage'];
 
-declare type WebExtPort = ReturnType<WebExtRuntime['connect']>;
+declare type WebExtPort = ReturnType<WebExtRuntime['connect']> | Runtime.Port;
 
 declare type WebExtRuntime = typeof browser.runtime;