Add typing to v3 and move to vitest

Author: manuelmeister

CHANGELOG.md

@@ -1,5 +1,9 @@
 ### Unreleased
 
+### 3.0.0-alpha.3
+- BREAKING: Now uses named exports
+- Publishes the types
+
 ### 2.0.0-alpha.6
 - Bugfix: `href` and `$href` can now also be used on the root API endpoint
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "hal-json-vuex",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.3",
   "description": "Use a HAL JSON API with Vuex",
   "main": "./dist/hal-json-vuex.umd.cjs",
   "module": "./dist/hal-json-vuex.js",

package.json

@@ -1,60 +1,62 @@
+import type ResourceInterface from './interfaces/ResourceInterface'
+import type CollectionInterface from './interfaces/CollectionInterface'
+import type { Link, StoreDataCollection } from '@/interfaces/StoreData'
+
 import { isEntityReference } from './halHelpers'
 import LoadingCollection from './LoadingCollection'
-import ResourceInterface from './interfaces/ResourceInterface'
-import CollectionInterface from './interfaces/CollectionInterface'
-import { Link } from './interfaces/StoreData'
 import Resource from './Resource'
 
 /**
   * Filter out items that are marked as deleting (eager removal)
   */
-function filterDeleting (array: Array<ResourceInterface>): Array<ResourceInterface> {
+function filterDeleting<T extends ResourceInterface> (array: Array<T>): Array<T> {
   return array.filter(entry => !entry._meta.deleting)
 }
 
-class Collection extends Resource {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class Collection<ItemType extends ResourceInterface, ResourceType extends CollectionInterface<ItemType, ResourceType> = any> extends Resource<ResourceType, StoreDataCollection<ResourceType>> implements CollectionInterface<ItemType, ResourceType> {
   /**
      * Get items excluding ones marked as 'deleting' (eager remove)
      * The items property should always be a getter, in order to make the call to mapArrayOfEntityReferences
      * lazy, since that potentially fetches a large number of entities from the API.
      */
-  public get items (): Array<ResourceInterface> {
-    return filterDeleting(this._mapArrayOfEntityReferences(this._storeData.items))
+  public get items (): Array<ItemType> {
+    return filterDeleting<ItemType>(this._mapArrayOfEntityReferences(this._storeData.items))
   }
 
   /**
      * Get all items including ones marked as 'deleting' (lazy remove)
      */
-  public get allItems (): Array<ResourceInterface> {
+  public get allItems (): Array<ItemType> {
     return this._mapArrayOfEntityReferences(this._storeData.items)
   }
 
   /**
      * Returns a promise that resolves to the collection object, once all items have been loaded
      */
-  public $loadItems () :Promise<CollectionInterface> {
+  public $loadItems (): Promise<this> {
     return this._itemLoader(this._storeData.items)
   }
 
   /**
      *  Returns a promise that resolves to the collection object, once all items have been loaded
      */
-  private _itemLoader (array: Array<Link>) : Promise<CollectionInterface> {
+  private _itemLoader (array: Array<ItemType>) : Promise<this> {
     if (!this._containsUnknownEntityReference(array)) {
-      return Promise.resolve(this as unknown as CollectionInterface) // we know that this object must be of type CollectionInterface
+      return Promise.resolve(this) // we know that this object must be of type CollectionInterface
     }
 
     // eager loading of 'fetchAllUri' (e.g. parent for embedded collections)
     if (this.config.avoidNPlusOneRequests) {
-      return this.apiActions.reload(this as unknown as CollectionInterface) as Promise<CollectionInterface> // we know that reload resolves to a type CollectionInterface
+      return this.apiActions.reload<ItemType>(this) as unknown as Promise<this> // we know that reload resolves to a type CollectionInterface
 
       // no eager loading: replace each reference (Link) with a Resource (ResourceInterface)
     } else {
       const arrayWithReplacedReferences = this._replaceEntityReferences(array)
 
       return Promise.all(
         arrayWithReplacedReferences.map(entry => entry._meta.load)
-      ).then(() => this as unknown as CollectionInterface) // we know that this object must be of type CollectionInterface
+      ).then(() => this) // we know that this object must be of type CollectionInterface
     }
   }
 
@@ -68,7 +70,7 @@ class Collection extends Resource {
      * @returns array          the new array with replaced items, or a LoadingCollection if any of the array
      *                         elements is still loading.
      */
-  private _mapArrayOfEntityReferences (array: Array<Link>): Array<ResourceInterface> {
+  private _mapArrayOfEntityReferences (array: Array<ItemType>): Array<ItemType> {
     if (!this._containsUnknownEntityReference(array)) {
       return this._replaceEntityReferences(array)
     }
@@ -77,27 +79,26 @@ class Collection extends Resource {
 
     // eager loading of 'fetchAllUri' (e.g. parent for embedded collections)
     if (this.config.avoidNPlusOneRequests) {
-      return LoadingCollection.create(itemsLoaded)
+      return LoadingCollection.create<ItemType>(itemsLoaded)
 
       // no eager loading: replace each reference (Link) with a Resource (ResourceInterface)
     } else {
-      return LoadingCollection.create(itemsLoaded, this._replaceEntityReferences(array))
+      return LoadingCollection.create<ItemType>(itemsLoaded, this._replaceEntityReferences(array))
     }
   }
 
   /**
    * Replace each item in array with a proper Resource (or LoadingResource)
    */
-  private _replaceEntityReferences (array: Array<Link>): Array<ResourceInterface> {
-    return array
-      .filter(entry => isEntityReference(entry))
-      .map(entry => this.apiActions.get(entry.href))
+  private _replaceEntityReferences (array: Array<ItemType>): Array<ItemType> {
+    const links = array.filter(entry => isEntityReference(entry)) as unknown as Link[]
+    return links.map(entry => this.apiActions.get<ItemType>(entry.href) as ItemType)
   }
 
   /**
    * Returns true if any of the items within 'array' is not yet known to the API (meaning it has never been loaded)
    */
-  private _containsUnknownEntityReference (array: Array<Link>): boolean {
+  private _containsUnknownEntityReference (array: Array<ItemType>): boolean {
     return array.some(entry => isEntityReference(entry) && this.apiActions.isUnknown(entry.href))
   }
 }