bt-core-app 0.0.0

package/src/composables/track.ts

@@ -0,0 +1,55 @@
+import { type MaybeRefOrGetter, type Ref, ref, toRef, toValue, watch } from "vue";
+import { copyDeep } from '../composables/helpers';
+
+export interface UseTrackerOptions {
+    propsToIgnore?: string[]
+    propsToTrack?: string[],
+    useTracker?: boolean
+}
+
+export function useTracker(data: MaybeRefOrGetter<any>, options?: UseTrackerOptions) { //propsToIgnore, propsToTrack) {
+    const isChanged = ref(false);
+    const asyncItem: Ref<any> = toRef(data);
+    let originalJSON = createJSON(toValue(data));
+
+    if (options?.useTracker !== false) {
+        watch(asyncItem, (v) => {
+            isChanged.value = createJSON(v) != originalJSON;
+        }, { deep: true })
+    }
+
+    function createJSON(dataItem: any) {
+        const copy = copyDeep(dataItem);
+
+        if (options != null) {
+            if (options.propsToIgnore != null) {
+                //delete from copy
+                options.propsToIgnore.forEach(k => {
+                    delete copy[k];
+                })
+            }
+            else if (options.propsToTrack != null) {
+                //only keep these
+                const dataProps = Object.keys(dataItem)
+                dataProps.forEach(k => {
+                    if (!options!.propsToTrack!.some(x => x == k)) {
+                        delete copy[k]
+                    }
+                })
+            }
+        }
+
+        return JSON.stringify(copy);
+    }
+
+    function restart() {
+        originalJSON = createJSON(toValue(asyncItem));
+        isChanged.value = false;
+    }
+
+    return {
+        asyncItem,
+        isChanged,
+        restartTracker: restart
+    }
+}

package/src/composables/urls.ts

@@ -0,0 +1,11 @@
+export type Environment = 'production' | 'staging' | 'development'
+
+/**
+ * ms: BASE_AUTH_URL, BASE_DATA_URL, WEB_APP_URL, Microservice, LOCAL_DB_NAME
+ * @param microservice 
+ * @returns 
+ */
+export function useUrl(microservice?: string) {
+    let ms = `VITE_${microservice ?? 'BASE_DATA_URL'}`
+    return import.meta.env[ms] as string | undefined
+}

package/src/core.ts

@@ -0,0 +1,92 @@
+import { App } from 'vue'
+import { createApi } from './composables/api'
+import { createAuth, type GetAuthUrl, type AuthSubscription } from './composables/auth'
+import { BaseCosmeticTheme, createCosmetics, UseCosmeticsOptions } from './composables/cosmetics'
+import { createDates } from './composables/dates'
+import { createDemo } from './composables/demo'
+import { createFilters } from './composables/filters'
+import { createNavigation, type NavigationItem } from './composables/navigation'
+import { createPresets } from './composables/presets'
+import { createPWA } from './composables/pwa'
+import { createStoreBuilder } from './composables/stores'
+import { RemovableRef } from '@vueuse/core'
+
+import BTSpan from './components/BT-Span.vue'
+
+export interface CoreApp {
+    install(app: App) : void
+}
+
+export interface CreateCoreOptions extends UseCosmeticsOptions<BaseCosmeticTheme> {
+    defaultCacheExpiryHours?: number
+    navItems?: NavigationItem[]
+
+    getAuthUrl: GetAuthUrl
+    presets: any
+    setCredentials?: (state: RemovableRef<any>, payload: any) => void
+    subscriptionOptions?: AuthSubscription[]
+}
+
+export function createCore(options: CreateCoreOptions): CoreApp {
+    
+    return {
+        install(app: App) {
+            // const core = this
+
+            //register components
+            app.component('bt-span', BTSpan)
+
+            //define globals
+            // app.config.globalProperties.$btcore = core
+
+            const cosmetics = createCosmetics(options)
+            
+            const demo = createDemo()
+            
+            const navigation = createNavigation(options)
+
+            const presets = createPresets(options)
+
+            const auth = createAuth({ 
+                demo: demo,
+                getAuthItem: navigation.findItem,
+                getAuthUrl: options.getAuthUrl,
+                setCredentials: options.setCredentials,
+                subscriptionOptions: options.subscriptionOptions
+            })
+
+            const api = createApi({
+                auth: auth,
+                findPath: navigation.findPath,
+                useBearerToken: true
+            })
+
+            const dates = createDates({
+                getTimeZone: auth.getTimeZone
+            })
+
+            const filters = createFilters({
+                dates: dates
+            })
+
+            const pwa = createPWA()
+
+            const storeBuilder = createStoreBuilder({
+                api,
+                auth
+            })
+
+            //provide
+            app.provide('bt-api', api)
+            app.provide('bt-auth', auth)
+            app.provide('bt-cosmetics', cosmetics)
+            app.provide('bt-dates', dates)
+            app.provide('bt-demo', demo)
+            app.provide('bt-filters', filters)
+            app.provide('bt-navigation', navigation)
+            app.provide('bt-presets', presets)
+            app.provide('bt-pwa', pwa)
+            app.provide('bt-store', storeBuilder)
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export * from './composables/actions-tracker'
+export * from './composables/actions'
+export * from './composables/demo'
+export * from './composables/document-meta'
+export * from './composables/draggable'
+export * from './composables/forage'
+export * from './composables/helpers'
+export * from './composables/id'
+export * from './composables/list'
+export * from './composables/resizable'
+export * from './composables/rules'
+export * from './composables/stores'
+export * from './composables/track'
+export * from './composables/urls'
+export * from './useApi'
+export * from './core'

package/src/types.ts

@@ -0,0 +1,13 @@
+/**
+    Inline: merges toolbars | much more compact | hides navigation
+    Page: shows navigation and page settings
+    Blade: shows blade minimize, maximize, close, and pins as a column
+    Free-moving: show blade as draggable and resizable with minimize, maximize, and close and pinning
+ */
+export type BladeVariant = 'page' | 'blade' | 'freestyle' | 'inline' | 'pane'
+
+export type BladeMode = 'new' | 'view' | 'edit'
+
+export interface BaseModel {
+    id?: string
+}

package/src/useApi.ts

@@ -0,0 +1,68 @@
+import { inject } from 'vue'
+// import { BTActions } from './composables/actions'
+import { BTAuth } from './composables/auth'
+import { BTApi } from './composables/api'
+import { BTCosmetics } from './composables/cosmetics'
+import { BTDates } from './composables/dates'
+import { BTDemo } from './composables/demo'
+import { BTFilters } from './composables/filters'
+import { BTNavigation } from './composables/navigation'
+import { BTPresets } from './composables/presets'
+import { BTPWA } from './composables/pwa'
+import { BTStore, CreateStoreOptions } from './composables/stores'
+
+// /**returns a new instance */
+// export function useActions(): BTActions {
+//     return inject('bt-actions')!
+// }
+
+/**returns a singleton */
+export function useApi(): BTApi {
+    return inject('bt-api')!
+}
+
+/**returns a singleton */
+export function useAuth(): BTAuth {
+    return inject('bt-auth')!
+}
+
+/**returns a singleton */
+export function useCosmetics(): BTCosmetics {
+    return inject('bt-cosmetics')!
+}
+
+/**returns a singleton */
+export function useDates(): BTDates {
+    return inject('bt-dates')!
+}
+
+/**returns a singleton */
+export function useDemo(): BTDemo {
+    return inject('bt-demo')!
+}
+
+/**returns a singleton */
+export function useFilters(): BTFilters {
+    return inject('bt-filters')!
+}
+
+/**returns a singleton */
+export function useNavigation(): BTNavigation {
+    return inject('bt-navigation')!
+}
+
+/**returns a singleton */
+export function usePresets(preset?: string): any {
+    const p = inject('bt-presets')! as BTPresets
+    return p.usePresets(preset)
+}
+
+/**returns a singleton */
+export function usePWA(): BTPWA {
+    return inject('bt-pwa')!
+}
+
+/**returns a new instance */
+export function useStore(): (opt: CreateStoreOptions) => BTStore {
+    return inject('bt-store')!
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

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)
+    })
+})