@types/k6 0.52.0 → 0.53.1

k6/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for k6 (https://grafana.com/docs/k6/lates
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6.
 
 ### Additional Details
- * Last updated: Wed, 26 Jun 2024 11:07:12 GMT
+ * Last updated: Fri, 23 Aug 2024 08:10:16 GMT
  * Dependencies: none
 
 # Credits

k6/crypto.d.ts

@@ -1,5 +1,3 @@
-import { bytes } from ".";
-
 /**
  * Generate random bytes.
  * @param size - Number of bytes to generate.
@@ -181,7 +179,7 @@ export type OutputEncoding = StringEncoding | BinaryEncoding;
  * @template OE - Output encoding.
  */
 export type Output<OE extends OutputEncoding> = OE extends StringEncoding ? string
-    : OE extends BinaryEncoding ? bytes
+    : OE extends BinaryEncoding ? ArrayBuffer
     : never;
 
 /**

k6/experimental/streams.d.ts

@@ -0,0 +1,198 @@
+/**
+ * This module provides an experimental implementation of the Streams API
+ * for k6.
+ *
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/
+ */
+
+/**
+ * The ReadableStream object provides the API for creating and managing readable
+ * streams of raw data, bit by bit, as soon as it is available, without needing to generate a buffer, string, or blob.
+ */
+export class ReadableStream {
+    /**
+     * The ReadableStream constructor returns a newly created ReadableStream object.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestream/
+     *
+     * @param underlyingSource - defines the source of data for the stream.
+     * @param queuingStrategy - defines the queuing strategy to adopt for the stream.
+     */
+    constructor(underlyingSource?: UnderlyingSource, queuingStrategy?: QueuingStrategy);
+
+    /**
+     * Closes the stream and signals a reason for the closure.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestream/cancel/
+     *
+     * Used when you’ve completely finished with the stream and don’t need any more data from it,
+     * even if chunks are enqueued waiting to be read.
+     *
+     * That data is lost after cancel is called, and the stream is not readable anymore.
+     * To close the stream without getting rid of enqueued chunks, use `ReadableStreamDefaultController.close()`.
+     *
+     * It returns a promise that is resolved with `undefined` when the stream is canceled.
+     *
+     * @param reason - the reason for canceling the stream.
+     */
+    cancel(reason: any): Promise<void>;
+
+    /**
+     * Creates a reader and locks the stream to it.
+     * While the stream is locked, no other reader can be acquired until this one is released.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestream/getreader/
+     */
+    getReader(): ReadableStreamDefaultReader;
+}
+
+/**
+ * The object that defines the source of data for the stream.
+ */
+export interface UnderlyingSource {
+    /**
+     * Called when the stream is created.
+     * It can be used to perform any setup tasks.
+     * The content of this method is to be defined by the user.
+     */
+    start?: (controller: ReadableStreamDefaultController) => void | Promise<void>;
+
+    /**
+     * Called repeatedly to fetch and queue data into the stream,
+     * until it reaches its high watermark.
+     * If `pull()` returns a promise, it won’t be called again until the promise is resolved.
+     */
+    pull?: (controller: ReadableStreamDefaultController) => void | Promise<void>;
+
+    /**
+     * Called when the stream is canceled.
+     * It can be used to release access to the stream source and perform any cleanup tasks.
+     * The reason parameter passed to this method is an optional human-readable value
+     * that represents the reason for canceling the stream.
+     */
+    cancel?: (reason?: any) => void | Promise<void>;
+
+    /**
+     * Specifies the type of the underlying source.
+     * It can currently only receive the value 'default' which is its default value.
+     */
+    type?: "default";
+}
+
+/**
+ * The object that allows the user to control a ReadableStream’s state and internal queue.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultcontroller/
+ */
+export interface ReadableStreamDefaultController {
+    /**
+     * Closes the associated stream.
+     * Readers can still read any previously enqueued chunks from the stream.
+     * Once those chunks are read, the stream closes, and no more data is available.
+     */
+    close: () => void;
+
+    /**
+     * Enqueues a chunk of data into the associated stream.
+     */
+    enqueue: (chunk: any) => void;
+
+    /**
+     * Makes any future interactions with the associated stream to error.
+     */
+    error: (reason: any) => void;
+}
+
+/**
+ * The object that defines the queuing strategy to adopt for the stream.
+ *
+ * Although the user can define a custom queueing strategy, the default behavior and recommended way
+ * to use the `ReadableStream` is to use a `CountQueuingStrategy` object.
+ */
+export interface QueuingStrategy {
+    /**
+     * Represents the maximum number of chunks that the stream can hold in its internal queue.
+     * The default value is 1.
+     */
+    highWaterMark?: number;
+
+    /**
+     * Returns the size of the chunk passed as an argument.
+     * The default value is a function that returns 1.
+     */
+    size?(chunk: any): number;
+}
+
+/**
+ * The CountQueuingStrategy object is the default QueuingStrategy for ReadableStream.
+ * It counts the number of chunks in the queue.
+ */
+export class CountQueuingStrategy {
+    /**
+     * The CountQueuingStrategy constructor returns a newly created CountQueuingStrategy object.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestream/countqueuingstrategy/
+     *
+     * @param options - an object with optional property `highWaterMark` that determines
+     * the maximum number of chunks that the queue can contain.
+     */
+    constructor(options?: { highWaterMark?: number });
+
+    /**
+     * Represents the maximum number of chunks that the stream can hold in its internal queue.
+     * The default value is 1.
+     */
+    readonly highWaterMark: number;
+
+    /**
+     * Returns the size of the chunk passed as an argument.
+     * The default value is a function that returns 1.
+     */
+    size(chunk: any): number;
+}
+
+/**
+ * The object used to read stream data.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultreader/
+ */
+export class ReadableStreamDefaultReader {
+    /**
+     * The ReadableStreamDefaultReader constructor returns a newly created ReadableStreamDefaultReader object.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultreader/
+     *
+     * @param stream - defines the stream the reader will own.
+     */
+    constructor(stream: ReadableStream);
+
+    /**
+     * Closes the reader and signals a reason for the closure.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultreader/cancel/
+     *
+     * Used when you’ve completely finished with the stream and don’t need any more data from it,
+     * even if chunks are enqueued waiting to be read.
+     * That data is lost after cancel is called, and the stream is not readable anymore.
+     * To close the stream without getting rid of enqueued chunks, use `ReadableStreamDefaultController.close()`.
+     *
+     * It returns a promise that is resolved with `undefined` when the stream is canceled.
+     *
+     * @param reason - the reason for canceling the stream.
+     */
+    cancel(reason: any): Promise<void>;
+
+    /**
+     * Returns a promise providing access to the next chunk in the stream’s internal queue.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultreader/read/
+     *
+     * - If the stream is closed and no more data is available, the promise resolves with an object of the form:
+     *   `{ done: true, value: undefined }`.
+     * - If the stream is errored, the promise rejects with the error that caused the stream to error.
+     */
+    read(): Promise<{ done: false; value: any } | { done: true; value: undefined }>;
+
+    /**
+     * Releases the reader’s lock on the stream.
+     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/streams/readablestreamdefaultreader/releaselock/
+     *
+     * If the associated stream is errored as the lock is released, the reader will be errored as well.
+     * This method is useful when done with the stream and want to release the lock on it.
+     *
+     * If the reader’s lock is released as pending read operations are still in progress,
+     * the reader’s `ReadableStreamDefaultReader.read()` calls are immediately rejected with a `TypeError`.
+     */
+    readonly releaseLock: () => void;
+}

k6/experimental/websockets.d.ts

@@ -1,4 +1,5 @@
 import { CookieJar } from "../http";
+import { ReadableStream } from "./streams";
 
 /**
  * This module provides an experimental implementation of the WebSocket API
@@ -55,7 +56,7 @@ export class WebSocket {
      *
      * @param data - the data to send to the server
      */
-    send(data: string | ArrayBuffer): void;
+    send(data: string | ArrayBuffer | Blob): void;
 
     /**
      * Bind event names to event handlers to be executed when their
@@ -123,6 +124,26 @@ export class WebSocket {
     onpong: () => void;
 }
 
+export type BlobPart = ArrayBuffer | ArrayBufferView | Blob | string;
+
+export interface BlobOptions {
+    type?: string | undefined;
+}
+
+/**
+ * The Blob represents binary data and can be used to interact with it.
+ */
+export class Blob {
+    readonly type: string;
+    readonly size: number;
+    constructor(blobParts?: BlobPart[], options?: BlobOptions);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    slice(start?: number, end?: number): Blob;
+    stream(): ReadableStream;
+    text(): Promise<string>;
+}
+
 /**
  * k6 specific WebSocket parameters.
  * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/websockets/params/
@@ -177,9 +198,7 @@ export enum ReadyState {
  * transmitted over a Websocket connection.
  */
 export enum BinaryType {
-    /**
-     * Binary data is returned in ArrayBuffer form. k6 supports only this type.
-     */
+    Blob = "blob",
     ArrayBuffer = "arraybuffer",
 }
 
@@ -226,7 +245,7 @@ export interface MessageEvent {
     /**
      * The data sent by the message emitter.
      */
-    data: string | ArrayBuffer;
+    data: string | ArrayBuffer | Blob;
 
     /**
      * the type of the event.

k6/global.d.ts

@@ -6,8 +6,6 @@
  * others in both contexts. Comments note availability.
  */
 
-import { bytes } from ".";
-
 export {};
 
 // Available without importing

k6/http.d.ts

@@ -1,4 +1,4 @@
-import { bytes, JSONValue } from ".";
+import { JSONValue } from ".";
 import { Selection } from "./html";
 
 /**
@@ -185,7 +185,7 @@ export function batch<Q extends BatchRequests>(requests: Q): BatchResponses<Q>;
  *   console.log(f.content_type);
  * }
  */
-export function file(data: string | bytes | ArrayBuffer, filename?: string, contentType?: string): FileData;
+export function file(data: string | ArrayBuffer, filename?: string, contentType?: string): FileData;
 
 /**
  * Get active cookie jar.
@@ -688,7 +688,7 @@ export abstract class FileData {
     protected __brand: never;
 
     /** File data. */
-    data: string | bytes | ArrayBuffer;
+    data: string | ArrayBuffer;
 
     /** Filename to include in MIME message. */
     filename?: string;
@@ -992,7 +992,7 @@ declare namespace http {
      *   console.log(f.content_type);
      * }
      */
-    function file(data: string | bytes | ArrayBuffer, filename?: string, contentType?: string): FileData;
+    function file(data: string | ArrayBuffer, filename?: string, contentType?: string): FileData;
 
     /**
      * Get active cookie jar.

k6/index.d.ts

@@ -124,11 +124,6 @@ export interface Checkers<VT> {
 // === Common types ===
 // --------------------
 
-/**
- * Array of numbers. The number range is from 0 to 255.
- */
-export type bytes = number[];
-
 // === JSON ===
 // ------------
 

k6/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/k6",
-    "version": "0.52.0",
+    "version": "0.53.1",
     "description": "TypeScript definitions for k6",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6",
     "license": "MIT",
@@ -60,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "c77eb5d37a165f06102b569ae717ea8b899b5197a284ee88298683ce3ae51dd4",
+    "typesPublisherContentHash": "51f2f592838cc27d3b1784aa8140db6d7c0e256577c0d8f960419afa871ee531",
     "typeScriptVersion": "4.8"
 }