bt-core-app 1.4.2 → 1.4.3

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>

package/src/components/Dialog-Select-Date.vue

@@ -1,89 +0,0 @@
-<template>
-    <v-dialog v-model="show">
-        <div>
-            <v-card
-                :max-width="maxWidth ?? '400'"
-                :min-width="minWidth"
-                class="mx-auto"
-                :title="title">
-                <v-card-text class="pa-0">
-                    <VueDatePicker
-                        auto-apply
-                        dark
-                        :enable-time-picker="useTime"
-                        inline
-                        :is-24="false"
-                        :model-auto="range"
-                        :range="range"
-                        :time-picker-inline="!range && useTime"
-                        :timezone="timeZone"
-                        utc
-                        v-bind="$attrs"
-                        v-model="date" />
-                </v-card-text>
-                <v-card-actions>
-                    <v-row no-gutters>
-                        <v-col cols="6">
-                            <v-btn v-if="required !== true" block @click="cancel">{{ cancelText ?? 'Cancel' }}</v-btn>
-                        </v-col>
-                        <v-col cols="6">
-                            <v-btn block @click="accept" :disabled="!canAccept">{{ confirmText ?? 'OK' }}</v-btn>
-                        </v-col>
-                    </v-row>
-                </v-card-actions>
-            </v-card>
-        </div>
-    </v-dialog>
-</template>
-  
-<script setup lang="ts">
-    import { computed, onMounted, ref } from 'vue'
-    import VueDatePicker from '@vuepic/vue-datepicker'
-    import '@vuepic/vue-datepicker/dist/main.css'
-    import { useAuth } from '../composables/auth'
-    import { type SelectDateProps } from '../composables/dialogs'
-
-    const props = withDefaults(defineProps<SelectDateProps>(), {
-        cancelValue: false,
-        height: '400'
-    })
-
-    const emit = defineEmits(['confirm', 'cancel'])
-    const date = ref()
-    const { timeZone } = useAuth()
-
-    const canAccept = computed(() => {
-        return !props.required || date.value
-    })
-
-    let show = false
-
-    function accept() {
-        if (props.required && !date.value) {
-            //required
-            return
-        }
-
-        show = false
-        emit('confirm', date.value)
-    }
-
-    // function maybeAccept(items: any) {
-    //     if (!props.multiple) {
-    //         if (isArrayOfLength(items, 1) || (props.canUnselect && !isLengthyArray(items))) {
-    //             show = false
-    //             emit('confirm', getSelectedValues(items))
-    //         }
-    //     }
-    // }
-
-    function cancel() {
-        show = false
-        emit('cancel', undefined)
-    }
-
-    onMounted(() => {
-        show = true
-    })
-
-</script>

package/src/components/Dialog-Select.vue

@@ -1,140 +0,0 @@
-<template>
-    <v-dialog v-model="show">
-        <div>
-            <v-card
-                :max-width="maxWidth ?? '400'"
-                :min-width="minWidth"
-                class="mx-auto"
-                :title="title">
-                <!-- <v-card-title v-if="title != null">{{ title }}</v-card-title> -->
-                <v-card-text class="pa-0">
-                    <v-text-field
-                        v-if="ui.showSearch.value"
-                        append-inner-icon="mdi-magnify"
-                        density="compact"
-                        hide-details
-                        placeholder="Search"
-                        v-model="ui.searchString.value" />
-                    <!-- <div v-if="multiple" @click="selectAll" class="text-center my-1">
-                        <v-btn>Select All</v-btn>
-                    </div> -->
-                    <v-list v-if="isLengthyArray(ui.filteredItems.value)"
-                        class="overflow-y-auto"
-                        v-model:selected="selection"
-                        :height="height"
-                        :select-strategy="multiple ? 'independent' : 'single-independent'"
-                        @update:selected="maybeAccept">
-                        <template v-for="(fItem) in ui.filteredItems.value" :key="index">
-                            <v-list-item :value="fItem">
-                                <slot v-bind:item="fItem">
-                                    <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>
-                            </template>
-                    </v-list>
-                </v-card-text>
-                <v-card-actions>
-                    <v-row no-gutters>
-                        <v-col :cols="multiple ? 6 : 12">
-                            <v-btn v-if="required !== true" block @click="cancel">{{ cancelText ?? 'Cancel' }}</v-btn>
-                        </v-col>
-                        <v-col v-if="multiple == true" cols="6">
-                            <v-btn block @click="accept" :disabled="!canAccept">{{ confirmText ?? 'OK' }}</v-btn>
-                        </v-col>
-                        
-                    </v-row>
-                </v-card-actions>
-                <v-overlay 
-                    v-model="ui.isLoading.value"
-                    class="align-center justify-center text-center"
-                    contained
-                    persistent>
-                    <v-progress-circular indeterminate />
-                    <p>{{ ui.loadingMsg }}</p>
-                </v-overlay>
-            </v-card>
-        </div>
-    </v-dialog>
-</template>
-  
-<script setup lang="ts">
-    import { computed, onMounted, ref } from 'vue';
-    import { isLengthyArray, isArrayOfLength, nestedValue } from '../composables/helpers'
-    import { useFilters } from '../composables/filters'
-    import { useList } from '../composables/list';
-    import { type SelectDialogProps } from '../composables/dialogs'
-    
-    const props = withDefaults(defineProps<SelectDialogProps>(), {
-        cancelValue: false,
-        height: '400',
-        showSearch: true
-    })
-
-    const emit = defineEmits(['confirm', 'cancel'])
-
-    const ui = useList(props)
-    const filters = useFilters()
-    const selection = ref([])
-
-    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 canAccept = computed(() => {
-        return !props.required || isLengthyArray(selection.value)
-    })
-
-    let show = false
-
-    function getSelectedValues(items: any) {
-        const res = props.itemValue != null ? items.map((x: any) => nestedValue(x, props.itemValue)) : items
-        if (props.multiple) {
-            return res
-        }
-        else {
-            return res.length > 0 ? res[0] : null
-        }
-    }
-    
-    function accept() {
-        if (props.required && !isLengthyArray(selection.value)) {
-            //required
-            return
-        }
-
-        show = false
-        emit('confirm', getSelectedValues(selection.value))
-    }
-
-    function maybeAccept(items: any) {
-        if (!props.multiple) {
-            if (isArrayOfLength(items, 1) || (props.canUnselect && !isLengthyArray(items))) {
-                show = false
-                emit('confirm', getSelectedValues(items))
-            }
-        }
-    }
-
-    function cancel() {
-        show = false
-        emit('cancel', undefined)
-    }
-
-    onMounted(() => {
-        show = true
-    })
-
-</script>