rearrage_stuff

node_modules/sync-message-port/dist/lib/index.d.ts

@@ -0,0 +1,82 @@
+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;
+}