typing and test improvements

Author: unstoppablecarl

package.json

@@ -1,7 +1,7 @@
 {
   "name": "vue-cache-store",
   "type": "module",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "packageManager": "[email protected]",
   "description": "Cache and re-use computed/reactive properties in vue",
   "author": {
@@ -65,7 +65,7 @@
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-esbuild": "^6.1.1",
     "rollup-plugin-typescript2": "^0.36.0",
-    "typescript": "^5.5.4",
+    "typescript": "^5.9.2",
     "vitest": "3.2.4",
     "vue": "^3.5.17"
   },

pnpm-lock.yaml

@@ -4,10 +4,6 @@ export type ToWritableComputed<T = any> = {
   [K in keyof T]: WritableComputedRef<T[K]>;
 };
 
-/**
- *
- * @param obj
- */
 export function toWritableComputed<T extends object>(obj: Ref<T> | ComputedRef<T> | WritableComputedRef<T>) {
   const rawStore = toValue(obj)
   const refs = {}

src/toWritableComputed.ts

@@ -2,9 +2,9 @@ import { computed, type ComputedRef, watch } from 'vue'
 import { makeRecordStore, type RecordStore } from './makeRecordStore'
 
 export function watchRecordStore<
-  ID extends NonNullable<any> = Parameters<Parameters<typeof watchRecordStore>[0]>[0],
-  R extends object = NonNullable<ReturnType<Parameters<typeof watchRecordStore>[0]>>,
-  T extends object = ReturnType<Parameters<typeof watchRecordStore>[1]>,
+  ID extends NonNullable<any>,
+  R extends object,
+  T extends object,
 >
 (
   getRecord: (id: ID) => R | undefined,

src/watchRecordStore.ts

@@ -3,7 +3,7 @@ import { makeRecordStore } from '../src'
 import { mount } from '@vue/test-utils'
 import { computed, reactive, ref, toRef } from 'vue'
 
-describe('define cache store', async () => {
+describe('makeCacheStore() components', async () => {
 
   it('ref()', async () => {
     const x = ref('a')

tests/makeRecordStore.component.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 import { makeRecordStore } from '../src'
 import { computed, type ComputedRef, nextTick, ref, watch } from 'vue'
 
-describe('define cache store', async () => {
+describe('makeCacheStore()', async () => {
 
   it('only run once', async () => {
     const count = ref(0)

tests/makeRecordStore.test.ts

@@ -2,7 +2,19 @@ import { describe, expectTypeOf, it } from 'vitest'
 import type { Reactive, ToRefs } from 'vue'
 import { type GenericRecordStore, makeRecordStore, type RecordStore } from '../src'
 
-describe('defineCacheStore() types', async () => {
+
+type Item = {
+  id: number,
+  name: string,
+}
+
+type ItemInfo = {
+  id: number,
+  name: string,
+  context: RecordStore<number, ItemInfo>
+}
+
+describe('makeCacheStore() types', async () => {
 
   it('type GenericCacheStore', async () => {
     function creatorFunction(id: number) {
@@ -16,13 +28,31 @@ describe('defineCacheStore() types', async () => {
     expectTypeOf(store).toEqualTypeOf<GenericRecordStore>()
   })
 
-  it('makeRecordStore() types: id number', () => {
+  it('test inferred types', async () => {
 
-    type ItemInfo = {
-      id: number,
-      name: string,
-      context: RecordStore<number, ItemInfo>
-    }
+    const store = makeRecordStore((id: number, context): Item => {
+
+      if (id !== 44) {
+        const otherItem = context.get(44)
+        expectTypeOf(otherItem).toEqualTypeOf<Item>()
+      }
+
+      expectTypeOf<
+        Parameters<typeof context.get>[0]
+      >().toEqualTypeOf<number>()
+
+      return {
+        id,
+        name: 'susan',
+      }
+    })
+
+    const item = store.get(99)
+
+    expectTypeOf(item).toEqualTypeOf<Item>()
+  })
+
+  it('makeRecordStore() types: id number', () => {
 
     const cache = makeRecordStore<number, ItemInfo>((id, context) => {
       return {

tests/makeRecordStore.types.test.ts

@@ -0,0 +1,58 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { watchRecordStore } from '../src'
+import { type Person, type PersonInfo, usePeople } from './helpers/people'
+import { type Reactive } from 'vue'
+
+describe('watchRecordStore() types', async () => {
+
+  it('type inferred types', async () => {
+    const {
+      people,
+      getPerson,
+      getPersonInfo,
+    } = usePeople()
+
+    people.value.push({
+      id: 99,
+      name: 'Jim',
+    })
+
+    people.value.push({
+      id: 44,
+      name: 'Sam',
+    })
+    const store = watchRecordStore(
+      (id: number): Person => {
+        return getPerson(id) as Person
+      },
+      (person, context): PersonInfo => {
+        if (person.value.id !== 44) {
+          const otherItem = context.get(44)
+          expectTypeOf(otherItem).toEqualTypeOf<Reactive<PersonInfo>>()
+        }
+
+        expectTypeOf<
+          ReturnType<typeof context.get>
+        >().toEqualTypeOf<Reactive<PersonInfo>>()
+
+        expectTypeOf<
+          Parameters<typeof context.get>[0]
+        >().toEqualTypeOf<number>()
+
+        return getPersonInfo(person)
+      },
+    )
+
+    const item = store.get(99)
+
+    expectTypeOf(item).toEqualTypeOf<Reactive<PersonInfo>>()
+
+    expectTypeOf<
+      ReturnType<typeof store.get>
+    >().toEqualTypeOf<Reactive<PersonInfo>>()
+
+    expectTypeOf<
+      Parameters<typeof store.get>[0]
+    >().toEqualTypeOf<number>()
+  })
+})