@overdeck/desktop 0.50.1 → 0.50.3

package/server/node_modules/@types/node/stream/consumers.d.ts

@@ -1,114 +1,38 @@
-declare module "node:stream/consumers" {
-    import { Blob, NonSharedBuffer } from "node:buffer";
-    import { ReadableStream } from "node:stream/web";
+/**
+ * The utility consumer functions provide common options for consuming
+ * streams.
+ * @since v16.7.0
+ */
+declare module "stream/consumers" {
+    import { Blob as NodeBlob, NonSharedBuffer } from "node:buffer";
+    import { ReadableStream as WebReadableStream } from "node:stream/web";
     /**
-     * ```js
-     * import { arrayBuffer } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { TextEncoder } from 'node:util';
-     *
-     * const encoder = new TextEncoder();
-     * const dataArray = encoder.encode('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataArray);
-     * const data = await arrayBuffer(readable);
-     * console.log(`from readable: ${data.byteLength}`);
-     * // Prints: from readable: 76
-     * ```
      * @since v16.7.0
      * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
      */
-    function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
+    function arrayBuffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
     /**
-     * ```js
-     * import { blob } from 'node:stream/consumers';
-     *
-     * const dataBlob = new Blob(['hello world from consumers!']);
-     *
-     * const readable = dataBlob.stream();
-     * const data = await blob(readable);
-     * console.log(`from readable: ${data.size}`);
-     * // Prints: from readable: 27
-     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Blob` containing the full contents of the stream.
      */
-    function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
+    function blob(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NodeBlob>;
     /**
-     * ```js
-     * import { buffer } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { Buffer } from 'node:buffer';
-     *
-     * const dataBuffer = Buffer.from('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataBuffer);
-     * const data = await buffer(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
-    function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
-    /**
-     * ```js
-     * import { bytes } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     * import { Buffer } from 'node:buffer';
-     *
-     * const dataBuffer = Buffer.from('hello world from consumers!');
-     *
-     * const readable = Readable.from(dataBuffer);
-     * const data = await bytes(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
-     * @since v25.6.0
-     * @returns Fulfills with a `Uint8Array` containing the full contents of the stream.
-     */
-    function bytes(
-        stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>,
-    ): Promise<NodeJS.NonSharedUint8Array>;
+    function buffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
-     * ```js
-     * import { json } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     *
-     * const items = Array.from(
-     *   {
-     *     length: 100,
-     *   },
-     *   () => ({
-     *     message: 'hello world from consumers!',
-     *   }),
-     * );
-     *
-     * const readable = Readable.from(JSON.stringify(items));
-     * const data = await json(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 100
-     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a
      * UTF-8 encoded string that is then passed through `JSON.parse()`.
      */
-    function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
+    function json(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
     /**
-     * ```js
-     * import { text } from 'node:stream/consumers';
-     * import { Readable } from 'node:stream';
-     *
-     * const readable = Readable.from('Hello world from consumers!');
-     * const data = await text(readable);
-     * console.log(`from readable: ${data.length}`);
-     * // Prints: from readable: 27
-     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
      */
-    function text(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
+    function text(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
 }
-declare module "stream/consumers" {
-    export * from "node:stream/consumers";
+declare module "node:stream/consumers" {
+    export * from "stream/consumers";
 }

package/server/node_modules/@types/node/stream/promises.d.ts

@@ -1,12 +1,12 @@
-declare module "node:stream/promises" {
-    import { Abortable } from "node:events";
+declare module "stream/promises" {
     import {
         FinishedOptions as _FinishedOptions,
         PipelineDestination,
+        PipelineOptions,
+        PipelinePromise,
         PipelineSource,
         PipelineTransform,
     } from "node:stream";
-    import { ReadableStream, WritableStream } from "node:stream/web";
     interface FinishedOptions extends _FinishedOptions {
         /**
          * If true, removes the listeners registered by this function before the promise is fulfilled.
@@ -14,130 +14,15 @@ declare module "node:stream/promises" {
          */
         cleanup?: boolean | undefined;
     }
-    /**
-     * ```js
-     * import { finished } from 'node:stream/promises';
-     * import { createReadStream } from 'node:fs';
-     *
-     * const rs = createReadStream('archive.tar');
-     *
-     * async function run() {
-     *   await finished(rs);
-     *   console.log('Stream is done reading.');
-     * }
-     *
-     * run().catch(console.error);
-     * rs.resume(); // Drain the stream.
-     * ```
-     *
-     * The `finished` API also provides a [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streamfinishedstream-options-callback).
-     *
-     * `stream.finished()` leaves dangling event listeners (in particular
-     * `'error'`, `'end'`, `'finish'` and `'close'`) after the returned promise is
-     * resolved or rejected. The reason for this is so that unexpected `'error'`
-     * events (due to incorrect stream implementations) do not cause unexpected
-     * crashes. If this is unwanted behavior then `options.cleanup` should be set to
-     * `true`:
-     *
-     * ```js
-     * await finished(rs, { cleanup: true });
-     * ```
-     * @since v15.0.0
-     * @returns Fulfills when the stream is no longer readable or writable.
-     */
     function finished(
-        stream: NodeJS.ReadableStream | NodeJS.WritableStream | ReadableStream | WritableStream,
+        stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
         options?: FinishedOptions,
     ): Promise<void>;
-    interface PipelineOptions extends Abortable {
-        end?: boolean | undefined;
-    }
-    type PipelineResult<S extends PipelineDestination<any, any>> = S extends (...args: any[]) => PromiseLike<infer R>
-        ? Promise<R>
-        : Promise<void>;
-    /**
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * await pipeline(
-     *   createReadStream('archive.tar'),
-     *   createGzip(),
-     *   createWriteStream('archive.tar.gz'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * To use an `AbortSignal`, pass it inside an options object, as the last argument.
-     * When the signal is aborted, `destroy` will be called on the underlying pipeline,
-     * with an `AbortError`.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * const ac = new AbortController();
-     * const { signal } = ac;
-     * setImmediate(() => ac.abort());
-     * try {
-     *   await pipeline(
-     *     createReadStream('archive.tar'),
-     *     createGzip(),
-     *     createWriteStream('archive.tar.gz'),
-     *     { signal },
-     *   );
-     * } catch (err) {
-     *   console.error(err); // AbortError
-     * }
-     * ```
-     *
-     * The `pipeline` API also supports async generators:
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     *
-     * await pipeline(
-     *   createReadStream('lowercase.txt'),
-     *   async function* (source, { signal }) {
-     *     source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
-     *     for await (const chunk of source) {
-     *       yield await processChunk(chunk, { signal });
-     *     }
-     *   },
-     *   createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * Remember to handle the `signal` argument passed into the async generator.
-     * Especially in the case where the async generator is the source for the
-     * pipeline (i.e. first argument) or the pipeline will never complete.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import fs from 'node:fs';
-     * await pipeline(
-     *   async function* ({ signal }) {
-     *     await someLongRunningfn({ signal });
-     *     yield 'asd';
-     *   },
-     *   fs.createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streampipelinesource-transforms-destination-callback):
-     * @since v15.0.0
-     * @returns Fulfills when the pipeline is complete.
-     */
     function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
         source: A,
         destination: B,
         options?: PipelineOptions,
-    ): PipelineResult<B>;
+    ): PipelinePromise<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -147,7 +32,7 @@ declare module "node:stream/promises" {
         transform1: T1,
         destination: B,
         options?: PipelineOptions,
-    ): PipelineResult<B>;
+    ): PipelinePromise<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -159,7 +44,7 @@ declare module "node:stream/promises" {
         transform2: T2,
         destination: B,
         options?: PipelineOptions,
-    ): PipelineResult<B>;
+    ): PipelinePromise<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -173,7 +58,7 @@ declare module "node:stream/promises" {
         transform3: T3,
         destination: B,
         options?: PipelineOptions,
-    ): PipelineResult<B>;
+    ): PipelinePromise<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -189,23 +74,17 @@ declare module "node:stream/promises" {
         transform4: T4,
         destination: B,
         options?: PipelineOptions,
-    ): PipelineResult<B>;
+    ): PipelinePromise<B>;
     function pipeline(
-        streams: readonly [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>],
+        streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
         options?: PipelineOptions,
     ): Promise<void>;
     function pipeline(
-        ...streams: [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>]
-    ): Promise<void>;
-    function pipeline(
-        ...streams: [
-            PipelineSource<any>,
-            ...PipelineTransform<any, any>[],
-            PipelineDestination<any, any>,
-            options: PipelineOptions,
-        ]
+        stream1: NodeJS.ReadableStream,
+        stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
+        ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
     ): Promise<void>;
 }
-declare module "stream/promises" {
-    export * from "node:stream/promises";
+declare module "node:stream/promises" {
+    export * from "stream/promises";
 }