implemented of() and named() for numbers

node/tests/flagsets/array.test.ts

@@ -1,4 +1,5 @@
 import { ArrayFlagSet } from '~'
+import { describe, expect, test } from 'vitest'
 
 describe(ArrayFlagSet, () => {
     test('none', () => {

node/tests/flagsets/base64.test.ts

@@ -1,4 +1,5 @@
 import { Base64BitFlagSet } from '~'
+import { describe, expect, test } from 'vitest'
 
 describe(Base64BitFlagSet, () => {
     test('none', () => {

node/tests/flagsets/bigint.test.ts

@@ -1,4 +1,5 @@
 import { BigBitFlagSet } from '~'
+import { describe, expect, test } from 'vitest'
 
 describe(BigBitFlagSet, () => {
     test('none', () => {

node/tests/flagsets/collection.test.ts

@@ -1,4 +1,5 @@
 import { CollectionFlagSet } from '~'
+import { describe, expect, test } from 'vitest'
 
 function set<T>(...values: T[]): Set<T> {
     return new Set<T>(values)
@@ -19,7 +20,7 @@ describe(CollectionFlagSet, () => {
         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')
+            set('A', 'B', 'C'),
         )
     })
 
@@ -41,10 +42,10 @@ describe(CollectionFlagSet, () => {
         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')
+            set('A'),
         )
         expect(
-            flags.intersection(set('A', 'B', 'D'), set('A', 'B', 'C'))
+            flags.intersection(set('A', 'B', 'D'), set('A', 'B', 'C')),
         ).toEqual(set('A', 'B'))
     })
 

node/tests/flagsets/number.test.ts

@@ -1,14 +1,40 @@
-import { BitFlagSet } from '~'
+import { BitFlagSet, createBitFlagSet } from '~'
+import { describe, expect, test } from 'vitest'
 
 describe(BitFlagSet, () => {
     test('none', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect(flags.none()).toEqual(0)
     })
 
+    test('of', () => {
+        const flags = createBitFlagSet([])
+
+        expect(flags.of()).toEqual(0)
+        expect(flags.of(1)).toEqual(1)
+        expect(flags.of(3, 8)).toEqual(11)
+        expect(flags.of(3, 5, 2)).toEqual(7)
+    })
+
+    test('named', () => {
+        const flags = createBitFlagSet([
+            { value: 1, as: 'A' },
+            { value: 2, as: 'B' },
+            { value: 4, as: 'C' },
+            { value: 8, as: 'D' },
+            { compose: ['A', 'B'], as: 'AB' },
+            { compose: ['A', 'C'], as: 'AC' },
+        ])
+
+        expect(flags.named()).toEqual(0)
+        expect(flags.named('A')).toEqual(1)
+        expect(flags.named('AB', 'D')).toEqual(11)
+        expect(flags.named('AB', 'AC', 'B')).toEqual(7)
+    })
+
     test('union', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect(flags.union(0, 0)).toEqual(0)
         expect(flags.union(1, 0)).toEqual(1)
@@ -18,7 +44,7 @@ describe(BitFlagSet, () => {
     })
 
     test('difference', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect(flags.difference(0, 0)).toEqual(0)
         expect(flags.difference(1, 0)).toEqual(1)
@@ -28,7 +54,7 @@ describe(BitFlagSet, () => {
     })
 
     test('intersection', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect(flags.intersection(0, 0)).toEqual(0)
         expect(flags.intersection(1, 0)).toEqual(0)
@@ -39,7 +65,7 @@ describe(BitFlagSet, () => {
     })
 
     test('isSuperset', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect(flags.isSuperset(0, 0)).toBe(true)
         expect(flags.isSuperset(3, 0)).toBe(true)
@@ -50,7 +76,7 @@ describe(BitFlagSet, () => {
     })
 
     test('enumerate', () => {
-        const flags = new BitFlagSet()
+        const flags = createBitFlagSet([])
 
         expect([...flags.enumerate(0)]).toEqual([])
         expect([...flags.enumerate(1)]).toEqual([1])