New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@augment-vir/assert

Package Overview
Dependencies
Maintainers
1
Versions
43
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@augment-vir/assert - npm Package Compare versions

Comparing version

31.9.1
to
31.9.2

296

dist/assertions/boundary.d.ts

@@ -42,4 +42,16 @@ import { type MaybePromise } from '@augment-vir/core';

* assert.endsWith('ab', 'a'); // fails
* assert.endsWith(['a', 'b'], 'b'); // passes
* assert.endsWith(['a', 'b'], 'a'); // fails
* assert.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // passes
* assert.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // fails
* ```

@@ -66,4 +78,16 @@ *

* assert.endsWithout('ab', 'a'); // passes
* assert.endsWithout(['a', 'b'], 'b'); // fails
* assert.endsWithout(['a', 'b'], 'a'); // passes
* assert.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // fails
* assert.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // passes
* ```

@@ -90,4 +114,16 @@ *

* assert.startsWith('ab', 'a'); // passes
* assert.startsWith(['a', 'b'], 'b'); // fails
* assert.startsWith(['a', 'b'], 'a'); // passes
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // fails
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // passes
* ```

@@ -114,4 +150,16 @@ *

* assert.startsWith('ab', 'a'); // fails
* assert.startsWith(['a', 'b'], 'b'); // passes
* assert.startsWith(['a', 'b'], 'a'); // fails
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // passes
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // fails
* ```

@@ -140,4 +188,16 @@ *

* check.endsWith('ab', 'a'); // returns `false`
* check.endsWith(['a', 'b'], 'b'); // returns `true`
* check.endsWith(['a', 'b'], 'a'); // returns `false`
* check.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `true`
* check.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `false`
* ```

@@ -163,4 +223,16 @@ *

* check.endsWithout('ab', 'a'); // returns `true`
* check.endsWithout(['a', 'b'], 'b'); // returns `false`
* check.endsWithout(['a', 'b'], 'a'); // returns `true`
* check.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -186,4 +258,16 @@ *

* check.startsWith('ab', 'a'); // returns `true`
* check.startsWith(['a', 'b'], 'b'); // returns `false`
* check.startsWith(['a', 'b'], 'a'); // returns `true`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -209,4 +293,16 @@ *

* check.startsWith('ab', 'a'); // returns `true`
* check.startsWith(['a', 'b'], 'b'); // returns `false`
* check.startsWith(['a', 'b'], 'a'); // returns `true`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -234,4 +330,16 @@ *

* assertWrap.endsWith('ab', 'a'); // throws an error
* assertWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* assertWrap.endsWith(['a', 'b'], 'a'); // throws an error
* assertWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* assertWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // throws an error
* ```

@@ -260,4 +368,16 @@ *

* assertWrap.endsWithout('ab', 'a'); // returns `'ab'`
* assertWrap.endsWithout(['a', 'b'], 'b'); // throws an error
* assertWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
* assertWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // throws an error
* assertWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -285,4 +405,16 @@ *

* assertWrap.startsWith('ab', 'a'); // returns `'ab'`
* assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
* assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // throws an error
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -310,4 +442,16 @@ *

* assertWrap.startsWith('ab', 'a'); // throws an error
* assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // throws an error
* ```

@@ -338,4 +482,16 @@ *

* checkWrap.endsWith('ab', 'a'); // returns `undefined`
* checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`
* checkWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* checkWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `undefined`
* ```

@@ -363,4 +519,16 @@ *

* checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
* checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -388,4 +556,16 @@ *

* checkWrap.startsWith('ab', 'a'); // returns `'ab'`
* checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -413,4 +593,16 @@ *

* checkWrap.startsWith('ab', 'a'); // returns `'ab'`
* checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -440,4 +632,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // throws an error
* await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -466,4 +664,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
* await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // throws an error
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* ```

@@ -492,4 +696,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
* await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // throws an error
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* ```

@@ -517,4 +727,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // throws an error
* await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -521,0 +737,0 @@ *

296

dist/assertions/boundary.js

@@ -82,4 +82,16 @@ import { stringify } from '@augment-vir/core';

* assert.endsWith('ab', 'a'); // fails
* assert.endsWith(['a', 'b'], 'b'); // passes
* assert.endsWith(['a', 'b'], 'a'); // fails
* assert.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // passes
* assert.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // fails
* ```

@@ -106,4 +118,16 @@ *

* assert.endsWithout('ab', 'a'); // passes
* assert.endsWithout(['a', 'b'], 'b'); // fails
* assert.endsWithout(['a', 'b'], 'a'); // passes
* assert.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // fails
* assert.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // passes
* ```

@@ -130,4 +154,16 @@ *

* assert.startsWith('ab', 'a'); // passes
* assert.startsWith(['a', 'b'], 'b'); // fails
* assert.startsWith(['a', 'b'], 'a'); // passes
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // fails
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // passes
* ```

@@ -154,4 +190,16 @@ *

* assert.startsWith('ab', 'a'); // fails
* assert.startsWith(['a', 'b'], 'b'); // passes
* assert.startsWith(['a', 'b'], 'a'); // fails
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // passes
* assert.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // fails
* ```

@@ -182,4 +230,16 @@ *

* check.endsWith('ab', 'a'); // returns `false`
* check.endsWith(['a', 'b'], 'b'); // returns `true`
* check.endsWith(['a', 'b'], 'a'); // returns `false`
* check.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `true`
* check.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `false`
* ```

@@ -210,4 +270,16 @@ *

* check.endsWithout('ab', 'a'); // returns `true`
* check.endsWithout(['a', 'b'], 'b'); // returns `false`
* check.endsWithout(['a', 'b'], 'a'); // returns `true`
* check.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -238,4 +310,16 @@ *

* check.startsWith('ab', 'a'); // returns `true`
* check.startsWith(['a', 'b'], 'b'); // returns `false`
* check.startsWith(['a', 'b'], 'a'); // returns `true`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -266,4 +350,16 @@ *

* check.startsWith('ab', 'a'); // returns `true`
* check.startsWith(['a', 'b'], 'b'); // returns `false`
* check.startsWith(['a', 'b'], 'a'); // returns `true`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `false`
* check.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `true`
* ```

@@ -296,4 +392,16 @@ *

* assertWrap.endsWith('ab', 'a'); // throws an error
* assertWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* assertWrap.endsWith(['a', 'b'], 'a'); // throws an error
* assertWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* assertWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // throws an error
* ```

@@ -332,4 +440,16 @@ *

* assertWrap.endsWithout('ab', 'a'); // returns `'ab'`
* assertWrap.endsWithout(['a', 'b'], 'b'); // throws an error
* assertWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
* assertWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // throws an error
* assertWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -367,4 +487,16 @@ *

* assertWrap.startsWith('ab', 'a'); // returns `'ab'`
* assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
* assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // throws an error
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -402,4 +534,16 @@ *

* assertWrap.startsWith('ab', 'a'); // throws an error
* assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* assertWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // throws an error
* ```

@@ -440,4 +584,16 @@ *

* checkWrap.endsWith('ab', 'a'); // returns `undefined`
* checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
* checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`
* checkWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `['a', 'b']`
* checkWrap.endsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `undefined`
* ```

@@ -480,4 +636,16 @@ *

* checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
* checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.endsWithout(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -520,4 +688,16 @@ *

* checkWrap.startsWith('ab', 'a'); // returns `'ab'`
* checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -560,4 +740,16 @@ *

* checkWrap.startsWith('ab', 'a'); // returns `'ab'`
* checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
* checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'b',
* ); // returns `undefined`
* checkWrap.startsWith(
* [
* 'a',
* 'b',
* ],
* 'a',
* ); // returns `['a', 'b']`
* ```

@@ -602,4 +794,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // throws an error
* await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -628,4 +826,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
* await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // throws an error
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* ```

@@ -654,4 +858,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
* await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // throws an error
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* ```

@@ -679,4 +889,10 @@ *

* await waitUntil.endsWith('a', () => 'ab'); // throws an error
* await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
* await waitUntil.endsWith('b', () => [
* 'a',
* 'b',
* ]); // returns `['a', 'b']`
* await waitUntil.endsWith('a', () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -683,0 +899,0 @@ *

40

dist/assertions/equality/entry-equality.js

@@ -41,3 +41,6 @@ import { stringify } from '@augment-vir/core';

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
allKeys.forEach((key) => {

@@ -83,3 +86,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
const valid = allKeys.some((key) => {

@@ -134,3 +140,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
return allKeys.every((key) => {

@@ -178,3 +187,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
return allKeys.some((key) => {

@@ -225,3 +237,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
allKeys.forEach((key) => {

@@ -274,3 +289,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
const valid = allKeys.some((key) => {

@@ -328,3 +346,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
const valid = allKeys.every((key) => {

@@ -380,3 +401,6 @@ const actualValue = actual[key];

}
const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
const allKeys = Array.from(new Set([
...Reflect.ownKeys(actual),
...Reflect.ownKeys(expected),
]));
const valid = allKeys.some((key) => {

@@ -383,0 +407,0 @@ const actualValue = actual[key];

128

dist/assertions/keys.d.ts

@@ -101,4 +101,10 @@ import { type MaybePromise, type NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';

*
* assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
* assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
* assert.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // passes
* assert.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // fails
* ```

@@ -122,4 +128,10 @@ *

*
* assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
* assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
* assert.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // fails
* assert.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // passes
* ```

@@ -219,4 +231,10 @@ *

*
* check.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `true`
* check.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
* check.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `true`
* check.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `false`
* ```

@@ -239,4 +257,10 @@ *

*
* check.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
* check.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `true`
* check.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `false`
* check.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `true`
* ```

@@ -346,4 +370,10 @@ *

*
* assertWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
* assertWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
* assertWrap.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `{a: 0, b: 1}`
* assertWrap.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // throws an error
* ```

@@ -368,4 +398,10 @@ *

*
* assertWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
* assertWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
* assertWrap.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // throws an error
* assertWrap.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `{a: 0, b: 1}`
* ```

@@ -475,4 +511,10 @@ *

*
* checkWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
* checkWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
* checkWrap.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `{a: 0, b: 1}`
* checkWrap.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `undefined`
* ```

@@ -497,4 +539,10 @@ *

*
* checkWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
* checkWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
* checkWrap.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `undefined`
* checkWrap.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `{a: 0, b: 1}`
* ```

@@ -620,8 +668,20 @@ *

*
* await waitUntil.hasKeys(['a', 'b'], () => {
* return {a: 0, b: 1};
* }); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(['b', 'c'], () => {
* return {a: 0, b: 1};
* }); // throws an error
* await waitUntil.hasKeys(
* [
* 'a',
* 'b',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(
* [
* 'b',
* 'c',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // throws an error
* ```

@@ -648,8 +708,20 @@ *

*
* await waitUntil.hasKeys(['a', 'b'], () => {
* return {a: 0, b: 1};
* }); // throws an error
* await waitUntil.hasKeys(['b', 'c'], () => {
* return {a: 0, b: 1};
* }); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(
* [
* 'a',
* 'b',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // throws an error
* await waitUntil.hasKeys(
* [
* 'b',
* 'c',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // returns `{a: 0, b: 1}`
* ```

@@ -656,0 +728,0 @@ *

128

dist/assertions/keys.js

@@ -128,4 +128,10 @@ import { stringify, } from '@augment-vir/core';

*
* assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
* assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
* assert.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // passes
* assert.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // fails
* ```

@@ -154,4 +160,10 @@ *

*
* assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
* assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
* assert.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // fails
* assert.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // passes
* ```

@@ -264,4 +276,10 @@ *

*
* check.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `true`
* check.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
* check.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `true`
* check.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `false`
* ```

@@ -286,4 +304,10 @@ *

*
* check.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
* check.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `true`
* check.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `false`
* check.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `true`
* ```

@@ -415,4 +439,10 @@ *

*
* assertWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
* assertWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
* assertWrap.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `{a: 0, b: 1}`
* assertWrap.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // throws an error
* ```

@@ -443,4 +473,10 @@ *

*
* assertWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
* assertWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
* assertWrap.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // throws an error
* assertWrap.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `{a: 0, b: 1}`
* ```

@@ -584,4 +620,10 @@ *

*
* checkWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
* checkWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
* checkWrap.hasKeys({a: 0, b: 1}, [
* 'a',
* 'b',
* ]); // returns `{a: 0, b: 1}`
* checkWrap.hasKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `undefined`
* ```

@@ -613,4 +655,10 @@ *

*
* checkWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
* checkWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
* checkWrap.lacksKeys({a: 0, b: 1}, [
* 'b',
* 'c',
* ]); // returns `undefined`
* checkWrap.lacksKeys({a: 0, b: 1}, [
* 'c',
* 'd',
* ]); // returns `{a: 0, b: 1}`
* ```

@@ -743,8 +791,20 @@ *

*
* await waitUntil.hasKeys(['a', 'b'], () => {
* return {a: 0, b: 1};
* }); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(['b', 'c'], () => {
* return {a: 0, b: 1};
* }); // throws an error
* await waitUntil.hasKeys(
* [
* 'a',
* 'b',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(
* [
* 'b',
* 'c',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // throws an error
* ```

@@ -771,8 +831,20 @@ *

*
* await waitUntil.hasKeys(['a', 'b'], () => {
* return {a: 0, b: 1};
* }); // throws an error
* await waitUntil.hasKeys(['b', 'c'], () => {
* return {a: 0, b: 1};
* }); // returns `{a: 0, b: 1}`
* await waitUntil.hasKeys(
* [
* 'a',
* 'b',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // throws an error
* await waitUntil.hasKeys(
* [
* 'b',
* 'c',
* ],
* () => {
* return {a: 0, b: 1};
* },
* ); // returns `{a: 0, b: 1}`
* ```

@@ -779,0 +851,0 @@ *

242

dist/assertions/length.d.ts

@@ -35,5 +35,25 @@ import { type AnyObject, type AtLeastTuple, type MaybePromise, type Tuple } from '@augment-vir/core';

*
* assert.isLengthAtLeast(['a', 'b', 'c'], 2); // passes
* assert.isLengthAtLeast(['a', 'b', 'c'], 3); // passes
* assert.isLengthAtLeast(['a', 'b'], 3); // fails
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // passes
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -56,5 +76,25 @@ *

*
* assert.isLengthExactly(['a', 'b', 'c'], 2); // fails
* assert.isLengthExactly(['a', 'b', 'c'], 3); // passes
* assert.isLengthExactly(['a', 'b'], 3); // fails
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // fails
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -79,5 +119,25 @@ *

*
* check.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `true`
* check.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `true`
* check.isLengthAtLeast(['a', 'b'], 3); // returns `false`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `true`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `true`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `false`
* ```

@@ -99,5 +159,25 @@ *

*
* check.isLengthExactly(['a', 'b', 'c'], 2); // fails
* check.isLengthExactly(['a', 'b', 'c'], 3); // passes
* check.isLengthExactly(['a', 'b'], 3); // fails
* check.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // fails
* check.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* check.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -122,5 +202,25 @@ *

*
* assertWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(['a', 'b'], 3); // throws an error
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // throws an error
* ```

@@ -145,5 +245,25 @@ *

*
* assertWrap.isLengthExactly(['a', 'b', 'c'], 2); // throws an error
* assertWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* assertWrap.isLengthExactly(['a', 'b'], 3); // throws an error
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // throws an error
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // throws an error
* ```

@@ -170,5 +290,25 @@ *

*
* checkWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(['a', 'b'], 3); // returns `undefined`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `undefined`
* ```

@@ -192,5 +332,25 @@ *

*
* checkWrap.isLengthExactly(['a', 'b', 'c'], 2); // returns `undefined`
* checkWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* checkWrap.isLengthExactly(['a', 'b'], 3); // returns `undefined`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `undefined`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `undefined`
* ```

@@ -217,5 +377,16 @@ *

*
* await waitUntil.isLengthAtLeast(2, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b']); // throws an error
* await waitUntil.isLengthAtLeast(2, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -241,5 +412,16 @@ *

*
* await waitUntil.isLengthAtLeast(2, () => ['a', 'b', 'c']); // throws an error
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b']); // throws an error
* await waitUntil.isLengthAtLeast(2, () => [
* 'a',
* 'b',
* 'c',
* ]); // throws an error
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -246,0 +428,0 @@ *

242

dist/assertions/length.js

@@ -57,5 +57,25 @@ /* eslint-disable @typescript-eslint/no-unused-vars */

*
* assert.isLengthAtLeast(['a', 'b', 'c'], 2); // passes
* assert.isLengthAtLeast(['a', 'b', 'c'], 3); // passes
* assert.isLengthAtLeast(['a', 'b'], 3); // fails
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // passes
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* assert.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -78,5 +98,25 @@ *

*
* assert.isLengthExactly(['a', 'b', 'c'], 2); // fails
* assert.isLengthExactly(['a', 'b', 'c'], 3); // passes
* assert.isLengthExactly(['a', 'b'], 3); // fails
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // fails
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* assert.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -103,5 +143,25 @@ *

*
* check.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `true`
* check.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `true`
* check.isLengthAtLeast(['a', 'b'], 3); // returns `false`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `true`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `true`
* check.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `false`
* ```

@@ -128,5 +188,25 @@ *

*
* check.isLengthExactly(['a', 'b', 'c'], 2); // fails
* check.isLengthExactly(['a', 'b', 'c'], 3); // passes
* check.isLengthExactly(['a', 'b'], 3); // fails
* check.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // fails
* check.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // passes
* check.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // fails
* ```

@@ -156,5 +236,25 @@ *

*
* assertWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(['a', 'b'], 3); // throws an error
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // throws an error
* ```

@@ -187,5 +287,25 @@ *

*
* assertWrap.isLengthExactly(['a', 'b', 'c'], 2); // throws an error
* assertWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* assertWrap.isLengthExactly(['a', 'b'], 3); // throws an error
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // throws an error
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* assertWrap.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // throws an error
* ```

@@ -220,5 +340,25 @@ *

*
* checkWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(['a', 'b'], 3); // returns `undefined`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthAtLeast(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `undefined`
* ```

@@ -252,5 +392,25 @@ *

*
* checkWrap.isLengthExactly(['a', 'b', 'c'], 2); // returns `undefined`
* checkWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
* checkWrap.isLengthExactly(['a', 'b'], 3); // returns `undefined`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 2,
* ); // returns `undefined`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* 'c',
* ],
* 3,
* ); // returns `['a', 'b', 'c']`
* checkWrap.isLengthExactly(
* [
* 'a',
* 'b',
* ],
* 3,
* ); // returns `undefined`
* ```

@@ -287,5 +447,16 @@ *

*
* await waitUntil.isLengthAtLeast(2, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b']); // throws an error
* await waitUntil.isLengthAtLeast(2, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -311,5 +482,16 @@ *

*
* await waitUntil.isLengthAtLeast(2, () => ['a', 'b', 'c']); // throws an error
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b', 'c']); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => ['a', 'b']); // throws an error
* await waitUntil.isLengthAtLeast(2, () => [
* 'a',
* 'b',
* 'c',
* ]); // throws an error
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* 'c',
* ]); // returns `['a', 'b', 'c']`
* await waitUntil.isLengthAtLeast(3, () => [
* 'a',
* 'b',
* ]); // throws an error
* ```

@@ -316,0 +498,0 @@ *

8

dist/assertions/output.js

@@ -26,3 +26,9 @@ import { combineErrorMessages, ensureError, ensureErrorAndPrependMessage, extractErrorMessage, stringify, wait, } from '@augment-vir/core';

: failureMessageOrExpectedOutput;
return [asserter, functionToCall, inputs, expectedOutput, failureMessage];
return [
asserter,
functionToCall,
inputs,
expectedOutput,
failureMessage,
];
}

@@ -29,0 +35,0 @@ function innerAssertOutput(asserter, functionToCall, inputs, expectedOutput, failureMessage, shouldReturnResult) {

200

dist/assertions/values.d.ts

@@ -87,5 +87,17 @@ import type { NarrowToActual, NarrowToExpected } from '@augment-vir/core';

*
* assert.hasValues({child, child2}, [child, child2]); // passes
* assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
* assert.hasValues([child], [child, child2]); // passes
* assert.hasValues({child, child2}, [
* child,
* child2,
* ]); // passes
* assert.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // fails
* assert.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // passes
* ```

@@ -113,5 +125,14 @@ *

*
* assert.lacksValues({}, [child, child2]); // passes
* assert.lacksValues({child, child2}, [child, child2]); // fails
* assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
* assert.lacksValues({}, [
* child,
* child2,
* ]); // passes
* assert.lacksValues({child, child2}, [
* child,
* child2,
* ]); // fails
* assert.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // fails
* ```

@@ -283,5 +304,17 @@ *

*
* check.hasValues({child, child2}, [child, child2]); // returns `true`
* check.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
* check.hasValues([child], [child, child2]); // returns `true`
* check.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `true`
* check.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `false`
* check.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `true`
* ```

@@ -308,5 +341,14 @@ *

*
* check.lacksValues({}, [child, child2]); // returns `true`
* check.lacksValues({child, child2}, [child, child2]); // returns `false`
* check.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
* check.lacksValues({}, [
* child,
* child2,
* ]); // returns `true`
* check.lacksValues({child, child2}, [
* child,
* child2,
* ]); // returns `false`
* check.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `false`
* ```

@@ -479,5 +521,17 @@ *

*
* assertWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`;
* assertWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
* assertWrap.hasValues([child], [child, child2]); // returns `[child]`;
* assertWrap.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `{child, child2}`;
* assertWrap.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // throws an error
* assertWrap.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `[child]`;
* ```

@@ -506,5 +560,14 @@ *

*
* assertWrap.lacksValues({}, [child, child2]); // returns `{}`;
* assertWrap.lacksValues({child, child2}, [child, child2]); // throws an error
* assertWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
* assertWrap.lacksValues({}, [
* child,
* child2,
* ]); // returns `{}`;
* assertWrap.lacksValues({child, child2}, [
* child,
* child2,
* ]); // throws an error
* assertWrap.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // throws an error
* ```

@@ -683,5 +746,17 @@ *

*
* checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
* checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
* checkWrap.hasValues([child], [child, child2]); // returns `[child]`
* checkWrap.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `{child, child2}`
* checkWrap.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* checkWrap.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `[child]`
* ```

@@ -708,5 +783,14 @@ *

*
* checkWrap.lacksValues({}, [child, child2]); // returns `{}`
* checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
* checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
* checkWrap.lacksValues({}, [
* child,
* child2,
* ]); // returns `{}`
* checkWrap.lacksValues({child, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* checkWrap.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* ```

@@ -890,9 +974,27 @@ *

*
* await waitUntil.hasValues([child, child2], () => {
* return {child, child2};
* }); // returns `{child, child2}`;
* await waitUntil.hasValues([child, child2], () => {
* return {child: {a: 'a'}, child2};
* }); // throws an error
* await waitUntil.hasValues([child, child2], () => [child]); // returns `[child]`;
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => {
* return {child, child2};
* },
* ); // returns `{child, child2}`;
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => {
* return {child: {a: 'a'}, child2};
* },
* ); // throws an error
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => [child],
* ); // returns `[child]`;
* ```

@@ -922,11 +1024,29 @@ *

*
* await waitUntil.lacksValues([child, child2], () => {
* return {};
* }); // returns `{}`;
* await waitUntil.lacksValues([child, child2], () => {
* return {child, child2};
* }); // throws an error
* await waitUntil.lacksValues([child, child2], () => {
* return {child: {a: 'a'}, child2};
* }); // throws an error
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {};
* },
* ); // returns `{}`;
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {child, child2};
* },
* ); // throws an error
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {child: {a: 'a'}, child2};
* },
* ); // throws an error
* ```

@@ -933,0 +1053,0 @@ *

200

dist/assertions/values.js

@@ -97,5 +97,17 @@ import { stringify } from '@augment-vir/core';

*
* assert.hasValues({child, child2}, [child, child2]); // passes
* assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
* assert.hasValues([child], [child, child2]); // passes
* assert.hasValues({child, child2}, [
* child,
* child2,
* ]); // passes
* assert.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // fails
* assert.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // passes
* ```

@@ -144,5 +156,14 @@ *

*
* assert.lacksValues({}, [child, child2]); // passes
* assert.lacksValues({child, child2}, [child, child2]); // fails
* assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
* assert.lacksValues({}, [
* child,
* child2,
* ]); // passes
* assert.lacksValues({child, child2}, [
* child,
* child2,
* ]); // fails
* assert.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // fails
* ```

@@ -396,5 +417,17 @@ *

*
* check.hasValues({child, child2}, [child, child2]); // returns `true`
* check.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
* check.hasValues([child], [child, child2]); // returns `true`
* check.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `true`
* check.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `false`
* check.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `true`
* ```

@@ -423,5 +456,14 @@ *

*
* check.lacksValues({}, [child, child2]); // returns `true`
* check.lacksValues({child, child2}, [child, child2]); // returns `false`
* check.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
* check.lacksValues({}, [
* child,
* child2,
* ]); // returns `true`
* check.lacksValues({child, child2}, [
* child,
* child2,
* ]); // returns `false`
* check.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `false`
* ```

@@ -648,5 +690,17 @@ *

*
* assertWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`;
* assertWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
* assertWrap.hasValues([child], [child, child2]); // returns `[child]`;
* assertWrap.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `{child, child2}`;
* assertWrap.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // throws an error
* assertWrap.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `[child]`;
* ```

@@ -697,5 +751,14 @@ *

*
* assertWrap.lacksValues({}, [child, child2]); // returns `{}`;
* assertWrap.lacksValues({child, child2}, [child, child2]); // throws an error
* assertWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
* assertWrap.lacksValues({}, [
* child,
* child2,
* ]); // returns `{}`;
* assertWrap.lacksValues({child, child2}, [
* child,
* child2,
* ]); // throws an error
* assertWrap.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // throws an error
* ```

@@ -968,5 +1031,17 @@ *

*
* checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
* checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
* checkWrap.hasValues([child], [child, child2]); // returns `[child]`
* checkWrap.hasValues({child, child2}, [
* child,
* child2,
* ]); // returns `{child, child2}`
* checkWrap.hasValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* checkWrap.hasValues(
* [child],
* [
* child,
* child2,
* ],
* ); // returns `[child]`
* ```

@@ -1000,5 +1075,14 @@ *

*
* checkWrap.lacksValues({}, [child, child2]); // returns `{}`
* checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
* checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
* checkWrap.lacksValues({}, [
* child,
* child2,
* ]); // returns `{}`
* checkWrap.lacksValues({child, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* checkWrap.lacksValues({child: {a: 'a'}, child2}, [
* child,
* child2,
* ]); // returns `undefined`
* ```

@@ -1249,9 +1333,27 @@ *

*
* await waitUntil.hasValues([child, child2], () => {
* return {child, child2};
* }); // returns `{child, child2}`;
* await waitUntil.hasValues([child, child2], () => {
* return {child: {a: 'a'}, child2};
* }); // throws an error
* await waitUntil.hasValues([child, child2], () => [child]); // returns `[child]`;
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => {
* return {child, child2};
* },
* ); // returns `{child, child2}`;
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => {
* return {child: {a: 'a'}, child2};
* },
* ); // throws an error
* await waitUntil.hasValues(
* [
* child,
* child2,
* ],
* () => [child],
* ); // returns `[child]`;
* ```

@@ -1281,11 +1383,29 @@ *

*
* await waitUntil.lacksValues([child, child2], () => {
* return {};
* }); // returns `{}`;
* await waitUntil.lacksValues([child, child2], () => {
* return {child, child2};
* }); // throws an error
* await waitUntil.lacksValues([child, child2], () => {
* return {child: {a: 'a'}, child2};
* }); // throws an error
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {};
* },
* ); // returns `{}`;
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {child, child2};
* },
* ); // throws an error
* await waitUntil.lacksValues(
* [
* child,
* child2,
* ],
* () => {
* return {child: {a: 'a'}, child2};
* },
* ); // throws an error
* ```

@@ -1292,0 +1412,0 @@ *

5

dist/augments/guards/wait-until.js

@@ -47,3 +47,6 @@ import { guardOverrides } from '../../assertions/extendable-assertions.js';

}
}, [input, failureMessage], false);
}, [
input,
failureMessage,
], false);
}, waitUntilMethods);

14

package.json
{
"name": "@augment-vir/assert",
"version": "31.9.1",
"version": "31.9.2",
"description": "A collection of assertions for test and production code alike.",

@@ -44,12 +44,12 @@ "keywords": [

"dependencies": {
"@augment-vir/core": "^31.9.1",
"@date-vir/duration": "^7.1.2",
"@augment-vir/core": "^31.9.2",
"@date-vir/duration": "^7.2.0",
"deep-eql": "^5.0.2",
"expect-type": "^1.1.0",
"type-fest": "^4.33.0"
"type-fest": "^4.35.0"
},
"devDependencies": {
"@types/deep-eql": "^4.0.2",
"@web/dev-server-esbuild": "^1.0.3",
"@web/test-runner": "^0.19.0",
"@web/dev-server-esbuild": "^1.0.4",
"@web/test-runner": "^0.20.0",
"@web/test-runner-commands": "^0.9.0",

@@ -60,3 +60,3 @@ "@web/test-runner-playwright": "^0.11.0",

"istanbul-smart-text-reporter": "^1.1.5",
"typescript": "^5.7.2"
"typescript": "^5.7.3"
},

@@ -63,0 +63,0 @@ "engines": {