@overdeck/desktop 0.50.1 → 0.50.3

package/server/node_modules/undici-types/pool-stats.d.ts

@@ -1,19 +1,19 @@
-import Pool from './pool'
+import Pool from "./pool"
 
 export default PoolStats
 
 declare class PoolStats {
-  constructor (pool: Pool)
+  constructor(pool: Pool);
   /** Number of open socket connections in this pool. */
-  connected: number
+  connected: number;
   /** Number of open socket connections in this pool that do not have an active request. */
-  free: number
+  free: number;
   /** Number of pending requests across all clients in this pool. */
-  pending: number
+  pending: number;
   /** Number of queued requests across all clients in this pool. */
-  queued: number
+  queued: number;
   /** Number of currently active requests across all clients in this pool. */
-  running: number
+  running: number;
   /** Number of active, pending, or queued requests across all clients in this pool. */
-  size: number
+  size: number;
 }

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

@@ -1,39 +1,39 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
-import { URL } from 'node:url'
-import Dispatcher from './dispatcher'
+import { URL } from 'url'
+import Dispatcher from "./dispatcher";
 
 export default Pool
 
-type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 declare class Pool extends Dispatcher {
-  constructor (url: string | URL, options?: Pool.Options)
+  constructor(url: string | URL, options?: Pool.Options)
   /** `true` after `pool.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
   /** Aggregate stats for a Pool. */
-  readonly stats: TPoolStats
+  readonly stats: TPoolStats;
 
   // Override dispatcher APIs.
-  override connect (
+  override connect(
     options: PoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
     options: PoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void
+  ): void;
 }
 
 declare namespace Pool {
-  export type PoolStats = TPoolStats
+  export type PoolStats = TPoolStats;
   export interface Options extends Client.Options {
     /** Default: `(origin, opts) => new Client(origin, opts)`. */
     factory?(origin: URL, opts: object): Dispatcher;
     /** The max number of clients to create. `null` if no limit. Default `null`. */
     connections?: number | null;
-    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
-    clientTtl?: number | null;
+
+    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options["interceptors"]
   }
 }

package/server/node_modules/undici-types/proxy-agent.d.ts

@@ -1,15 +1,15 @@
 import Agent from './agent'
-import buildConnector from './connector'
+import buildConnector from './connector';
 import Dispatcher from './dispatcher'
-import { OutgoingHttpHeaders } from './header'
+import { IncomingHttpHeaders } from './header'
 
 export default ProxyAgent
 
 declare class ProxyAgent extends Dispatcher {
-  constructor (options: ProxyAgent.Options | string)
+  constructor(options: ProxyAgent.Options | string)
 
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
-  close (): Promise<void>
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  close(): Promise<void>;
 }
 
 declare namespace ProxyAgent {
@@ -20,17 +20,9 @@ declare namespace ProxyAgent {
      */
     auth?: string;
     token?: string;
-    headers?: OutgoingHttpHeaders;
+    headers?: IncomingHttpHeaders;
     requestTls?: buildConnector.BuildOptions;
     proxyTls?: buildConnector.BuildOptions;
     clientFactory?(origin: URL, opts: object): Dispatcher;
-    /**
-     * Undici tunnels via CONNECT when the target endpoint uses HTTPS, and
-     * forwards (HTTP/1.1 absolute-form request-target, per RFC 9112 §3.2.2)
-     * otherwise, regardless of whether the proxy URL is HTTP or HTTPS. The
-     * non-tunneled forwarding path does not negotiate HTTP/2 with the proxy.
-     * Set to true to force tunneling for plain HTTP requests as well.
-     */
-    proxyTunnel?: boolean;
   }
 }

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

@@ -1,47 +1,45 @@
-import { Readable } from 'node:stream'
-import { Blob } from 'node:buffer'
+import { Readable } from "stream";
+import { Blob } from 'buffer'
 
 export default BodyReadable
 
 declare class BodyReadable extends Readable {
-  constructor (opts: {
-    resume: (this: Readable, size: number) => void | null;
-    abort: () => void | null;
-    contentType?: string;
-    contentLength?: number;
-    highWaterMark?: number;
-  })
+  constructor(
+    resume?: (this: Readable, size: number) => void | null,
+    abort?: () => void | null,
+    contentType?: string
+  )
 
   /** Consumes and returns the body as a string
    *  https://fetch.spec.whatwg.org/#dom-body-text
    */
-  text (): Promise<string>
+  text(): Promise<string>
 
   /** Consumes and returns the body as a JavaScript Object
    *  https://fetch.spec.whatwg.org/#dom-body-json
    */
-  json (): Promise<unknown>
+  json(): Promise<unknown>
 
   /** Consumes and returns the body as a Blob
    *  https://fetch.spec.whatwg.org/#dom-body-blob
    */
-  blob (): Promise<Blob>
+  blob(): Promise<Blob>
 
   /** Consumes and returns the body as an Uint8Array
    *  https://fetch.spec.whatwg.org/#dom-body-bytes
    */
-  bytes (): Promise<Uint8Array>
+  bytes(): Promise<Uint8Array>
 
   /** Consumes and returns the body as an ArrayBuffer
    *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
    */
-  arrayBuffer (): Promise<ArrayBuffer>
+  arrayBuffer(): Promise<ArrayBuffer>
 
   /** Not implemented
    *
    *  https://fetch.spec.whatwg.org/#dom-body-formdata
    */
-  formData (): Promise<never>
+  formData(): Promise<never>
 
   /** Returns true if the body is not null and the body has been consumed
    *
@@ -51,7 +49,7 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /**
+  /** 
    * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream
@@ -61,8 +59,7 @@ declare class BodyReadable extends Readable {
   readonly body: never | undefined
 
   /** Dumps the response body by reading `limit` number of bytes.
-   * @param opts.limit Number of bytes to read (optional) - Default: 131072
-   * @param opts.signal AbortSignal to cancel the operation (optional)
+   * @param opts.limit Number of bytes to read (optional) - Default: 262144
    */
-  dump (opts?: { limit: number; signal?: AbortSignal }): Promise<void>
+  dump(opts?: { limit: number }): Promise<void>
 }

package/server/node_modules/undici-types/retry-agent.d.ts

@@ -4,5 +4,5 @@ import RetryHandler from './retry-handler'
 export default RetryAgent
 
 declare class RetryAgent extends Dispatcher {
-  constructor (dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
 }

package/server/node_modules/undici-types/retry-handler.d.ts

@@ -1,18 +1,18 @@
-import Dispatcher from './dispatcher'
+import Dispatcher from "./dispatcher";
 
-export default RetryHandler
+export default RetryHandler;
 
-declare class RetryHandler implements Dispatcher.DispatchHandler {
-  constructor (
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+  constructor(
     options: Dispatcher.DispatchOptions & {
       retryOptions?: RetryHandler.RetryOptions;
     },
     retryHandlers: RetryHandler.RetryHandlers
-  )
+  );
 }
 
 declare namespace RetryHandler {
-  export type RetryState = { counter: number; }
+  export type RetryState = { counter: number; };
 
   export type RetryContext = {
     state: RetryState;
@@ -21,7 +21,7 @@ declare namespace RetryHandler {
     };
   }
 
-  export type OnRetryCallback = (result?: Error | null) => void
+  export type OnRetryCallback = (result?: Error | null) => void;
 
   export type RetryCallback = (
     err: Error,
@@ -32,18 +32,9 @@ declare namespace RetryHandler {
       };
     },
     callback: OnRetryCallback
-  ) => void
+  ) => number | null;
 
   export interface RetryOptions {
-    /**
-     * If true, the retry handler will throw an error if the request fails,
-     * this will prevent the folling handlers from being called, and will destroy the socket.
-     *
-     * @type {boolean}
-     * @memberof RetryOptions
-     * @default true
-     */
-    throwOnError?: boolean;
     /**
      * Callback to be invoked on every retry iteration.
      * It receives the error, current state of the retry object and the options object
@@ -119,7 +110,7 @@ declare namespace RetryHandler {
   }
 
   export interface RetryHandlers {
-    dispatch: Dispatcher['dispatch'];
-    handler: Dispatcher.DispatchHandler;
+    dispatch: Dispatcher["dispatch"];
+    handler: Dispatcher.DispatchHandlers;
   }
 }

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

@@ -3,7 +3,7 @@ export namespace util {
    * Retrieves a header name and returns its lowercase value.
    * @param value Header name
    */
-  export function headerNameToString (value: string | Buffer): string
+  export function headerNameToString(value: string | Buffer): string;
 
   /**
    * Receives a header object and returns the parsed value.
@@ -11,8 +11,8 @@ export namespace util {
    * @param obj Object to specify a proxy object. Used to assign parsed values.
    * @returns If `obj` is specified, it is equivalent to `obj`.
    */
-  export function parseHeaders (
+  export function parseHeaders(
     headers: (Buffer | string | (Buffer | string)[])[],
     obj?: Record<string, string | string[]>
-  ): Record<string, string | string[]>
+  ): Record<string, string | string[]>;
 }

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

@@ -1,6 +1,4 @@
 // These types are not exported, and are only used internally
-import { BufferSource } from 'node:stream/web'
-import * as undici from './index'
 
 /**
  * Take in an unknown value and return one that is of type T
@@ -11,13 +9,15 @@ type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) =>
 
 type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
 
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
 interface WebidlErrors {
-  /**
-   * @description Instantiate an error
-   */
   exception (opts: { header: string, message: string }): TypeError
   /**
-   * @description Instantiate an error when conversion from one type to another has failed
+   * @description Throw an error when conversion from one type to another has failed
    */
   conversionFailed (opts: {
     prefix: string
@@ -34,24 +34,11 @@ interface WebidlErrors {
   }): TypeError
 }
 
-interface WebIDLTypes {
-  UNDEFINED: 1,
-  BOOLEAN: 2,
-  STRING: 3,
-  SYMBOL: 4,
-  NUMBER: 5,
-  BIGINT: 6,
-  NULL: 7
-  OBJECT: 8
-}
-
 interface WebidlUtil {
   /**
    * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
    */
-  Type (object: unknown): WebIDLTypes[keyof WebIDLTypes]
-
-  TypeValueToString (o: unknown):
+  Type (object: unknown):
     | 'Undefined'
     | 'Boolean'
     | 'String'
@@ -61,8 +48,6 @@ interface WebidlUtil {
     | 'Null'
     | 'Object'
 
-  Types: WebIDLTypes
-
   /**
    * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
@@ -70,11 +55,11 @@ interface WebidlUtil {
     V: unknown,
     bitLength: number,
     signedness: 'signed' | 'unsigned',
-    flags?: number
+    opts?: ConvertToIntOpts
   ): number
 
   /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
   IntegerPart (N: number): number
 
@@ -83,28 +68,20 @@ interface WebidlUtil {
    */
   Stringify (V: any): string
 
-  MakeTypeAssertion <I>(I: I): (arg: any) => arg is I
-
   /**
    * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
    */
   markAsUncloneable (V: any): void
-
-  IsResizableArrayBuffer (V: ArrayBufferLike): boolean
-
-  HasFlag (flag: number, attributes: number): boolean
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#dfn-get-buffer-source-copy
-   */
-  getCopyOfBytesHeldByBufferSource (bufferSource: BufferSource): Uint8Array
 }
 
 interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-DOMString
    */
-  DOMString (V: unknown, prefix: string, argument: string, flags?: number): string
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-ByteString
@@ -144,140 +121,59 @@ interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-unsigned-short
    */
-  ['unsigned short'] (V: unknown, flags?: number): number
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
 
   /**
    * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
    */
-  ArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): ArrayBuffer
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
-   */
-  SharedArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): SharedArrayBuffer
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
   TypedArray (
     V: unknown,
-    T: new () => NodeJS.TypedArray,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.TypedArray
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
-   */
-  DataView (
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): DataView
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
-  ArrayBufferView (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.ArrayBufferView
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
 
   /**
    * @see https://webidl.spec.whatwg.org/#BufferSource
    */
   BufferSource (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | NodeJS.ArrayBufferView
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
-   */
-  AllowSharedBufferSource (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
 
   ['sequence<ByteString>']: SequenceConverter<string>
-
+  
   ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>
 
-  /**
-  * @see https://fetch.spec.whatwg.org/#requestinfo
-  */
-  RequestInfo (V: unknown): undici.Request | string
-
-  /**
-   * @see https://fetch.spec.whatwg.org/#requestinit
-   */
-  RequestInit (V: unknown): undici.RequestInit
-
-  /**
-   * @see https://html.spec.whatwg.org/multipage/webappapis.html#eventhandlernonnull
-   */
-  EventHandlerNonNull (V: unknown): Function | null
-
-  WebSocketStreamWrite (V: unknown): ArrayBuffer | NodeJS.TypedArray | string
-
   [Key: string]: (...args: any[]) => unknown
 }
 
-type WebidlIsFunction<T> = (arg: any) => arg is T
-
-interface WebidlIs {
-  Request: WebidlIsFunction<undici.Request>
-  Response: WebidlIsFunction<undici.Response>
-  ReadableStream: WebidlIsFunction<ReadableStream>
-  Blob: WebidlIsFunction<Blob>
-  URLSearchParams: WebidlIsFunction<URLSearchParams>
-  File: WebidlIsFunction<File>
-  FormData: WebidlIsFunction<undici.FormData>
-  URL: WebidlIsFunction<URL>
-  WebSocketError: WebidlIsFunction<undici.WebSocketError>
-  AbortSignal: WebidlIsFunction<AbortSignal>
-  MessagePort: WebidlIsFunction<MessagePort>
-  USVString: WebidlIsFunction<string>
-  /**
-   * @see https://webidl.spec.whatwg.org/#BufferSource
-   */
-  BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>
-}
-
 export interface Webidl {
   errors: WebidlErrors
   util: WebidlUtil
   converters: WebidlConverters
-  is: WebidlIs
-  attributes: WebIDLExtendedAttributes
 
   /**
    * @description Performs a brand-check on {@param V} to ensure it is a
    * {@param cls} object.
    */
-  brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
-
-  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (list: Interfaces): (V: any) => asserts V is Interfaces[number]
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-sequence
@@ -300,11 +196,10 @@ export interface Webidl {
    * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
    * interfaces are allowed.
    */
-  interfaceConverter <Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (
+  interfaceConverter <Interface>(cls: Interface): (
     V: unknown,
-    prefix: string,
-    argument: string
-  ) => asserts V is Interface
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
 
   // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
   // from the converters given?
@@ -331,16 +226,3 @@ export interface Webidl {
 
   argumentLengthCheck (args: { length: number }, min: number, context: string): void
 }
-
-interface WebIDLExtendedAttributes {
-  /** https://webidl.spec.whatwg.org/#Clamp */
-  Clamp: number
-  /** https://webidl.spec.whatwg.org/#EnforceRange */
-  EnforceRange: number
-  /** https://webidl.spec.whatwg.org/#AllowShared */
-  AllowShared: number
-  /** https://webidl.spec.whatwg.org/#AllowResizable */
-  AllowResizable: number
-  /** https://webidl.spec.whatwg.org/#LegacyNullToEmptyString */
-  LegacyNullToEmptyString: number
-}

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

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 
-import type { Blob } from 'node:buffer'
-import type { ReadableStream, WritableStream } from 'node:stream/web'
-import type { MessagePort } from 'node:worker_threads'
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
 import {
   EventInit,
   EventListenerOptions,
@@ -23,7 +22,7 @@ interface WebSocketEventMap {
 
 interface WebSocket extends EventTarget {
   binaryType: BinaryType
-
+  
   readonly bufferedAmount: number
   readonly extensions: string
 
@@ -96,16 +95,16 @@ interface MessageEventInit<T = any> extends EventInit {
   data?: T
   lastEventId?: string
   origin?: string
-  ports?: MessagePort[]
-  source?: MessagePort | null
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
 }
 
 interface MessageEvent<T = any> extends Event {
   readonly data: T
   readonly lastEventId: string
   readonly origin: string
-  readonly ports: readonly MessagePort[]
-  readonly source: MessagePort | null
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
   initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -113,8 +112,8 @@ interface MessageEvent<T = any> extends Event {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: MessagePort | null,
-    ports?: MessagePort[]
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
   ): void;
 }
 
@@ -136,7 +135,7 @@ interface ErrorEvent extends Event {
   readonly filename: string
   readonly lineno: number
   readonly colno: number
-  readonly error: Error
+  readonly error: any
 }
 
 export declare const ErrorEvent: {
@@ -149,40 +148,3 @@ interface WebSocketInit {
   dispatcher?: Dispatcher,
   headers?: HeadersInit
 }
-
-interface WebSocketStreamOptions {
-  protocols?: string | string[]
-  signal?: AbortSignal
-}
-
-interface WebSocketCloseInfo {
-  closeCode: number
-  reason: string
-}
-
-interface WebSocketStream {
-  closed: Promise<WebSocketCloseInfo>
-  opened: Promise<{
-    extensions: string
-    protocol: string
-    readable: ReadableStream
-    writable: WritableStream
-  }>
-  url: string
-
-  close(options?: Partial<WebSocketCloseInfo>): void
-}
-
-export declare const WebSocketStream: {
-  prototype: WebSocketStream
-  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
-}
-
-interface WebSocketError extends Event, WebSocketCloseInfo {}
-
-export declare const WebSocketError: {
-  prototype: WebSocketError
-  new (type: string, init?: WebSocketCloseInfo): WebSocketError
-}
-
-export declare const ping: (ws: WebSocket, body?: Buffer) => void