83 lines
3.2 KiB
TypeScript
83 lines
3.2 KiB
TypeScript
import { EventEmitter } from 'events';
|
|
import { MessageChannel, MessagePort, TransferListItem } from 'worker_threads';
|
|
/**
|
|
* Options that can be passed to {@link SyncMessagePort.receiveMessage}.
|
|
*/
|
|
export interface ReceiveMessageOptions {
|
|
/**
|
|
* The time (in milliseconds) to wait for a message before returning {@link
|
|
* timeoutValue} (if set) or throwing a [TimeoutException] otherwise.
|
|
*/
|
|
timeout?: number;
|
|
/**
|
|
* If a message isn't received within {@link timeout} milliseconds, this value
|
|
* is returned. Ignored if {@link timeout} is not set.
|
|
*/
|
|
timeoutValue?: unknown;
|
|
/**
|
|
* If the underlying channel is closed before calling {@link
|
|
* SyncMessagePort.receiveMessage} or while a call is pending, return this
|
|
* value.
|
|
*/
|
|
closedValue?: unknown;
|
|
}
|
|
/**
|
|
* An exception thrown by {@link SyncMessagePort.receiveMessage} if a message
|
|
* isn't received within {@link ReceivedMessageOptions.timeout} milliseconds.
|
|
*/
|
|
export declare class TimeoutException extends Error {
|
|
constructor(message: string);
|
|
}
|
|
/**
|
|
* A communication port that can receive messages synchronously from another
|
|
* `SyncMessagePort`.
|
|
*
|
|
* This also emits the same asynchronous events as `MessagePort`.
|
|
*/
|
|
export declare class SyncMessagePort extends EventEmitter {
|
|
private readonly port;
|
|
/** Creates a channel whose ports can be passed to `new SyncMessagePort()`. */
|
|
static createChannel(): MessageChannel;
|
|
/**
|
|
* An Int32 view of the shared buffer.
|
|
*
|
|
* Each port sets this to `BufferState.AwaitingMessage` before checking for
|
|
* new messages in `receiveMessage()`, and each port sets it to
|
|
* `BufferState.MessageSent` after sending a new message. It's set to
|
|
* `BufferState.Closed` when the channel is closed.
|
|
*/
|
|
private readonly buffer;
|
|
/**
|
|
* Creates a new message port. The `port` must be created by
|
|
* `SyncMessagePort.createChannel()` and must connect to a port passed to
|
|
* another `SyncMessagePort` in another worker.
|
|
*/
|
|
constructor(port: MessagePort);
|
|
/** See `MessagePort.postMesage()`. */
|
|
postMessage(value: unknown, transferList?: TransferListItem[]): void;
|
|
/**
|
|
* Returns the message sent by the other port, if one is available. This *does
|
|
* not* block, and will return `undefined` immediately if no message is
|
|
* available. In order to distinguish between a message with value `undefined`
|
|
* and no message, a message is return in an object with a `message` field.
|
|
*
|
|
* This may not be called while this has a listener for the `'message'` event.
|
|
* It does *not* throw an error if the port is closed when this is called;
|
|
* instead, it just returns `undefined`.
|
|
*/
|
|
receiveMessageIfAvailable(): {
|
|
message: unknown;
|
|
} | undefined;
|
|
/**
|
|
* Blocks and returns the next message sent by the other port.
|
|
*
|
|
* This may not be called while this has a listener for the `'message'` event.
|
|
* Throws an error if the channel is closed, including if it closes while this
|
|
* is waiting for a message, unless {@link ReceiveMessageOptions.closedValue}
|
|
* is passed.
|
|
*/
|
|
receiveMessage(options?: ReceiveMessageOptions): unknown;
|
|
/** See `MessagePort.close()`. */
|
|
close(): void;
|
|
}
|