From 5286482cd4acf4029b1f3a24161d962201caf140 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Mon, 18 May 2026 12:36:57 +0100 Subject: [PATCH 1/3] =?UTF-8?q?=F0=9F=A4=96=20Merge=20PR=20#74947=20node:?= =?UTF-8?q?=20v25.9=20by=20@Renegade334?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- types/node/async_hooks.d.ts | 108 ++++++++++ types/node/crypto.d.ts | 17 +- types/node/fs.d.ts | 6 +- types/node/fs/promises.d.ts | 126 +++++++++++ types/node/index.d.ts | 2 + types/node/inspector.generated.d.ts | 5 + types/node/module.d.ts | 1 + types/node/node-tests.ts | 1 + types/node/node-tests/async_hooks.ts | 3 + types/node/node-tests/process.ts | 1 + types/node/node-tests/repl.ts | 6 + types/node/node-tests/stream-iter.ts | 33 +++ types/node/node-tests/test.ts | 11 +- types/node/package.json | 2 +- types/node/process.d.ts | 26 ++- types/node/quic.d.ts | 4 +- types/node/repl.d.ts | 15 ++ types/node/stream/iter.d.ts | 298 +++++++++++++++++++++++++++ types/node/test.d.ts | 50 +++-- types/node/ts5.6/index.d.ts | 2 + types/node/ts5.7/index.d.ts | 2 + types/node/vm.d.ts | 9 +- types/node/zlib/iter.d.ts | 131 ++++++++++++ 23 files changed, 827 insertions(+), 32 deletions(-) create mode 100644 types/node/node-tests/stream-iter.ts create mode 100644 types/node/stream/iter.d.ts create mode 100644 types/node/zlib/iter.d.ts diff --git a/types/node/async_hooks.d.ts b/types/node/async_hooks.d.ts index bb82b8a3f0b16f..ac857ad185ef98 100644 --- a/types/node/async_hooks.d.ts +++ b/types/node/async_hooks.d.ts @@ -491,6 +491,75 @@ declare module "node:async_hooks" { * @experimental */ exit(callback: (...args: TArgs) => R, ...args: TArgs): R; + /** + * Creates a disposable scope that enters the given store and automatically + * restores the previous store value when the scope is disposed. This method is + * designed to work with JavaScript's explicit resource management (`using` syntax). + * + * Example: + * + * ```js + * import { AsyncLocalStorage } from 'node:async_hooks'; + * + * const asyncLocalStorage = new AsyncLocalStorage(); + * + * { + * using _ = asyncLocalStorage.withScope('my-store'); + * console.log(asyncLocalStorage.getStore()); // Prints: my-store + * } + * + * console.log(asyncLocalStorage.getStore()); // Prints: undefined + * ``` + * + * The `withScope()` method is particularly useful for managing context in + * synchronous code where you want to ensure the previous store value is restored + * when exiting a block, even if an error is thrown. + * + * ```js + * import { AsyncLocalStorage } from 'node:async_hooks'; + * + * const asyncLocalStorage = new AsyncLocalStorage(); + * + * try { + * using _ = asyncLocalStorage.withScope('my-store'); + * console.log(asyncLocalStorage.getStore()); // Prints: my-store + * throw new Error('test'); + * } catch (e) { + * // Store is automatically restored even after error + * console.log(asyncLocalStorage.getStore()); // Prints: undefined + * } + * ``` + * + * **Important:** When using `withScope()` in async functions before the first + * `await`, be aware that the scope change will affect the caller's context. The + * synchronous portion of an async function (before the first `await`) runs + * immediately when called, and when it reaches the first `await`, it returns the + * promise to the caller. At that point, the scope change becomes visible in the + * caller's context and will persist in subsequent synchronous code until something + * else changes the scope value. For async operations, prefer using `run()` which + * properly isolates context across async boundaries. + * + * ```js + * import { AsyncLocalStorage } from 'node:async_hooks'; + * + * const asyncLocalStorage = new AsyncLocalStorage(); + * + * async function example() { + * using _ = asyncLocalStorage.withScope('my-store'); + * console.log(asyncLocalStorage.getStore()); // Prints: my-store + * await someAsyncOperation(); // Function pauses here and returns promise + * console.log(asyncLocalStorage.getStore()); // Prints: my-store + * } + * + * // Calling without await + * example(); // Synchronous portion runs, then pauses at first await + * // After the promise is returned, the scope 'my-store' is now active in caller! + * console.log(asyncLocalStorage.getStore()); // Prints: my-store (unexpected!) + * ``` + * @since v25.9.0 + * @experimental + */ + withScope(store: T): RunScope; /** * Transitions into the context for the remainder of the current * synchronous execution and then persists the store through any following @@ -533,6 +602,45 @@ declare module "node:async_hooks" { */ enterWith(store: T): void; } + /** + * A disposable scope returned by `asyncLocalStorage.withScope()` that + * automatically restores the previous store value when disposed. This class + * implements the [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management) protocol and is designed to work + * with JavaScript's `using` syntax. + * + * The scope automatically restores the previous store value when the `using` block + * exits, whether through normal completion or by throwing an error. + * @since v25.9.0 + * @experimental + */ + interface RunScope extends Disposable { + /** + * Explicitly ends the scope and restores the previous store value. This method + * is idempotent: calling it multiple times has the same effect as calling it once. + * + * The `[Symbol.dispose]()` method defers to `dispose()`. + * + * If `withScope()` is called without the `using` keyword, `dispose()` must be + * called manually to restore the previous store value. Forgetting to call + * `dispose()` will cause the store value to persist for the remainder of the + * current execution context: + * + * ```js + * import { AsyncLocalStorage } from 'node:async_hooks'; + * + * const storage = new AsyncLocalStorage(); + * + * // Without using, the scope must be disposed manually + * const scope = storage.withScope('my-store'); + * // storage.getStore() === 'my-store' here + * + * scope.dispose(); // Restore previous value + * // storage.getStore() === undefined here + * ``` + * @since v25.9.0 + */ + dispose(): void; + } /** * @since v17.2.0, v16.14.0 * @return A map of provider types to the corresponding numeric id. diff --git a/types/node/crypto.d.ts b/types/node/crypto.d.ts index 3ebfec684c2cb7..1933d6030140e4 100644 --- a/types/node/crypto.d.ts +++ b/types/node/crypto.d.ts @@ -3778,7 +3778,7 @@ declare module "node:crypto" { interface CShakeParams extends Algorithm { customization?: NodeJS.BufferSource; functionName?: NodeJS.BufferSource; - length: number; + outputLength: number; } interface ContextParams extends Algorithm { context?: NodeJS.BufferSource; @@ -3815,6 +3815,10 @@ declare module "node:crypto" { hash: HashAlgorithmIdentifier; length?: number; } + interface KangarooTwelveParams { + customization?: NodeJS.BufferSource; + outputLength: number; + } interface JsonWebKey { alg?: string; crv?: string; @@ -3849,7 +3853,7 @@ declare module "node:crypto" { } interface KmacParams extends Algorithm { customization?: NodeJS.BufferSource; - length: number; + outputLength: number; } interface Pbkdf2Params extends Algorithm { hash: HashAlgorithmIdentifier; @@ -3884,6 +3888,10 @@ declare module "node:crypto" { interface RsaPssParams extends Algorithm { saltLength: number; } + interface TurboShakeParams { + domainSeparation?: number; + outputLength: number; + } interface Crypto { readonly subtle: SubtleCrypto; getRandomValues< @@ -3945,7 +3953,10 @@ declare module "node:crypto" { extractable: boolean, keyUsages: readonly KeyUsage[], ): Promise; - digest(algorithm: AlgorithmIdentifier | CShakeParams, data: NodeJS.BufferSource): Promise; + digest( + algorithm: AlgorithmIdentifier | CShakeParams | TurboShakeParams | KangarooTwelveParams, + data: NodeJS.BufferSource, + ): Promise; encapsulateBits( encapsulationAlgorithm: AlgorithmIdentifier, encapsulationKey: CryptoKey, diff --git a/types/node/fs.d.ts b/types/node/fs.d.ts index 639425652c22bc..1fce8b85862fd7 100644 --- a/types/node/fs.d.ts +++ b/types/node/fs.d.ts @@ -380,7 +380,8 @@ declare module "node:fs" { "ready": []; } /** - * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function. + * Instances of `fs.ReadStream` cannot be constructed directly. They are created and + * returned using the `fs.createReadStream()` function. * @since v0.1.93 */ class ReadStream extends stream.Readable { @@ -643,7 +644,8 @@ declare module "node:fs" { "ready": []; } /** - * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function. + * Instances of `fs.WriteStream` cannot be constructed directly. They are created and + * returned using the `fs.createWriteStream()` function. * @since v0.1.93 */ class WriteStream extends stream.Writable { diff --git a/types/node/fs/promises.d.ts b/types/node/fs/promises.d.ts index c1b38d1c8c172b..c9c24215addd70 100644 --- a/types/node/fs/promises.d.ts +++ b/types/node/fs/promises.d.ts @@ -37,6 +37,7 @@ declare module "node:fs/promises" { WriteVResult, } from "node:fs"; import { Stream } from "node:stream"; + import { ByteReadableStream, Transform, Writer } from "node:stream/iter"; import { ReadableStream } from "node:stream/web"; interface FileChangeInfo { eventType: WatchEventType; @@ -85,6 +86,57 @@ declare module "node:fs/promises" { interface ReadableWebStreamOptions { autoClose?: boolean | undefined; } + interface PullOptions extends Abortable { + /** + * Close the file handle when the stream ends. + * @default false + */ + autoClose?: boolean | undefined; + /** + * Byte offset to begin reading from. When specified, + * reads use explicit positioning (`pread` semantics). + */ + start?: number | undefined; + /** + * Maximum number of bytes to read before ending the + * iterator. Reads stop when `limit` bytes have been delivered or EOF is + * reached, whichever comes first. + */ + limit?: number | undefined; + /** + * Size in bytes of the buffer allocated for each + * read operation. + * @default 131072 + */ + chunkSize?: number | undefined; + } + interface WriterOptions { + /** + * Close the file handle when the writer ends or fails. + * @default false + */ + autoClose?: boolean | undefined; + /** + * Byte offset to start writing at. When specified, + * writes use explicit positioning. + */ + start?: number | undefined; + /** + * Maximum number of bytes the writer will accept. + * Async writes (`write()`, `writev()`) that would exceed the limit reject + * with `ERR_OUT_OF_RANGE`. Sync writes (`writeSync()`, `writevSync()`) + * return `false`. + */ + limit?: number | undefined; + /** + * Maximum chunk size in bytes for synchronous write + * operations. Writes larger than this threshold fall back to async I/O. + * Set this to match the reader's `chunkSize` for optimal `pipeTo()` + * performance. + * @default 131072 + */ + chunkSize?: number | undefined; + } // TODO: Add `EventEmitter` close interface FileHandle { /** @@ -202,6 +254,41 @@ declare module "node:fs/promises" { * @return Fulfills with `undefined` upon success. */ datasync(): Promise; + /** + * Return the file contents as an async iterable using the + * [`node:stream/iter`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html) pull model. Reads are performed in `chunkSize`-byte + * chunks (default 128 KB). If transforms are provided, they are applied + * via [`stream/iter pull()`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html#pullsource-transforms-options). + * + * The file handle is locked while the iterable is being consumed and unlocked + * when iteration completes, an error occurs, or the consumer breaks. + * + * This function is only available when the `--experimental-stream-iter` flag is + * enabled. + * + * ```js + * import { open } from 'node:fs/promises'; + * import { text } from 'node:stream/iter'; + * import { compressGzip } from 'node:zlib/iter'; + * + * const fh = await open('input.txt', 'r'); + * + * // Read as text + * console.log(await text(fh.pull({ autoClose: true }))); + * + * // Read 1 KB starting at byte 100 + * const fh2 = await open('input.txt', 'r'); + * console.log(await text(fh2.pull({ start: 100, limit: 1024, autoClose: true }))); + * + * // Read with compression + * const fh3 = await open('input.txt', 'r'); + * const compressed = fh3.pull(compressGzip(), { autoClose: true }); + * ``` + * @since v25.9.0 + * @experimental + */ + pull(...transforms: Transform[]): ByteReadableStream; + pull(...args: [...transforms: Transform[], options: PullOptions]): ByteReadableStream; /** * Request that all data for the open file descriptor is flushed to the storage * device. The specific implementation is operating system and device specific. @@ -450,6 +537,45 @@ declare module "node:fs/promises" { buffers: TBuffers, position?: number, ): Promise>; + /** + * Return a [`node:stream/iter`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html) writer backed by this file handle. + * + * The writer supports both `Symbol.asyncDispose` and `Symbol.dispose`: + * + * * `await using w = fh.writer()` — if the writer is still open (no `end()` + * called), `asyncDispose` calls `fail()`. If `end()` is pending, it waits + * for it to complete. + * * `using w = fh.writer()` — calls `fail()` unconditionally. + * + * The `writeSync()` and `writevSync()` methods enable the try-sync fast path + * used by [`stream/iter pipeTo()`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html#pipetosource-transforms-writer). When the reader's chunk size matches the + * writer's `chunkSize`, all writes in a `pipeTo()` pipeline complete + * synchronously with zero promise overhead. + * + * This function is only available when the `--experimental-stream-iter` flag is + * enabled. + * + * ```js + * import { open } from 'node:fs/promises'; + * import { from, pipeTo } from 'node:stream/iter'; + * import { compressGzip } from 'node:zlib/iter'; + * + * // Async pipeline + * const fh = await open('output.gz', 'w'); + * await pipeTo(from('Hello!'), compressGzip(), fh.writer({ autoClose: true })); + * + * // Sync pipeline with limit + * const src = await open('input.txt', 'r'); + * const dst = await open('output.txt', 'w'); + * const w = dst.writer({ limit: 1024 * 1024 }); // Max 1 MB + * await pipeTo(src.pull({ autoClose: true }), w); + * await w.end(); + * await dst.close(); + * ``` + * @since v25.9.0 + * @experimental + */ + writer(options?: WriterOptions): Writer; /** * Read from a file and write to an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s * @since v13.13.0, v12.17.0 diff --git a/types/node/index.d.ts b/types/node/index.d.ts index 08ab4f052053a7..14dd60bcb7e98a 100644 --- a/types/node/index.d.ts +++ b/types/node/index.d.ts @@ -95,6 +95,7 @@ /// /// /// +/// /// /// /// @@ -113,3 +114,4 @@ /// /// /// +/// diff --git a/types/node/inspector.generated.d.ts b/types/node/inspector.generated.d.ts index 93ae27188180ca..0e2e4416daaf5e 100644 --- a/types/node/inspector.generated.d.ts +++ b/types/node/inspector.generated.d.ts @@ -2035,6 +2035,9 @@ declare module "node:inspector" { autoAttach: boolean; waitForDebuggerOnStart: boolean; } + interface GetTargetsReturnType { + targetInfos: TargetInfo[]; + } interface TargetCreatedEventDataType { targetInfo: TargetInfo; } @@ -2506,6 +2509,7 @@ declare module "node:inspector" { */ post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void; post(method: "NodeWorker.detach", callback?: (err: Error | null) => void): void; + post(method: "Target.getTargets", callback?: (err: Error | null, params: Target.GetTargetsReturnType) => void): void; post(method: "Target.setAutoAttach", params?: Target.SetAutoAttachParameterType, callback?: (err: Error | null) => void): void; post(method: "Target.setAutoAttach", callback?: (err: Error | null) => void): void; post(method: "DOMStorage.clear", params?: DOMStorage.ClearParameterType, callback?: (err: Error | null) => void): void; @@ -3642,6 +3646,7 @@ declare module "node:inspector/promises" { * Detached from the worker with given sessionId. */ post(method: "NodeWorker.detach", params?: NodeWorker.DetachParameterType): Promise; + post(method: "Target.getTargets"): Promise; post(method: "Target.setAutoAttach", params?: Target.SetAutoAttachParameterType): Promise; post(method: "DOMStorage.clear", params?: DOMStorage.ClearParameterType): Promise; /** diff --git a/types/node/module.d.ts b/types/node/module.d.ts index 7f61a678e67fc0..ae6c32988d9da3 100644 --- a/types/node/module.d.ts +++ b/types/node/module.d.ts @@ -218,6 +218,7 @@ declare module "node:module" { * This feature requires `--allow-worker` if used with the * [Permission Model](https://nodejs.org/docs/latest-v25.x/api/permissions.html#permission-model). * @since v20.6.0, v18.19.0 + * @deprecated Use `module.registerHooks()` instead. * @param specifier Customization hooks to be registered; this should be * the same string that would be passed to `import()`, except that if it is * relative, it is resolved relative to `parentURL`. diff --git a/types/node/node-tests.ts b/types/node/node-tests.ts index 06dcab94707cd3..2031eb8a76f6a2 100644 --- a/types/node/node-tests.ts +++ b/types/node/node-tests.ts @@ -30,6 +30,7 @@ import "./node-tests/repl"; import "./node-tests/sea"; import "./node-tests/sqlite"; import "./node-tests/stream"; +import "./node-tests/stream-iter"; import "./node-tests/stream-web"; import "./node-tests/string_decoder"; import "./node-tests/test"; diff --git a/types/node/node-tests/async_hooks.ts b/types/node/node-tests/async_hooks.ts index 99c96b5a31e21e..1c349f5ac40ae6 100644 --- a/types/node/node-tests/async_hooks.ts +++ b/types/node/node-tests/async_hooks.ts @@ -6,6 +6,7 @@ import { executionAsyncId, executionAsyncResource, HookCallbacks, + RunScope, triggerAsyncId, } from "node:async_hooks"; @@ -86,6 +87,8 @@ import { return 42; }, 1); ctx.enterWith("test"); + using scope: RunScope = ctx.withScope("test"); + scope.dispose(); } { diff --git a/types/node/node-tests/process.ts b/types/node/node-tests/process.ts index 6bdb6bdf33fc36..1fbbc00268f651 100644 --- a/types/node/node-tests/process.ts +++ b/types/node/node-tests/process.ts @@ -54,6 +54,7 @@ import { fileURLToPath } from "node:url"; } process.setUncaughtExceptionCaptureCallback(myCb); process.setUncaughtExceptionCaptureCallback(null); + process.addUncaughtExceptionCaptureCallback((err) => true); const b: boolean = process.hasUncaughtExceptionCaptureCallback(); } diff --git a/types/node/node-tests/repl.ts b/types/node/node-tests/repl.ts index 4cab7e673665a6..798f9568d76fa7 100644 --- a/types/node/node-tests/repl.ts +++ b/types/node/node-tests/repl.ts @@ -66,6 +66,12 @@ import { Context } from "node:vm"; this; return ""; }, + handleError(err) { + if (err instanceof SyntaxError) { + return "print"; + } + return "unhandled"; + }, }); function test() { diff --git a/types/node/node-tests/stream-iter.ts b/types/node/node-tests/stream-iter.ts new file mode 100644 index 00000000000000..34460498514e97 --- /dev/null +++ b/types/node/node-tests/stream-iter.ts @@ -0,0 +1,33 @@ +import { FileHandle, open } from "node:fs/promises"; +import { bytes, from, fromSync, pipeTo, pull, pullSync, text, textSync } from "node:stream/iter"; +import { compressGzip, compressGzipSync, decompressGzip, decompressGzipSync } from "node:zlib/iter"; + +// Async round-trip +void async function() { + const compressed: Uint8Array = await bytes(pull(from("hello"), compressGzip())); + const original: string = await text(pull(from(compressed), decompressGzip())); +}; + +// Sync round-trip +{ + const compressed: Iterable = pullSync(fromSync("hello"), compressGzipSync()); + const original: string = textSync(pullSync(compressed, decompressGzipSync())); +} + +// Read a file, compress, write to another file +void async function() { + const src: FileHandle = await open("input.txt", "r"); + const dst: FileHandle = await open("output.gz", "w"); + const bytesWritten: number = await pipeTo(src.pull(), compressGzip(), dst.writer({ autoClose: true })); + await src.close(); + + // Read it back + const gz: FileHandle = await open("output.gz", "r"); + const result: string = await text(gz.pull(decompressGzip(), { autoClose: true })); +}; + +void async function() { + const fh: FileHandle = await open("file"); + using syncDispose = fh.writer(); + await using asyncDispose = fh.writer(); +}; diff --git a/types/node/node-tests/test.ts b/types/node/node-tests/test.ts index e088b876b54e96..8f3a5b3abfa3f1 100644 --- a/types/node/node-tests/test.ts +++ b/types/node/node-tests/test.ts @@ -853,15 +853,12 @@ test("mocks a module", (t) => { // module specifier as a string // $ExpectType MockModuleContext const mock = t.mock.module("node:readline", { - namedExports: { - fn() { - return 42; - }, - }, - defaultExport: { + exports: { + default: class Exported {}, foo() { - return "bar"; + return 42; }, + bar: 42, }, cache: true, }); diff --git a/types/node/package.json b/types/node/package.json index 529656eb1b5f0c..0558ddd3943238 100644 --- a/types/node/package.json +++ b/types/node/package.json @@ -1,7 +1,7 @@ { "private": true, "name": "@types/node", - "version": "25.8.9999", + "version": "25.9.9999", "nonNpm": "conflict", "nonNpmDescription": "Node.js", "projects": [ diff --git a/types/node/process.d.ts b/types/node/process.d.ts index 501997c937a066..00ab94e16b367f 100644 --- a/types/node/process.d.ts +++ b/types/node/process.d.ts @@ -822,6 +822,28 @@ declare module "node:process" { * @since v0.7.0 */ abort(): never; + /** + * The `process.addUncaughtExceptionCaptureCallback()` function adds a callback + * that will be invoked when an uncaught exception occurs, receiving the exception + * value as its first argument. + * + * Unlike `process.setUncaughtExceptionCaptureCallback()`, this function allows + * multiple callbacks to be registered and does not conflict with the + * [`domain`](https://nodejs.org/docs/latest-v25.x/api/domain.html) module. Callbacks are called in reverse order of registration + * (most recent first). If a callback returns `true`, subsequent callbacks + * and the default uncaught exception handling are skipped. + * + * ```js + * import process from 'node:process'; + * + * process.addUncaughtExceptionCaptureCallback((err) => { + * console.error('Caught exception:', err.message); + * return true; // Indicates exception was handled + * }); + * ``` + * @since v25.9.0 + */ + addUncaughtExceptionCaptureCallback(fn: (err: unknown) => boolean): void; /** * The `process.chdir()` method changes the current working directory of the * Node.js process or throws an exception if doing so fails (for instance, if @@ -1418,9 +1440,11 @@ declare module "node:process" { * method with a non-`null` argument while another capture function is set will * throw an error. * - * Using this function is mutually exclusive with using the deprecated `domain` built-in module. + * To register multiple callbacks that can coexist, use + * `process.addUncaughtExceptionCaptureCallback()` instead. * @since v9.3.0 */ + // TODO: callback parameter should be `unknown` setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void; /** * Indicates whether a callback has been set using {@link setUncaughtExceptionCaptureCallback}. diff --git a/types/node/quic.d.ts b/types/node/quic.d.ts index 7fe6188d187079..71437088b9b4df 100644 --- a/types/node/quic.d.ts +++ b/types/node/quic.d.ts @@ -179,7 +179,7 @@ declare module "node:quic" { * The TLS crypto keys to use for sessions. * @since v23.8.0 */ - keys?: KeyObject | webcrypto.CryptoKey | ReadonlyArray | undefined; + keys?: KeyObject | readonly KeyObject[] | undefined; /** * Specifies the maximum UDP packet payload size. * @since v23.8.0 @@ -653,7 +653,7 @@ declare module "node:quic" { /** * Sends an unreliable datagram to the remote peer, returning the datagram ID. * If the datagram payload is specified as an `ArrayBufferView`, then ownership of - * that view will be transfered to the underlying stream. + * that view will be transferred to the underlying stream. * @since v23.8.0 */ sendDatagram(datagram: string | NodeJS.ArrayBufferView): bigint; diff --git a/types/node/repl.d.ts b/types/node/repl.d.ts index 7481bead57902b..4bb74ec4a257d1 100644 --- a/types/node/repl.d.ts +++ b/types/node/repl.d.ts @@ -86,6 +86,21 @@ declare module "node:repl" { * @default false */ breakEvalOnSigint?: boolean | undefined; + /** + * This function customizes error handling in the REPL. + * It receives the thrown exception as its first argument and must return one + * of the following values synchronously: + * * `'print'` to print the error to the output stream (default behavior). + * * `'ignore'` to skip all remaining error handling. + * * `'unhandled'` to treat the exception as fully unhandled. In this case, + * the error will be passed to process-wide exception handlers, such as + * the `'uncaughtException'` event. + * The `'unhandled'` value may or may not be desirable in situations + * where the `REPLServer` instance has been closed, depending on the particular + * use case. + * @since v25.9.0 + */ + handleError?: ((err: unknown) => "print" | "ignore" | "unhandled") | undefined; } type REPLEval = ( this: REPLServer, diff --git a/types/node/stream/iter.d.ts b/types/node/stream/iter.d.ts new file mode 100644 index 00000000000000..0b77eb3d0b4f2e --- /dev/null +++ b/types/node/stream/iter.d.ts @@ -0,0 +1,298 @@ +declare module "node:stream/iter" { + // Symbols and custom typedefs + const broadcastProtocol: unique symbol; + const drainableProtocol: unique symbol; + const shareProtocol: unique symbol; + const shareSyncProtocol: unique symbol; + const toAsyncStreamable: unique symbol; + const toStreamable: unique symbol; + type Source = + | string + | ArrayBufferLike + | ArrayBufferView + | Iterable + | AsyncIterable + | Streamable + | AsyncStreamable; + type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable | Streamable; + type Transform = StatelessTransformFn | StatefulTransform; + type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform; + type TransformResult = + | string + | ArrayBufferLike + | ArrayBufferView + | Iterable + | AsyncIterable; + type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable; + interface AsyncStreamable { + [toAsyncStreamable](): Source; + } + interface Broadcastable { + [broadcastProtocol](options: BroadcastOptions): Broadcast; + } + interface Drainable { + [drainableProtocol](): Promise | null; + } + interface Shareable { + [shareProtocol](options: ShareOptions): Share; + } + interface Streamable { + [toStreamable](): SyncSource; + } + interface SyncShareable { + [shareSyncProtocol](options: ShareSyncOptions): SyncShare; + } + // IDL dictionaries, enums, typedefs + type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest"; + type ByteReadableStream = AsyncIterable; + type SyncByteReadableStream = Iterable; + interface WriteOptions { + signal?: AbortSignal; + } + interface PushStreamOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + signal?: AbortSignal; + } + interface PullOptions { + signal?: AbortSignal; + } + interface PipeToOptions { + signal?: AbortSignal; + preventClose?: boolean; + preventFail?: boolean; + } + interface PipeToSyncOptions { + preventClose?: boolean; + preventFail?: boolean; + } + interface ConsumeOptions { + signal?: AbortSignal; + limit?: number; + } + interface ConsumeSyncOptions { + limit?: number; + } + interface TextConsumeOptions extends ConsumeOptions { + encoding?: string; + } + interface TextConsumeSyncOptions extends ConsumeSyncOptions { + encoding?: string; + } + interface MergeOptions { + signal?: AbortSignal; + } + interface BroadcastOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + signal?: AbortSignal; + } + interface ShareOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + signal?: AbortSignal; + } + interface ShareSyncOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + } + interface DuplexDirectionOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + } + interface DuplexOptions { + highWaterMark?: number; + backpressure?: BackpressurePolicy; + a?: DuplexDirectionOptions; + b?: DuplexDirectionOptions; + signal?: AbortSignal; + } + interface TransformCallbackOptions { + signal: AbortSignal; + } + interface StatelessTransformFn { + (chunks: Uint8Array[] | null, options: TransformCallbackOptions): TransformResult | null; + } + interface SyncStatelessTransformFn { + (chunks: Uint8Array[] | null): SyncTransformResult | null; + } + interface StatefulTransform { + transform( + source: AsyncIterable, + options: TransformCallbackOptions, + ): AsyncIterable; + } + interface SyncStatefulTransform { + transform(source: Iterable): Iterable; + } + // IDL interfaces + interface PushWriter extends Writer, Drainable {} + interface PushStreamResult { + writer: PushWriter; + readable: ByteReadableStream; + } + interface BroadcastWriter extends Writer, Drainable {} + interface BroadcastResult { + writer: BroadcastWriter; + broadcast: Broadcast; + } + interface Writer extends Disposable, AsyncDisposable { + readonly desiredSize: number | null; + write(chunk: Uint8Array | string, options?: WriteOptions): Promise; + writev(chunks: Array, options?: WriteOptions): Promise; + writeSync(chunk: Uint8Array | string): boolean; + writevSync(chunks: Array): boolean; + end(options?: WriteOptions): Promise; + endSync(): number; + fail(reason?: any): void; + } + interface PartialWriter extends Partial { + write(chunk: Uint8Array | string, options?: WriteOptions): Promise; + } + interface SyncWriter extends Disposable { + readonly desiredSize: number | null; + writeSync(chunk: Uint8Array | string): number; + writevSync(chunks: Array): number; + endSync(): number; + fail(reason?: any): void; + } + interface PartialSyncWriter extends Partial { + writeSync(chunk: Uint8Array | string): number; + } + interface Broadcast extends Disposable { + readonly consumerCount: number; + readonly bufferSize: number; + push(...args: any[]): ByteReadableStream; + cancel(reason?: any): void; + } + interface Share extends Disposable { + readonly consumerCount: number; + readonly bufferSize: number; + pull(...args: any[]): ByteReadableStream; + cancel(reason?: any): void; + } + interface SyncShare extends Disposable { + readonly consumerCount: number; + readonly bufferSize: number; + pull(...args: any): SyncByteReadableStream; + cancel(reason?: any): void; + } + interface DuplexChannel extends AsyncDisposable { + readonly writer: Writer; + readonly readable: ByteReadableStream; + close(): Promise; + } + // Push stream creation + function push(...transforms: Transform[]): PushStreamResult; + function push(...args: [...transforms: Transform[], options: PushStreamOptions]): PushStreamResult; + // Stream factories + function from(input: Source): ByteReadableStream; + function fromSync(input: SyncSource): SyncByteReadableStream; + // Pull pipelines + function pull(source: Source, ...transforms: Transform[]): ByteReadableStream; + function pull( + source: Source, + ...args: [...transforms: Transform[], options: PullOptions] + ): ByteReadableStream; + function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream; + // Pipe operations + function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise; + function pipeTo(source: Source, ...args: [...transforms: Transform[], writer: PartialWriter]): Promise; + function pipeTo( + source: Source, + ...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions] + ): Promise; + function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number; + function pipeToSync( + source: SyncSource, + ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter] + ): number; + function pipeToSync( + source: SyncSource, + ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions] + ): number; + // Consumers + function bytes(source: Source, options?: ConsumeOptions): Promise; + function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array; + function text(source: Source, options?: TextConsumeOptions): Promise; + function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string; + function arrayBuffer(source: Source, options?: ConsumeOptions): Promise; + function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer; + function array(source: Source, options?: ConsumeOptions): Promise; + function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[]; + // Utilities + function tap(callback: StatelessTransformFn): StatelessTransformFn; + function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn; + function merge(...sources: Source[]): ByteReadableStream; + function merge(...args: [...sources: Source[], options: MergeOptions]): ByteReadableStream; + function ondrain(drainable: any): Promise | null; + // Multi-consumer + function broadcast(options?: BroadcastOptions): BroadcastResult; + function share(source: Source, options?: ShareOptions): Share; + function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare; + // Duplex + function duplex(options?: DuplexOptions): [DuplexChannel, DuplexChannel]; + // Node.js-specific extensions + namespace Broadcast { + /** + * Create a `Broadcast` from an existing source. The source is consumed + * automatically and pushed to all subscribers. + * @since v25.9.0 + * @param options Same as `broadcast()`. + */ + function from( + input: ByteReadableStream | SyncByteReadableStream | Broadcastable, + options?: BroadcastOptions, + ): BroadcastResult; + } + namespace Share { + /** + * Create a `Share` from an existing source. + * @since v25.9.0 + * @param options Same as `share()`. + */ + function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share; + } + namespace SyncShare { + /** + * @since v25.9.0 + */ + function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare; + } + namespace Stream { + export { + array, + arrayBuffer, + arrayBufferSync, + arraySync, + broadcast, + broadcastProtocol, + bytes, + bytesSync, + drainableProtocol, + duplex, + from, + fromSync, + merge, + ondrain, + pipeTo, + pipeToSync, + pull, + pullSync, + push, + share, + shareProtocol, + shareSync, + shareSyncProtocol, + tap, + tapSync, + text, + textSync, + toAsyncStreamable, + toStreamable, + }; + } +} +declare module "stream/iter" { + export * from "node:stream/iter"; +} diff --git a/types/node/test.d.ts b/types/node/test.d.ts index 18f45b39375a2a..0ad8b60c29e2ac 100644 --- a/types/node/test.d.ts +++ b/types/node/test.d.ts @@ -1479,19 +1479,40 @@ declare module "node:test" { */ cache?: boolean | undefined; /** - * The value to use as the mocked module's default export. - * - * If this value is not provided, ESM mocks do not include a default export. - * If the mock is a CommonJS or builtin module, this setting is used as the value of `module.exports`. - * If this value is not provided, CJS and builtin mocks use an empty object as the value of `module.exports`. + * Optional mocked exports. The `default` property, if + * provided, is used as the mocked module's default export. All other own + * enumerable properties are used as named exports. + * **This option cannot be used with `defaultExport` or `namedExports`.** + * * If the mock is a CommonJS or builtin module, `exports.default` is used as + * the value of `module.exports`. + * * If `exports.default` is not provided for a CommonJS or builtin mock, + * `module.exports` defaults to an empty object. + * * If named exports are provided with a non-object default export, the mock + * throws an exception when used as a CommonJS or builtin module. + */ + exports?: object | undefined; + /** + * An optional value used as the mocked module's default + * export. If this value is not provided, ESM mocks do not include a default + * export. If the mock is a CommonJS or builtin module, this setting is used as + * the value of `module.exports`. If this value is not provided, CJS and builtin + * mocks use an empty object as the value of `module.exports`. + * **This option cannot be used with `options.exports`.** + * This option is deprecated and will be removed in a later version. + * Prefer `options.exports.default`. + * @deprecated */ defaultExport?: any; /** - * An object whose keys and values are used to create the named exports of the mock module. - * - * If the mock is a CommonJS or builtin module, these values are copied onto `module.exports`. - * Therefore, if a mock is created with both named exports and a non-object default export, - * the mock will throw an exception when used as a CJS or builtin module. + * An optional object whose keys and values are used to + * create the named exports of the mock module. If the mock is a CommonJS or + * builtin module, these values are copied onto `module.exports`. Therefore, if a + * mock is created with both named exports and a non-object default export, the + * mock will throw an exception when used as a CJS or builtin module. + * **This option cannot be used with `options.exports`.** + * This option is deprecated and will be removed in a later version. + * Prefer `options.exports`. + * @deprecated */ namedExports?: object | undefined; } @@ -1666,14 +1687,19 @@ declare module "node:test" { * [`--experimental-test-module-mocks`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--experimental-test-module-mocks) * command-line flag. * + * **Note**: [module customization hooks](https://nodejs.org/docs/latest-v25.x/api/module.html#customization-hooks) registered via the **synchronous** API effect resolution of + * the `specifier` provided to `mock.module`. Customization hooks registered via the **asynchronous** + * API are currently ignored (because the test runner's loader is synchronous, and node does not + * support multi-chain / cross-chain loading). + * * The following example demonstrates how a mock is created for a module. * * ```js * test('mocks a builtin module in both module systems', async (t) => { - * // Create a mock of 'node:readline' with a named export named 'fn', which + * // Create a mock of 'node:readline' with a named export named 'foo', which * // does not exist in the original 'node:readline' module. * const mock = t.mock.module('node:readline', { - * namedExports: { fn() { return 42; } }, + * exports: { foo: () => 42 }, * }); * * let esmImpl = await import('node:readline'); diff --git a/types/node/ts5.6/index.d.ts b/types/node/ts5.6/index.d.ts index a157660109376b..c088541c099655 100644 --- a/types/node/ts5.6/index.d.ts +++ b/types/node/ts5.6/index.d.ts @@ -97,6 +97,7 @@ /// /// /// +/// /// /// /// @@ -115,3 +116,4 @@ /// /// /// +/// diff --git a/types/node/ts5.7/index.d.ts b/types/node/ts5.7/index.d.ts index 32c541ba0b07f5..2510b2ed66c46d 100644 --- a/types/node/ts5.7/index.d.ts +++ b/types/node/ts5.7/index.d.ts @@ -97,6 +97,7 @@ /// /// /// +/// /// /// /// @@ -115,3 +116,4 @@ /// /// /// +/// diff --git a/types/node/vm.d.ts b/types/node/vm.d.ts index b4591fa1f5562a..963078cadd9d6e 100644 --- a/types/node/vm.d.ts +++ b/types/node/vm.d.ts @@ -232,11 +232,12 @@ declare module "node:vm" { * * 1. Creates a new context. * 2. If `contextObject` is an object, contextifies it with the new context. - * If `contextObject` is undefined, creates a new object and contextifies it. + * If `contextObject` is undefined, creates a new object and contextifies it. * If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything. - * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code - * does not have access to the scope in which this method is called. - * 4. Returns the result. + * 3. Compiles the code as a `vm.Script` + * 4. Runs the compiled code within the created context. The code does not have access to the scope in + * which this method is called. + * 5. Returns the result. * * The following example compiles code that sets a global variable, then executes * the code multiple times in different contexts. The globals are set on and diff --git a/types/node/zlib/iter.d.ts b/types/node/zlib/iter.d.ts new file mode 100644 index 00000000000000..085bea541ab94a --- /dev/null +++ b/types/node/zlib/iter.d.ts @@ -0,0 +1,131 @@ +declare module "node:zlib/iter" { + import { StatefulTransform, SyncStatefulTransform } from "node:stream/iter"; + interface BrotliOptions { + chunkSize?: number | undefined; + params?: { [key: number]: number | boolean } | undefined; + dictionary?: NodeJS.ArrayBufferView | undefined; + } + interface ZlibOptions { + chunkSize?: number | undefined; + windowBits?: number | undefined; + dictionary?: NodeJS.ArrayBufferView | undefined; + } + interface ZlibCompressionOptions extends ZlibOptions { + level?: number | undefined; + memLevel?: number | undefined; + strategy?: number | undefined; + } + interface ZstdOptions { + chunkSize?: number | undefined; + params?: { [key: number]: number | boolean } | undefined; + dictionary?: NodeJS.ArrayBufferView | undefined; + } + interface ZstdCompressionOptions extends ZstdOptions { + pledgedSrcSize?: number | undefined; + } + /** + * Create a Brotli compression transform. Output is compatible with + * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressBrotli(options?: BrotliOptions): StatefulTransform; + /** + * Create a Brotli compression transform. Output is compatible with + * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressBrotliSync(options?: BrotliOptions): SyncStatefulTransform; + /** + * Create a deflate compression transform. Output is compatible with + * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressDeflate(options?: ZlibCompressionOptions): StatefulTransform; + /** + * Create a deflate compression transform. Output is compatible with + * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressDeflateSync(options?: ZlibCompressionOptions): SyncStatefulTransform; + /** + * Create a gzip compression transform. Output is compatible with `zlib.gunzip()` + * and `decompressGzip()`/`decompressGzipSync()`. + * @returns A stateful transform. + */ + function compressGzip(options?: ZlibCompressionOptions): StatefulTransform; + /** + * Create a gzip compression transform. Output is compatible with `zlib.gunzip()` + * and `decompressGzip()`/`decompressGzipSync()`. + * @returns A stateful transform. + */ + function compressGzipSync(options?: ZlibCompressionOptions): SyncStatefulTransform; + /** + * Create a Zstandard compression transform. Output is compatible with + * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressZstd(options?: ZstdCompressionOptions): StatefulTransform; + /** + * Create a Zstandard compression transform. Output is compatible with + * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. + * @since v25.9.0 + * @returns A stateful transform. + */ + function compressZstdSync(options?: ZstdCompressionOptions): SyncStatefulTransform; + /** + * Create a Brotli decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressBrotli(options?: BrotliOptions): StatefulTransform; + /** + * Create a Brotli decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressBrotliSync(options?: BrotliOptions): SyncStatefulTransform; + /** + * Create a deflate decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressDeflate(options?: ZlibOptions): StatefulTransform; + /** + * Create a deflate decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressDeflateSync(options?: ZlibOptions): SyncStatefulTransform; + /** + * Create a gzip decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressGzip(options?: ZlibOptions): StatefulTransform; + /** + * Create a gzip decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressGzipSync(options?: ZlibOptions): SyncStatefulTransform; + /** + * Create a Zstandard decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressZstd(options?: ZstdOptions): StatefulTransform; + /** + * Create a Zstandard decompression transform. + * @since v25.9.0 + * @returns A stateful transform. + */ + function decompressZstdSync(options?: ZstdOptions): SyncStatefulTransform; +} +declare module "zlib/iter" { + export * from "node:zlib/iter"; +} From 4fe75cba055219d8c2688ee8c51ac5866f3ca5fc Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 18 May 2026 09:01:19 -0700 Subject: [PATCH 2/3] [jquery.pin] mark as non-npm (#75018) --- types/jquery.pin/package.json | 2 ++ 1 file changed, 2 insertions(+) diff --git a/types/jquery.pin/package.json b/types/jquery.pin/package.json index 0d4c05ca70f023..d1aca02078f50e 100644 --- a/types/jquery.pin/package.json +++ b/types/jquery.pin/package.json @@ -2,6 +2,8 @@ "private": true, "name": "@types/jquery.pin", "version": "1.0.9999", + "nonNpm": true, + "nonNpmDescription": "jquery.pin", "projects": [ "https://github.com/webpop/jquery.pin" ], From b3264e733dc7ff6f3ef5a8b7cc8aabd7fe9a9c8b Mon Sep 17 00:00:00 2001 From: Ian Gilman Date: Mon, 18 May 2026 09:57:08 -0700 Subject: [PATCH 3/3] =?UTF-8?q?=F0=9F=A4=96=20Merge=20PR=20#75010=20Removi?= =?UTF-8?q?ng=20openseadragon=20as=20it=20now=20bundles=20its=20own=20type?= =?UTF-8?q?s=20by=20@iangilman?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- notNeededPackages.json | 4 + types/openseadragon/.eslintrc.json | 5 - types/openseadragon/.npmignore | 5 - types/openseadragon/index.d.ts | 1917 -------------------- types/openseadragon/openseadragon-tests.ts | 244 --- types/openseadragon/package.json | 41 - types/openseadragon/tsconfig.json | 21 - 7 files changed, 4 insertions(+), 2233 deletions(-) delete mode 100644 types/openseadragon/.eslintrc.json delete mode 100644 types/openseadragon/.npmignore delete mode 100644 types/openseadragon/index.d.ts delete mode 100644 types/openseadragon/openseadragon-tests.ts delete mode 100644 types/openseadragon/package.json delete mode 100644 types/openseadragon/tsconfig.json diff --git a/notNeededPackages.json b/notNeededPackages.json index fd62f8d997937e..5ed19ae673bb75 100644 --- a/notNeededPackages.json +++ b/notNeededPackages.json @@ -5009,6 +5009,10 @@ "libraryName": "openpgp", "asOfVersion": "5.0.0" }, + "openseadragon": { + "libraryName": "openseadragon", + "asOfVersion": "6.0.0" + }, "opn": { "libraryName": "opn", "asOfVersion": "5.5.0" diff --git a/types/openseadragon/.eslintrc.json b/types/openseadragon/.eslintrc.json deleted file mode 100644 index 0f7b7412939420..00000000000000 --- a/types/openseadragon/.eslintrc.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "rules": { - "@typescript-eslint/no-empty-interface": "off" - } -} diff --git a/types/openseadragon/.npmignore b/types/openseadragon/.npmignore deleted file mode 100644 index 93e307400a5456..00000000000000 --- a/types/openseadragon/.npmignore +++ /dev/null @@ -1,5 +0,0 @@ -* -!**/*.d.ts -!**/*.d.cts -!**/*.d.mts -!**/*.d.*.ts diff --git a/types/openseadragon/index.d.ts b/types/openseadragon/index.d.ts deleted file mode 100644 index c77aca7bc7ed6f..00000000000000 --- a/types/openseadragon/index.d.ts +++ /dev/null @@ -1,1917 +0,0 @@ -declare namespace OpenSeadragon { - class Browser { - vendor: BROWSERS; - version: number; - alpha: boolean; - } - - enum BROWSERS { - UNKNOWN = 0, - IE = 1, - FIREFOX = 2, - SAFARI = 3, - CHROME = 4, - OPERA = 5, - EDGE = 6, - CHROMEEDGE = 7, - } - - enum ButtonState { - REST, - GROUP, - HOVER, - DOWN, - } - - enum ControlAnchor { - NONE, - TOP_LEFT, - TOP_RIGHT, - BOTTOM_LEFT, - BOTTOM_RIGHT, - ABSOLUTE, - } - - const DEFAULT_SETTINGS: Options; - - const fullScreenApi: { - supportsFullScreen: boolean; - isFullScreen: () => boolean; - getFullScreenElement: () => HTMLElement; - requestFullScreen: () => void; - exitFullScreen: () => void; - cancelFullScreen: () => void; - fullScreenEventName: string; - fullScreenErrorEventName: string; - }; - - enum OverlayPlacement { - CENTER, - TOP_LEFT, - TOP, - TOP_RIGHT, - RIGHT, - BOTTOM_RIGHT, - BOTTOM, - BOTTOM_LEFT, - LEFT, - } - - enum OverlayRotationMode { - NO_ROTATION, - EXACT, - BOUNDING_BOX, - } - - let pixelDensityRatio: number; - - enum Placement { - CENTER, - TOP_LEFT, - TOP, - TOP_RIGHT, - RIGHT, - BOTTOM_RIGHT, - BOTTOM, - BOTTOM_LEFT, - LEFT, - } - - let supportsCanvas: boolean; - - let version: { - versionStr: string; - major: number; - minor: number; - revision: number; - }; - - function addClass(element: Element | string, className: string): void; - - function addEvent( - element: Element | string, - eventName: string, - handler: (event: Event) => void, - useCapture?: boolean | { capture?: boolean; passive?: boolean; once?: boolean }, - ): void; - - function cancelEvent(event?: OSDEvent): void; - - function capitalizeFirstLetter(value: string): string; - - function createCallback(object: object, method: (...args: any[]) => void, ...args: any[]): (...args: any[]) => void; - - function delegate(object: object, method: (...args: any[]) => void): (object: any, ...args: any[]) => void; // REVIEW: unsure of return type - - function eventIsCanceled(event: OSDEvent): boolean; - - function extend(): any; - - function getCssPropertyWithVendorPrefix(property: string): string; - - function getElement(element: string | Element): HTMLElement; - - function getElementOffset(element: Element | string): Point; - - function getElementPosition(element: Element | string): Point; - - function getElementSize(element: Element | string): Point; - - function getElementStyle(element: Element | string): CSSStyleDeclaration; - - function getViewer(element: string | Element): Viewer; - - function getMousePosition(event?: OSDEvent): Point; - - function getPageScroll(): Point; - - function getString(property: string): string; - - function getUrlParameter(key: string): string; - - function getWindowSize(): Point; - - function imageFormatSupported(extension?: string): boolean; - - function indexOf(array: any[], searchElement: object, fromIndex?: number): number; - - // (missing jquery functions) - - function makeAjaxRequest(options: { - url: string; - success: (obj: object) => void; - error: (obj: object) => void; - headers: object; - responseType: string; - withCredentials?: boolean | undefined; - }): XMLHttpRequest; - - function makeCenteredNode(element: Element | string): HTMLElement; - - function makeNeutralElement(tagName: string): HTMLElement; - - function makeTransparentImage(src: string): HTMLElement; - - function normalizeEventListenerOptions( - options: boolean | { capture?: boolean; passive?: boolean; once?: boolean }, - ): string; - - function now(): number; - - function parseJSON(string: string): object; - - function parseXml(string: string): Document; - - function pointInElement(element: Element | string, point: Point): boolean; - - function positiveModulo(number: number, modulo: number): number; - - function removeClass(element: Element | string, className: string): void; - - function removeEvent( - element: Element | string, - eventName: string, - handler: EventHandler, - useCapture?: boolean | { capture?: boolean }, - ): void; - - function setElementOpacity(element: Element | string, opacity: number, usesAlpha?: boolean): void; - - function setElementPointerEvents(element: Element | string, value: string): void; - - function setElementPointerEventsNone(element: Element | string): void; - - function setElementTouchActionNone(element: Element | string): void; - - function setImageFormatsSupported(formats: { - bmp?: boolean; - jpeg?: boolean; - jpg?: boolean; - png?: boolean; - tif?: boolean; - wdp?: boolean; - }): void; - - function setPageScroll(point: Point): void; - - function setString(property: string, value: string): void; - - function stopEvent(event?: OSDEvent): void; - - interface GestureSettings { - scrollToZoom?: boolean | undefined; - clickToZoom?: boolean | undefined; - dblClickToZoom?: boolean | undefined; - dragToPan?: boolean | undefined; - pinchToZoom?: boolean | undefined; - flickEnabled?: boolean | undefined; - flickMinSpeed?: number | undefined; - flickMomentum?: number | undefined; - } - - interface NavImagesValues { - REST: string; - GROUP: string; - HOVER: string; - DOWN: string; - } - - interface NavImages { - zoomIn: NavImagesValues; - zoomOut: NavImagesValues; - home: NavImagesValues; - fullpage: NavImagesValues; - rotateleft: NavImagesValues; - rotateright: NavImagesValues; - flip: NavImagesValues; - previous: NavImagesValues; - next: NavImagesValues; - } - - type DrawerType = "html" | "canvas" | "webgl"; - type DrawerConstructor = new(options: TDrawerOptions) => DrawerBase; - - interface Options { - id?: string | undefined; - element?: HTMLElement | undefined; - tileSources?: - | string - | TileSourceOptions - | { - type: string; - levels?: Array<{ - url: string; - height: number; - width: number; - }>; - } - | { - Image: { - xmlns?: string | undefined; - Url: string; - Format: string; - Overlap: string; - TileSize: string; - Size: { - Width: string; - Height: string; - }; - }; - } - | Array; - tabIndex?: number | undefined; - overlays?: any[] | undefined; - xmlPath?: string; - prefixUrl?: string | undefined; - navImages?: NavImages | undefined; - debugMode?: boolean | undefined; - debugGridColor?: string | undefined; - silenceMultiImageWarnings?: boolean; - blendTime?: number | undefined; - alwaysBlend?: boolean | undefined; - autoHideControls?: boolean | undefined; - immediateRender?: boolean | undefined; - defaultZoomLevel?: number | undefined; - drawer?: DrawerType | DrawerConstructor | Array; - drawerOptions?: DrawerOptions; - opacity?: number | undefined; - preload?: boolean | undefined; - compositeOperation?: - | "source-over" - | "source-atop" - | "source-in" - | "source-out" - | "destination-over" - | "destination-atop" - | "destination-in" - | "destination-out" - | "lighter" - | "copy" - | "xor" - | "multiply" - | "screen" - | "overlay" - | "darken" - | "lighten" - | "color-dodge" - | "color-burn" - | "hard-light" - | "soft-light" - | "difference" - | "exclusion" - | "hue" - | "saturation" - | "color" - | "luminosity" - | undefined; - imageSmoothingEnabled?: boolean; - placeholderFillStyle?: string | CanvasGradient | CanvasPattern | undefined; - subPixelRoundingForTransparency?: object; - degrees?: number | undefined; - flipped?: boolean | undefined; - overlayPreserveContentDirection?: boolean; - minZoomLevel?: number | undefined; - maxZoomLevel?: number | undefined; - homeFillsViewer?: boolean | undefined; - panHorizontal?: boolean | undefined; - panVertical?: boolean | undefined; - constrainDuringPan?: boolean | undefined; - wrapHorizontal?: boolean | undefined; - wrapVertical?: boolean | undefined; - minZoomImageRatio?: number | undefined; - maxZoomPixelRatio?: number | undefined; - smoothTileEdgesMinZoom?: number | undefined; - iOSDevice?: boolean | undefined; - autoResize?: boolean | undefined; - preserveImageSizeOnResize?: boolean | undefined; - minScrollDeltaTime?: number | undefined; - rotationIncrement?: number; - maxTilesPerFrame?: number; - pixelsPerWheelLine?: number | undefined; - pixelsPerArrowPress?: number | undefined; - visibilityRatio?: number | undefined; - viewportMargins?: object | undefined; - imageLoaderLimit?: number | undefined; - clickTimeThreshold?: number | undefined; - clickDistThreshold?: number | undefined; - dblClickTimeThreshold?: number | undefined; - dblClickDistThreshold?: number | undefined; - springStiffness?: number | undefined; - animationTime?: number | undefined; - gestureSettingsMouse?: GestureSettings | undefined; - gestureSettingsTouch?: GestureSettings | undefined; - gestureSettingsPen?: GestureSettings | undefined; - gestureSettingsUnknown?: GestureSettings | undefined; - zoomPerClick?: number | undefined; - zoomPerScroll?: number | undefined; - zoomPerDblClickDrag?: number; - zoomPerSecond?: number | undefined; - showNavigator?: boolean | undefined; - navigatorElement?: HTMLElement; - navigatorId?: string | undefined; - navigatorPosition?: "TOP_LEFT" | "TOP_RIGHT" | "BOTTOM_LEFT" | "BOTTOM_RIGHT" | "ABSOLUTE" | undefined; - navigatorSizeRatio?: number | undefined; - navigatorMaintainSizeRatio?: boolean | undefined; - navigatorTop?: number | string | undefined; - navigatorLeft?: number | string | undefined; - navigatorHeight?: number | string | undefined; - navigatorWidth?: number | string | undefined; - navigatorAutoResize?: boolean | undefined; - navigatorAutoFade?: boolean | undefined; - navigatorRotate?: boolean | undefined; - navigatorBackground?: string | undefined; - navigatorOpacity?: number | undefined; - navigatorBorderColor?: string | undefined; - navigatorDisplayRegionColor?: string | undefined; - controlsFadeDelay?: number | undefined; - controlsFadeLength?: number | undefined; - maxImageCacheCount?: number | undefined; - timeout?: number | undefined; - tileRetryMax?: number; - tileRetryDelay?: number; - /** - * @deprecated Use the `drawer` option to specify preferred renderer. - */ - useCanvas?: boolean | undefined; - minPixelRatio?: number | undefined; - mouseNavEnabled?: boolean | undefined; - showNavigationControl?: boolean | undefined; - navigationControlAnchor?: ControlAnchor | undefined; - showZoomControl?: boolean | undefined; - showHomeControl?: boolean | undefined; - showFullPageControl?: boolean | undefined; - showRotationControl?: boolean | undefined; - showFlipControl?: boolean | undefined; - showSequenceControl?: boolean | undefined; - sequenceControlAnchor?: ControlAnchor | undefined; - navPrevNextWrap?: boolean | undefined; - toolbar?: string | HTMLElement | undefined; - zoomInButton?: string | Element | undefined; - zoomOutButton?: string | Element | undefined; - homeButton?: string | Element | undefined; - fullPageButton?: string | Element | undefined; - rotateLeftButton?: string | Element | undefined; - rotateRightButton?: string | Element | undefined; - previousButton?: string | Element | undefined; - nextButton?: string | Element | undefined; - sequenceMode?: boolean | undefined; - /** - * If sequenceMode is true, display this page initially. - * @default 0 - */ - initialPage?: number | undefined; - preserveViewport?: boolean | undefined; - preserveOverlays?: boolean | undefined; - showReferenceStrip?: boolean | undefined; - referenceStripScroll?: string | undefined; - referenceStripElement?: HTMLElement | undefined; - referenceStripHeight?: number | undefined; - referenceStripWidth?: number | undefined; - referenceStripPosition?: string | undefined; - referenceStripSizeRatio?: number | undefined; - collectionMode?: boolean | undefined; - collectionRows?: number | undefined; - collectionColumns?: number | undefined; - collectionLayout?: "horizontal" | "vertical" | undefined; - collectionTileSize?: number | undefined; - collectionTileMargin?: number | undefined; - crossOriginPolicy?: "Anonymous" | "use-credentials" | false | undefined; - ajaxWithCredentials?: boolean | undefined; - loadTilesWithAjax?: boolean | undefined; - ajaxHeaders?: object | undefined; - splitHashDataForPost?: boolean; - } - - interface TileSourceOptions { - url?: string | undefined; - referenceStripThumbnailUrl?: string | undefined; - success?: ((event: Event) => void) | undefined; - ajaxWithCredentials?: boolean | undefined; - ajaxHeaders?: object | undefined; - splitHashDataForPost?: boolean; - width?: number | undefined; - height?: number | undefined; - tileSize?: number | undefined; - tileWidth?: number | undefined; - tileHeight?: number | undefined; - tileOverlap?: number | undefined; - minLevel?: number | undefined; - maxLevel?: number | undefined; - getTileUrl?: ((l: number, x: number, y: number) => string) | undefined; - } - - class Button extends EventSource { - currentState: ButtonState; - element: HTMLElement; - fadeDelay: number; - fadeLength: number; - tracker: MouseTracker; - - constructor(options: { - userData?: string | undefined; - element?: Element | undefined; - tooltip?: string | undefined; - srcRest?: string | undefined; - srcGroup?: string | undefined; - srcHover?: string | undefined; - srcDown?: string | undefined; - fadeDelay?: number | undefined; - fadeLength?: number | undefined; - onPress?: EventHandler | undefined; - onRelease?: EventHandler | undefined; - onClick?: EventHandler | undefined; - onEnter?: EventHandler | undefined; - onExit?: EventHandler | undefined; - onFocus?: EventHandler | undefined; - onBlur?: EventHandler | undefined; - }); - disable(): void; - enable(): void; - notifyGroupEnter(): void; - notifyGroupExit(): void; - destroy(): void; - } - - class ButtonGroup { - buttons: Button[]; - element: HTMLElement; - tracker: MouseTracker; - - constructor(options: { buttons: Button[]; element?: Element | undefined }); - - addButton(button: Button): void; - destroy(): void; - } - - interface TControlOptions { - anchor?: ControlAnchor | undefined; - attachToViewer?: boolean | undefined; - autoFade?: boolean | undefined; - } - - class Control { - anchor: ControlAnchor; - autoFade: boolean; - container: HTMLElement; - element: HTMLElement; - wrapper: HTMLElement; - - constructor(element: Element, options: TControlOptions, container: Element); - - destroy(): void; - isVisible(): boolean; - setOpacity(opacity: number): void; - setVisible(visible: boolean): void; - } - - class ControlDock { - constructor(options: object); - - addControl(element: string | Element, controlOptions: TControlOptions): void; - areControlsEnabled(): boolean; - clearControls(): ControlDock; - removeControl(element: Control): ControlDock; - setControlsEnabled(enabled: boolean): ControlDock; - } - - class DisplayRect extends Rect { - maxLevel: number; - minLevel: number; - - constructor(x: number, y: number, width: number, height: number, minLevel: number, maxLevel: number); - } - - class Drawer { - canvas: HTMLCanvasElement; - container: HTMLElement; - context: CanvasRenderingContext2D | null; - // element : Element; // Deprecated - - constructor(options: { - viewer: Viewer; - viewport: Viewport; - element: HTMLElement; - debugGridColor?: string | undefined; - }); - - blendSketch(options: { - opacity: number; - scale?: number | undefined; - translate?: Point | undefined; - compositeOperation?: string | undefined; - bounds?: Rect | undefined; - }): void; - canRotate(): boolean; - clear(): void; - destroy(): void; - drawTile( - tile: Tile, - drawingHandler: (context: CanvasRenderingContext2D, tile: any, rendered: any) => void, // TODO: determine handler parameter types - useSketch: boolean, - scale?: number, - translate?: Point, - ): void; - getCanvasSize(sketch: boolean): Point; - getOpacity(): number; - setOpacity(opacity: number): Drawer; - viewportToDrawerRectangle(rectangle: Rect): Rect; - setImageSmoothingEnabled(imageSmoothingEnabled?: boolean): void; - viewportCoordToDrawerCoord(point: Point): Point; - clipWithPolygons(polygons: Point[][], useSketch?: boolean): void; - } - - class DrawerBase { - constructor(options: { viewer: Viewer; viewport: Viewport; element: HTMLElement }); - static isSupported(): boolean; - canRotate(): boolean; - destroy(): void; - drawDebuggingRect(rect: Rect): void; - getType(): string | undefined; - setImageSmoothingEnabled(imageSmoothingEnabled: boolean): void; - viewportCoordToDrawerCoord(point: Point): Point; - viewportToDrawerRectangle(rectangle: Rect): Rect; - } - - interface TDrawerOptions { - viewer: Viewer; - viewport: Viewport; - element: HTMLElement; - debugGridColor?: number; - } - - class CanvasDrawer extends DrawerBase { - canvas: HTMLCanvasElement; - container: HTMLElement; - - constructor(options: TDrawerOptions); - } - - class DziTileSource extends TileSource { - tilesUrl: string; - fileFormat: string; - displayRects: DisplayRect[]; - - constructor( - width: number | object, - height: number, - tileSize: number, - tileOverlap: number, - tilesUrl: string, - fileFormat: string, - displayRects: DisplayRect[], - ); - } - - class EventSource = any> { - addHandler( - eventName: K, - handler: EventHandler, - userData?: object, - priority?: number, - ): boolean; - addOnceHandler( - eventName: K, - handler: EventHandler, - userData?: object, - times?: number, - priority?: number, - ): boolean; - getHandler(eventName: K): void; - numberOfHandlers(eventName: K): number; - raiseEvent(eventName: K, eventArgs: object): boolean; - removeAllHandlers(eventName: K): boolean; - removeHandler(eventName: K, handler: EventHandler): boolean; - } - - class HTMLDrawer extends DrawerBase { - canvas: HTMLCanvasElement; - container: HTMLElement; - constructor(options: TDrawerOptions); - } - - class IIIFTileSource extends TileSource { - constructor(options: TileSourceOptions & { tileFormat?: string | undefined }); - } - - interface TImageJobOptions { - src?: string; - tile?: Tile; - source?: TileSource; - loadWithAjax?: string; - ajaxHeaders?: Record; - ajaxWithCredentials?: boolean; - crossOriginPolicy?: string; - postData?: string | null; - userData?: any; - abort?(): void; - callback?(): void; - timeout?: number; - tries?: number; - } - - class ImageJob { - data: any; - userData: any; - constructor(options: TImageJobOptions); - finish(data: any, request: XMLHttpRequest, errorMessage: string): void; - start(): void; - } - - class ImageLoader { - constructor(options: { jobLimit?: number | undefined; timeout?: number | undefined }); - - addJob(options: TImageJobOptions): void; - clear(): void; - } - - class ImageTileSource extends TileSource { - constructor(options: { - url: string; - buildPyramid?: boolean | undefined; - crossOriginPolicy?: string | boolean | undefined; - ajaxWithCredentials?: string | boolean | undefined; - }); - _freeupCanvasMemory(): void; - destroy(viewer: Viewer): void; - getContext2D(level: number, x: number, y: number): CanvasRenderingContext2D | null; - } - - class LegacyTileSource extends TileSource { - constructor( - aspectRatio: number, - dimensions: number, - tileSize: number, - tileOverlap: number, - minLevel: number, - maxLevel: number, - levels?: Array<{ - url: string; - width: number; - height: number; - }>, - ); - } - - class Mat3 { - constructor(values: any[]); - multiply(other: Mat3): Mat3; - static makeIdentity(): Mat3; - static makeRotation(angleInRadians: number): Mat3; - static makeScaling(sx: number, sy: number): Mat3; - static makeTranslation(tx: number, ty: number): Mat3; - } - - interface MouseTrackerOptions { - element: HTMLElement | string; - startDisabled?: boolean | undefined; - clickTimeThreshold?: number | undefined; - clickDistThreshold?: number | undefined; - dblClickTimeThreshold?: number | undefined; - dblClickDistThreshold?: number | undefined; - stopDelay?: number | undefined; - preProcessEventHandler?: PreprocessEventHandler | undefined; - contextMenuHandler?: EventHandler | undefined; - enterHandler?: EventHandler | undefined; - /** - * @deprecated use leaveHandler instead - */ - exitHandler?: EventHandler | undefined; - leaveHandler?: EventHandler | undefined; - overHandler?: EventHandler | undefined; - outHandler?: EventHandler | undefined; - pressHandler?: EventHandler | undefined; - nonPrimaryPressHandler?: EventHandler | undefined; - releaseHandler?: EventHandler | undefined; - nonPrimaryReleaseHandler?: EventHandler | undefined; - moveHandler?: EventHandler | undefined; - scrollHandler?: EventHandler | undefined; - clickHandler?: EventHandler | undefined; - dblClickHandler?: EventHandler | undefined; - dragHandler?: EventHandler | undefined; - dragEndHandler?: EventHandler | undefined; - pinchHandler?: EventHandler | undefined; - keyDownHandler?: EventHandler | undefined; - keyUpHandler?: EventHandler | undefined; - keyHandler?: EventHandler | undefined; - focusHandler?: EventHandler | undefined; - blurHandler?: EventHandler | undefined; - userData?: object | undefined; - } - - class MouseTracker { - clickTimeThreshold: number; - clickDistThreshold: number; - dblClickTimeThreshold: number; - dblClickDistThreshold: number; - element: HTMLElement; - - constructor(options: MouseTrackerOptions); - - blurHandler: EventHandler; - clickHandler: EventHandler; - contextMenuHandler: EventHandler; - dblClickHandler: EventHandler; - destroy(): void; - dragEndHandler: EventHandler; - dragHandler: EventHandler; - enterHandler: EventHandler; - /** - * @deprecated use leaveHandler instead - */ - exitHandler: EventHandler; - leaveHandler: EventHandler; - focusHandler: EventHandler; - getActivePointerCount(): number; - getActivePointersListByType(type: string): GesturePointList; - /** - * @deprecated Just use `this.tracking` - */ - isTracking(): boolean; - keyDownHandler: EventHandler; - keyHandler: EventHandler; - keyUpHandler: EventHandler; - moveHandler: EventHandler; - nonPrimaryPressHandler: EventHandler; - nonPrimaryReleaseHandler: EventHandler; - overHandler: EventHandler; - outHandler: EventHandler; - pinchHandler: EventHandler; - pressHandler: EventHandler; - preProcessEventHandler: PreprocessEventHandler; - releaseHandler: EventHandler; - scrollHandler: EventHandler; - setTracking(track: boolean): MouseTracker; - stopHandler: EventHandler; - } - - interface EventProcessInfo { - eventSource: MouseTracker; - originalEvent: Event; - originalTarget: HTMLElement; - eventPhase: EventPhase; - eventType: - | "keydown" - | "keyup" - | "keypress" - | "focus" - | "blur" - | "contextmenu" - | "gotpointercapture" - | "lostpointercapture" - | "pointerenter" - | "pointerleave" - | "pointerover" - | "pointerout" - | "pointerdown" - | "pointerup" - | "pointermove" - | "pointercancel" - | "wheel" - | "click" - | "dblclick"; - pointerType: string; - isEmulated: boolean; - isStoppable: boolean; - isCancelable: boolean; - defaultPrevented: boolean; - preventDefault: boolean; - preventGesture: boolean; - stopPropagation: boolean; - shouldCapture: boolean; - shouldReleaseCapture: boolean; - userData: unknown; - } - - interface GesturePoint { - id: number; - type: string; - captured: boolean; - isPrimary: boolean; - insideElementPressed: boolean; - insideElement: boolean; - speed: number; - direction: number; - contactPos: Point; - contactTime: number; - lastPos: Point; - lastTime: number; - currentPos: Point; - currentTime: number; - } - - class GesturePointList { - buttons: number; - captureCount: number; - clicks: number; - contacts: number; - type: string; - - constructor(type: string); - - add(gesturePoint: GesturePoint): number; - addContact(): void; - asArray(): GesturePoint[]; - getById(id: number): GesturePoint | null; - getByIndex(index: number): GesturePoint | null; - getLength(): number; - getPrimary(): GesturePoint | null; - removeById(id: number): number; - removeContact(): void; - } - - class Navigator extends Viewer { - setFlip(state: boolean): void; - update(viewport?: Viewport): void; - updateSize(): void; - setWidth(width: number | string): void; - setHeight(width: number | string): void; - } - - class OsmTileSource extends TileSource { - constructor(width: number | object, height: number, tileSize: number, tileOverlap: number, tilesUrl: string); - } - - type OnDrawCallback = (position: Point, size: Point, element: Element) => void; - - interface OverlayOptions { - element: HTMLElement; - location: Point | Rect; - placement?: Placement | undefined; - onDraw?: OnDrawCallback | undefined; - checkResize?: boolean | undefined; - width?: number | undefined; - height?: number | undefined; - rotationMode?: OverlayRotationMode | undefined; - } - - class Overlay { - constructor(options: OverlayOptions); - adjust(position: Point, size: Point): void; - destroy(): void; - drawHTML(container: Element): void; - getBounds(viewport: Viewport): Rect; - update(location: Point | Rect | object, placement: Placement): void; - } - - class Point { - x: number; - y: number; - constructor(x?: number, y?: number); - apply(func: (v: number) => number): Point; - clone(): Point; - distanceTo(point: Point): number; - divide(factor: number): Point; - equals(point: Point): boolean; - minus(point: Point): Point; - negate(): Point; - plus(point: Point): Point; - rotate(degrees: number, pivot?: Point): Point; - squaredDistanceTo(point: Point): number; - times(factor: number): Rect; - toString(): string; - } - - class Rect { - x: number; - y: number; - width: number; - height: number; - degrees: number; - constructor(x?: number, y?: number, width?: number, height?: number, degrees?: number); - clone(): Rect; - containsPoint(point: Point, epsilon?: number): boolean; - equals(rectangle: Rect): boolean; - getAspectRatio(): number; - getBottomLeft(): Point; - getBottomRight(): Point; - getBoundingBox(): Rect; - getCenter(): Point; - getIntegerBoundingBox(): Rect; - getSize(): Point; - getTopLeft(): Point; - getTopRight(): Point; - intersection(rect: Rect): Rect; - rotate(degrees: number, pivot?: Rect): Rect; - times(factor: number): Rect; - toString(): string; - translate(delta: Point): Rect; - union(rect: Rect): Rect; - } - - class ReferenceStrip { - constructor(options: object); - setFocus(): void; - update(): void; - } - - interface TSpringObj { - value: number; - time: number; - } - - class Spring { - animationTime: number; - current: TSpringObj; - springStiffness: number; - start: TSpringObj; - target: TSpringObj; - constructor(options: { - springStiffness: number; - animationTime: number; - initial?: number | undefined; - exponential?: boolean | undefined; - }); - isAtTargetValue(): boolean; - resetTo(target: number): void; - shiftBy(delta: number): void; - springTo(target: number): void; - update(): void; - } - - class Tile { - ajaxHeaders: object; - beingDrawn: boolean; - blendStart: number; - bounds: Rect; - cacheKey: string; - context2D: CanvasRenderingContext2D; - element: HTMLElement; - exists: boolean; - flipped: boolean; - hasTransparency: boolean; - /** - * @deprecated use `getImage()` instead - */ - image: object; - imgElement: HTMLImageElement; - isBottomMost: boolean; - isRightMost: boolean; - lastTouchTime: number; - level: number; - loaded: boolean; - loading: boolean; - loadWithAjax: boolean; - opacity: number; - position: Point; - positionedBounds: Rect; - postData: string; - size: Point; - sourceBounds: Rect; - style: string; - /** - * @deprecated use `getUrl()` instead - */ - url: string; - visibility: number; - x: number; - y: number; - - constructor( - level: number, - x: number, - y: number, - bounds: Rect, - exists: boolean, - url: string, - context2D: CanvasRenderingContext2D, - loadWithAjax: boolean, - ajaxHeaders: object, - sourceBounds: Rect, - postData: string, - cacheKey: string, - ); - getCanvasContext(): CanvasRenderingContext2D; - getImage(): object; - drawCanvas( - context: CanvasRenderingContext2D, - drawingHandler: (context: CanvasRenderingContext2D, tile: any, rendered: any) => void, - scale?: number, - translate?: Point, - ): void; - drawHTML(container: Element): void; - getScaleForEdgeSmoothing(): number; - getTranslationForEdgeSmoothing(scale?: number): Point; - getUrl(): string; - toString(): string; - unload(): void; - } - - class TileCache { - constructor(options: { maxImageCacheCount?: number | undefined }); - cacheTile(options: { - tile: Tile; - image: HTMLImageElement; // TODO: check type - tiledImage: TiledImage; - cutoff?: number | undefined; - }): void; - clearTilesFor(tiledImage: TiledImage): void; - numTilesLoaded(): number; - } - - interface TiledImageInitOptions { - source: TileSource; - viewer: Viewer; - tileCache: TileCache; - drawer: Drawer; - imageLoader: ImageLoader; - x?: number | undefined; - y?: number | undefined; - width?: number | undefined; - height?: number | undefined; - fitBounds?: Rect | undefined; - fitBoundsPlacement?: Placement | undefined; - clip?: Rect | undefined; - springStiffness?: number | undefined; - animationTime?: boolean | undefined; - minZoomImageRatio?: number | undefined; - wrapHorizontal?: boolean | undefined; - wrapVertical?: boolean | undefined; - immediateRender?: boolean | undefined; - blendTime?: number | undefined; - alwaysBlend?: boolean | undefined; - minPixelRatio?: number | undefined; - smoothTileEdgesMinZoom?: number | undefined; - iOSDevice?: boolean | undefined; - opacity?: number | undefined; - preload?: boolean | undefined; - compositeOperation?: string | undefined; - debugMode?: boolean | undefined; - placeholderFillStyle?: string | CanvasGradient | CanvasPattern | undefined; - crossOriginPolicy?: string | boolean | undefined; - ajaxWithCredentials?: boolean | undefined; - loadTilesWithAjax?: boolean | undefined; - ajaxHeaders?: object | undefined; - } - - class TiledImage extends EventSource { - source: TileSource; - constructor(options: TiledImageInitOptions); - - destroy(): void; - draw(): void; - fitBounds(bounds: Rect, anchor?: Placement, immediately?: boolean): void; - getBounds(current?: boolean): Rect; - getBoundsNoRotate(current?: boolean): Rect; - getClip(): Rect | null; - getClippedBounds(current?: boolean): Rect; - getCompositeOperation(): string; - getContentSize(): Point; - getDrawArea(): Rect; - getFullyLoaded(): boolean; - getFlip(): boolean; - getOpacity(): number; - getPreload(): boolean; - getRotation(current?: boolean): number; - getSizeInWindowCoordinates(): Point; - getTileBounds(level: number, x: number, y: number): Rect; - getTilesToDraw(): any[]; - imageToViewerElementCoordinates(pixel: Point): Point; - imageToViewportCoordinates(position: Point, current?: boolean): Point; - imageToViewportCoordinates(imageX: number, imageY: number, current?: boolean): Point; - imageToViewportRectangle( - imageX: number, - imageY?: number, - pixelWidth?: number, - pixelHeight?: number, - current?: boolean, - ): Rect; - imageToViewportRectangle(position: Rect, pixelWidth?: number, pixelHeight?: number, current?: boolean): Rect; - - imageToViewportZoom(imageZoom: number): number; - imageToWindowCoordinates(pixel: Point): Point; - needsDraw(): boolean; - redraw(): void; - reset(): void; - resetCroppingPolygons(): void; - setAjaxHeaders(ajaxHeaders: object, propagate?: boolean): void; - setClip(newClip: Rect | null): void; - setCompositeOperation(compositeOperation: string): void; - setCroppingPolygons(polygons: Point[][]): void; - setDrawn(): boolean; - setFlip(flip: boolean): void; - setHeight(height: number, immediately?: boolean): void; - setOpacity(opacity: number): void; - setPosition(position: Point, immediately?: boolean): void; - setPreload(preload: boolean): void; - setRotation(degrees: number, immediately?: boolean): void; - setWidth(width: number, immediately?: boolean): void; - update(viewportChanged: boolean): boolean; - viewerElementToImageCoordinates(pixel: Point): Point; - viewportToImageCoordinates(position: Point, current?: boolean): Point; - viewportToImageCoordinates(viewerX: number, viewerY: number, current?: boolean): Point; - viewportToImageRectangle(position: Rect, current?: boolean): Rect; - viewportToImageRectangle( - viewportX: number, - viewportY: number, - pixelWidth?: number, - pixelHeight?: number, - current?: boolean, - ): Rect; - viewportToImageZoom(viewportZoom: number): number; - windowToImageCoordinates(pixel: Point): Point; - } - - interface ConfigureOptions { - [key: string]: any; - } - - class TileSource extends EventSource { - aspectRatio: number; - dimensions: Point; - maxLevel: number; - minLevel: number; - ready: boolean; - tileOverlap: number; - - constructor(options: TileSourceOptions); - configure(data: string | object | any[] | Document, url: string, postData: string): ConfigureOptions; - createTileCache(cacheObject: object, data: any, tile: Tile): void; - destroyTileCache(cacheObject: object): void; - downloadTileAbort(context: ImageJob): void; - downloadTileStart(context: ImageJob): void; - getClosestLevel(): number; - getImageInfo(url: string): void; - getLevelScale(level: number): number; - getNumTiles(level: number): number; - getPixelRatio(level: number): number; - getTileAjaxHeaders(level: number, x: number, y: number): object; - getTileAtPoint(level: number, point: Point): Tile; - getTileBounds(level: number, x: number, y: number, isSource?: boolean): Rect; - getTileCacheData(cacheObject: object): any; - getTileCacheDataAsContext2D(cacheObject: object): CanvasRenderingContext2D; - getTileCacheDataAsImage(cacheObject: object): HTMLImageElement; - getTileHashKey(level: number, x: number, y: number, url: string, ajaxHeaders: object, postData: any): void; - getTileHeight(level: number): number; - getTilePostData(level: number, x: number, y: number): any; - getTileUrl(level: number, x: number, y: number): string | (() => string); - getTileWidth(level: number): number; - hasTransparency(): boolean; - setMaxLevel(level: number): void; - supports(data: string | object | any[] | Document, url: string): boolean; - tileExists(level: number, x: number, y: number): boolean; - } - - class TmsTileSource extends TileSource { - constructor(width: number, height: number, tileSize: number, tileOverlap: number, tilesUrl: string); - } - - interface ImageOptions { - index?: number | undefined; - replace?: boolean | undefined; - x?: number | undefined; - y?: number | undefined; - width?: number | undefined; - height?: number | undefined; - fitBounds?: Rect | undefined; - fitBoundsPlacement?: Placement | undefined; - clip?: Rect | undefined; - opacity?: number | undefined; - preload?: boolean | undefined; - degrees?: number | undefined; - flipped?: boolean | undefined; - compositeOperation?: string | undefined; - crossOriginPolicy?: string | undefined; - ajaxWithCredentials?: boolean | undefined; - loadTilesWithAjax?: boolean | undefined; - ajaxHeaders?: object | undefined; - success?: ((event: Event) => void) | undefined; - error?: ((error: Error) => void) | undefined; - collectionImmediately?: boolean | undefined; - placeholderFillStyle?: string | CanvasGradient | CanvasPattern | undefined; - } - - interface TiledImageOptions extends ImageOptions { - tileSource: string | object; - } - - interface SimpleImageOptions extends ImageOptions { - url: string; - } - - class Viewer { - canvas: HTMLCanvasElement; - container: HTMLElement; - drawer: Drawer; - element: HTMLElement; - initialPage: number; - navigator: Navigator; - viewport: Viewport; - world: World; - referenceStrip: ReferenceStrip; - - constructor(options: Options); - _cancelPendingImages(): void; - addButton(button: Button): void; - addOverlay( - element: Element | string | OverlayOptions, - location?: Point | Rect, - placement?: Placement, - onDraw?: (element: HTMLElement, location: Location, placement: Placement) => void, - ): Viewer; - addReferenceStrip(): void; - addSimpleImage(options: SimpleImageOptions): void; - addTiledImage(options: TiledImageOptions): void; - bindSequenceControls(): Viewer; - bindStandardControls(): Viewer; - clearOverlays(): Viewer; - close(): Viewer; - currentPage(): number; - destroy(): void; - forceRedraw(): Viewer; - forceResize(): void; - gestureSettingsByDeviceType(type: string): GestureSettings; - getOverlayById(element: Element | string): Overlay; - goToNextPage(): void; - goToPage(page: number): Viewer; - goToPreviousPage(): void; - isFullPage(): boolean; - isFullScreen(): boolean; - isMouseNavEnabled(): boolean; - isOpen(): boolean; - isVisible(): boolean; - open(tileSources: string | object | TileSource[], initialPage?: number): Viewer; - removeOverlay(overlay: Element | string): Viewer; - removeReferenceStrip(): void; - requestDrawer(drawerCandidate: string | DrawerBase, options: { - mainDrawer?: boolean; - redrawImmediately?: boolean; - drawerOptions: object; - }): object | boolean; - setAjaxHeaders(ajaxHeaders: object, propagate?: boolean): void; - setDebugMode(debug: boolean): Viewer; - setFullPage(fullScreen: boolean): Viewer; - setFullScreen(fullScreen: boolean): Viewer; - setMouseNavEnabled(enabled: boolean): Viewer; - setVisible(visible: boolean): Viewer; - updateOverlay(element: Element | string, location: Point | Rect, placement?: Placement): Viewer; - } - - interface Viewer extends ControlDock, EventSource {} - - interface ViewportOptions { - margins: object; - springStiffness?: number; - animationTime?: number; - minZoomImageRatio?: number; - maxZoomPixelRatio?: number; - visibilityRatio?: number; - wrapHorizontal?: boolean; - wrapVertical?: boolean; - defaultZoomLevel?: number; - minZoomLevel?: number; - maxZoomLevel?: number; - degrees?: number; - homeFillsViewer?: boolean; - silenceMultiImageWarnings?: boolean; - } - - class Viewport { - constructor(options: ViewportOptions); - - applyConstraints(immediately?: boolean): Viewport; - deltaPixelsFromPoints(deltaPoints: Point, current?: boolean): Point; - deltaPixelsFromPointsNoRotate(deltaPoints: Point, current?: boolean): Point; - deltaPointsFromPixels(deltaPoints: Point, current?: boolean): Point; - deltaPointsFromPixelsNoRotate(deltaPoints: Point, current?: boolean): Point; - ensureVisible(immediately?: boolean): Viewport; - fitBounds(bounds: Rect, immediately?: boolean): Viewport; - fitBoundsWithConstraints(bounds: Rect, immediately?: boolean): Viewport; - fitHorizontally(immediately?: boolean): Viewport; - fitVertically(immediately?: boolean): Viewport; - getAspectRatio(): number; - getBounds(current?: boolean): Rect; - getBoundsNoRotate(current?: boolean): Rect; - getBoundsNoRotateWithMargins(current?: boolean): Rect; - getBoundsWithMargins(current?: boolean): Rect; - getCenter(current?: boolean): Point; - getConstrainedBounds(current?: boolean): Rect; - getContainerSize(): Point; - getFlip(): boolean; - getHomeBounds(): Rect; - getHomeBoundsNoRotate(): Rect; - getHomeZoom(): number; - getMargins(): object; - getMaxZoom(): number; - getMaxZoomPixelRatio(): number; - getMinZoom(): number; - getRotation(current?: boolean): number; - getZoom(current?: boolean): number; - goHome(immediately?: boolean): Viewport; - imageToViewerElementCoordinates(pixel: Point): Point; - imageToViewportCoordinates(position: Point): Point; - imageToViewportCoordinates(imageX: number, imageY: number): Point; - imageToViewportCoordinates(imageX: number, imageY: number, pixelWidth: number, pixelHeight: number): Point; - imageToViewportRectangle( - imageX: number | Rect, - imageY?: number, - pixelWidth?: number, - pixelHeight?: number, - ): Rect; - imageToViewportZoom(imageZoom: number): number; - imageToWindowCoordinates(pixel: Point): Point; - panBy(delta: Point, immediately?: boolean): Viewport; - panTo(center: Point, immediately?: boolean): Viewport; - pixelFromPoint(point: Point, current?: boolean): Point; - pixelFromPointNoRotate(point: Point, current?: boolean): Point; - pointFromPixel(point: Point, current?: boolean): Point; - pointFromPixelNoRotate(point: Point, current?: boolean): Point; - resetContentSize(contentSize: Point): Viewport; - resize(): Viewport; - rotateBy(degrees: number, pivot?: Point): Viewport; - rotateTo(degrees: number, pivot?: Point, immediately?: boolean): Viewport; - setFlip(state: boolean): Viewport; - setMargins(margins: object): void; - setMaxZoomPixelRatio(ratio: number, applyConstraints?: boolean, immediately?: boolean): void; - setRotation(degrees: number, immediately?: boolean): Viewport; - setRotationWithPivot(degrees: number, pivot?: Point, immediately?: boolean): Viewport; - toggleFlip(): Viewport; - update(): boolean; - viewerElementToImageCoordinates(pixel: Point): Point; - viewerElementToViewportCoordinates(pixel: Point): Point; - viewerElementToViewportRectangle(rectangle: Rect): Rect; - viewportToImageCoordinates(position: Point): Point; - viewportToImageCoordinates(viewerX: number, viewerY: number): Point; - viewportToImageRectangle(rectangle: Rect): Rect; - viewportToImageRectangle(viewerX: number, viewerY: number, pointWidth: number, pointHeight: number): Rect; - viewportToImageZoom(viewportZoom: number): number; - viewportToViewerElementCoordinates(point: Point): Point; - viewportToViewerElementRectangle(rectangle: Rect): Rect; - viewportToWindowCoordinates(point: Point): Point; - windowToImageCoordinates(pixel: Point): Point; - windowToViewportCoordinates(pixel: Point): Point; - zoomBy(factor: number, refPoint?: Point, immediately?: boolean): Viewport; - zoomTo(factor: number, refPoint?: Point, immediately?: boolean): Viewport; - } - - class WebGLDrawer extends DrawerBase { - canvas: HTMLCanvasElement; - container: HTMLElement; - - constructor(options: TDrawerOptions); - - draw(tiledImages: any[]): void; - } - - class World extends EventSource { - constructor(options: object); - addItem(item: TiledImage, options?: { index?: number | undefined }): void; - arrange(options: { - immediately?: boolean | undefined; - layout?: "horizontal" | "vertical" | undefined; - rows?: number | undefined; - columns?: number | undefined; - tileSize?: number | undefined; - tileMargin?: number | undefined; - }): void; - draw(): void; - getContentFactor(): number; - getHomeBounds(): Rect; - getIndexOfItem(item: TiledImage): number; - getItemAt(id: number): TiledImage; - getItemCount(): number; - needsDraw(): boolean; - removeAll(): void; - removeItem(item: TiledImage): void; - resetItems(): void; - setAutoRefigureSizes(value?: boolean): void; - setItemIndex(item: TiledImage, index: number): void; - update(viewportChanged: boolean): void; - } - - class ZoomifyTileSource extends TileSource { - constructor(width: number, height: number, tileSize: number, tilesUrl: string); - } - - type EventHandler = (event: T) => void; - - interface DrawerOptions { - webgl?: object; - canvas?: object; - html?: object; - custom?: object; - } - - type PreprocessEventHandler = (event: EventProcessInfo) => void; - - interface ButtonEventMap { - "blur": ButtonEvent; - "click": ButtonEvent; - "enter": ButtonEvent; - "exit": ButtonEvent; - "focus": ButtonEvent; - "press": ButtonEvent; - "release": ButtonEvent; - } - - interface TiledImageEventMap { - "bounds-change": TiledImageEvent; - "clip-change": TiledImageEvent; - "composite-operation-change": CompositeOperationChangeTiledImageEvent; - "fully-loaded-change": FullyLoadedChangeTiledImageEvent; - "opacity-change": OpacityChangeTiledImageEvent; - } - - interface TileSourceEventMap { - "open-failed": OpenFailedTileSourceEvent; - "ready": ReadyTileSourceEvent; - } - - interface ViewerEventMap { - "add-item-failed": AddItemFailedEvent; - "add-overlay": AddOverlayEvent; - "after-resize": AfterResizeEvent; - "animation": ViewerEvent; - "animation-finish": ViewerEvent; - "animation-start": ViewerEvent; - "before-destroy": ViewerEvent; - "canvas-blur": CanvasTrackerEvent; - "canvas-click": CanvasClickEvent; - "canvas-contextmenu": CanvasContextMenuEvent; - "canvas-double-click": CanvasDoubleClickEvent; - "canvas-drag": CanvasDragEvent; - "canvas-drag-end": CanvasDragEvent; - "canvas-enter": CanvasEnterEvent; - "canvas-exit": CanvasExitEvent; - "canvas-focus": CanvasTrackerEvent; - "canvas-key": CanvasKeyEvent; - "canvas-key-press": CanvasOriginalEvent; - "canvas-nonprimary-press": CanvasNonPrimaryButtonEvent; - "canvas-nonprimary-release": CanvasNonPrimaryButtonEvent; - "canvas-pinch": CanvasPinchEvent; - "canvas-press": CanvasPressEvent; - "canvas-release": CanvasReleaseEvent; - "canvas-scroll": CanvasScrollEvent; - "clear-overlay": ViewerEvent; - "close": ViewerEvent; - "constrain": ConstrainEvent; - "container-enter": ContainerEvent; - "container-exit": ContainerEvent; - "controls-enabled": ControlsEnabledEvent; - "destroy": ViewerEvent; - "flip": FlipEvent; - "full-page": FullPageEvent; - "full-screen": FullScreenEvent; - "home": HomeEvent; - "mouse-enabled": MouseEnabledEvent; - "navigator-click": NavigatorClickEvent; - "navigator-drag": NavigatorDragEvent; - "navigator-scroll": NavigatorScrollEvent; - "open": OpenEvent; - "open-failed": OpenFailedEvent; - "page": PageEvent; - "pan": PanEvent; - "pre-full-page": PreFullPageEvent; - "pre-full-screen": PreFullScreenEvent; - "remove-overlay": RemoveOverlayEvent; - "reset-size": ResetSizeEvent; - "resize": ResizeEvent; - "rotate": RotateEvent; - "tile-drawing": TileDrawingEvent; - "tile-drawn": TileEvent; - "tile-load-failed": TileLoadFailedEvent; - "tile-loaded": TileLoadedEvent; - "tile-unloaded": TileEvent; - "update-level": UpdateLevelEvent; - "update-overlay": UpdateOverlayEvent; - "update-tile": TileEvent; - "update-viewport": ViewerEvent; - "viewport-change": ViewerEvent; - "visible": VisibleEvent; - "zoom": ZoomEvent; - } - - interface WorldEventMap { - "add-item": AddItemWorldEvent; - "item-index-change": ItemIndexChangeWorldEvent; - "metrics-change": WorldEvent; - "remove-item": RemoveItemWorldEvent; - } - - interface OSDEvent { - eventSource: T; - userData: unknown; - } - - interface ButtonEvent extends OSDEvent