@furystack/shades-common-components 7.0.0 → 8.0.0

package/src/services/collection-service.spec.ts

@@ -7,31 +7,25 @@ const testEntries = [{ foo: 1 }, { foo: 2 }, { foo: 3 }]
 describe('CollectionService', () => {
   describe('Selection', () => {
     it('Should add and remove selection', async () => {
-      await usingAsync(
-        new CollectionService({
-          defaultSettings: {},
-          loader: async () => ({ count: 3, entries: testEntries }),
-        }),
-        async (collectionService) => {
-          await collectionService.getEntries({})
-          testEntries.forEach((entry) => {
-            expect(collectionService.isSelected(entry)).toBe(false)
-          })
+      await usingAsync(new CollectionService({}), async (collectionService) => {
+        collectionService.data.setValue({ count: 3, entries: testEntries })
+        testEntries.forEach((entry) => {
+          expect(collectionService.isSelected(entry)).toBe(false)
+        })
 
-          collectionService.addToSelection(testEntries[0])
+        collectionService.addToSelection(testEntries[0])
 
-          expect(collectionService.isSelected(testEntries[0])).toBe(true)
-          expect(collectionService.isSelected(testEntries[1])).toBe(false)
-          expect(collectionService.isSelected(testEntries[2])).toBe(false)
+        expect(collectionService.isSelected(testEntries[0])).toBe(true)
+        expect(collectionService.isSelected(testEntries[1])).toBe(false)
+        expect(collectionService.isSelected(testEntries[2])).toBe(false)
 
-          collectionService.removeFromSelection(testEntries[0])
+        collectionService.removeFromSelection(testEntries[0])
 
-          expect(collectionService.isSelected(testEntries[0])).toBe(false)
+        expect(collectionService.isSelected(testEntries[0])).toBe(false)
 
-          collectionService.toggleSelection(testEntries[1])
-          expect(collectionService.isSelected(testEntries[1])).toBe(true)
-        },
-      )
+        collectionService.toggleSelection(testEntries[1])
+        expect(collectionService.isSelected(testEntries[1])).toBe(true)
+      })
     })
   })
 })

package/src/services/collection-service.ts

@@ -1,31 +1,16 @@
-import type { PartialResult, FindOptions } from '@furystack/core'
-import { Lock } from 'semaphore-async-await'
 import type { Disposable } from '@furystack/utils'
-import { debounce, ObservableValue } from '@furystack/utils'
+import { ObservableValue } from '@furystack/utils'
 
 export interface CollectionData<T> {
   entries: T[]
   count: number
 }
 
-export type EntryLoader<T> = <TFields extends Array<keyof T>>(
-  searchOptions: FindOptions<T, TFields>,
-) => Promise<CollectionData<PartialResult<T, TFields>>>
-
 export interface CollectionServiceOptions<T> {
-  /**
-   * A method used to retrieve the entries from the data source
-   */
-  loader: EntryLoader<T>
-  /**
-   * The default filter / top / skip / etc... options
-   */
-  defaultSettings: FindOptions<T, Array<keyof T>>
   /**
    * An optional field that can be used for quick search
    */
   searchField?: keyof T
-
   /**
    * @param entry The clicked entry
    * optional callback for row clicks
@@ -38,19 +23,15 @@ export interface CollectionServiceOptions<T> {
    */
 
   onRowDoubleClick?: (entry: T) => void
-
-  /**
-   * An optional debounce interval in milliseconds
-   */
-  debounceMs?: number
 }
 
 export class CollectionService<T> implements Disposable {
   public dispose() {
-    this.querySettings.dispose()
     this.data.dispose()
-    this.error.dispose()
-    this.isLoading.dispose()
+    this.selection.dispose()
+    this.searchTerm.dispose()
+    this.hasFocus.dispose()
+    this.focusedEntry.dispose()
   }
 
   public isSelected = (entry: T) => this.selection.getValue().includes(entry)
@@ -67,18 +48,8 @@ export class CollectionService<T> implements Disposable {
     this.isSelected(entry) ? this.removeFromSelection(entry) : this.addToSelection(entry)
   }
 
-  private readonly loadLock = new Lock()
-
-  public getEntries: EntryLoader<T>
-
   public data = new ObservableValue<CollectionData<T>>({ count: 0, entries: [] })
 
-  public error = new ObservableValue<unknown | undefined>(undefined)
-
-  public isLoading = new ObservableValue<boolean>(false)
-
-  public querySettings: ObservableValue<FindOptions<T, Array<keyof T>>>
-
   public focusedEntry = new ObservableValue<T | undefined>(undefined)
 
   public selection = new ObservableValue<T[]>([])
@@ -193,35 +164,9 @@ export class CollectionService<T> implements Disposable {
     this.focusedEntry.setValue(entry)
   }
 
-  constructor(private options: CollectionServiceOptions<T>) {
-    this.querySettings = new ObservableValue<FindOptions<T, Array<keyof T>>>(this.options.defaultSettings)
-
-    const loader = this.options.debounceMs
-      ? debounce(this.options.loader, this.options.debounceMs)
-      : this.options.loader
-
-    this.getEntries = async (opt) => {
-      await this.loadLock.acquire()
-      try {
-        this.error.setValue(undefined)
-        this.isLoading.setValue(true)
-        const result = await loader(opt)
-        this.data.setValue(result)
-        return result
-      } catch (error) {
-        this.error.setValue(error)
-        throw error
-      } finally {
-        this.loadLock.release()
-        this.isLoading.setValue(false)
-      }
-    }
-
-    this.querySettings.subscribe((val) => this.getEntries(val))
-    this.getEntries(this.querySettings.getValue())
-  }
+  constructor(private options: CollectionServiceOptions<T> = {}) {}
 
-  public async handleRowDoubleClick(entry: T) {
+  public handleRowDoubleClick(entry: T) {
     this.options.onRowDoubleClick?.(entry)
   }
 }