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

package/src/main/db/badge.ts

@@ -5,10 +5,10 @@ import { BadgeRequirement } from './badge-requirement'
 import { Key } from './key'
 import { Alternates } from './alternates'
 import { MarkdownString } from '../api/markdown-string'
-import { coalesceToArray } from '../util'
 import { MoralityList } from './morality-list'
 import { AbstractIndex } from './abstract-index'
-import { toDate } from '../to-date'
+import { toDate } from '../util/to-date'
+import { coalesceToArray } from '../util/coalesce-to-array'
 
 export class Badge {
   readonly #requirementsIndex: AbstractIndex<BadgeRequirement>

package/src/main/db/bundle-header.ts

@@ -1,7 +1,7 @@
 import { Link } from '../api/link'
 import { MarkdownString } from '../api/markdown-string'
 import { BundleHeaderData } from '../api/bundle-header-data'
-import { toDate } from '../to-date'
+import { toDate } from '../util/to-date'
 
 export class BundleHeader {
   /**

package/src/main/db/contact.ts

@@ -4,7 +4,7 @@ import { MarkdownString } from '../api/markdown-string'
 import { ContactData } from '../api/contact-data'
 import { Location } from './location'
 import { MoralityList } from './morality-list'
-import { coalesceToArray } from '../util'
+import { coalesceToArray } from '../util/coalesce-to-array'
 
 export class Contact {
   /**

package/src/main/db/mission.ts

@@ -3,8 +3,8 @@ import { MarkdownString } from '../api/markdown-string'
 import { Link } from '../api/link'
 import { MissionData } from '../api/mission-data'
 import { Key } from './key'
-import { coalesceToArray } from '../util'
 import { MoralityList } from './morality-list'
+import { coalesceToArray } from '../util/coalesce-to-array'
 
 export class Mission {
   /**

package/src/main/index.ts

@@ -37,5 +37,5 @@ export * from './db/morality-list'
 export * from './db/paged'
 export * from './db/zone'
 
-// ROOT
-export * from './util'
+// UTILS
+export * from './util/links'

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-index.test.ts

@@ -433,7 +433,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ])
 
-        const result = index.search({ sort: { by: 'canonical' } })
+        const result = index.search({ sort: 'canonical.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-1', 'badge-2', 'badge-3', 'badge-4'])
       })
@@ -446,7 +446,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ])
 
-        const result = index.search({ sort: { dir: 'desc' } })
+        const result = index.search({ sort: 'canonical.desc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-3', 'badge-2', 'badge-1'])
       })
@@ -458,7 +458,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ])
 
-        const result = index.search({ sort: { by: 'badge-name' } })
+        const result = index.search({ sort: 'name.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
@@ -470,7 +470,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ])
 
-        const result = index.search({ sort: { by: 'badge-name', dir: 'desc' } })
+        const result = index.search({ sort: 'name.desc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
       })
@@ -482,7 +482,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ])
 
-        const result = index.search({ sort: { by: 'badge-name' } })
+        const result = index.search({ sort: 'name.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
@@ -494,7 +494,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ])
 
-        const result = index.search({ sort: { by: 'zone-key' } })
+        const result = index.search({ sort: 'zone-key.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
@@ -506,7 +506,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ])
 
-        const result = index.search({ sort: { by: 'zone-key', dir: 'desc' } })
+        const result = index.search({ sort: 'zone-key.desc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
       })
@@ -519,7 +519,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ])
 
-        const result = index.search({ sort: { by: 'zone-key' } })
+        const result = index.search({ sort: 'zone-key.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-1', 'badge-3', 'badge-2'])
       })
@@ -538,7 +538,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-5', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ])
 
-        const result = index.search({ sort: { by: 'zone-key' } })
+        const result = index.search({ sort: 'zone-key.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-5', 'badge-1', 'badge-3', 'badge-2', 'badge-4'])
       })
@@ -550,7 +550,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', releaseDate: '2020-01-01' })),
         ])
 
-        const result = index.search({ sort: { by: 'release-date' } })
+        const result = index.search({ sort: 'release-date.asc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
@@ -562,10 +562,31 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', releaseDate: '2025-02-03' })),
         ])
 
-        const result = index.search({ sort: { by: 'release-date', dir: 'desc' } })
+        const result = index.search({ sort: 'release-date.desc' })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-1', 'badge-3', 'badge-2'])
       })
+
+      test(`sort should apply before paging`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'badge-a', name: 'A' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-c', name: 'C' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-e', name: 'E' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-d', name: 'D' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-b', name: 'B' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-f', name: 'F' })),
+        ])
+
+        const page1 = index.search({ sort: 'name.asc', page: 1, pageSize: 2 })
+        const page2 = index.search({ sort: 'name.asc', page: 2, pageSize: 2 })
+        const page3 = index.search({ sort: 'name.asc', page: 3, pageSize: 2 })
+        const page1Keys = page1.items.map(x => x.key)
+        const page2Keys = page2.items.map(x => x.key)
+        const page3Keys = page3.items.map(x => x.key)
+        expect(page1Keys).toStrictEqual(['badge-a', 'badge-b'])
+        expect(page2Keys).toStrictEqual(['badge-c', 'badge-d'])
+        expect(page3Keys).toStrictEqual(['badge-e', 'badge-f'])
+      })
     })
   })
 })

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', () => {