@augment-vir/assert 30.0.5 → 30.2.0

package/dist/assertions/equality/ts-type-equality.d.ts

@@ -6,6 +6,9 @@ type AssertTypeOf<TestingType> = {
     notEquals: ExpectTypeOf<TestingType, {
         positive: false;
     }>['toEqualTypeOf'];
+    slowEquals: ExpectTypeOf<TestingType, {
+        positive: true;
+    }>['branded']['toEqualTypeOf'];
     matches: ExpectTypeOf<TestingType, {
         positive: true;
     }>['toMatchTypeOf'];
@@ -20,22 +23,6 @@ input: Actual): AssertTypeOf<Actual>;
 declare function tsType<Actual>(): AssertTypeOf<Actual>;
 export declare const tsTypeGuards: {
     assert: {
-        /**
-         * Check if a value or type matches type expectations. Use this to write type tests.
-         *
-         * This should not be used in production code. It won't cause any issues there, but it also
-         * provides no value there.
-         *
-         * Performs no type guarding.
-         *
-         * @example
-         *
-         * ```ts
-         * import {assert} from '@augment-vir/assert';
-         *
-         * assert.tsType('hello').equals<string>();
-         * ```
-         */
         /**
          * Asserts within the TypeScript type system that a given type or value matches type
          * expectations (using the [`expect-type`](https://www.npmjs.com/package/expect-type) package.

package/dist/assertions/equality/ts-type-equality.js

@@ -8,6 +8,7 @@ input) {
         notEquals: () => { },
         matches: () => { },
         notMatches: () => { },
+        slowEquals: () => { },
     };
 }
 const assertions = {

package/dist/assertions/length.d.ts

@@ -4,7 +4,6 @@ declare function isLengthAtLeast<const Element, const Length extends number>(act
 declare function isLengthAtLeast(actual: string | AnyObject, length: number, failureMessage?: string | undefined): void;
 declare function isLengthExactly<const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is Tuple<Element, Length>;
 declare function isLengthExactly(actual: string | AnyObject, length: number, failureMessage?: string | undefined): void;
-/** These functions are not used at run time, they're only here for types. */
 declare function checkIsLengthAtLeast<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is AtLeastTuple<Element, Length>;
 declare function checkIsLengthAtLeast(actual: string | AnyObject, length: number): boolean;
 declare function assertWrapIsLengthAtLeast<Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): AtLeastTuple<Element, Length>;

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,22 @@
+import { type MaybePromise } from '@augment-vir/core';
+/**
+ * Runs a custom provided checker that is applied deeply to any given variables. Automatically
+ * handles async custom checkers.
+ *
+ * @category Assert
+ */
+export declare function checkCustomDeepQuality(a: unknown, b: unknown, customChecker: (a: unknown, b: unknown) => boolean): boolean;
+/**
+ * Runs a custom provided checker that is applied deeply to any given variables. Automatically
+ * handles async custom checkers.
+ *
+ * @category Assert
+ */
+export declare function checkCustomDeepQuality(a: unknown, b: unknown, customChecker: (a: unknown, b: unknown) => Promise<boolean>): Promise<boolean>;
+/**
+ * Runs a custom provided checker that is applied deeply to any given variables. Automatically
+ * handles async custom checkers.
+ *
+ * @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,73 @@
+import { ensureError, getObjectTypedKeys, } from '@augment-vir/core';
+import { check } from './guards/check.js';
+/**
+ * Runs a custom provided checker that is applied deeply to any given variables. Automatically
+ * handles async custom checkers.
+ *
+ * @category Assert
+ */
+export function checkCustomDeepQuality(a, b, customChecker) {
+    a = flattenComplexObject(a);
+    b = flattenComplexObject(b);
+    if (check.isObject(a) && check.isObject(b)) {
+        if (!checkCustomDeepQuality(getObjectTypedKeys(a).sort(), getObjectTypedKeys(b).sort(), customChecker)) {
+            return false;
+        }
+        let receivedPromise = false;
+        const results = getObjectTypedKeys(a).map((key) => {
+            const result = checkCustomDeepQuality(a[key], b[key], customChecker);
+            if (check.isPromise(result)) {
+                receivedPromise = true;
+            }
+            return result;
+        });
+        return handleMaybePromise(receivedPromise, results);
+    }
+    else if (check.isArray(a) && check.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        let receivedPromise = false;
+        const results = a.map((entry, index) => {
+            const result = checkCustomDeepQuality(entry, b[index], customChecker);
+            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.0.5",
+    "version": "30.2.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.0.5",
-        "@date-vir/duration": "^6.0.0",
+        "@augment-vir/core": "^30.2.0",
+        "@date-vir/duration": "^6.0.1",
         "deep-eql": "^5.0.2",
         "expect-type": "^0.20.0",
         "type-fest": "^4.26.1"