@augment-vir/assert 31.9.0 → 31.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/dist/assertions/boundary.d.ts +256 -40
  2. package/dist/assertions/boundary.js +256 -40
  3. package/dist/assertions/equality/entry-equality.js +32 -8
  4. package/dist/assertions/keys.d.ts +100 -28
  5. package/dist/assertions/keys.js +100 -28
  6. package/dist/assertions/length.d.ts +212 -30
  7. package/dist/assertions/length.js +212 -30
  8. package/dist/assertions/output.js +7 -1
  9. package/dist/assertions/values.d.ts +160 -40
  10. package/dist/assertions/values.js +160 -40
  11. package/dist/augments/guards/wait-until.js +4 -1
  12. package/package.json +7 -7
package/dist/assertions/boundary.d.ts CHANGED
@@ -39,8 +39,20 @@ export declare const boundaryGuards: {
39
39
  *
40
40
  * assert.endsWith('ab', 'b'); // passes
41
41
  * assert.endsWith('ab', 'a'); // fails
42
- * assert.endsWith(['a', 'b'], 'b'); // passes
43
- * assert.endsWith(['a', 'b'], 'a'); // fails
42
+ * assert.endsWith(
43
+ * [
44
+ * 'a',
45
+ * 'b',
46
+ * ],
47
+ * 'b',
48
+ * ); // passes
49
+ * assert.endsWith(
50
+ * [
51
+ * 'a',
52
+ * 'b',
53
+ * ],
54
+ * 'a',
55
+ * ); // fails
44
56
  * ```
45
57
  *
46
58
  * @throws {@link AssertionError} If the parent does not end with the child.
@@ -62,8 +74,20 @@ export declare const boundaryGuards: {
62
74
  *
63
75
  * assert.endsWithout('ab', 'b'); // fails
64
76
  * assert.endsWithout('ab', 'a'); // passes
65
- * assert.endsWithout(['a', 'b'], 'b'); // fails
66
- * assert.endsWithout(['a', 'b'], 'a'); // passes
77
+ * assert.endsWithout(
78
+ * [
79
+ * 'a',
80
+ * 'b',
81
+ * ],
82
+ * 'b',
83
+ * ); // fails
84
+ * assert.endsWithout(
85
+ * [
86
+ * 'a',
87
+ * 'b',
88
+ * ],
89
+ * 'a',
90
+ * ); // passes
67
91
  * ```
68
92
  *
69
93
  * @throws {@link AssertionError} If the parent ends with the child.
@@ -85,8 +109,20 @@ export declare const boundaryGuards: {
85
109
  *
86
110
  * assert.startsWith('ab', 'b'); // fails
87
111
  * assert.startsWith('ab', 'a'); // passes
88
- * assert.startsWith(['a', 'b'], 'b'); // fails
89
- * assert.startsWith(['a', 'b'], 'a'); // passes
112
+ * assert.startsWith(
113
+ * [
114
+ * 'a',
115
+ * 'b',
116
+ * ],
117
+ * 'b',
118
+ * ); // fails
119
+ * assert.startsWith(
120
+ * [
121
+ * 'a',
122
+ * 'b',
123
+ * ],
124
+ * 'a',
125
+ * ); // passes
90
126
  * ```
91
127
  *
92
128
  * @throws {@link AssertionError} If the parent does not start with the child.
@@ -108,8 +144,20 @@ export declare const boundaryGuards: {
108
144
  *
109
145
  * assert.startsWith('ab', 'b'); // passes
110
146
  * assert.startsWith('ab', 'a'); // fails
111
- * assert.startsWith(['a', 'b'], 'b'); // passes
112
- * assert.startsWith(['a', 'b'], 'a'); // fails
147
+ * assert.startsWith(
148
+ * [
149
+ * 'a',
150
+ * 'b',
151
+ * ],
152
+ * 'b',
153
+ * ); // passes
154
+ * assert.startsWith(
155
+ * [
156
+ * 'a',
157
+ * 'b',
158
+ * ],
159
+ * 'a',
160
+ * ); // fails
113
161
  * ```
114
162
  *
115
163
  * @throws {@link AssertionError} If the parent does start with the child.
@@ -133,8 +181,20 @@ export declare const boundaryGuards: {
133
181
  *
134
182
  * check.endsWith('ab', 'b'); // returns `true`
135
183
  * check.endsWith('ab', 'a'); // returns `false`
136
- * check.endsWith(['a', 'b'], 'b'); // returns `true`
137
- * check.endsWith(['a', 'b'], 'a'); // returns `false`
184
+ * check.endsWith(
185
+ * [
186
+ * 'a',
187
+ * 'b',
188
+ * ],
189
+ * 'b',
190
+ * ); // returns `true`
191
+ * check.endsWith(
192
+ * [
193
+ * 'a',
194
+ * 'b',
195
+ * ],
196
+ * 'a',
197
+ * ); // returns `false`
138
198
  * ```
139
199
  *
140
200
  * @see
@@ -155,8 +215,20 @@ export declare const boundaryGuards: {
155
215
  *
156
216
  * check.endsWithout('ab', 'b'); // returns `false`
157
217
  * check.endsWithout('ab', 'a'); // returns `true`
158
- * check.endsWithout(['a', 'b'], 'b'); // returns `false`
159
- * check.endsWithout(['a', 'b'], 'a'); // returns `true`
218
+ * check.endsWithout(
219
+ * [
220
+ * 'a',
221
+ * 'b',
222
+ * ],
223
+ * 'b',
224
+ * ); // returns `false`
225
+ * check.endsWithout(
226
+ * [
227
+ * 'a',
228
+ * 'b',
229
+ * ],
230
+ * 'a',
231
+ * ); // returns `true`
160
232
  * ```
161
233
  *
162
234
  * @see
@@ -177,8 +249,20 @@ export declare const boundaryGuards: {
177
249
  *
178
250
  * check.startsWith('ab', 'b'); // returns `false`
179
251
  * check.startsWith('ab', 'a'); // returns `true`
180
- * check.startsWith(['a', 'b'], 'b'); // returns `false`
181
- * check.startsWith(['a', 'b'], 'a'); // returns `true`
252
+ * check.startsWith(
253
+ * [
254
+ * 'a',
255
+ * 'b',
256
+ * ],
257
+ * 'b',
258
+ * ); // returns `false`
259
+ * check.startsWith(
260
+ * [
261
+ * 'a',
262
+ * 'b',
263
+ * ],
264
+ * 'a',
265
+ * ); // returns `true`
182
266
  * ```
183
267
  *
184
268
  * @see
@@ -199,8 +283,20 @@ export declare const boundaryGuards: {
199
283
  *
200
284
  * check.startsWith('ab', 'b'); // returns `false`
201
285
  * check.startsWith('ab', 'a'); // returns `true`
202
- * check.startsWith(['a', 'b'], 'b'); // returns `false`
203
- * check.startsWith(['a', 'b'], 'a'); // returns `true`
286
+ * check.startsWith(
287
+ * [
288
+ * 'a',
289
+ * 'b',
290
+ * ],
291
+ * 'b',
292
+ * ); // returns `false`
293
+ * check.startsWith(
294
+ * [
295
+ * 'a',
296
+ * 'b',
297
+ * ],
298
+ * 'a',
299
+ * ); // returns `true`
204
300
  * ```
205
301
  *
206
302
  * @see
@@ -223,8 +319,20 @@ export declare const boundaryGuards: {
223
319
  *
224
320
  * assertWrap.endsWith('ab', 'b'); // returns `'ab'`
225
321
  * assertWrap.endsWith('ab', 'a'); // throws an error
226
- * assertWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
227
- * assertWrap.endsWith(['a', 'b'], 'a'); // throws an error
322
+ * assertWrap.endsWith(
323
+ * [
324
+ * 'a',
325
+ * 'b',
326
+ * ],
327
+ * 'b',
328
+ * ); // returns `['a', 'b']`
329
+ * assertWrap.endsWith(
330
+ * [
331
+ * 'a',
332
+ * 'b',
333
+ * ],
334
+ * 'a',
335
+ * ); // throws an error
228
336
  * ```
229
337
  *
230
338
  * @returns The parent value if it does end with the child.
@@ -248,8 +356,20 @@ export declare const boundaryGuards: {
248
356
  *
249
357
  * assertWrap.endsWithout('ab', 'b'); // throws an error
250
358
  * assertWrap.endsWithout('ab', 'a'); // returns `'ab'`
251
- * assertWrap.endsWithout(['a', 'b'], 'b'); // throws an error
252
- * assertWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
359
+ * assertWrap.endsWithout(
360
+ * [
361
+ * 'a',
362
+ * 'b',
363
+ * ],
364
+ * 'b',
365
+ * ); // throws an error
366
+ * assertWrap.endsWithout(
367
+ * [
368
+ * 'a',
369
+ * 'b',
370
+ * ],
371
+ * 'a',
372
+ * ); // returns `['a', 'b']`
253
373
  * ```
254
374
  *
255
375
  * @returns The parent value if it does not end with the child.
@@ -272,8 +392,20 @@ export declare const boundaryGuards: {
272
392
  *
273
393
  * assertWrap.startsWith('ab', 'b'); // throws an error
274
394
  * assertWrap.startsWith('ab', 'a'); // returns `'ab'`
275
- * assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
276
- * assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
395
+ * assertWrap.startsWith(
396
+ * [
397
+ * 'a',
398
+ * 'b',
399
+ * ],
400
+ * 'b',
401
+ * ); // throws an error
402
+ * assertWrap.startsWith(
403
+ * [
404
+ * 'a',
405
+ * 'b',
406
+ * ],
407
+ * 'a',
408
+ * ); // returns `['a', 'b']`
277
409
  * ```
278
410
  *
279
411
  * @returns The parent value if it starts with the child.
@@ -296,8 +428,20 @@ export declare const boundaryGuards: {
296
428
  *
297
429
  * assertWrap.startsWith('ab', 'b'); // returns `'ab'`
298
430
  * assertWrap.startsWith('ab', 'a'); // throws an error
299
- * assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
300
- * assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
431
+ * assertWrap.startsWith(
432
+ * [
433
+ * 'a',
434
+ * 'b',
435
+ * ],
436
+ * 'b',
437
+ * ); // returns `['a', 'b']`
438
+ * assertWrap.startsWith(
439
+ * [
440
+ * 'a',
441
+ * 'b',
442
+ * ],
443
+ * 'a',
444
+ * ); // throws an error
301
445
  * ```
302
446
  *
303
447
  * @returns The parent value if it does not start with the child.
@@ -323,8 +467,20 @@ export declare const boundaryGuards: {
323
467
  *
324
468
  * checkWrap.endsWith('ab', 'b'); // returns `'ab'`
325
469
  * checkWrap.endsWith('ab', 'a'); // returns `undefined`
326
- * checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
327
- * checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`
470
+ * checkWrap.endsWith(
471
+ * [
472
+ * 'a',
473
+ * 'b',
474
+ * ],
475
+ * 'b',
476
+ * ); // returns `['a', 'b']`
477
+ * checkWrap.endsWith(
478
+ * [
479
+ * 'a',
480
+ * 'b',
481
+ * ],
482
+ * 'a',
483
+ * ); // returns `undefined`
328
484
  * ```
329
485
  *
330
486
  * @returns The first value if the check passes, otherwise `undefined`.
@@ -347,8 +503,20 @@ export declare const boundaryGuards: {
347
503
  *
348
504
  * checkWrap.endsWithout('ab', 'b'); // returns `undefined`
349
505
  * checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
350
- * checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
351
- * checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
506
+ * checkWrap.endsWithout(
507
+ * [
508
+ * 'a',
509
+ * 'b',
510
+ * ],
511
+ * 'b',
512
+ * ); // returns `undefined`
513
+ * checkWrap.endsWithout(
514
+ * [
515
+ * 'a',
516
+ * 'b',
517
+ * ],
518
+ * 'a',
519
+ * ); // returns `['a', 'b']`
352
520
  * ```
353
521
  *
354
522
  * @returns The first value if the check passes, otherwise `undefined`.
@@ -371,8 +539,20 @@ export declare const boundaryGuards: {
371
539
  *
372
540
  * checkWrap.startsWith('ab', 'b'); // returns `undefined`
373
541
  * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
374
- * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
375
- * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
542
+ * checkWrap.startsWith(
543
+ * [
544
+ * 'a',
545
+ * 'b',
546
+ * ],
547
+ * 'b',
548
+ * ); // returns `undefined`
549
+ * checkWrap.startsWith(
550
+ * [
551
+ * 'a',
552
+ * 'b',
553
+ * ],
554
+ * 'a',
555
+ * ); // returns `['a', 'b']`
376
556
  * ```
377
557
  *
378
558
  * @returns The first value if the check passes, otherwise `undefined`.
@@ -395,8 +575,20 @@ export declare const boundaryGuards: {
395
575
  *
396
576
  * checkWrap.startsWith('ab', 'b'); // returns `undefined`
397
577
  * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
398
- * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
399
- * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
578
+ * checkWrap.startsWith(
579
+ * [
580
+ * 'a',
581
+ * 'b',
582
+ * ],
583
+ * 'b',
584
+ * ); // returns `undefined`
585
+ * checkWrap.startsWith(
586
+ * [
587
+ * 'a',
588
+ * 'b',
589
+ * ],
590
+ * 'a',
591
+ * ); // returns `['a', 'b']`
400
592
  * ```
401
593
  *
402
594
  * @returns The first value if the check passes, otherwise `undefined`.
@@ -421,8 +613,14 @@ export declare const boundaryGuards: {
421
613
  *
422
614
  * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
423
615
  * await waitUntil.endsWith('a', () => 'ab'); // throws an error
424
- * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
425
- * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
616
+ * await waitUntil.endsWith('b', () => [
617
+ * 'a',
618
+ * 'b',
619
+ * ]); // returns `['a', 'b']`
620
+ * await waitUntil.endsWith('a', () => [
621
+ * 'a',
622
+ * 'b',
623
+ * ]); // throws an error
426
624
  * ```
427
625
  *
428
626
  * @returns The callback output once it passes.
@@ -446,8 +644,14 @@ export declare const boundaryGuards: {
446
644
  *
447
645
  * await waitUntil.endsWith('b', () => 'ab'); // throws an error
448
646
  * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
449
- * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
450
- * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
647
+ * await waitUntil.endsWith('b', () => [
648
+ * 'a',
649
+ * 'b',
650
+ * ]); // throws an error
651
+ * await waitUntil.endsWith('a', () => [
652
+ * 'a',
653
+ * 'b',
654
+ * ]); // returns `['a', 'b']`
451
655
  * ```
452
656
  *
453
657
  * @returns The callback output once it passes.
@@ -471,8 +675,14 @@ export declare const boundaryGuards: {
471
675
  *
472
676
  * await waitUntil.endsWith('b', () => 'ab'); // throws an error
473
677
  * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
474
- * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
475
- * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
678
+ * await waitUntil.endsWith('b', () => [
679
+ * 'a',
680
+ * 'b',
681
+ * ]); // throws an error
682
+ * await waitUntil.endsWith('a', () => [
683
+ * 'a',
684
+ * 'b',
685
+ * ]); // returns `['a', 'b']`
476
686
  * ```
477
687
  *
478
688
  * @returns The callback output once it passes.
@@ -495,8 +705,14 @@ export declare const boundaryGuards: {
495
705
  * ```ts
496
706
  * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
497
707
  * await waitUntil.endsWith('a', () => 'ab'); // throws an error
498
- * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
499
- * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
708
+ * await waitUntil.endsWith('b', () => [
709
+ * 'a',
710
+ * 'b',
711
+ * ]); // returns `['a', 'b']`
712
+ * await waitUntil.endsWith('a', () => [
713
+ * 'a',
714
+ * 'b',
715
+ * ]); // throws an error
500
716
  * ```
501
717
  *
502
718
  * @returns The callback output once it passes.