bt-core-app 1.4.1 → 1.4.3

package/src/components/BT-Header-Option.vue

@@ -1,39 +0,0 @@
-<template>
-    <v-slide-x-transition group>
-        <span v-if="option.prefix != null">{{ option.prefix }}</span>
-        <span v-if="option.bool != null">
-            <v-icon v-if="nestedValue(data, option.value) === true" :size="size">mdi-check</v-icon>
-        </span>
-        <bt-entity
-            v-else-if="option.nav != null && (option.itemText != null || option.textFilter != null)"
-            inline
-            :itemText="option.itemText"
-            :itemId="nestedValue(data, option.value)"
-            :nav="option.nav"
-            :single="option.single"
-            :textFilter="option.textFilter" />
-        <span v-else>{{ displayText(data) }}</span>
-    </v-slide-x-transition>
-</template>
-
-<script setup lang="ts">
-import { type TableColumn } from '../composables/list'
-import { nestedValue } from '../composables/helpers'
-import { useFilters } from '../composables/filters'
-import { computed } from 'vue';
-    
-    interface Props {
-        data: any
-        option: TableColumn
-        size?: string | number
-    }
-
-    const props = defineProps<Props>()
-    const filters = useFilters()
-    const displayText = computed(() => (item: any) => {
-        let v = nestedValue(item, props.option.value)
-        v = props.option.textFunction != null ? props.option.textFunction(v) : v
-        return props.option.textFilter != null ? filters.findFilter(props.option.textFilter)(v) : v
-    })
-    
-</script>

package/src/components/BT-Json.vue

@@ -1,67 +0,0 @@
-<template>
-    <v-card max-height="350" class="overflow-y-auto">
-        <v-card-text>
-            <div v-for="(j, ind) in display" :key="ind">
-                <pre v-html="syntaxHighlight(j)"></pre>
-            </div>
-        </v-card-text>
-    </v-card>
-</template>
-
-<script setup lang="ts">
-    import { computed } from 'vue'
-    
-    const props = defineProps(['value'])
-
-    const display = computed(() => {
-        if (props.value == null) {
-            return []
-        }
-
-        if (Array.isArray(props.value))
-            return props.value
-
-        return [props.value]
-    })
-
-    function syntaxHighlight(json: any) {
-        if (typeof json != 'string') {
-            json = JSON.stringify(json, undefined, 2); //Object.keys(json).sort(), 2);
-        }
-        json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-        const e = json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match: any) {
-            var cls = 'number';
-            if (/^"/.test(match)) {
-                if (/:$/.test(match)) {
-                    cls = 'key';
-                } else {
-                    cls = 'string';
-                }
-            } else if (/true|false/.test(match)) {
-                cls = 'boolean';
-            } else if (/null/.test(match)) {
-                cls = 'null';
-            }
-            return '<span class="' + cls + '">' + match + '</span>';
-        });
-
-        return e
-    }
-
-</script>
-
-<style>
-    pre {
-        outline: 1px solid #ccc; 
-        padding: 5px; 
-        margin: 5px; }
-
-    pre .string { 
-        color: green; 
-    }
-    pre .number { color: darkorange; }
-    pre .boolean { color: rgb(191, 255, 0); }
-    pre .null { color: magenta; }
-    pre .key { color: rgb(141, 141, 141); }
-</style>

package/src/components/BT-Nav-Menu-Item.vue

@@ -1,61 +0,0 @@
-<template>
-    <v-list-group v-if="doShowItem && relevantChildren.length > 0"
-        color="accent"
-        :subGroup="isSubGroup"
-        fluid>
-        <template #activator="{ props }">
-            <v-list-item v-bind="props"
-                :prepend-icon="item.icon"
-                :title="item.displayName" />
-        </template>
-        <BT-Nav-Menu-Item 
-            v-for="child in relevantChildren"
-            :key="child.name"
-            isSubGroup
-            :item="child" />
-    </v-list-group>
-    <v-list-item v-else-if="doShowItem"
-        color="accent"
-        :prepend-icon="item.icon"
-        nav
-        :title="item.displayName ?? item.name"
-        :to="{ name: item.name }">
-    </v-list-item>
-    <v-divider v-else-if="item.isDivider" />
-    <div v-else>test</div>
-</template>
-
-<script setup lang="ts">
-    import BTNavMenuItem from './BT-Nav-Menu-Item.vue'
-    import { computed } from 'vue'
-    import { useAuth } from '../composables/auth'
-    import { isLengthyArray } from '../composables/helpers'
-    import { type NavigationItem } from '../composables/navigation'
-    // import { VListItem, VListGroup, VDivider } from 'vuetify/components'
-    
-    interface ItemProps {
-        allowedSubscriptionCodes?: string[],
-        isSubGroup?: boolean,
-        item?: any
-    }
-
-    const props = withDefaults(defineProps<ItemProps>(), {
-        allowedSubscriptionCodes: () => [],
-        isSubGroup: false,
-        item: null
-    })
-
-    const { doShowByNav } = useAuth()
-
-    const relevantChildren = computed(() => {
-        const l = props.item.children?.filter((x: NavigationItem) => x.isInNavMenu !== false) ?? []
-        if (!isLengthyArray(props.allowedSubscriptionCodes)) {
-            return l
-        }
-
-        return l.filter((navItem: NavigationItem) => !isLengthyArray(navItem.subFilters) || props.allowedSubscriptionCodes.some(code => navItem.subFilters?.some(sFilter => sFilter == code)))
-    })
-    
-    const doShowItem = computed(() => doShowByNav(props.item, true))
-
-</script>

package/src/components/BT-Nav-Sidebar.vue

@@ -1,79 +0,0 @@
-<template>
-    <v-navigation-drawer
-        v-if="isLoggedIn"
-        disabled-resize-watcher
-        expand-on-hover
-        :rail="!state.drawerStick"
-        permanent
-        v-model="state.drawer">
-        <slot>
-            <v-list class="pt-1">
-                <v-list-item nav :title="title">
-                    <template #prepend>
-                        <v-avatar size="36">
-                            <v-img :src="iconSrc" />
-                        </v-avatar>
-                    </template>
-                    <template #append>
-                        <v-row class="mr-1">
-                            <v-btn
-                                @click="toggleDrawerStick"
-                                flat
-                                icon
-                                size="small"
-                                title="Pin/Unpin Menu">
-                                <v-icon>{{ state.drawerStick ? 'mdi-pin-off' : 'mdi-pin' }}</v-icon>
-                            </v-btn>
-                        </v-row>
-                    </template>
-                </v-list-item>
-                <slot name="top-list">
-                   
-                </slot>
-            </v-list>
-
-            <slot name="middle-list">
-                <v-list nav>
-                    <BT-Nav-Menu-Item
-                        v-for="(item, index) in navItems"
-                        :key="index"
-                        :item="item" />
-                </v-list>
-            </slot>
-        </slot>
-        <template #append>
-            <slot name="bottom-list">
-                <v-list v-if="isLoggedIn" class="ma-0 pa-0">
-                    <v-list-item
-                        class="bg-primary"
-                        prepend-icon="mdi-logout"
-                        title="Logout"
-                        @click="() => logout()" />
-                </v-list>
-            </slot>
-        </template>
-    </v-navigation-drawer>
-</template>
-
-<script setup lang="ts">
-import BTNavMenuItem from './BT-Nav-Menu-Item.vue'
-import { useCosmetics } from '../composables/cosmetics'
-import { useNavigation } from '../composables/navigation'
-import { useAuth } from '../composables/auth'
-import { computed } from 'vue'
-// import { VListItem, VList, VNavigationDrawer, VAvatar, VImg, VRow, VBtn } from 'vuetify/components'
-
-interface SidebarProps {
-    // greeting?: string
-    iconSrc?: string
-    title?: string
-}
-
-defineProps<SidebarProps>()
-const { state, toggleDrawerStick } = useCosmetics()
-const { isLoggedIn, logout } = useAuth()
-const navigation = useNavigation()
-
-const navItems = computed(() => navigation.navigationItems.filter(x => x.isInNavMenu !== false && navigation.backgroundName.value == x.background));
-
-</script>

package/src/components/BT-Select-List-Box.vue

@@ -1,258 +0,0 @@
-<template>
-    <v-col
-        :class="colClass"
-        :lg="mLg"
-        :md="mMd"
-        :sm="mSm"
-        :cols="cols">
-        <v-list-item v-if="!alwaysOpen && mIsSelecting" @click="mIsSelecting = false"
-            :subtitle="label">
-            <template #append>
-                <v-row class="ma-0 pa-0">
-                    <slot name="actions" />
-                    <v-icon>mdi-chevron-up</v-icon>
-                    <slot name="actionsRight" />
-                    <v-menu 
-                        v-if="showSettings"
-                        offset-y 
-                        :close-on-content-click="false">
-                        <template v-slot:activator="{ props }">
-                            <v-btn 
-                                icon="mdi-cog"
-                                :size="mSize"
-                                title="Settings"
-                                v-bind="props" />
-                        </template>
-                        <v-list>
-                            <slot name="settings" />
-                        </v-list>
-                    </v-menu>
-                </v-row>
-            </template>
-        </v-list-item>
-        <v-slide-y-transition hide-on-leave group>
-            <v-text-field
-                v-if="(alwaysOpen || mIsSelecting) && showSearch !== false && isLengthyArray(searchProps)"
-                @click:prepend-inner="ui.searchString.value = undefined"
-                hide-details
-                key="1"
-                placeholder="Search"
-                :prepend-inner-icon="ui.searchString.value != null ? 'mdi-close' : undefined"
-                v-model="ui.searchString.value">
-                <template #append-inner>
-                    <v-btn
-                        v-if="canRefresh"
-                        @click="ui.refresh({ deepRefresh: true })"
-                        icon="mdi-refresh"
-                        :size="mSize"
-                        variant="text" />
-                </template>
-
-            </v-text-field>
-            <v-virtual-scroll
-                v-if="(alwaysOpen || mIsSelecting) && useVirtualScroller"
-                :height="height"
-                :items="ui.filteredItems.value"
-                key="2">
-                <template #default="{ item }">
-                    <slot name="item" v-bind:item="item" v-bind:selectItem="selectItem(item)" :active="isActive(item)">
-                        <v-list-item @click="selectItem(item)" :active="isActive(item)" color="primary">
-                            <slot v-bind:item="item">
-                                <v-list-item-title v-if="itemText != null || textFilter != null || textFunction != null">
-                                    {{ displayTitle(item) }}
-                                </v-list-item-title>
-                                <v-list-item-subtitle v-if="itemSubtext != null || subtextFilter != null || subtextFunction != null">
-                                    {{ displaySubtitle(item) }}
-                                </v-list-item-subtitle>
-                            </slot>
-
-                        </v-list-item>
-                    </slot>
-                </template>
-            </v-virtual-scroll>
-            <v-list
-                v-else-if="alwaysOpen || mIsSelecting"
-                :bg-color="transparent ? 'transparent' : undefined"
-                :height="height"
-                key="3">
-                <v-list-item
-                    v-if="canSelectNone"
-                    key="-1"
-                    density="compact"
-                    @click="selectItem(null)"
-                    subtitle="(Select None)" />
-                
-                <template v-for="(fItem, fInd) in ui.filteredItems.value">
-                    <slot name="item" :items="fItem" :index="fInd" :size="mSize">
-                        <v-list-item
-                            :active="isActive(fItem)"
-                            :key="fInd"
-                            :value="fItem"
-                            @click="selectItem(fItem)">
-                            <slot :item="fItem" :index="fInd" :size="mSize">
-                                <v-list-item-title v-if="itemText != null || textFilter != null || textFunction != null">
-                                    {{ displayTitle(fItem) }}
-                                </v-list-item-title>
-                                <v-list-item-subtitle v-if="itemSubtext != null || subtextFilter != null || subtextFunction != null">
-                                    {{ displaySubtitle(fItem) }}
-                                </v-list-item-subtitle>
-                            </slot>
-                        </v-list-item>
-                    </slot>
-                </template>
-            </v-list>
-            <slot v-else name="selected" :item="selectedItem" :open="openList">
-                <v-list-item
-                    @click="openList"
-                    key="4"
-                    :title="label"
-                    :subtitle="displayTitle(selectedItem) ?? placeholder">
-                    <template #append>
-                        <v-row no-gutters>
-                            <slot name="actions" />
-                            <v-icon>mdi-chevron-down</v-icon>
-                            <slot name="actionsRight" />
-                            <v-menu
-                                v-if="showSettings"
-                                offset-y 
-                                :close-on-content-click="false">
-                                <template v-slot:activator="{ props }">
-                                    <v-btn 
-                                        icon
-                                        v-bind="props"
-                                        :size="mSize"
-                                        title="Settings" />
-                                </template>
-                                <v-list>
-                                    <slot name="settings" />
-                                </v-list>
-                            </v-menu>
-                        </v-row>
-                    </template>
-                </v-list-item>
-            </slot>
-            
-        </v-slide-y-transition>
-        
-        <v-overlay 
-            v-model="ui.isLoading.value"
-            class="align-center justify-center text-center"
-            contained
-            persistent>
-            <v-progress-circular indeterminate />
-            <p>{{ ui.loadingMsg.value }}</p>
-        </v-overlay>
-    </v-col>
-    
-</template>
-
-<script setup lang="ts">
-    import { type ListProps, useList } from '../composables/list'
-    import { computed, inject, ref } from 'vue'
-    import { useFilters } from '../composables/filters'
-    import { isLengthyArray, nestedValue } from '../composables/helpers'
-
-    defineOptions({
-        inheritAttrs: false
-    })
-
-    interface SelectProps extends ListProps {
-        alwaysOpen?: boolean
-        canRefresh?: boolean
-        canSearch?: boolean
-        canSelectNone?: boolean
-        colClass?: string
-        cols?: string | boolean
-        height?: string
-        isMobile?: boolean
-        isEditing?: boolean
-        isSelecting?: boolean
-        items?: [],
-        itemSubtext?: string
-        itemText?: string
-        itemValue?: string //inherited
-        label?: string
-        lg?: string | boolean
-        modelValue?: any
-        md?: string | boolean
-        nav?: string
-        placeholder?: string
-        showSettings?: boolean
-        sm?: string | boolean
-        subtextFilter?: string
-        subtextFunction?: Function
-        textFilter?: string
-        textFunction?: Function
-        transparent?: boolean
-        useVirtualScroller?: boolean
-    }
-
-    const emit = defineEmits(['update:modelValue', 'change'])
-
-    const props = withDefaults(defineProps<SelectProps>(), {
-        canRefresh: true,
-        height: '400',
-        isEditing: undefined,
-        sortOrder: 'Ascending',
-        cols: '12',
-        lg: false,
-        md: false,
-        sm: '6'
-    })
-
-    const mIsSelecting = ref(props.alwaysOpen ?? props.isSelecting ?? false)
-    const mSize = inject('size', () => ref('small'), true)
-    const mIsEditing = inject('isEditing', () => ref(false), true)
-    const cIsEditing = computed(() => props.isEditing ?? mIsEditing.value)
-
-    const ui = useList(props, undefined, {
-        useBladeSrc: false,
-        useRouteSrc: false
-    })
-
-    const filters = useFilters()
-
-    const displaySubtitle = computed(() => (item: any) => {
-        let v = props.subtextFunction != null ? props.subtextFunction(item) : item
-        v = props.itemSubtext != null ? nestedValue(v, props.itemSubtext) : v
-        return props.subtextFilter != null ? filters.findFilter(props.subtextFilter)(v) : v
-    })
-
-    const displayTitle = computed(() => (item: any) => {
-        let v = props.textFunction != null ? props.textFunction(item) : item
-        v = props.itemText != null ? nestedValue(v, props.itemText) : v
-        return props.textFilter != null ? filters.findFilter(props.textFilter)(v) : v
-    })
-
-    const isActive = computed(() => (item: any) => {
-        return (props.itemValue ? item[props.itemValue] : item) == props.modelValue
-    })
-
-    function openList() {
-        if (cIsEditing.value)
-            mIsSelecting.value = true
-    }
-
-    function selectItem(item: any) {
-        mIsSelecting.value = false
-
-        if (item != null || props.canSelectNone) {
-            let v = item
-
-            if (item != null && props.itemValue != null)
-                v = item[props.itemValue]
-
-            emit('update:modelValue', v)
-            emit('change', v)
-        }
-    }
-
-    const selectedItem = computed(() => {
-        return props.modelValue != null ? ui.asyncItems.value.find((x: any) => (x.id == props.modelValue)) : null
-    })
-    
-    const mIsMobile = inject('isMobile', () => ref(false), true)
-    const mLg = computed(() => (props.isMobile ?? mIsMobile.value) ? false : props.lg)
-    const mMd = computed(() => (props.isMobile ?? mIsMobile.value) ? false : props.md)
-    const mSm = computed(() => (props.isMobile ?? mIsMobile.value) ? false : props.sm)
-</script>

package/src/components/BT-Select.vue

@@ -1,46 +0,0 @@
-<template>
-    <v-select
-        :append-icon="canRefresh ? 'mdi-refresh' : undefined"
-        :clearable="canSelectNone"
-        @click:append-icon="ui.refresh({ deepRefresh: true })"
-        hide-details
-        :items="ui.filteredItems.value"
-        :item-title="itemText"
-        :item-value="itemValue"
-        :variant="fieldVariant" />
-</template>
-
-<script setup lang="ts">
-    import { type ListProps, type ListEvents, useList } from '../composables/list';
-    import { type FieldVariant } from '../types'
-
-    interface SelectEvents extends ListEvents {
-
-    }
-
-    interface SelectProps extends ListProps {
-        additionalUrl?: string
-        canRefresh?: boolean
-        canSelectNone?: boolean
-        fieldVariant?: FieldVariant
-        items?: [],
-        itemText?: string
-        itemValue?: string //inherited
-        multiple?: boolean
-        nav?: string
-        onFilter?: Function
-        textFilter?: string
-    }
-
-    const emit = defineEmits<SelectEvents>()
-
-    const props = withDefaults(defineProps<SelectProps>(), {
-        sortOrder: 'Ascending'
-    })
-
-    const ui = useList(props, emit, {
-        useBladeSrc: false,
-        useRouteSrc: false
-    })
-
-</script>

package/src/components/BT-Snack.vue

@@ -1,31 +0,0 @@
-<template>
-    <v-snackbar
-        v-model="showSnack"
-        :timeout="cTimeout">
-        {{ modelValue }}
-    </v-snackbar>
-</template>
-
-<script setup lang="ts">
-import { computed, ref, watch } from 'vue';
-
-
-    interface SnackProps {
-        isTimed?: boolean
-        modelValue?: string
-        timeout?: string,
-        
-    }
-
-    const props = withDefaults(defineProps<SnackProps>(), {
-        isTimed: true,
-        timeout: '5000'
-    })
-
-    const cTimeout = computed(() => { return props.isTimed ? props.timeout : -1 })
-    const showSnack = ref(false)
-    watch(() => props.modelValue, () => {
-        showSnack.value = true
-    })
-
-</script>

package/src/components/BT-Span.vue

@@ -1,21 +0,0 @@
-<template>
-    <span>{{ prefix }}{{ displayText }}{{ suffix }}</span>
-</template>
-
-<script setup lang="ts">
-    import { useFilters } from '../composables/filters'
-    import { computed } from 'vue'
-    
-    interface Props {
-        filter: string
-        prefix?: string
-        suffix?: string
-        value: any
-    }
-
-    const props = defineProps<Props>()
-    const { findFilter } = useFilters()
-    const displayText = computed(() => {
-        return props.filter ? findFilter(props.filter)(props.value) : props.value
-    })
-</script>

package/src/components/Dialog-Confirm.vue

@@ -1,47 +0,0 @@
-<template>
-    <v-dialog v-model="show">
-        <div>
-            <v-card :max-width="maxWidth ?? '400'" :min-width="minWidth" :title="title" class="mx-auto">
-                <v-card-text>
-                    <div class="text-h6">{{ msg }}</div>
-                </v-card-text>
-                <v-card-actions>
-                    <v-btn @click="cancel">{{ cancelText ?? 'No' }}</v-btn>
-                    <v-btn @click="confirm">{{ confirmText ?? 'Yes' }}</v-btn>
-                </v-card-actions>
-            </v-card>
-        </div>
-    </v-dialog>
-</template>
-  
-<script setup lang="ts">
-    import { onMounted } from 'vue';
-    import { type ConfirmDialogProps } from '../composables/dialogs'
-    
-    const props = withDefaults(defineProps<ConfirmDialogProps>(), {
-        cancelValue: false,
-        confirmValue: true,
-        startIncludeDetails: false
-    })
-
-    // const props = defineProps(['cancelText', 'confirmText', 'msg', 'minWidth', 'title'])
-    
-    const emit = defineEmits(['confirm', 'cancel'])
-
-    let show = false
-
-    function cancel() {
-        show = false
-        emit('cancel', props.cancelValue)
-    }
-
-    function confirm() {
-        show = false
-        emit('confirm', props.confirmValue)
-    }
-
-    onMounted(() => {
-        show = true
-    })
-
-</script>