bt-core-app 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bt-core-app",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Core app tools for some basic features like navigation, authentication, server apis, and cosmetics",
   "homepage": "https://github.com/BlitzItTech/bt-core",
   "bugs": {

package/test/api.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect, afterAll, afterEach, beforeAll } from 'vitest'
+import { createApi } from '../src/composables/api'
+import { setupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
+
+const handlers = [
+    http.get('https://test-api/get/1', () => {
+        return HttpResponse.json({
+            data: { test: 'a' },
+            count: 0,
+            filters: ['test']
+        })
+    }),
+    http.get('https://test-api/get/2', () => {
+        return new HttpResponse('not found', {
+            status: 304
+        })
+    }),
+    http.get('https://test-api/getAll', () => {
+        return HttpResponse.json({
+            data: [{ test: 'a' }, { test: 'b' }],
+            count: 2,
+            filters: ['test', 'test two']
+        })
+    }),
+    http.post('https://test-api/post', () => {
+        return HttpResponse.json({ data: { test: 'b' } })
+    }),
+    http.patch('https://test-api/patch', () => {
+        return HttpResponse.json({ data: { test: 'c' } })
+    })
+]
+
+const server = setupServer(...handlers)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
+
+afterAll(() => server.close())
+
+afterEach(() => server.resetHandlers())
+
+describe('default api', () => {
+    const api = createApi({
+        findPath: () => 'https://test-api/',
+        defaultThrowError: false
+    })
+
+    test('get', async () => {
+        const res = await api.get<any>({ additionalUrl: 'get', id: '1', nav: 'test' })
+        expect(res).not.toBeNull()
+        expect(res.data.test).toEqual('a')
+        expect(res.filters[0]).toEqual('test')
+    })
+
+    test('get fails', async () => {
+        const res = await api.get<any>({ additionalUrl: 'get', id: '2', nav: 'test' })
+        expect(res.status).toEqual(304)
+    })
+
+    test('getAll', async () => {
+        const res = await api.get<any>({ additionalUrl: 'getAll', nav: 'test' })
+        expect(res).not.toBeNull()
+        expect(res.data.length).toEqual(2)
+        expect(res.count).toEqual(2)
+        expect(res.filters[0]).toEqual('test')
+        expect(res.filters[1]).toEqual('test two')
+    })
+
+    test('post', async () => {
+        const res = await api.post<any>({ additionalUrl: 'post', nav: 'test', data: { data: 'a' }})
+        expect(res).not.toBeNull()
+        expect(res).toEqual({ data: { test: 'b' } })
+    })
+
+    test('patch', async () => {
+        const res = await api.patch<any>({ additionalUrl: 'patch', nav: 'test', data: { data: 'a' }})
+        expect(res).not.toBeNull()
+        expect(res).toEqual({ data: { test: 'c' } })
+    })
+})
+
+// describe('default api fails', () => {
+
+// })

package/test/forage.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'vitest'
+import { withSetup } from './utils'
+import { useLocalDb } from '../src/composables/forage'
+
+describe('foraging', () => {
+    const [db] = withSetup(() => useLocalDb())
+    
+    test('local db exists', () => {
+        expect(db).not.toBeNull()
+        expect(db._config.name).toEqual('Db_undefined')
+    })
+
+})
+
+// describe('local cache', () => {
+//     const [cache] = withSetup(() => useLocalCache())
+
+//     test('save', async () => {
+//         expect(cache).not.toBeNull()
+
+//         await cache.saveAsync({ test: 'a' }, 'test-key')
+
+//         const res = await cache.getAsync('test-key')
+
+//         expect(res.test).toEqual('a')
+
+//         await cache.clearAsync()
+
+//         const none = await cache.getAsync('test-key')
+//     })
+// })

package/test/helpers.test.ts

@@ -0,0 +1,231 @@
+import { nestedValue, toCompareString, hasSearch, deepSelect, containsSearch, copyItemByAlphabet, copyDeep, csvContains, toggleCSV, roundTo, isArrayOfLength, isLengthyArray, addWeekday, removeWeekday, appendUrl, getAreaAround, getAreaToLeft, getAreaToRight, getLocationLine, capitalizeWords, fromCamelCase, toCamelCase, weekdayValue, weekdayShortName, containsWeekday, validEmail } from '../src/composables/helpers'
+import { describe, expect, test } from 'vitest'
+
+describe("helpers", () => {
+
+    test('append url', () => {
+        expect(appendUrl('https://test.com/', '/test')).toEqual('https://test.com/test')
+        expect(appendUrl('https://test.com', 'test')).toEqual('https://test.com/test')
+        expect(appendUrl('https://test.com/', 'test')).toEqual('https://test.com/test')
+        expect(appendUrl('https://test.com', '/test')).toEqual('https://test.com/test')
+        expect(appendUrl('https://test.com///', '///test')).toEqual('https://test.com/test')
+    })
+
+    test('get area around', () => {
+        //starts with top left and goes anti-clockwise
+        expect(getAreaAround({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: -1, lng: 1 },{ lat: -1, lng: -1 },{ lat: 1, lng: -1 },{ lat: 1, lng: 1 }])
+        expect(getAreaAround({ lat: 0, lng: 0 }, 2)).toEqual([{ lat: -2, lng: 2 },{ lat: -2, lng: -2 },{ lat: 2, lng: -2 },{ lat: 2, lng: 2 }])
+        expect(getAreaAround({ lat: 2, lng: 6 }, 1)).toEqual([{ lat: 1, lng: 7 },{ lat: 1, lng: 5 },{ lat: 3, lng: 5 },{ lat: 3, lng: 7 }])
+    })
+
+    test('get area to left', () => {
+        //starts with top left and goes anti-clockwise
+        expect(getAreaToLeft({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: -2, lng: 1 },{ lat: -2, lng: -1 },{ lat: 0, lng: -1 },{ lat: 0, lng: 1 }])
+        expect(getAreaToLeft({ lat: 0, lng: 0 }, 2)).toEqual([{ lat: -4, lng: 2 },{ lat: -4, lng: -2 },{ lat: 0, lng: -2 },{ lat: 0, lng: 2 }])
+    })
+
+    test('get area to right', () => {
+        //starts with top left and goes anti-clockwise
+        expect(getAreaToRight({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: 0, lng: 1 },{ lat: 0, lng: -1 },{ lat: 2, lng: -1 },{ lat: 2, lng: 1 }])
+        expect(getAreaToRight({ lat: 2, lng: 0 }, 2)).toEqual([{ lat: 2, lng: 2 },{ lat: 2, lng: -2 },{ lat: 6, lng: -2 },{ lat: 6, lng: 2 }])
+    })
+
+    test('get location line', () => {
+        expect(getLocationLine(null)).toEqual('')
+        expect(getLocationLine({ streetNumber: '9', streetName: 'Morgan St', suburb: 'Timboon', state: 'VIC', postcode: '3268' })).toEqual('9 Morgan St, Timboon VIC 3268')
+    })
+
+    test('from camel case', () => {
+        expect(fromCamelCase('testOneTwo')).toEqual('Test One Two')
+        expect(fromCamelCase('testOne Two')).toEqual('Test One  Two')
+        expect(fromCamelCase('tesTOneTwo')).not.toEqual('Test One Two')
+        expect(fromCamelCase()).toBeUndefined()
+    })
+
+    test('to camel case', () => {
+        expect(toCamelCase(undefined)).toBeUndefined()
+        expect(toCamelCase({ Test: 't' })).not.toEqual({ Test: 't' })
+        expect(toCamelCase({ Test: 't' })).toEqual({ test: 't' })
+    })
+
+    test('capitalize', () => {
+        expect(capitalizeWords('test')).toEqual('Test')
+        expect(capitalizeWords('test one')).toEqual('Test One')
+    })
+    
+    test('weekdays csv string sort value', () => {
+        expect(weekdayValue('sun, wed, sat')).toEqual(1)
+        expect(weekdayValue('wed, sat')).toEqual(4)
+        expect(weekdayValue('')).toEqual(8)
+        expect(weekdayValue()).toEqual(0)
+        expect(weekdayValue('sun, wed, sat, always')).toEqual(0)
+        expect(weekdayValue('Tuesday')).toEqual(3)
+    })
+
+    test('weekday short name conversion', () => {
+        expect(weekdayShortName('Sun, Mon, tuesday')).toEqual('sun,mon,tue')
+        expect(weekdayShortName('Sun, Mon, blah')).toEqual('sun,mon')
+        expect(weekdayShortName('Sun, Fri, Wedne')).toEqual('sun,fri')
+        expect(weekdayShortName('Sunday')).toEqual('sun')
+    })
+
+    test('contains weekday', () => {
+        expect(containsWeekday('sun', 'sun')).toEqual(true)
+        expect(containsWeekday('sun', 'Sunday')).toEqual(true)
+        expect(containsWeekday('sun,mon,tue, wed', 'Tuesday')).toEqual(true)
+        expect(containsWeekday('sun,mon,tuesday, wed', 'Tuesday')).toEqual(true)
+        expect(containsWeekday('sun,mon, wed', 'tue')).toEqual(false)
+    })
+
+    test('add weekday', () => {
+        expect(addWeekday(undefined, 'sun')).toEqual('sun')
+        expect(addWeekday(undefined, 'sun')).toEqual('sun')
+        expect(addWeekday('mon,sun', 'sun')).toEqual('sun,mon')
+        expect(addWeekday('mon,sun, always, m', 'sun')).toEqual('always,sun,mon')
+    })
+
+    test('remove weekday', () => {
+        expect(removeWeekday(undefined, 'sun')).toEqual(undefined)
+        expect(removeWeekday('sun', 'sun')).toEqual(undefined)
+        expect(removeWeekday('sun, thur, tue', 'sun')).toEqual('tue,thu')
+        expect(removeWeekday('always', 'sun')).toEqual('always')
+    })
+
+    test('is array of length', () => {
+        expect(isArrayOfLength([], 0)).toEqual(true)
+        expect(isArrayOfLength([1,1,1], 3)).toEqual(true)
+        expect(isArrayOfLength(undefined, 0)).toEqual(false)
+        expect(isArrayOfLength({}, 0)).toEqual(false)
+    })
+
+    test('is lengthy array', () => {
+        expect(isLengthyArray([])).toEqual(false)
+        expect(isLengthyArray(undefined)).toEqual(false)
+        expect(isLengthyArray([1])).toEqual(true)
+        expect(isLengthyArray([1,1])).toEqual(true)
+        expect(isLengthyArray([1,1], 1)).toEqual(true)
+        expect(isLengthyArray([1,1], 3)).toEqual(false)
+    })
+
+    test('rounding decimal places', () => {
+        expect(roundTo(1, 0)).toEqual(1)
+        expect(roundTo(1.1, 0)).toEqual(1)
+        expect(roundTo(1.6, 0)).toEqual(2)
+        expect(roundTo(2.22567, 3)).toEqual(2.226)
+        expect(roundTo(2.22547, 3)).toEqual(2.225)
+    })
+
+    test('toggle csv', () => {
+        expect(toggleCSV('one,two,three', 'two')).toEqual('one,three')
+        expect(toggleCSV('two', 'two')).toEqual(null)
+    })
+
+    test('csv contains', () => {
+        expect(csvContains('one,two,three', 'two')).toEqual(true)
+        expect(csvContains('one,two,three', 'three')).toEqual(true)
+        expect(csvContains('one,three', 'two')).toEqual(false)
+        expect(csvContains(undefined, 'two')).toEqual(false)
+    })
+
+    test('copy deep', () => {
+        expect(copyDeep(null)).toStrictEqual(null)
+        expect(copyDeep(undefined)).toStrictEqual(undefined)
+        
+        let item = { test: { one: 'treat' } }
+        let copy = copyDeep(item)
+        item.test.one = 'other'
+
+        expect(item.test).not.toEqual(copy.test)
+        expect(item).not.toEqual(copy)
+    })
+
+    test('copy by property alphabet', () => {
+        expect(copyItemByAlphabet(null)).toStrictEqual(null)
+        expect(copyItemByAlphabet(undefined)).toStrictEqual(undefined)
+
+        let item = { test: { b: 'treat', a: 't' }, v: 'a', s: 'a', z: undefined }
+        //consistency
+        expect(JSON.stringify(copyItemByAlphabet(item))).toEqual(JSON.stringify(copyItemByAlphabet(item)))
+        expect(JSON.stringify(copyItemByAlphabet(item))).toEqual(JSON.stringify({ s: 'a', test: { a: 't', b: 'treat' }, v: 'a', z: undefined }))
+        expect(JSON.stringify(copyItemByAlphabet(item))).not.toEqual(JSON.stringify({ s: 'a', test: { b: 'treat', a: 't' }, v: 'a' }))
+    })
+
+    test('contains search', () => {
+        expect(containsSearch(undefined, undefined)).toEqual(true)
+        expect(containsSearch('a', undefined)).toEqual(true)
+        expect(containsSearch('aa', 'aa')).toEqual(true)
+        expect(containsSearch('aa', 'a')).toEqual(true)
+        expect(containsSearch('aa', 'b')).toEqual(false)
+        expect(containsSearch('Testing One Two Three', ' one')).toEqual(true)
+        expect(containsSearch('Testing One Two Three', '  one')).toEqual(false)
+    })
+
+    test('deep select', () => {
+        expect(deepSelect(null)).toEqual([])
+
+        let item = [
+            { a: 'a', b: [{ a: 'd' }] },
+            { a: 'b'},
+            { a: 'c' }
+        ]
+
+        expect(deepSelect(item, x => x.b).length).toEqual(4)
+
+        let ite = [{
+            b: [
+                { a: 'a', b: [{ a: 'b', b: [{ a: 'c' }] }]},
+                { a: 'd' },
+                { a: 'e', b: [{ a: 'f' }]}
+            ]
+        }]
+
+        expect(deepSelect(ite, x => x.b).length).toEqual(7)
+
+        let te = {
+            b: [
+                { a: 'a', b: [{ a: 'b', b: [{ a: 'c' }] }]},
+                { a: 'd' },
+                { a: 'e', b: [{ a: 'f' }]}
+            ]
+        }
+
+        //misses the parent
+        expect(deepSelect(te, x => x.b).length).toEqual(6)
+    })
+
+    test('has search', () => {
+        expect(hasSearch(undefined, 'test', ['a', 'b'])).toEqual(false)
+        expect(hasSearch('test', undefined, ['a', 'b'])).toEqual(true)
+        expect(hasSearch({ test: 'one two three', a: 'one' }, 'four', ['test', 'a'])).toEqual(false)
+        expect(hasSearch({ test: 'two', a: 'one' }, 'one', undefined)).toEqual(false)
+        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'three', ['a', 'b'])).toEqual(false)
+        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'three', ['a', 'b', 'test'])).toEqual(true)
+        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'one', ['b'])).toEqual(false)
+        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'one', ['a', 'b'])).toEqual(true)
+    })
+
+    test('to compare string', () => {
+        expect(toCompareString('one')).toEqual('one')
+        expect(toCompareString(undefined)).toStrictEqual(null)
+        expect(toCompareString('one two three')).toEqual('onetwothree')
+    })
+
+    test('nested value', () => {
+        let item = {
+            a: { b: 'b', c: { d: 'd' } },
+            b: 'str'
+        }
+
+        expect(nestedValue(item, 'b')).toEqual('str')
+        expect(nestedValue(item, 'a.c.d')).toEqual('d')
+        expect(nestedValue(item, 'a.b')).toEqual('b')
+    })
+
+    test('valid email', () => {
+        expect(validEmail('andrewderoon@gmail.com')).toEqual(true)
+        expect(validEmail('@gmail.com')).toEqual(false)
+        expect(validEmail('a@')).toEqual(false)
+        expect(validEmail('a@e')).toEqual(true)
+        expect(validEmail('andrewderoon.com')).toEqual(false)
+    })
+})

package/test/navigation.test.ts

@@ -0,0 +1,99 @@
+import { createNavigation } from '../src/composables/navigation'
+import { describe, expect, test } from 'vitest'
+
+describe("navigation", () => {
+    const nav = createNavigation({
+        defaultCacheExpiryHours: 3,
+        navItems: [
+            {
+                name: 'test-nav'
+            },
+            {
+                name: 'navA',
+                background: 'b',
+                displayName: 'discs',
+                hideAppBar: true,
+                hideNavigation: true,
+                hesitate: true,
+                icon: 'mdi-plus',
+                path: '/testing/one',
+                children: [
+                    {
+                        name: 'navB',
+                        cacheExpiryHours: 4,
+                        children: [
+                            {
+                                archiveName: 'nav-archive',
+                                aliases: ['nav-alias', 'nav-alia'],
+                                name: 'navC',
+                                path: '/test/alias'
+                            }
+                        ],
+                        singleName: 'navone'
+                    }
+                ]
+            }
+        ]
+    })
+
+    test('find archive name', () => {
+        expect(nav.findArchiveName('navC')).toEqual('nav-archive')
+        expect(nav.findArchiveName('navB')).toEqual(undefined)
+        expect(nav.findArchiveName('navD')).toEqual(undefined)
+    })
+
+    test('find cache length', () => {
+        expect(nav.findCacheHours('navC')).toEqual(3)
+        expect(nav.findCacheHours('navB')).toEqual(4)
+    })
+
+    test('find display', () => {
+        expect(nav.findDisplay('test-nav')).toEqual(undefined)
+        expect(nav.findDisplay('navA')).toEqual('discs')
+    })
+
+    test('find icon', () => {
+        expect(nav.findIcon('test-nav')).toEqual(undefined)
+        expect(nav.findIcon('navA')).toEqual('mdi-plus')
+    })
+
+    test('find item', () => {
+        expect(nav.findItem('test-nav')).not.toBeNull()
+        expect(nav.findItem('test-navs')).toBeNull()
+        expect(nav.findItem('test-nav')?.name).toEqual('test-nav')
+        expect(nav.findItem('nav-alias')?.name).toEqual('navC')
+    })
+
+    test('find store name', () => {
+        expect(nav.findStoreName('navA')).toEqual('navA')
+        expect(nav.findStoreName('navB')).toEqual('navB')
+        expect(nav.findStoreName('test-nav')).toEqual('test-nav')
+    })
+
+    test('find path', () => {
+        expect(nav.findPath('test-nav')).toEqual('')
+        expect(nav.findPath('navA')).toEqual('/testing/one')
+        expect(nav.findPath('nav-alias')).toEqual('/test/alias')
+    })
+
+    test('find single display', () => {
+        expect(nav.findSingleDisplay('navA')).toEqual('disc')
+        expect(nav.findSingleDisplay('navB')).toEqual('navone')
+    })
+
+    test('update nav props', () => {
+        nav.updateNavigationProperties('test-nav')
+
+        expect(nav.showAppBar.value).toEqual(true)
+        expect(nav.showAppNavigation.value).toEqual(true)
+        expect(nav.backgroundName.value).toEqual(undefined)
+        expect(nav.hesitate.value).toEqual(false)
+
+        nav.updateNavigationProperties('navA')
+
+        expect(nav.showAppBar.value).toEqual(false)
+        expect(nav.showAppNavigation.value).toEqual(false)
+        expect(nav.backgroundName.value).toEqual('b')
+        expect(nav.hesitate.value).toEqual(true)
+    })
+})

package/test/stores-last-update.test.ts

@@ -0,0 +1,138 @@
+import { setActivePinia, createPinia } from 'pinia'
+import { createSessionStore, createWholeLastUpdateStore } from '../src/composables/stores'
+import { createApi } from '../src/composables/api'
+import { describe, test, expect, beforeEach, afterAll, afterEach, beforeAll } from 'vitest'
+import { setupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
+import { createApp } from 'vue'
+import { withSetup } from './utils'
+
+const handlers = [
+    http.get('https://api/get/1', () => {
+        return HttpResponse.json({
+            data: { test: 'g' }
+        })
+    }),
+    http.get('https://api/getAll', () => {
+        return HttpResponse.json({
+            data: [{ test: 'a', id: '1' }, { test: 'b', id: '2' }],
+            count: 2,
+            filters: ['test', 'test two']
+        })
+    }),
+    http.post('https://api/post', () => {
+        return HttpResponse.json({ data: { test: 'd', id: '11' } })
+    }),
+    http.patch('https://api/patch', () => {
+        return HttpResponse.json({ data: { test: 'e', rowVersion: 2 } })
+    })
+]
+
+const server = setupServer(...handlers)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
+
+afterAll(() => server.close())
+
+afterEach(() => {
+    server.resetHandlers()
+})
+
+describe('use last update store no api no caching', () => {
+    const [api, app] = withSetup(() => createApi({
+        findPath: () => 'https://api/',
+        defaultThrowError: false
+    }))
+
+    const pinia = createPinia()
+    app.use(pinia)
+
+    setActivePinia(pinia)
+
+    const store = createWholeLastUpdateStore({
+        api: null,
+        storageMode: 'session',
+        storeName: 'whole'
+    })()
+
+    test('all session activity', async () => {
+
+        await store.post<any>({ data: { id: '1', test: 'a' }})
+        await store.post<any>({ data: { id: '2', test: 'b' }})
+        await store.post<any>({ data: { id: '3', test: 'c' }})
+
+        let postRes = await store.get<any>({ id: '1' })
+        expect(postRes.data).toEqual({ id: '1', test: 'a' })
+
+        await store.patch<any>({ data: { id: '1', test: 'd' }})
+        postRes = await store.get<any>({ id: '1' })
+        expect(postRes.data).toEqual({ id: '1', test: 'd' })
+
+        let getAll = await store.getAll<any>({})
+        expect(getAll.data.length).toEqual(3)
+        expect(getAll.count).toEqual(3)
+
+
+        await store.deleteItem({ data: { id: '1' }})
+        postRes = await store.get<any>({ id: '1' })
+        expect(postRes.data).toEqual(undefined)
+
+        getAll = await store.getAll<any>({})
+        expect(getAll.data.length).toEqual(2)
+        expect(getAll.count).toEqual(2)
+    })
+
+})
+
+
+describe('use last update store with api no caching', () => {
+    const [api, app] = withSetup(() => createApi({
+        findPath: () => 'https://api/',
+        defaultThrowError: false
+    }))
+
+    const pinia = createPinia()
+        app.use(pinia)
+        setActivePinia(pinia)
+
+    const store = createWholeLastUpdateStore({
+        storageMode: 'session',
+        api: api,
+        storeName: 'whole-api'
+    })()
+
+
+    test('get', async () => {
+        const res = await store.get<any>({ id: '1' })
+        expect(res.data).toEqual({ test: 'a', id: '1' })
+        let getAll = await store.getAll<any>({})
+        expect(getAll.data.length).toEqual(2)
+        expect(getAll.count).toEqual(2)
+    })
+
+
+    test('get all', async () => {
+        const res = await store.getAll<any>({})
+        expect(res).toEqual({
+            data: [{test: 'a', id: '1' },{test: 'b', id: '2' }],
+            count: 2,
+            filters: []
+        })
+    })
+    
+    test('post', async () => {
+        const res = await store.post<any>({ data: { test: 'a', id: '11' }})
+        expect(res).not.toBeNull()
+        
+        //gets api post return
+        let getRes = await store.get<any>({ id: '11' })
+        expect(getRes.data).toEqual({ test: 'd', id: '11' })
+    })
+
+    test('patch', async () => {
+        const res = await store.patch<any>({ data: { test: 'a', id: '1', rowVersion: 1 }})
+        let getRes = await store.get<any>({ id: '1' })
+        expect(getRes.data.rowVersion).toEqual(2)
+    })
+
+})

package/test/stores-session.test.ts

@@ -0,0 +1,118 @@
+import { setActivePinia, createPinia } from 'pinia'
+import { createSessionStore, createWholeLastUpdateStore } from '../src/composables/stores'
+import { createApi } from '../src/composables/api'
+import { describe, test, expect, beforeEach, afterAll, afterEach, beforeAll } from 'vitest'
+import { setupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
+import { createApp } from 'vue'
+import { withSetup } from './utils'
+
+const handlers = [
+    http.get('https://test-api/get/1', () => {
+        return HttpResponse.json({
+            data: { test: 'a' }
+        })
+    }),
+    http.get('https://test-api/get/2', () => {
+        return new HttpResponse('not found', {
+            status: 304
+        })
+    }),
+    http.get('https://test-api/getAll', () => {
+        return HttpResponse.json({
+            data: [{ test: 'a' }, { test: 'b' }],
+            count: 2,
+            filters: ['test', 'test two']
+        })
+    }),
+    http.post('https://test-api/post', () => {
+        return HttpResponse.json({ data: { test: 'b' } })
+    }),
+    http.patch('https://test-api/patch', () => {
+        return HttpResponse.json({ data: { test: 'c', rowVersion: 2 } })
+    })
+]
+
+const server = setupServer(...handlers)
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
+
+afterAll(() => server.close())
+
+afterEach(() => {
+    server.resetHandlers()
+})
+
+describe('use session store with no api no caching', () => {
+    const [api, app] = withSetup(() => createApi())
+
+    const pinia = createPinia()
+    app.use(pinia)
+    setActivePinia(pinia)
+
+    const store = createSessionStore({
+        storageMode: 'session',
+        storeName: 'sesh'
+    })()
+
+    test('all session activity', async () => {
+        await store.post<any>({ data: { id: '1', test: 'a' }})
+        let postRes = await store.get<any>({ id: '1' })
+        expect(postRes.data).toEqual({ id: '1', test: 'a' })
+        await store.patch<any>({ nav: 'test', data: { id: '1', test: 'b' }})
+        postRes = await store.get<any>({ id: '1' })
+        expect(postRes.data).toEqual({ id: '1', test: 'b' })
+        await store.deleteItem({ id: '1' })
+        postRes = await store.get<any>({ id: '1' })
+        expect(postRes).toEqual(undefined)
+    })
+})
+
+describe('use session store with api no caching', () => {
+    const [api, app] = withSetup(() => createApi({
+        findPath: () => 'https://test-api/',
+        defaultThrowError: false
+    }))
+
+    const pinia = createPinia()
+    app.use(pinia)
+
+    setActivePinia(pinia)
+
+    const store = createSessionStore({
+        storageMode: 'session',
+        api: api,
+        storeName: 'test'
+    })()
+
+
+    test('get', async () => {
+        const res = await store.get<any>({ nav: 'test', id: '1' })
+        expect(res).toEqual({ data: { test: 'a' }})
+        //expect(store.searchMemory['test_no-user-id_1']).toEqual({ data: { test: 'a' }})
+    })
+
+    test('get all', async () => {
+        const res = await store.getAll<any>({ nav: 'test' })
+        expect(res).toEqual({
+            data: [{test: 'a' },{test: 'b'}],
+            count: 2,
+            filters: ['test', 'test two']
+        })
+    })
+
+    test('post', async () => {
+        const res = await store.post<any>({ nav: 'test', data: { test: 'a', id: '11' }})
+        expect(res).not.toBeNull()
+        //gets api post return
+        let getRes = await store.get<any>({ nav: 'test', id: '11' })
+        expect(getRes.data).toEqual({ test: 'b' })
+    })
+
+    test('patch', async () => {
+        const res = await store.patch<any>({ nav: 'test', data: { test: 'a', id: '1', rowVersion: 1 }})
+        let getRes = await store.get<any>({ nav: 'test', id: '1' })
+        expect(getRes.data.rowVersion).toEqual(2)
+    })
+
+})

package/test/track.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "vitest"
+import { withSetup } from './utils'
+import { useTracker } from '../src/composables/track'
+import { twiddleThumbs } from "../src/composables/helpers"
+
+describe("track", () => {
+    test('tracker test', async () => {
+
+        const item = { test: 'a' }
+        const [{ asyncItem, isChanged, restartTracker }] = withSetup(() => useTracker(item))
+
+        
+        expect(isChanged.value).toEqual(false)
+        asyncItem.value.test = 'b'
+        await twiddleThumbs(500)
+        expect(isChanged.value).toEqual(true)
+        asyncItem.value.test = 'a'
+        await twiddleThumbs(500)
+        expect(isChanged.value).toEqual(false)
+        asyncItem.value.test = 'b'
+        await twiddleThumbs(500)
+        expect(isChanged.value).toEqual(true)
+        restartTracker()
+        await twiddleThumbs(500)
+        expect(isChanged.value).toEqual(false)
+        
+    })
+    
+})

package/test/utils.ts

@@ -0,0 +1,15 @@
+import { createApp } from 'vue'
+
+export function withSetup(composable) {
+    let result
+    const app = createApp({
+        setup() {
+            result = composable()
+            return () => {}
+        }
+    })
+
+    app.mount(document.createElement('div'))
+
+    return [result, app]
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "ES2021.String", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "paths": {
+      "@/*": [
+       "src/*"
+      ]
+     },
+     "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }],
+  "exclude": ["node_modules"]
+}

package/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vite + Vue + TS</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>

package/public/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>