@augment-vir/common 22.4.0 → 23.0.0

package/dist/cjs/augments/object/matches-object-shape.js

@@ -79,8 +79,7 @@ function compareInnerValue(testValue, matchValue, throwKeyError, allowExtraProps
         if ((0, typed_has_property_1.typedHasProperty)(matchValue, 'constructor')) {
             if (!(0, typed_has_property_1.typedHasProperty)(testValue, 'constructor') ||
                 testValue.constructor !== matchValue.constructor) {
-                throwKeyError(`constructor "${testValue?.constructor
-                    ?.name}" did not match expected constructor "${matchValue.constructor}"`);
+                throwKeyError(`constructor "${testValue?.constructor?.name}" did not match expected constructor "${matchValue.constructor}"`);
             }
         }
     }

package/dist/cjs/augments/promise/promise.js

@@ -14,9 +14,24 @@ exports.isPromiseLike = isPromiseLike;
 class PromiseTimeoutError extends Error {
     constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
         super(message);
-        this.durationMs = durationMs;
-        this.message = message;
-        this.name = 'PromiseTimeoutError';
+        Object.defineProperty(this, "durationMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: durationMs
+        });
+        Object.defineProperty(this, "message", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: message
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'PromiseTimeoutError'
+        });
     }
 }
 exports.PromiseTimeoutError = PromiseTimeoutError;

package/dist/cjs/augments/promise/wait.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForCondition = exports.waitValue = exports.wait = void 0;
+exports.waitUntilTruthy = exports.defaultWaitUntilDefinedOptions = exports.waitValue = exports.wait = void 0;
 const error_1 = require("../error");
 const deferred_promise_1 = require("./deferred-promise");
 function wait(delayMs) {
@@ -17,27 +17,50 @@ async function waitValue(delayMs, returnValue) {
     return wait(delayMs).then(() => returnValue);
 }
 exports.waitValue = waitValue;
-async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
-    let condition = false;
+exports.defaultWaitUntilDefinedOptions = {
+    interval: {
+        milliseconds: 100,
+    },
+    timeout: {
+        milliseconds: 10000,
+    },
+};
+/**
+ * Runs the predicate until it returns a truthy value, then returns that value. Use the options
+ * input to modify the timeout and interval durations. Automatically catches errors and handles
+ * async predicates.
+ */
+async function waitUntilTruthy(predicate, failureMessage, optionsInput = {}) {
+    const options = {
+        ...exports.defaultWaitUntilDefinedOptions,
+        ...optionsInput,
+    };
+    let lastValue = undefined;
     let lastError;
     async function checkCondition() {
         try {
-            condition = !!(await conditionCallback());
+            lastValue = await predicate();
         }
         catch (error) {
-            condition = false;
+            lastValue = undefined;
             lastError = error;
         }
     }
     const startTime = Date.now();
-    await checkCondition();
-    while (!condition) {
-        await wait(intervalMs);
-        if (Date.now() - startTime >= timeoutMs) {
-            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
-            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${(0, error_1.extractErrorMessage)(lastError)}`);
-        }
+    while (!lastValue) {
         await checkCondition();
+        await wait(options.interval.milliseconds);
+        if (Date.now() - startTime >= options.timeout.milliseconds) {
+            const message = failureMessage ? `${failureMessage}: ` : '';
+            const preMessage = `${message}Timeout of "${options.timeout.milliseconds}" exceeded waiting for value to be defined`;
+            if (lastError) {
+                throw (0, error_1.ensureErrorAndPrependMessage)(lastError, preMessage);
+            }
+            else {
+                throw new Error(preMessage);
+            }
+        }
     }
+    return lastValue;
 }
-exports.waitForCondition = waitForCondition;
+exports.waitUntilTruthy = waitUntilTruthy;

package/dist/cjs/augments/random.js

@@ -2,7 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomString = exports.createUuid = exports.randomBoolean = exports.randomInteger = void 0;
 const common_number_1 = require("./common-number");
-const crypto = globalThis.crypto;
+function accessCrypto() {
+    if (globalThis.crypto) {
+        return globalThis.crypto;
+    }
+    else {
+        return require('crypto').webcrypto;
+    }
+}
+const crypto = accessCrypto();
 // can't get this coverage to work
 /* c8 ignore start */
 /**

package/dist/cjs/augments/truncate-number.js

@@ -5,13 +5,13 @@ const common_number_1 = require("./common-number");
 const common_string_1 = require("./common-string");
 const regexp_1 = require("./regexp");
 const defaultTruncationSuffixes = [
-    'k',
-    'M',
-    'B',
-    'T',
-    'P',
-    'E',
-    'Z',
+    'k', // thousand
+    'M', // million
+    'B', // billion
+    'T', // trillion
+    'P', // peta-, quadrillion
+    'E', // exa- quintillion
+    'Z', // zetta- sextillion
     'Y', // yotta- septillion
 ];
 function combineBeforeAndAfterDot({ beforeDot, afterDot = '', maxLength, }) {

package/dist/esm/augments/object/matches-object-shape.js

@@ -74,8 +74,7 @@ function compareInnerValue(testValue, matchValue, throwKeyError, allowExtraProps
         if (typedHasProperty(matchValue, 'constructor')) {
             if (!typedHasProperty(testValue, 'constructor') ||
                 testValue.constructor !== matchValue.constructor) {
-                throwKeyError(`constructor "${testValue?.constructor
-                    ?.name}" did not match expected constructor "${matchValue.constructor}"`);
+                throwKeyError(`constructor "${testValue?.constructor?.name}" did not match expected constructor "${matchValue.constructor}"`);
             }
         }
     }

package/dist/esm/augments/promise/promise.js

@@ -10,9 +10,24 @@ export function isPromiseLike(input) {
 export class PromiseTimeoutError extends Error {
     constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
         super(message);
-        this.durationMs = durationMs;
-        this.message = message;
-        this.name = 'PromiseTimeoutError';
+        Object.defineProperty(this, "durationMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: durationMs
+        });
+        Object.defineProperty(this, "message", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: message
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'PromiseTimeoutError'
+        });
     }
 }
 export function wrapPromiseInTimeout(durationMs, originalPromise) {

package/dist/esm/augments/promise/wait.js

@@ -1,4 +1,4 @@
-import { extractErrorMessage } from '../error';
+import { ensureErrorAndPrependMessage } from '../error';
 import { createDeferredPromiseWrapper } from './deferred-promise';
 export function wait(delayMs) {
     const deferredPromiseWrapper = createDeferredPromiseWrapper();
@@ -12,26 +12,49 @@ export function wait(delayMs) {
 export async function waitValue(delayMs, returnValue) {
     return wait(delayMs).then(() => returnValue);
 }
-export async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
-    let condition = false;
+export const defaultWaitUntilDefinedOptions = {
+    interval: {
+        milliseconds: 100,
+    },
+    timeout: {
+        milliseconds: 10000,
+    },
+};
+/**
+ * Runs the predicate until it returns a truthy value, then returns that value. Use the options
+ * input to modify the timeout and interval durations. Automatically catches errors and handles
+ * async predicates.
+ */
+export async function waitUntilTruthy(predicate, failureMessage, optionsInput = {}) {
+    const options = {
+        ...defaultWaitUntilDefinedOptions,
+        ...optionsInput,
+    };
+    let lastValue = undefined;
     let lastError;
     async function checkCondition() {
         try {
-            condition = !!(await conditionCallback());
+            lastValue = await predicate();
         }
         catch (error) {
-            condition = false;
+            lastValue = undefined;
             lastError = error;
         }
     }
     const startTime = Date.now();
-    await checkCondition();
-    while (!condition) {
-        await wait(intervalMs);
-        if (Date.now() - startTime >= timeoutMs) {
-            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
-            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${extractErrorMessage(lastError)}`);
-        }
+    while (!lastValue) {
         await checkCondition();
+        await wait(options.interval.milliseconds);
+        if (Date.now() - startTime >= options.timeout.milliseconds) {
+            const message = failureMessage ? `${failureMessage}: ` : '';
+            const preMessage = `${message}Timeout of "${options.timeout.milliseconds}" exceeded waiting for value to be defined`;
+            if (lastError) {
+                throw ensureErrorAndPrependMessage(lastError, preMessage);
+            }
+            else {
+                throw new Error(preMessage);
+            }
+        }
     }
+    return lastValue;
 }

package/dist/esm/augments/random.js

@@ -1,5 +1,13 @@
 import { clamp, ensureMinAndMax } from './common-number';
-const crypto = globalThis.crypto;
+function accessCrypto() {
+    if (globalThis.crypto) {
+        return globalThis.crypto;
+    }
+    else {
+        return require('crypto').webcrypto;
+    }
+}
+const crypto = accessCrypto();
 // can't get this coverage to work
 /* c8 ignore start */
 /**

package/dist/esm/augments/truncate-number.js

@@ -2,13 +2,13 @@ import { addCommasToNumber, convertIntoNumber, doesRequireScientificNotation } f
 import { typedSplit } from './common-string';
 import { safeMatch } from './regexp';
 const defaultTruncationSuffixes = [
-    'k',
-    'M',
-    'B',
-    'T',
-    'P',
-    'E',
-    'Z',
+    'k', // thousand
+    'M', // million
+    'B', // billion
+    'T', // trillion
+    'P', // peta-, quadrillion
+    'E', // exa- quintillion
+    'Z', // zetta- sextillion
     'Y', // yotta- septillion
 ];
 function combineBeforeAndAfterDot({ beforeDot, afterDot = '', maxLength, }) {

package/dist/types/augments/promise/wait.d.ts

@@ -1,9 +1,18 @@
+import { FalsyTypes } from '../boolean';
 export declare function wait(delayMs: number): Promise<void>;
 export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
-export type WaitForConditionInputs = {
-    conditionCallback: () => boolean | Promise<boolean>;
-    timeoutMs?: number;
-    intervalMs?: number;
-    timeoutMessage?: string;
+export type WaitUntilTruthyOptions = {
+    interval: {
+        milliseconds: number;
+    };
+    timeout: {
+        milliseconds: number;
+    };
 };
-export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;
+export declare const defaultWaitUntilDefinedOptions: WaitUntilTruthyOptions;
+/**
+ * Runs the predicate until it returns a truthy value, then returns that value. Use the options
+ * input to modify the timeout and interval durations. Automatically catches errors and handles
+ * async predicates.
+ */
+export declare function waitUntilTruthy<Value>(predicate: () => Value | Promise<Value> | FalsyTypes, failureMessage?: string | undefined, optionsInput?: Partial<WaitUntilTruthyOptions>): Promise<Awaited<Value>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "22.4.0",
+    "version": "23.0.0",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"
@@ -29,7 +29,7 @@
         "type-fest": "^4.9.0"
     },
     "devDependencies": {
-        "typescript": "5.2.2"
+        "typescript": "5.3.3"
     },
     "publishConfig": {
         "access": "public"