@overdeck/desktop 0.50.1 → 0.50.3

package/server/node_modules/undici-types/errors.d.ts

@@ -1,24 +1,24 @@
-import { IncomingHttpHeaders } from './header'
+import { IncomingHttpHeaders } from "./header";
 import Client from './client'
 
 export default Errors
 
 declare namespace Errors {
   export class UndiciError extends Error {
-    name: string
-    code: string
+    name: string;
+    code: string;
   }
 
   /** Connect timeout error. */
   export class ConnectTimeoutError extends UndiciError {
-    name: 'ConnectTimeoutError'
-    code: 'UND_ERR_CONNECT_TIMEOUT'
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
   }
 
   /** A header exceeds the `headersTimeout` option. */
   export class HeadersTimeoutError extends UndiciError {
-    name: 'HeadersTimeoutError'
-    code: 'UND_ERR_HEADERS_TIMEOUT'
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
   }
 
   /** Headers overflow error. */
@@ -29,102 +29,101 @@ declare namespace Errors {
 
   /** A body exceeds the `bodyTimeout` option. */
   export class BodyTimeoutError extends UndiciError {
-    name: 'BodyTimeoutError'
-    code: 'UND_ERR_BODY_TIMEOUT'
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
   }
 
-  export class ResponseError extends UndiciError {
+  export class ResponseStatusCodeError extends UndiciError {
     constructor (
-      message: string,
-      code: number,
-      options: {
-        headers?: IncomingHttpHeaders | string[] | null,
-        body?: null | Record<string, any> | string
-      }
-    )
-    name: 'ResponseError'
-    code: 'UND_ERR_RESPONSE'
-    statusCode: number
+      message?: string,
+      statusCode?: number,
+      headers?: IncomingHttpHeaders | string[] | null,
+      body?: null | Record<string, any> | string
+    );
+    name: 'ResponseStatusCodeError';
+    code: 'UND_ERR_RESPONSE_STATUS_CODE';
     body: null | Record<string, any> | string
-    headers: IncomingHttpHeaders | string[] | null
+    status: number
+    statusCode: number
+    headers: IncomingHttpHeaders | string[] | null;
   }
 
   /** Passed an invalid argument. */
   export class InvalidArgumentError extends UndiciError {
-    name: 'InvalidArgumentError'
-    code: 'UND_ERR_INVALID_ARG'
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
   }
 
   /** Returned an invalid value. */
   export class InvalidReturnValueError extends UndiciError {
-    name: 'InvalidReturnValueError'
-    code: 'UND_ERR_INVALID_RETURN_VALUE'
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
   }
 
   /** The request has been aborted by the user. */
   export class RequestAbortedError extends UndiciError {
-    name: 'AbortError'
-    code: 'UND_ERR_ABORTED'
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
   }
 
   /** Expected error with reason. */
   export class InformationalError extends UndiciError {
-    name: 'InformationalError'
-    code: 'UND_ERR_INFO'
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
   }
 
   /** Request body length does not match content-length header. */
   export class RequestContentLengthMismatchError extends UndiciError {
-    name: 'RequestContentLengthMismatchError'
-    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
   }
 
   /** Response body length does not match content-length header. */
   export class ResponseContentLengthMismatchError extends UndiciError {
-    name: 'ResponseContentLengthMismatchError'
-    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
   }
 
   /** Trying to use a destroyed client. */
   export class ClientDestroyedError extends UndiciError {
-    name: 'ClientDestroyedError'
-    code: 'UND_ERR_DESTROYED'
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
   }
 
   /** Trying to use a closed client. */
   export class ClientClosedError extends UndiciError {
-    name: 'ClientClosedError'
-    code: 'UND_ERR_CLOSED'
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
   }
 
   /** There is an error with the socket. */
   export class SocketError extends UndiciError {
-    name: 'SocketError'
-    code: 'UND_ERR_SOCKET'
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
     socket: Client.SocketInfo | null
   }
 
   /** Encountered unsupported functionality. */
   export class NotSupportedError extends UndiciError {
-    name: 'NotSupportedError'
-    code: 'UND_ERR_NOT_SUPPORTED'
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
   }
 
   /** No upstream has been added to the BalancedPool. */
   export class BalancedPoolMissingUpstreamError extends UndiciError {
-    name: 'MissingUpstreamError'
-    code: 'UND_ERR_BPL_MISSING_UPSTREAM'
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
   }
 
   export class HTTPParserError extends UndiciError {
-    name: 'HTTPParserError'
-    code: string
+    name: 'HTTPParserError';
+    code: string;
   }
 
   /** The response exceed the length allowed. */
   export class ResponseExceededMaxSizeError extends UndiciError {
-    name: 'ResponseExceededMaxSizeError'
-    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
   }
 
   export class RequestRetryError extends UndiciError {
@@ -133,55 +132,18 @@ declare namespace Errors {
       statusCode: number,
       headers?: IncomingHttpHeaders | string[] | null,
       body?: null | Record<string, any> | string
-    )
-    name: 'RequestRetryError'
-    code: 'UND_ERR_REQ_RETRY'
-    statusCode: number
+    );
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
     data: {
       count: number;
-    }
-
-    headers: Record<string, string | string[]>
+    };
+    headers: Record<string, string | string[]>;
   }
 
   export class SecureProxyConnectionError extends UndiciError {
-    constructor (
-      cause?: Error,
-      message?: string,
-      options?: Record<any, any>
-    )
-    name: 'SecureProxyConnectionError'
-    code: 'UND_ERR_PRX_TLS'
-  }
-
-  export class ProxyConnectionError extends UndiciError {
-    constructor (
-      cause?: Error,
-      message?: string,
-      options?: Record<any, any>
-    )
-    name: 'ProxyConnectionError'
-    code: 'UND_ERR_PRX_CONN'
-  }
-
-  export class MaxOriginsReachedError extends UndiciError {
-    name: 'MaxOriginsReachedError'
-    code: 'UND_ERR_MAX_ORIGINS_REACHED'
-  }
-
-  /** SOCKS5 proxy related error. */
-  export class Socks5ProxyError extends UndiciError {
-    constructor (
-      message?: string,
-      code?: string
-    )
-    name: 'Socks5ProxyError'
-    code: string
-  }
-
-  /** WebSocket decompressed message exceeded maximum size. */
-  export class MessageSizeExceededError extends UndiciError {
-    name: 'MessageSizeExceededError'
-    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED'
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
   }
 }

package/server/node_modules/undici-types/eventsource.d.ts

@@ -18,9 +18,9 @@ interface EventSource extends EventTarget {
   readonly CLOSED: 2
   readonly CONNECTING: 0
   readonly OPEN: 1
-  onerror: ((this: EventSource, ev: ErrorEvent) => any) | null
-  onmessage: ((this: EventSource, ev: MessageEvent) => any) | null
-  onopen: ((this: EventSource, ev: Event) => any) | null
+  onerror: (this: EventSource, ev: ErrorEvent) => any
+  onmessage: (this: EventSource, ev: MessageEvent) => any
+  onopen: (this: EventSource, ev: Event) => any
   readonly readyState: 0 | 1 | 2
   readonly url: string
   readonly withCredentials: boolean
@@ -56,11 +56,6 @@ export declare const EventSource: {
 }
 
 interface EventSourceInit {
-  withCredentials?: boolean
-  // @deprecated use `node.dispatcher` instead
+  withCredentials?: boolean,
   dispatcher?: Dispatcher
-  node?: {
-    dispatcher?: Dispatcher
-    reconnectionTime?: number
-  }
 }

package/server/node_modules/undici-types/fetch.d.ts

@@ -2,11 +2,11 @@
 // and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
 /// <reference types="node" />
 
-import { Blob } from 'node:buffer'
-import { URL, URLSearchParams } from 'node:url'
-import { ReadableStream } from 'node:stream/web'
+import { Blob } from 'buffer'
+import { URL, URLSearchParams } from 'url'
+import { ReadableStream } from 'stream/web'
 import { FormData } from './formdata'
-import { HeaderRecord } from './header'
+
 import Dispatcher from './dispatcher'
 
 export type RequestInfo = string | URL | Request
@@ -33,66 +33,41 @@ export class BodyMixin {
 
   readonly arrayBuffer: () => Promise<ArrayBuffer>
   readonly blob: () => Promise<Blob>
-  readonly bytes: () => Promise<Uint8Array>
   /**
    * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
-   * Calling body.formData() buffers and parses the entire body. Since this is dictated by the spec,
-   * this method must only be called on responses from trusted servers.
-   * For responses from untrusted or user-controlled servers, use a dedicated streaming parser such as
-   * [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) and apply application-specific limits as follows:
-   *
+   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
+   * 
    * @example
    * ```js
    * import { Busboy } from '@fastify/busboy'
    * import { Readable } from 'node:stream'
-   *
+   * 
    * const response = await fetch('...')
    * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
-   *
+   * 
    * // handle events emitted from `busboy`
-   *
+   * 
    * Readable.fromWeb(response.body).pipe(busboy)
    * ```
    */
   readonly formData: () => Promise<FormData>
   readonly json: () => Promise<unknown>
   readonly text: () => Promise<string>
-  readonly textStream: () => ReadableStream<string>
 }
 
 export interface SpecIterator<T, TReturn = any, TNext = undefined> {
   next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
 }
 
-export interface SpecIteratorObject<T, TReturn = undefined, TNext = unknown> extends SpecIterator<T, TReturn, TNext> {
-  [Symbol.iterator](): SpecIteratorObject<T, TReturn, TNext>;
-  map<U>(callbackfn: (value: T, index: number) => U): SpecIteratorObject<U>;
-  filter<S extends T>(predicate: (value: T, index: number) => value is S): SpecIteratorObject<S>;
-  filter(predicate: (value: T, index: number) => unknown): SpecIteratorObject<T>;
-  take(limit: number): SpecIteratorObject<T>;
-  drop(count: number): SpecIteratorObject<T>;
-  flatMap<U>(callbackfn: (value: T, index: number) => Iterator<U> | Iterable<U>): SpecIteratorObject<U>;
-  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
-  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
-  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
-  toArray(): T[];
-  forEach(callbackfn: (value: T, index: number) => void): void;
-  some(predicate: (value: T, index: number) => unknown): boolean;
-  every(predicate: (value: T, index: number) => unknown): boolean;
-  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;
-  find(predicate: (value: T, index: number) => unknown): T | undefined;
-  readonly [Symbol.toStringTag]: string;
-}
-
-export interface SpecIterableIterator<T> extends SpecIteratorObject<T> {
+export interface SpecIterableIterator<T> extends SpecIterator<T> {
   [Symbol.iterator](): SpecIterableIterator<T>;
 }
 
 export interface SpecIterable<T> {
-  [Symbol.iterator](): SpecIterableIterator<T>;
+  [Symbol.iterator](): SpecIterator<T>;
 }
 
-export type HeadersInit = [string, string][] | HeaderRecord | Headers
+export type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
 
 export declare class Headers implements SpecIterable<[string, string]> {
   constructor (init?: HeadersInit)
@@ -144,21 +119,20 @@ type RequestDestination =
   | 'xslt'
 
 export interface RequestInit {
-  body?: BodyInit | null
-  cache?: RequestCache
-  credentials?: RequestCredentials
-  dispatcher?: Dispatcher
-  duplex?: RequestDuplex
+  method?: string
+  keepalive?: boolean
   headers?: HeadersInit
+  body?: BodyInit | null
+  redirect?: RequestRedirect
   integrity?: string
-  keepalive?: boolean
-  method?: string
+  signal?: AbortSignal | null
+  credentials?: RequestCredentials
   mode?: RequestMode
-  redirect?: RequestRedirect
   referrer?: string
   referrerPolicy?: ReferrerPolicy
-  signal?: AbortSignal | null
   window?: null
+  dispatcher?: Dispatcher
+  duplex?: RequestDuplex
 }
 
 export type ReferrerPolicy =
@@ -170,7 +144,7 @@ export type ReferrerPolicy =
   | 'same-origin'
   | 'strict-origin'
   | 'strict-origin-when-cross-origin'
-  | 'unsafe-url'
+  | 'unsafe-url';
 
 export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
 
@@ -197,7 +171,7 @@ export declare class Request extends BodyMixin {
   readonly signal: AbortSignal
   readonly duplex: RequestDuplex
 
-  public clone (): Request
+  readonly clone: () => Request
 }
 
 export interface ResponseInit {
@@ -227,9 +201,9 @@ export declare class Response extends BodyMixin {
   readonly url: string
   readonly redirected: boolean
 
-  public clone (): Response
+  readonly clone: () => Response
 
   static error (): Response
-  static json (data: any, init?: ResponseInit): Response
-  static redirect (url: string | URL, status?: ResponseRedirectStatus): Response
+  static json(data: any, init?: ResponseInit): Response
+  static redirect (url: string | URL, status: ResponseRedirectStatus): Response
 }

package/server/node_modules/undici-types/file.d.ts

@@ -0,0 +1,39 @@
+// Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/File.ts (MIT)
+/// <reference types="node" />
+
+import { Blob } from 'buffer'
+
+export interface BlobPropertyBag {
+  type?: string
+  endings?: 'native' | 'transparent'
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+  /**
+   * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+   */
+  lastModified?: number
+}
+
+export declare class File extends Blob {
+  /**
+   * Creates a new File instance.
+   *
+   * @param fileBits An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
+   * @param fileName The name of the file.
+   * @param options An options object containing optional attributes for the file.
+   */
+  constructor(fileBits: ReadonlyArray<string | NodeJS.ArrayBufferView | Blob>, fileName: string, options?: FilePropertyBag)
+
+  /**
+   * Name of the file referenced by the File object.
+   */
+  readonly name: string
+
+  /**
+   * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+   */
+  readonly lastModified: number
+
+  readonly [Symbol.toStringTag]: string
+}

package/server/node_modules/undici-types/filereader.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+
+import { Blob } from 'buffer'
+import { DOMException, EventInit } from './patch'
+
+export declare class FileReader {
+  __proto__: EventTarget & FileReader
+
+  constructor ()
+
+  readAsArrayBuffer (blob: Blob): void
+  readAsBinaryString (blob: Blob): void
+  readAsText (blob: Blob, encoding?: string): void
+  readAsDataURL (blob: Blob): void
+
+  abort (): void
+
+  static readonly EMPTY = 0
+  static readonly LOADING = 1
+  static readonly DONE = 2
+
+  readonly EMPTY = 0
+  readonly LOADING = 1
+  readonly DONE = 2
+
+  readonly readyState: number
+
+  readonly result: string | ArrayBuffer | null
+
+  readonly error: DOMException | null
+
+  onloadstart: null | ((this: FileReader, event: ProgressEvent) => void)
+  onprogress: null | ((this: FileReader, event: ProgressEvent) => void)
+  onload: null | ((this: FileReader, event: ProgressEvent) => void)
+  onabort: null |  ((this: FileReader, event: ProgressEvent) => void)
+  onerror: null | ((this: FileReader, event: ProgressEvent) => void)
+  onloadend: null | ((this: FileReader, event: ProgressEvent) => void)
+}
+
+export interface ProgressEventInit extends EventInit {
+  lengthComputable?: boolean
+  loaded?: number
+  total?: number
+}
+
+export declare class ProgressEvent {
+  __proto__: Event & ProgressEvent
+
+  constructor (type: string, eventInitDict?: ProgressEventInit)
+
+  readonly lengthComputable: boolean
+  readonly loaded: number
+  readonly total: number
+}

package/server/node_modules/undici-types/formdata.d.ts

@@ -1,7 +1,7 @@
 // Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/FormData.ts (MIT)
 /// <reference types="node" />
 
-import { File } from 'node:buffer'
+import { File } from './file'
 import { SpecIterableIterator } from './fetch'
 
 /**
@@ -24,7 +24,7 @@ export declare class FormData {
     or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
    * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
    */
-  append (name: string, value: unknown, fileName?: string): void
+  append(name: string, value: unknown, fileName?: string): void
 
   /**
    * Set a new value for an existing key inside FormData,
@@ -36,7 +36,7 @@ export declare class FormData {
    * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
    *
    */
-  set (name: string, value: unknown, fileName?: string): void
+  set(name: string, value: unknown, fileName?: string): void
 
   /**
    * Returns the first value associated with a given key from within a `FormData` object.
@@ -46,7 +46,7 @@ export declare class FormData {
    *
    * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
    */
-  get (name: string): FormDataEntryValue | null
+  get(name: string): FormDataEntryValue | null
 
   /**
    * Returns all the values associated with a given key from within a `FormData` object.
@@ -55,7 +55,7 @@ export declare class FormData {
    *
    * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
    */
-  getAll (name: string): FormDataEntryValue[]
+  getAll(name: string): FormDataEntryValue[]
 
   /**
    * Returns a boolean stating whether a `FormData` object contains a certain key.
@@ -64,14 +64,14 @@ export declare class FormData {
    *
    * @return A boolean value.
    */
-  has (name: string): boolean
+  has(name: string): boolean
 
   /**
    * Deletes a key and its value(s) from a `FormData` object.
    *
    * @param name The name of the key you want to delete.
    */
-  delete (name: string): void
+  delete(name: string): void
 
   /**
    * Executes given callback function for each field of the FormData instance

package/server/node_modules/undici-types/global-dispatcher.d.ts

@@ -1,9 +1,9 @@
-import Dispatcher from './dispatcher'
-
-declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher> (dispatcher: DispatcherImplementation): void
-declare function getGlobalDispatcher (): Dispatcher
+import Dispatcher from "./dispatcher";
 
 export {
   getGlobalDispatcher,
   setGlobalDispatcher
 }
+
+declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher>(dispatcher: DispatcherImplementation): void;
+declare function getGlobalDispatcher(): Dispatcher;

package/server/node_modules/undici-types/global-origin.d.ts

@@ -1,7 +1,7 @@
-declare function setGlobalOrigin (origin: string | URL | undefined): void
-declare function getGlobalOrigin (): URL | undefined
-
 export {
-  setGlobalOrigin,
-  getGlobalOrigin
+	setGlobalOrigin,
+	getGlobalOrigin
 }
+  
+declare function setGlobalOrigin(origin: string | URL | undefined): void;
+declare function getGlobalOrigin(): URL | undefined;

package/server/node_modules/undici-types/handlers.d.ts

@@ -1,16 +1,15 @@
-import Dispatcher from './dispatcher'
+import Dispatcher from "./dispatcher";
 
-export declare class RedirectHandler implements Dispatcher.DispatchHandler {
-  static buildDispatch (dispatcher: Dispatcher, maxRedirections: number): Dispatcher.Dispatch
-
-  constructor (
-    dispatch: Dispatcher.Dispatch,
+export declare class RedirectHandler implements Dispatcher.DispatchHandlers {
+  constructor(
+    dispatch: Dispatcher,
     maxRedirections: number,
     opts: Dispatcher.DispatchOptions,
-    handler: Dispatcher.DispatchHandler
-  )
+    handler: Dispatcher.DispatchHandlers,
+    redirectionLimitReached: boolean
+  );
 }
 
-export declare class DecoratorHandler implements Dispatcher.DispatchHandler {
-  constructor (handler: Dispatcher.DispatchHandler)
+export declare class DecoratorHandler implements Dispatcher.DispatchHandlers {
+  constructor(handler: Dispatcher.DispatchHandlers);
 }