coh-content-db 2.0.0-rc.15 → 2.0.0-rc.16

package/src/main/util/coalesce-to-array.ts

@@ -0,0 +1,13 @@
+/**
+ * For fields that accept either an array of values or a single value, coalesces the value to an array.
+ *
+ * Arrays are returned as-is.
+ * Single values are returned as a single-value array.
+ * Undefined values are returned as undefined.
+ *
+ * @param value The value to coalesce.
+ */
+export function coalesceToArray<T>(value?: T | T[]): T[] | undefined {
+  if (!value) return undefined
+  return Array.isArray(value) ? value as T[] : [value]
+}

package/src/main/{util.ts → util/links.ts}

@@ -1,11 +1,11 @@
-import { BadgeData } from './api/badge-data'
-import { Badge } from './db/badge'
-import { ZoneData } from './api/zone-data'
-import { Zone } from './db/zone'
-import { Contact } from './db/contact'
-import { ContactData } from './api/contact-data'
-import { Mission } from './db/mission'
-import { MissionData } from './api/mission-data'
+import { BadgeData } from '../api/badge-data'
+import { Badge } from '../db/badge'
+import { ZoneData } from '../api/zone-data'
+import { Zone } from '../db/zone'
+import { Contact } from '../db/contact'
+import { ContactData } from '../api/contact-data'
+import { Mission } from '../db/mission'
+import { MissionData } from '../api/mission-data'
 
 /**
  * Returns the URI of the given badge that can be used in {@link MarkdownString} fields.
@@ -102,17 +102,3 @@ export function zoneLink(target: string | Zone | ZoneData): string {
   const key = typeof target === 'string' ? target : target.key
   return `[${key}](${zoneUri(target)})`
 }
-
-/**
- * For fields that accept either an array of values or a single value, coalesces the value to an array.
- *
- * Arrays are returned as-is.
- * Single values are returned as a single-value array.
- * Undefined values are returned as undefined.
- *
- * @param value The value to coalesce.
- */
-export function coalesceToArray<T>(value?: T | T[]): T[] | undefined {
-  if (!value) return undefined
-  return Array.isArray(value) ? value as T[] : [value]
-}

package/src/test/api/alignment.test.ts

@@ -51,14 +51,14 @@ describe('compareAlignment', () => {
 
   test('should work as a compare function', () => {
     const unsorted: (Alignment | undefined)[] = [undefined, 'hero', 'villain', 'praetorian', undefined, 'villain', 'praetorian']
-    const sorted = unsorted.sort(compareAlignment)
+    const sorted = unsorted.toSorted(compareAlignment)
 
     expect(sorted).toStrictEqual(['hero', 'villain', 'villain', 'praetorian', 'praetorian', undefined, undefined])
   })
 
   test('should sort against undefined', () => {
     const unsorted: (Alignment | undefined)[] = [undefined, 'hero']
-    const sorted = unsorted.sort(compareAlignment)
+    const sorted = unsorted.toSorted(compareAlignment)
 
     expect(sorted).toStrictEqual(['hero', undefined])
   })

package/src/test/api/sex.test.ts

@@ -49,14 +49,14 @@ describe('compareSex', () => {
 
   test('should work as a compare function', () => {
     const unsorted: (Sex | undefined)[] = [undefined, 'M', 'F', 'M', undefined, 'F', 'M']
-    const sorted = unsorted.sort(compareSex)
+    const sorted = unsorted.toSorted(compareSex)
 
     expect(sorted).toStrictEqual(['M', 'M', 'M', 'F', 'F', undefined, undefined])
   })
 
   test('should sort against undefined', () => {
     const unsorted: (Sex | undefined)[] = [undefined, 'M']
-    const sorted = unsorted.sort(compareSex)
+    const sorted = unsorted.toSorted(compareSex)
 
     expect(sorted).toStrictEqual(['M', undefined])
   })

package/src/test/db/badge.test.ts

@@ -254,6 +254,17 @@ describe(Badge.name, () => {
       }))
       expect(badge.zoneKeys).toStrictEqual(['a', 'c'])
     })
+
+    test(`should ignore locations with no zone key`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { coords: [1, 2, 3] } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c'])
+    })
   })
 
   describe('zoneKey', () => {
@@ -291,7 +302,7 @@ describe(Badge.name, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
       const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
       expect(compareByDefaultName(badgeA, badgeB)).toBeLessThan(0)
-      expect([badgeB, badgeA].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
     })
 
     test(`should return 0 for equal names`, () => {
@@ -309,8 +320,8 @@ describe(Badge.name, () => {
     test(`should sort undefined values last`, () => {
       const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
       const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
-      expect([badgeA, badgeB].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
-      expect([badgeB, badgeA].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
     })
   })
 
@@ -327,7 +338,7 @@ describe(Badge.name, () => {
         ],
       }))
       expect(compareByZoneKey(badgeA, badgeB)).toBeLessThan(0)
-      expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
     })
 
     test(`should return 0 for equal zoneKeys`, () => {
@@ -370,8 +381,8 @@ describe(Badge.name, () => {
           badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
         ],
       }))
-      expect([badgeA, badgeB].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
-      expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
     })
   })
 
@@ -380,7 +391,7 @@ describe(Badge.name, () => {
       const badgeA = new Badge(badgeDataFixture.create({ releaseDate: '2024-01-01' }))
       const badgeB = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
       expect(compareByReleaseDate(badgeA, badgeB)).toBeLessThan(0)
-      expect([badgeB, badgeA].sort(compareByReleaseDate)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByReleaseDate)).toStrictEqual([badgeA, badgeB])
     })
 
     test(`should return 0 for equal releaseDates`, () => {
@@ -399,10 +410,10 @@ describe(Badge.name, () => {
       const badgeA = undefined
       const badgeB = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
       expect(compareByReleaseDate(badgeA, badgeB)).toBeGreaterThan(0)
-      expect([badgeA, badgeB].sort(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
+      expect([badgeA, badgeB].toSorted(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
 
       expect(compareByReleaseDate(badgeB, badgeA)).toBeLessThan(0)
-      expect([badgeB, badgeA].sort(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
+      expect([badgeB, badgeA].toSorted(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
     })
   })
 })

package/src/test/util/coalese-to-array.test.ts

@@ -0,0 +1,17 @@
+import { coalesceToArray } from '../../main/util/coalesce-to-array'
+
+describe(coalesceToArray.name, () => {
+  test('should return an array unmodified', () => {
+    expect(coalesceToArray(['a', 'b'])).toStrictEqual(['a', 'b'])
+    expect(coalesceToArray([1, 2])).toStrictEqual([1, 2])
+  })
+
+  test('should return a single value as a single-value array', () => {
+    expect(coalesceToArray('a')).toStrictEqual(['a'])
+    expect(coalesceToArray(1)).toStrictEqual([1])
+  })
+
+  test('should return undefined value as undefined', () => {
+    expect(coalesceToArray()).toBeUndefined()
+  })
+})

package/src/test/{util.test.ts → util/links.test.ts}

@@ -1,8 +1,8 @@
-import { Badge, badgeLink, badgeUri, coalesceToArray, Contact, contactLink, contactUri, Mission, missionLink, missionUri, Zone, zoneLink, zoneUri } from '../main'
-import { badgeDataFixture } from './api/badge-data.fixture'
-import { zoneDataFixture } from './api/zone-data.fixture'
-import { contactDataFixture } from './api/contact-data.fixture'
-import { missionDataFixture } from './api/mission-data.fixture'
+import { Badge, badgeLink, badgeUri, Contact, contactLink, contactUri, Mission, missionLink, missionUri, Zone, zoneLink, zoneUri } from '../../main'
+import { badgeDataFixture } from '../api/badge-data.fixture'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+import { contactDataFixture } from '../api/contact-data.fixture'
+import { missionDataFixture } from '../api/mission-data.fixture'
 
 describe(badgeUri.name, () => {
   test('should return the expected pattern', () => {
@@ -147,19 +147,3 @@ describe(zoneLink.name, () => {
     expect(zoneLink(zone)).toBe('[foo](zone://foo)')
   })
 })
-
-describe(coalesceToArray.name, () => {
-  test('should return an array unmodified', () => {
-    expect(coalesceToArray(['a', 'b'])).toStrictEqual(['a', 'b'])
-    expect(coalesceToArray([1, 2])).toStrictEqual([1, 2])
-  })
-
-  test('should return a single value as a single-value array', () => {
-    expect(coalesceToArray('a')).toStrictEqual(['a'])
-    expect(coalesceToArray(1)).toStrictEqual([1])
-  })
-
-  test('should return undefined value as undefined', () => {
-    expect(coalesceToArray()).toBeUndefined()
-  })
-})

package/src/test/{to-date.test.ts → util/to-date.test.ts}

@@ -1,4 +1,4 @@
-import { toDate } from '../main/to-date'
+import { toDate } from '../../main/util/to-date'
 
 describe(toDate.name, () => {
   test('should return a valid date', () => {