implementation of minimum, maximum, hasAny and hasAll for bitflags

node/tests/flagsets/array.test.ts

@@ -36,10 +36,7 @@ describe(ArrayFlagSet, () => {
         expect(flags.intersection(['A'], ['B'])).toEqual([])
         expect(flags.intersection(['A'], ['A', 'B'])).toEqual(['A'])
         expect(flags.intersection(['A', 'B', 'D'], ['A', 'C'])).toEqual(['A'])
-        expect(flags.intersection(['A', 'B', 'D'], ['A', 'B', 'C'])).toEqual([
-            'A',
-            'B',
-        ])
+        expect(flags.intersection(['A', 'B', 'D'], ['A', 'B', 'C'])).toEqual(['A', 'B'])
     })
 
     test('isSuperset', () => {

node/tests/flagsets/collection.test.ts

@@ -19,9 +19,7 @@ describe(CollectionFlagSet, () => {
         expect(flags.union(set('A'), set())).toEqual(set('A'))
         expect(flags.union(set(), set('B'))).toEqual(set('B'))
         expect(flags.union(set('A'), set('B'))).toEqual(set('A', 'B'))
-        expect(flags.union(set('A', 'B'), set('B', 'C'))).toEqual(
-            set('A', 'B', 'C'),
-        )
+        expect(flags.union(set('A', 'B'), set('B', 'C'))).toEqual(set('A', 'B', 'C'))
     })
 
     test('difference', () => {
@@ -41,12 +39,8 @@ describe(CollectionFlagSet, () => {
         expect(flags.intersection(set('A'), set())).toEqual(set())
         expect(flags.intersection(set('A'), set('B'))).toEqual(set())
         expect(flags.intersection(set('A'), set('A', 'B'))).toEqual(set('A'))
-        expect(flags.intersection(set('A', 'B', 'D'), set('A', 'C'))).toEqual(
-            set('A'),
-        )
-        expect(
-            flags.intersection(set('A', 'B', 'D'), set('A', 'B', 'C')),
-        ).toEqual(set('A', 'B'))
+        expect(flags.intersection(set('A', 'B', 'D'), set('A', 'C'))).toEqual(set('A'))
+        expect(flags.intersection(set('A', 'B', 'D'), set('A', 'B', 'C'))).toEqual(set('A', 'B'))
     })
 
     test('isSuperset', () => {
@@ -65,10 +59,6 @@ describe(CollectionFlagSet, () => {
 
         expect([...flags.enumerate(set())]).toEqual([])
         expect([...flags.enumerate(set('A'))]).toEqual(['A'])
-        expect([...flags.enumerate(set('A', 'B', 'C'))]).toEqual([
-            'A',
-            'B',
-            'C',
-        ])
+        expect([...flags.enumerate(set('A', 'B', 'C'))]).toEqual(['A', 'B', 'C'])
     })
 })

node/tests/flagsets/number.test.ts

@@ -75,6 +75,38 @@ describe(BitFlagSet, () => {
         expect(flags.isSuperset(8, 4)).toBe(false)
     })
 
+    test('hasAny', () => {
+        const flags = createBitFlagSet([
+            { value: 1, as: 'A' },
+            { value: 2, as: 'B', requires: ['A'] },
+            { value: 4, as: 'C', requires: ['A'] },
+            { value: 8, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.hasAny(15, 0)).toBe(false)
+        expect(flags.hasAny(0, 0)).toBe(false)
+        expect(flags.hasAny(7, 1)).toBe(true)
+        expect(flags.hasAny(1, 7)).toBe(true)
+        expect(flags.hasAny(5, 12)).toBe(false)
+        expect(flags.hasAny(2, 2)).toBe(false)
+    })
+
+    test('hasAll', () => {
+        const flags = createBitFlagSet([
+            { value: 1, as: 'A' },
+            { value: 2, as: 'B', requires: ['A'] },
+            { value: 4, as: 'C', requires: ['A'] },
+            { value: 8, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.hasAll(15, 0)).toBe(true)
+        expect(flags.hasAll(0, 0)).toBe(true)
+        expect(flags.hasAll(7, 2)).toBe(true)
+        expect(flags.hasAll(6, 2)).toBe(false)
+        expect(flags.hasAll(1, 7)).toBe(false)
+        expect(flags.hasAll(5, 12)).toBe(false)
+    })
+
     test('enumerate', () => {
         const flags = createBitFlagSet([])
 
@@ -85,4 +117,36 @@ describe(BitFlagSet, () => {
         expect([...flags.enumerate(11)]).toEqual([1, 2, 8])
         expect([...flags.enumerate(100)]).toEqual([4, 32, 64])
     })
+
+    test('maximum', () => {
+        const flags = createBitFlagSet([
+            { value: 1, as: 'A' },
+            { value: 2, as: 'B', requires: ['A'] },
+            { value: 4, as: 'C', requires: ['A'] },
+            { value: 8, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.maximum(0)).toEqual(0)
+        expect(flags.maximum(1)).toEqual(1)
+        expect(flags.maximum(2)).toEqual(3)
+        expect(flags.maximum(3)).toEqual(3)
+        expect(flags.maximum(4)).toEqual(5)
+        expect(flags.maximum(8)).toEqual(15)
+    })
+
+    test('minimum', () => {
+        const flags = createBitFlagSet([
+            { value: 1, as: 'A' },
+            { value: 2, as: 'B', requires: ['A'] },
+            { value: 4, as: 'C', requires: ['A'] },
+            { value: 8, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.minimum(0)).toEqual(0)
+        expect(flags.minimum(1)).toEqual(1)
+        expect(flags.minimum(2)).toEqual(0)
+        expect(flags.minimum(3)).toEqual(3)
+        expect(flags.minimum(4)).toEqual(0)
+        expect(flags.minimum(13)).toEqual(5)
+    })
 })