bt-core-app 0.0.0

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/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,19 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vite'
+import path from 'path'
+import vue from '@vitejs/plugin-vue'
+
+// https://vitejs.dev/config/
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'happy-dom'
+  },
+  plugins: [vue()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  }
+})