@vertexvis/utils 0.24.5 → 1.0.0-canary.0

package/dist/async.d.ts

@@ -1,79 +1,79 @@
-/**
- * Converts an async generator to an array of results.
- *
- * @param generator The generator to convert.
- * @returns A promise that resolves with an array of results yielded by the
- *  generator.
- */
-export declare function asArray<T>(generator: AsyncGenerator<T>): Promise<T[]>;
-/**
- * Returns a promise that resolves successfully after the given delay.
- *
- * @param ms The delay in milliseconds.
- */
-export declare function delay(ms: number): Promise<void>;
-/**
- * Delays the resolution of `promise` by the given delay.
- *
- * @param ms The delay in milliseconds.
- * @param promise The promise to delay.
- */
-export declare function delay<T>(ms: number, promise: Promise<T>): Promise<T>;
-/**
- * Returns a promise that will reject after the given duration.
- *
- * @param ms A duration in milliseconds.
- */
-export declare function timeout(ms: number): Promise<void>;
-/**
- * Assigns a timeout to the given promise, where if the promise doesn't complete
- * within the given duration an exception will be thrown.
- *
- * @param ms The timeout, in milliseconds.
- * @param promise The promise to assign a timeout to.
- */
-export declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T>;
-export interface RetryOptions {
-    /**
-     * An array of delays that are used between each retry attempt.
-     */
-    delaysInMs?: number[];
-    /**
-     * The maximum number of retries that will be attempted.
-     */
-    maxRetries?: number;
-}
-/**
- * Executes and reattempts execution of an asynchronous function if it throws an
- * error. By default, this function will only retry once and reexecute
- * immediately after the previous execution throws. You can configure the number
- * of retry attempts and delays with the `maxRetries` and `delaysInMs` options.
- *
- * The `delaysInMs` is an array of delays in milliseconds for each retry
- * attempt. If there are more retry attempts than delays, the last delay will be
- * used.
- *
- * @param process The process to execute.
- * @param opts Options to configure retry behavior.
- * @returns A promise that resolves with a successful value, or the original
- *  rejected value if the process fails.
- */
-export declare function retry<T>(process: () => Promise<T>, opts?: RetryOptions): Promise<T>;
-/**
- * Returns a promise that either resolves with the result of `promise`, or a
- * value that indicates the execution was aborted.
- *
- * **Note:** Because Promises in JS cannot be canceled, an abort signal will not
- * cancel the execution of the promise.
- *
- * @param signal A signal that communicates the process should be aborted.
- * @param promise A promise who's value will be returned if not aborted.
- * @returns A value indicating if the process was aborted, or the value of
- * `promise`.
- */
-export declare function abort<T>(signal: AbortSignal, promise: Promise<T>): Promise<{
-    aborted: true;
-} | {
-    aborted: false;
-    result: T;
-}>;
+/**
+ * Converts an async generator to an array of results.
+ *
+ * @param generator The generator to convert.
+ * @returns A promise that resolves with an array of results yielded by the
+ *  generator.
+ */
+export declare function asArray<T>(generator: AsyncGenerator<T>): Promise<T[]>;
+/**
+ * Returns a promise that resolves successfully after the given delay.
+ *
+ * @param ms The delay in milliseconds.
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Delays the resolution of `promise` by the given delay.
+ *
+ * @param ms The delay in milliseconds.
+ * @param promise The promise to delay.
+ */
+export declare function delay<T>(ms: number, promise: Promise<T>): Promise<T>;
+/**
+ * Returns a promise that will reject after the given duration.
+ *
+ * @param ms A duration in milliseconds.
+ */
+export declare function timeout(ms: number): Promise<void>;
+/**
+ * Assigns a timeout to the given promise, where if the promise doesn't complete
+ * within the given duration an exception will be thrown.
+ *
+ * @param ms The timeout, in milliseconds.
+ * @param promise The promise to assign a timeout to.
+ */
+export declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T>;
+export interface RetryOptions {
+    /**
+     * An array of delays that are used between each retry attempt.
+     */
+    delaysInMs?: number[];
+    /**
+     * The maximum number of retries that will be attempted.
+     */
+    maxRetries?: number;
+}
+/**
+ * Executes and reattempts execution of an asynchronous function if it throws an
+ * error. By default, this function will only retry once and reexecute
+ * immediately after the previous execution throws. You can configure the number
+ * of retry attempts and delays with the `maxRetries` and `delaysInMs` options.
+ *
+ * The `delaysInMs` is an array of delays in milliseconds for each retry
+ * attempt. If there are more retry attempts than delays, the last delay will be
+ * used.
+ *
+ * @param process The process to execute.
+ * @param opts Options to configure retry behavior.
+ * @returns A promise that resolves with a successful value, or the original
+ *  rejected value if the process fails.
+ */
+export declare function retry<T>(process: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+/**
+ * Returns a promise that either resolves with the result of `promise`, or a
+ * value that indicates the execution was aborted.
+ *
+ * **Note:** Because Promises in JS cannot be canceled, an abort signal will not
+ * cancel the execution of the promise.
+ *
+ * @param signal A signal that communicates the process should be aborted.
+ * @param promise A promise who's value will be returned if not aborted.
+ * @returns A value indicating if the process was aborted, or the value of
+ * `promise`.
+ */
+export declare function abort<T>(signal: AbortSignal, promise: Promise<T>): Promise<{
+    aborted: true;
+} | {
+    aborted: false;
+    result: T;
+}>;

package/dist/binaryReader.d.ts

@@ -1,58 +1,58 @@
-/**
- * A `BinaryReader` represents a view and offset for iteratively reading data
- * from an `ArrayBuffer`.
- *
- * Readers are created by calling the `BinaryReader.fromArrayBuffer()` method,
- * and passed to helper methods such as `BinaryReader.readInt32()` to read data
- * from the buffer. These helpers return a new `BinaryReader` that contains an
- * adjusted offset and the read value, and can further be passed to additional
- * helpers.
- *
- * @example
- * ```
- * // Reading from an `ArrayBuffer`
- * const reader = BinaryReader.fromArrayBuffer(buffer);
- * const messageLength = BinaryReader.readInt32(reader);
- * console.log(messageLength.value); // 11
- *
- * const message = BinaryReader.readUtf8String(messageLength.value, messageLength);
- * console.log(message.value); // Hello world
- * ```
- */
-export interface BinaryReader {
-    offset: number;
-    data: DataView;
-}
-interface BinaryReaderValue<T> extends BinaryReader {
-    value: T;
-}
-/**
- * Returns a new `BinaryReader` for an `ArrayBuffer`.
- */
-export declare const fromArrayBuffer: (buffer: ArrayBuffer) => BinaryReader;
-/**
- * Returns a `BinaryReader` that contains the read Int32 value at the given
- * reader's offset. The returned reader will have its offset adjusted so it can
- * be passed to the next helper.
- */
-export declare const readInt32: (reader: BinaryReader) => BinaryReaderValue<number>;
-/**
- * Returns a `BinaryReader` that contains the read UTF-8 string at the given
- * reader's offset. The returned reader will have its offset adjusted so it can
- * be passed to the next helper.
- */
-export declare const readUtf8String: (length: number, reader: BinaryReader) => BinaryReaderValue<string>;
-/**
- * Returns a `BinaryReader` that contains the a signed `Int8Array` start from
- * the given reader's offset to the given length. The returned reader will have
- * its offset adjusted so it can be passed to the next helper.
- */
-export declare const readInt8Array: (length: number, reader: BinaryReader) => BinaryReaderValue<Int8Array>;
-/**
- * Returns a `BinaryReader` that contains the a signed `Int8Array` sliced from
- * the start of the reader's offset to offset + length. The new reader value has
- * an offset of zero, so downstream operations will not bee effected by the
- * previous offset
- */
-export declare const sliceInt8Array: (length: number, reader: BinaryReader) => BinaryReaderValue<Int8Array>;
-export {};
+/**
+ * A `BinaryReader` represents a view and offset for iteratively reading data
+ * from an `ArrayBuffer`.
+ *
+ * Readers are created by calling the `BinaryReader.fromArrayBuffer()` method,
+ * and passed to helper methods such as `BinaryReader.readInt32()` to read data
+ * from the buffer. These helpers return a new `BinaryReader` that contains an
+ * adjusted offset and the read value, and can further be passed to additional
+ * helpers.
+ *
+ * @example
+ * ```
+ * // Reading from an `ArrayBuffer`
+ * const reader = BinaryReader.fromArrayBuffer(buffer);
+ * const messageLength = BinaryReader.readInt32(reader);
+ * console.log(messageLength.value); // 11
+ *
+ * const message = BinaryReader.readUtf8String(messageLength.value, messageLength);
+ * console.log(message.value); // Hello world
+ * ```
+ */
+export interface BinaryReader {
+    offset: number;
+    data: DataView;
+}
+interface BinaryReaderValue<T> extends BinaryReader {
+    value: T;
+}
+/**
+ * Returns a new `BinaryReader` for an `ArrayBuffer`.
+ */
+export declare const fromArrayBuffer: (buffer: ArrayBuffer) => BinaryReader;
+/**
+ * Returns a `BinaryReader` that contains the read Int32 value at the given
+ * reader's offset. The returned reader will have its offset adjusted so it can
+ * be passed to the next helper.
+ */
+export declare const readInt32: (reader: BinaryReader) => BinaryReaderValue<number>;
+/**
+ * Returns a `BinaryReader` that contains the read UTF-8 string at the given
+ * reader's offset. The returned reader will have its offset adjusted so it can
+ * be passed to the next helper.
+ */
+export declare const readUtf8String: (length: number, reader: BinaryReader) => BinaryReaderValue<string>;
+/**
+ * Returns a `BinaryReader` that contains the a signed `Int8Array` start from
+ * the given reader's offset to the given length. The returned reader will have
+ * its offset adjusted so it can be passed to the next helper.
+ */
+export declare const readInt8Array: (length: number, reader: BinaryReader) => BinaryReaderValue<Int8Array>;
+/**
+ * Returns a `BinaryReader` that contains the a signed `Int8Array` sliced from
+ * the start of the reader's offset to offset + length. The new reader value has
+ * an offset of zero, so downstream operations will not bee effected by the
+ * previous offset
+ */
+export declare const sliceInt8Array: (length: number, reader: BinaryReader) => BinaryReaderValue<Int8Array>;
+export {};