@augment-vir/assert 31.9.1 → 31.9.3
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.
- package/dist/assertions/boundary.d.ts +256 -40
- package/dist/assertions/boundary.js +256 -40
- package/dist/assertions/equality/entry-equality.js +32 -8
- package/dist/assertions/equality/ts-type-equality.d.ts +2 -2
- package/dist/assertions/keys.d.ts +100 -28
- package/dist/assertions/keys.js +100 -28
- package/dist/assertions/length.d.ts +212 -30
- package/dist/assertions/length.js +212 -30
- package/dist/assertions/output.js +7 -1
- package/dist/assertions/values.d.ts +160 -40
- package/dist/assertions/values.js +160 -40
- package/dist/augments/guards/wait-until.js +4 -1
- package/package.json +8 -8
|
@@ -98,8 +98,14 @@ export declare const keyGuards: {
|
|
|
98
98
|
* ```ts
|
|
99
99
|
* import {assert} from '@augment-vir/assert';
|
|
100
100
|
*
|
|
101
|
-
* assert.hasKeys({a: 0, b: 1}, [
|
|
102
|
-
*
|
|
101
|
+
* assert.hasKeys({a: 0, b: 1}, [
|
|
102
|
+
* 'a',
|
|
103
|
+
* 'b',
|
|
104
|
+
* ]); // passes
|
|
105
|
+
* assert.hasKeys({a: 0, b: 1}, [
|
|
106
|
+
* 'b',
|
|
107
|
+
* 'c',
|
|
108
|
+
* ]); // fails
|
|
103
109
|
* ```
|
|
104
110
|
*
|
|
105
111
|
* @throws {@link AssertionError} If the parent does not have all the keys.
|
|
@@ -118,8 +124,14 @@ export declare const keyGuards: {
|
|
|
118
124
|
* ```ts
|
|
119
125
|
* import {assert} from '@augment-vir/assert';
|
|
120
126
|
*
|
|
121
|
-
* assert.lacksKeys({a: 0, b: 1}, [
|
|
122
|
-
*
|
|
127
|
+
* assert.lacksKeys({a: 0, b: 1}, [
|
|
128
|
+
* 'b',
|
|
129
|
+
* 'c',
|
|
130
|
+
* ]); // fails
|
|
131
|
+
* assert.lacksKeys({a: 0, b: 1}, [
|
|
132
|
+
* 'c',
|
|
133
|
+
* 'd',
|
|
134
|
+
* ]); // passes
|
|
123
135
|
* ```
|
|
124
136
|
*
|
|
125
137
|
* @throws {@link AssertionError} If the parent has any of the keys.
|
|
@@ -214,8 +226,14 @@ export declare const keyGuards: {
|
|
|
214
226
|
* ```ts
|
|
215
227
|
* import {check} from '@augment-vir/assert';
|
|
216
228
|
*
|
|
217
|
-
* check.hasKeys({a: 0, b: 1}, [
|
|
218
|
-
*
|
|
229
|
+
* check.hasKeys({a: 0, b: 1}, [
|
|
230
|
+
* 'a',
|
|
231
|
+
* 'b',
|
|
232
|
+
* ]); // returns `true`
|
|
233
|
+
* check.hasKeys({a: 0, b: 1}, [
|
|
234
|
+
* 'b',
|
|
235
|
+
* 'c',
|
|
236
|
+
* ]); // returns `false`
|
|
219
237
|
* ```
|
|
220
238
|
*
|
|
221
239
|
* @see
|
|
@@ -233,8 +251,14 @@ export declare const keyGuards: {
|
|
|
233
251
|
* ```ts
|
|
234
252
|
* import {check} from '@augment-vir/assert';
|
|
235
253
|
*
|
|
236
|
-
* check.lacksKeys({a: 0, b: 1}, [
|
|
237
|
-
*
|
|
254
|
+
* check.lacksKeys({a: 0, b: 1}, [
|
|
255
|
+
* 'b',
|
|
256
|
+
* 'c',
|
|
257
|
+
* ]); // returns `false`
|
|
258
|
+
* check.lacksKeys({a: 0, b: 1}, [
|
|
259
|
+
* 'c',
|
|
260
|
+
* 'd',
|
|
261
|
+
* ]); // returns `true`
|
|
238
262
|
* ```
|
|
239
263
|
*
|
|
240
264
|
* @see
|
|
@@ -339,8 +363,14 @@ export declare const keyGuards: {
|
|
|
339
363
|
* ```ts
|
|
340
364
|
* import {assertWrap} from '@augment-vir/assert';
|
|
341
365
|
*
|
|
342
|
-
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
343
|
-
*
|
|
366
|
+
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
367
|
+
* 'a',
|
|
368
|
+
* 'b',
|
|
369
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
370
|
+
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
371
|
+
* 'b',
|
|
372
|
+
* 'c',
|
|
373
|
+
* ]); // throws an error
|
|
344
374
|
* ```
|
|
345
375
|
*
|
|
346
376
|
* @returns The parent if it has all the keys.
|
|
@@ -360,8 +390,14 @@ export declare const keyGuards: {
|
|
|
360
390
|
* ```ts
|
|
361
391
|
* import {assertWrap} from '@augment-vir/assert';
|
|
362
392
|
*
|
|
363
|
-
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
364
|
-
*
|
|
393
|
+
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
394
|
+
* 'b',
|
|
395
|
+
* 'c',
|
|
396
|
+
* ]); // throws an error
|
|
397
|
+
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
398
|
+
* 'c',
|
|
399
|
+
* 'd',
|
|
400
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
365
401
|
* ```
|
|
366
402
|
*
|
|
367
403
|
* @returns The parent if it does not have any of the keys.
|
|
@@ -466,8 +502,14 @@ export declare const keyGuards: {
|
|
|
466
502
|
* ```ts
|
|
467
503
|
* import {checkWrap} from '@augment-vir/assert';
|
|
468
504
|
*
|
|
469
|
-
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
470
|
-
*
|
|
505
|
+
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
506
|
+
* 'a',
|
|
507
|
+
* 'b',
|
|
508
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
509
|
+
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
510
|
+
* 'b',
|
|
511
|
+
* 'c',
|
|
512
|
+
* ]); // returns `undefined`
|
|
471
513
|
* ```
|
|
472
514
|
*
|
|
473
515
|
* @returns The parent value if the check passes, otherwise `undefined`.
|
|
@@ -487,8 +529,14 @@ export declare const keyGuards: {
|
|
|
487
529
|
* ```ts
|
|
488
530
|
* import {checkWrap} from '@augment-vir/assert';
|
|
489
531
|
*
|
|
490
|
-
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
491
|
-
*
|
|
532
|
+
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
533
|
+
* 'b',
|
|
534
|
+
* 'c',
|
|
535
|
+
* ]); // returns `undefined`
|
|
536
|
+
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
537
|
+
* 'c',
|
|
538
|
+
* 'd',
|
|
539
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
492
540
|
* ```
|
|
493
541
|
*
|
|
494
542
|
* @returns The parent value if the check passes, otherwise `undefined`.
|
|
@@ -609,12 +657,24 @@ export declare const keyGuards: {
|
|
|
609
657
|
* ```ts
|
|
610
658
|
* import {waitUntil} from '@augment-vir/assert';
|
|
611
659
|
*
|
|
612
|
-
* await waitUntil.hasKeys(
|
|
613
|
-
*
|
|
614
|
-
*
|
|
615
|
-
*
|
|
616
|
-
*
|
|
617
|
-
*
|
|
660
|
+
* await waitUntil.hasKeys(
|
|
661
|
+
* [
|
|
662
|
+
* 'a',
|
|
663
|
+
* 'b',
|
|
664
|
+
* ],
|
|
665
|
+
* () => {
|
|
666
|
+
* return {a: 0, b: 1};
|
|
667
|
+
* },
|
|
668
|
+
* ); // returns `{a: 0, b: 1}`
|
|
669
|
+
* await waitUntil.hasKeys(
|
|
670
|
+
* [
|
|
671
|
+
* 'b',
|
|
672
|
+
* 'c',
|
|
673
|
+
* ],
|
|
674
|
+
* () => {
|
|
675
|
+
* return {a: 0, b: 1};
|
|
676
|
+
* },
|
|
677
|
+
* ); // throws an error
|
|
618
678
|
* ```
|
|
619
679
|
*
|
|
620
680
|
* @returns The callback output once it passes.
|
|
@@ -636,12 +696,24 @@ export declare const keyGuards: {
|
|
|
636
696
|
* ```ts
|
|
637
697
|
* import {waitUntil} from '@augment-vir/assert';
|
|
638
698
|
*
|
|
639
|
-
* await waitUntil.hasKeys(
|
|
640
|
-
*
|
|
641
|
-
*
|
|
642
|
-
*
|
|
643
|
-
*
|
|
644
|
-
*
|
|
699
|
+
* await waitUntil.hasKeys(
|
|
700
|
+
* [
|
|
701
|
+
* 'a',
|
|
702
|
+
* 'b',
|
|
703
|
+
* ],
|
|
704
|
+
* () => {
|
|
705
|
+
* return {a: 0, b: 1};
|
|
706
|
+
* },
|
|
707
|
+
* ); // throws an error
|
|
708
|
+
* await waitUntil.hasKeys(
|
|
709
|
+
* [
|
|
710
|
+
* 'b',
|
|
711
|
+
* 'c',
|
|
712
|
+
* ],
|
|
713
|
+
* () => {
|
|
714
|
+
* return {a: 0, b: 1};
|
|
715
|
+
* },
|
|
716
|
+
* ); // returns `{a: 0, b: 1}`
|
|
645
717
|
* ```
|
|
646
718
|
*
|
|
647
719
|
* @returns The callback output once it passes.
|
package/dist/assertions/keys.js
CHANGED
|
@@ -125,8 +125,14 @@ const assertions = {
|
|
|
125
125
|
* ```ts
|
|
126
126
|
* import {assert} from '@augment-vir/assert';
|
|
127
127
|
*
|
|
128
|
-
* assert.hasKeys({a: 0, b: 1}, [
|
|
129
|
-
*
|
|
128
|
+
* assert.hasKeys({a: 0, b: 1}, [
|
|
129
|
+
* 'a',
|
|
130
|
+
* 'b',
|
|
131
|
+
* ]); // passes
|
|
132
|
+
* assert.hasKeys({a: 0, b: 1}, [
|
|
133
|
+
* 'b',
|
|
134
|
+
* 'c',
|
|
135
|
+
* ]); // fails
|
|
130
136
|
* ```
|
|
131
137
|
*
|
|
132
138
|
* @throws {@link AssertionError} If the parent does not have all the keys.
|
|
@@ -150,8 +156,14 @@ const assertions = {
|
|
|
150
156
|
* ```ts
|
|
151
157
|
* import {assert} from '@augment-vir/assert';
|
|
152
158
|
*
|
|
153
|
-
* assert.lacksKeys({a: 0, b: 1}, [
|
|
154
|
-
*
|
|
159
|
+
* assert.lacksKeys({a: 0, b: 1}, [
|
|
160
|
+
* 'b',
|
|
161
|
+
* 'c',
|
|
162
|
+
* ]); // fails
|
|
163
|
+
* assert.lacksKeys({a: 0, b: 1}, [
|
|
164
|
+
* 'c',
|
|
165
|
+
* 'd',
|
|
166
|
+
* ]); // passes
|
|
155
167
|
* ```
|
|
156
168
|
*
|
|
157
169
|
* @throws {@link AssertionError} If the parent has any of the keys.
|
|
@@ -259,8 +271,14 @@ export const keyGuards = {
|
|
|
259
271
|
* ```ts
|
|
260
272
|
* import {check} from '@augment-vir/assert';
|
|
261
273
|
*
|
|
262
|
-
* check.hasKeys({a: 0, b: 1}, [
|
|
263
|
-
*
|
|
274
|
+
* check.hasKeys({a: 0, b: 1}, [
|
|
275
|
+
* 'a',
|
|
276
|
+
* 'b',
|
|
277
|
+
* ]); // returns `true`
|
|
278
|
+
* check.hasKeys({a: 0, b: 1}, [
|
|
279
|
+
* 'b',
|
|
280
|
+
* 'c',
|
|
281
|
+
* ]); // returns `false`
|
|
264
282
|
* ```
|
|
265
283
|
*
|
|
266
284
|
* @see
|
|
@@ -280,8 +298,14 @@ export const keyGuards = {
|
|
|
280
298
|
* ```ts
|
|
281
299
|
* import {check} from '@augment-vir/assert';
|
|
282
300
|
*
|
|
283
|
-
* check.lacksKeys({a: 0, b: 1}, [
|
|
284
|
-
*
|
|
301
|
+
* check.lacksKeys({a: 0, b: 1}, [
|
|
302
|
+
* 'b',
|
|
303
|
+
* 'c',
|
|
304
|
+
* ]); // returns `false`
|
|
305
|
+
* check.lacksKeys({a: 0, b: 1}, [
|
|
306
|
+
* 'c',
|
|
307
|
+
* 'd',
|
|
308
|
+
* ]); // returns `true`
|
|
285
309
|
* ```
|
|
286
310
|
*
|
|
287
311
|
* @see
|
|
@@ -408,8 +432,14 @@ export const keyGuards = {
|
|
|
408
432
|
* ```ts
|
|
409
433
|
* import {assertWrap} from '@augment-vir/assert';
|
|
410
434
|
*
|
|
411
|
-
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
412
|
-
*
|
|
435
|
+
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
436
|
+
* 'a',
|
|
437
|
+
* 'b',
|
|
438
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
439
|
+
* assertWrap.hasKeys({a: 0, b: 1}, [
|
|
440
|
+
* 'b',
|
|
441
|
+
* 'c',
|
|
442
|
+
* ]); // throws an error
|
|
413
443
|
* ```
|
|
414
444
|
*
|
|
415
445
|
* @returns The parent if it has all the keys.
|
|
@@ -435,8 +465,14 @@ export const keyGuards = {
|
|
|
435
465
|
* ```ts
|
|
436
466
|
* import {assertWrap} from '@augment-vir/assert';
|
|
437
467
|
*
|
|
438
|
-
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
439
|
-
*
|
|
468
|
+
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
469
|
+
* 'b',
|
|
470
|
+
* 'c',
|
|
471
|
+
* ]); // throws an error
|
|
472
|
+
* assertWrap.lacksKeys({a: 0, b: 1}, [
|
|
473
|
+
* 'c',
|
|
474
|
+
* 'd',
|
|
475
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
440
476
|
* ```
|
|
441
477
|
*
|
|
442
478
|
* @returns The parent if it does not have any of the keys.
|
|
@@ -575,8 +611,14 @@ export const keyGuards = {
|
|
|
575
611
|
* ```ts
|
|
576
612
|
* import {checkWrap} from '@augment-vir/assert';
|
|
577
613
|
*
|
|
578
|
-
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
579
|
-
*
|
|
614
|
+
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
615
|
+
* 'a',
|
|
616
|
+
* 'b',
|
|
617
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
618
|
+
* checkWrap.hasKeys({a: 0, b: 1}, [
|
|
619
|
+
* 'b',
|
|
620
|
+
* 'c',
|
|
621
|
+
* ]); // returns `undefined`
|
|
580
622
|
* ```
|
|
581
623
|
*
|
|
582
624
|
* @returns The parent value if the check passes, otherwise `undefined`.
|
|
@@ -603,8 +645,14 @@ export const keyGuards = {
|
|
|
603
645
|
* ```ts
|
|
604
646
|
* import {checkWrap} from '@augment-vir/assert';
|
|
605
647
|
*
|
|
606
|
-
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
607
|
-
*
|
|
648
|
+
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
649
|
+
* 'b',
|
|
650
|
+
* 'c',
|
|
651
|
+
* ]); // returns `undefined`
|
|
652
|
+
* checkWrap.lacksKeys({a: 0, b: 1}, [
|
|
653
|
+
* 'c',
|
|
654
|
+
* 'd',
|
|
655
|
+
* ]); // returns `{a: 0, b: 1}`
|
|
608
656
|
* ```
|
|
609
657
|
*
|
|
610
658
|
* @returns The parent value if the check passes, otherwise `undefined`.
|
|
@@ -732,12 +780,24 @@ export const keyGuards = {
|
|
|
732
780
|
* ```ts
|
|
733
781
|
* import {waitUntil} from '@augment-vir/assert';
|
|
734
782
|
*
|
|
735
|
-
* await waitUntil.hasKeys(
|
|
736
|
-
*
|
|
737
|
-
*
|
|
738
|
-
*
|
|
739
|
-
*
|
|
740
|
-
*
|
|
783
|
+
* await waitUntil.hasKeys(
|
|
784
|
+
* [
|
|
785
|
+
* 'a',
|
|
786
|
+
* 'b',
|
|
787
|
+
* ],
|
|
788
|
+
* () => {
|
|
789
|
+
* return {a: 0, b: 1};
|
|
790
|
+
* },
|
|
791
|
+
* ); // returns `{a: 0, b: 1}`
|
|
792
|
+
* await waitUntil.hasKeys(
|
|
793
|
+
* [
|
|
794
|
+
* 'b',
|
|
795
|
+
* 'c',
|
|
796
|
+
* ],
|
|
797
|
+
* () => {
|
|
798
|
+
* return {a: 0, b: 1};
|
|
799
|
+
* },
|
|
800
|
+
* ); // throws an error
|
|
741
801
|
* ```
|
|
742
802
|
*
|
|
743
803
|
* @returns The callback output once it passes.
|
|
@@ -759,12 +819,24 @@ export const keyGuards = {
|
|
|
759
819
|
* ```ts
|
|
760
820
|
* import {waitUntil} from '@augment-vir/assert';
|
|
761
821
|
*
|
|
762
|
-
* await waitUntil.hasKeys(
|
|
763
|
-
*
|
|
764
|
-
*
|
|
765
|
-
*
|
|
766
|
-
*
|
|
767
|
-
*
|
|
822
|
+
* await waitUntil.hasKeys(
|
|
823
|
+
* [
|
|
824
|
+
* 'a',
|
|
825
|
+
* 'b',
|
|
826
|
+
* ],
|
|
827
|
+
* () => {
|
|
828
|
+
* return {a: 0, b: 1};
|
|
829
|
+
* },
|
|
830
|
+
* ); // throws an error
|
|
831
|
+
* await waitUntil.hasKeys(
|
|
832
|
+
* [
|
|
833
|
+
* 'b',
|
|
834
|
+
* 'c',
|
|
835
|
+
* ],
|
|
836
|
+
* () => {
|
|
837
|
+
* return {a: 0, b: 1};
|
|
838
|
+
* },
|
|
839
|
+
* ); // returns `{a: 0, b: 1}`
|
|
768
840
|
* ```
|
|
769
841
|
*
|
|
770
842
|
* @returns The callback output once it passes.
|