@augment-vir/assert 30.1.0 → 30.3.0

package/dist/assertions/output.js

@@ -1,5 +1,5 @@
 import { combineErrorMessages, ensureError, ensureErrorAndPrependMessage, extractErrorMessage, stringify, wait, } from '@augment-vir/core';
-import { convertDuration, DurationUnit } from '@date-vir/duration';
+import { convertDuration } from '@date-vir/duration';
 import { AssertionError } from '../augments/assertion.error.js';
 import { parseWaitUntilOptions } from '../guard-types/wait-until-function.js';
 import { deepEquals } from './equality/simple-equality.js';
@@ -130,8 +130,8 @@ export async function waitUntilOutput(functionToCallOrAsserter, inputsOrFunction
     const failureMessage = usingCustomAsserter
         ? emptyOrFailureMessage
         : emptyOrFailureMessageOrOptions;
-    const timeout = convertDuration(options.timeout, DurationUnit.Milliseconds).milliseconds;
-    const interval = convertDuration(options.interval, DurationUnit.Milliseconds);
+    const timeout = convertDuration(options.timeout, { milliseconds: true }).milliseconds;
+    const interval = convertDuration(options.interval, { milliseconds: true });
     let lastCallbackOutput = notSetSymbol;
     let lastError = undefined;
     async function checkCondition() {

package/dist/augments/custom-equality.d.ts

@@ -0,0 +1,25 @@
+import { type MaybePromise } from '@augment-vir/core';
+/**
+ * Deeply checks inputs for equality with a custom checker callback. All objects are recursed into
+ * and the custom checker is only run on primitives. This function automatically handles async
+ * custom checkers and circular references.
+ *
+ * @category Assert
+ */
+export declare function checkCustomDeepQuality(a: unknown, b: unknown, customChecker: (a: unknown, b: unknown) => boolean): boolean;
+/**
+ * Deeply checks inputs for equality with a custom checker callback. All objects are recursed into
+ * and the custom checker is only run on primitives. This function automatically handles async
+ * custom checkers and circular references.
+ *
+ * @category Assert
+ */
+export declare function checkCustomDeepQuality(a: unknown, b: unknown, customChecker: (a: unknown, b: unknown) => Promise<boolean>): Promise<boolean>;
+/**
+ * Deeply checks inputs for equality with a custom checker callback. All objects are recursed into
+ * and the custom checker is only run on primitives. This function automatically handles async
+ * custom checkers and circular references.
+ *
+ * @category Assert
+ */
+export declare function checkCustomDeepQuality(a: unknown, b: unknown, customChecker: (a: unknown, b: unknown) => MaybePromise<boolean>): MaybePromise<boolean>;

package/dist/augments/custom-equality.js

@@ -0,0 +1,87 @@
+import { ensureError, getObjectTypedKeys, } from '@augment-vir/core';
+import { check } from './guards/check.js';
+/**
+ * Deeply checks inputs for equality with a custom checker callback. All objects are recursed into
+ * and the custom checker is only run on primitives. This function automatically handles async
+ * custom checkers and circular references.
+ *
+ * @category Assert
+ */
+export function checkCustomDeepQuality(a, b, customChecker) {
+    return recursiveCheckCustomDeepQuality(a, b, customChecker, new Set());
+}
+function recursiveCheckCustomDeepQuality(a, b, customChecker, checkedObjects) {
+    a = flattenComplexObject(a);
+    b = flattenComplexObject(b);
+    if (check.isObject(a) && check.isObject(b)) {
+        if (checkedObjects.has(a) || checkedObjects.has(b)) {
+            return true;
+        }
+        checkedObjects.add(a);
+        checkedObjects.add(b);
+        if (!recursiveCheckCustomDeepQuality(getObjectTypedKeys(a).sort(), getObjectTypedKeys(b).sort(), customChecker, checkedObjects)) {
+            return false;
+        }
+        let receivedPromise = false;
+        const results = getObjectTypedKeys(a).map((key) => {
+            const result = recursiveCheckCustomDeepQuality(a[key], b[key], customChecker, checkedObjects);
+            if (check.isPromise(result)) {
+                receivedPromise = true;
+            }
+            return result;
+        });
+        return handleMaybePromise(receivedPromise, results);
+    }
+    else if (check.isArray(a) && check.isArray(b)) {
+        if (checkedObjects.has(a) || checkedObjects.has(b)) {
+            return true;
+        }
+        checkedObjects.add(a);
+        checkedObjects.add(b);
+        if (a.length !== b.length) {
+            return false;
+        }
+        let receivedPromise = false;
+        const results = a.map((entry, index) => {
+            const result = recursiveCheckCustomDeepQuality(entry, b[index], customChecker, checkedObjects);
+            if (check.isPromise(result)) {
+                receivedPromise = true;
+            }
+            return result;
+        });
+        return handleMaybePromise(receivedPromise, results);
+    }
+    else {
+        return customChecker(a, b);
+    }
+}
+function flattenComplexObject(input) {
+    if (input instanceof Set) {
+        return Array.from(input.entries()).sort();
+    }
+    else if (input instanceof Map) {
+        return Object.fromEntries(input.entries());
+    }
+    else if (input instanceof RegExp) {
+        return input.source;
+    }
+    else {
+        return input;
+    }
+}
+function handleMaybePromise(hasPromise, results) {
+    if (hasPromise) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const awaitedResult = await Promise.all(results);
+                resolve(awaitedResult.every(check.isTrue));
+            }
+            catch (error) {
+                reject(ensureError(error));
+            }
+        });
+    }
+    else {
+        return results.every(check.isTrue);
+    }
+}

package/dist/guard-types/wait-until-function.js

@@ -1,5 +1,5 @@
 import { ensureError, ensureErrorAndPrependMessage, wait, } from '@augment-vir/core';
-import { convertDuration, DurationUnit } from '@date-vir/duration';
+import { convertDuration } from '@date-vir/duration';
 import { pickOverride } from './guard-override.js';
 export const defaultWaitUntilOptions = {
     interval: {
@@ -12,8 +12,8 @@ export const defaultWaitUntilOptions = {
 const notSetSymbol = Symbol('not set');
 export async function executeWaitUntil(assert, rawArgs, requireSynchronousResult) {
     const { callback, extraAssertionArgs, failureMessage, options } = parseWaitUntilArgs(rawArgs);
-    const timeout = convertDuration(options.timeout, DurationUnit.Milliseconds).milliseconds;
-    const interval = convertDuration(options.interval, DurationUnit.Milliseconds);
+    const timeout = convertDuration(options.timeout, { milliseconds: true }).milliseconds;
+    const interval = convertDuration(options.interval, { milliseconds: true });
     let lastCallbackOutput = notSetSymbol;
     let lastError = undefined;
     async function checkCondition() {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './augments/assertion-exports.js';
 export * from './augments/assertion.error.js';
+export * from './augments/custom-equality.js';
 export * from './augments/guards/assert-wrap.js';
 export * from './augments/guards/assert.js';
 export * from './augments/guards/check-wrap.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './augments/assertion-exports.js';
 export * from './augments/assertion.error.js';
+export * from './augments/custom-equality.js';
 export * from './augments/guards/assert-wrap.js';
 export * from './augments/guards/assert.js';
 export * from './augments/guards/check-wrap.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/assert",
-    "version": "30.1.0",
+    "version": "30.3.0",
     "description": "A collection of assertions for test and production code alike.",
     "keywords": [
         "augment",
@@ -41,8 +41,8 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^30.1.0",
-        "@date-vir/duration": "^6.0.0",
+        "@augment-vir/core": "^30.3.0",
+        "@date-vir/duration": "^6.0.1",
         "deep-eql": "^5.0.2",
         "expect-type": "^0.20.0",
         "type-fest": "^4.26.1"