bt-core-app 1.1.6 → 1.1.8

package/dist/components/BT-Span.vue.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    filter: string;
+    prefix?: string;
+    suffix?: string;
+    value: any;
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<Props>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<Props>>>, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/Dialog-Confirm.vue.d.ts

@@ -0,0 +1,38 @@
+import { ConfirmDialogProps } from '../composables/dialogs';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ConfirmDialogProps>, {
+    cancelValue: boolean;
+    confirmValue: boolean;
+    startIncludeDetails: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ConfirmDialogProps>, {
+    cancelValue: boolean;
+    confirmValue: boolean;
+    startIncludeDetails: boolean;
+}>>> & {
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}, {
+    cancelValue: any;
+    confirmValue: any;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/Dialog-Select-Date.vue.d.ts

@@ -0,0 +1,36 @@
+import { SelectDateProps } from '../composables/dialogs';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectDateProps>, {
+    cancelValue: boolean;
+    height: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectDateProps>, {
+    cancelValue: boolean;
+    height: string;
+}>>> & {
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}, {
+    height: string;
+    cancelValue: any;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/Dialog-Select.vue.d.ts

@@ -0,0 +1,48 @@
+import { SelectDialogProps } from '../composables/dialogs';
+
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectDialogProps>, {
+    cancelValue: boolean;
+    height: string;
+    showSearch: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectDialogProps>, {
+    cancelValue: boolean;
+    height: string;
+    showSearch: boolean;
+}>>> & {
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}, {
+    height: string;
+    cancelValue: any;
+    showSearch: boolean;
+}, {}>, {
+    default?(_: {
+        item: any;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Dialog-Text.vue.d.ts

@@ -0,0 +1,33 @@
+import { TextDialogProps } from '../composables/dialogs';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TextDialogProps>, {
+    height: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    confirm: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TextDialogProps>, {
+    height: string;
+}>>> & {
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}, {
+    height: string;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/composables/actions-tracker.d.ts

@@ -0,0 +1,19 @@
+import { ShallowRef } from 'vue';
+
+export interface DoActionOptions {
+    completionMsg?: string;
+    confirmationMsg?: string;
+    errorMsg?: string;
+    loadingMsg?: string;
+    requireConfirmation?: boolean;
+    throwError?: boolean;
+}
+export declare function useActionsTracker(useOptions?: DoActionOptions): {
+    actionErrorMsg: ShallowRef<string | undefined>;
+    actionLoadingMsg: ShallowRef<string | undefined>;
+    actionCompleteMsg: ShallowRef<string | undefined>;
+    clearErrors: () => void;
+    doAction: (action: any, options?: DoActionOptions) => Promise<any>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    logError: (err?: string | Error) => void;
+};

package/dist/composables/actions.d.ts

@@ -0,0 +1,79 @@
+import { ShallowRef, ComputedRef } from 'vue';
+import { DoActionOptions } from '../composables/actions-tracker';
+import { BTApi, PathOptions } from '../composables/api';
+import { BTStore } from '../composables/stores';
+import { BladeMode } from '../types';
+
+export type OnCanDoAsync = (item: any) => Promise<string | undefined>;
+export type OnDoAsync = (item: any) => Promise<string | undefined>;
+export type OnDoSuccessAsync = (item: any) => Promise<any>;
+export type OnGetAsync = (opt?: GetOptions) => Promise<any>;
+export type OnGetSuccessAsync = (item: any, opt?: GetOptions) => Promise<any>;
+export interface GetOptions extends PathOptions, DoActionOptions {
+    /**returns an error msg if failed */
+    onGetAsync?: OnGetAsync;
+    /**called after get occurs successfully */
+    onGetSuccessAsync?: OnGetSuccessAsync;
+    store?: BTStore;
+}
+export interface DeleteOptions extends PathOptions, DoActionOptions {
+    /**Returns a string if cannot */
+    onCanDeleteAsync?: OnCanDoAsync;
+    /**Will override the default store delete action */
+    onDeleteAsync?: OnDoAsync;
+    /**Will open a dialog box requesting user confirmation for delete action */
+    onDeleteSuccessAsync?: OnDoAsync;
+    store?: BTStore;
+}
+export interface RestoreOptions extends PathOptions, DoActionOptions {
+    /**Returns a string if cannot */
+    onCanRestoreAsync?: OnCanDoAsync;
+    /**Will override the default store delete action */
+    onRestoreAsync?: OnDoSuccessAsync;
+    /**Called after restore succeeds */
+    onRestoreSuccessAsync?: OnDoSuccessAsync;
+    store?: BTStore;
+}
+export interface SaveOptions extends PathOptions, DoActionOptions {
+    /**will seek to post if 'new' otherwise will patch */
+    mode?: BladeMode;
+    /**called to check whether to proceed with save */
+    onCanSaveAsync?: OnCanDoAsync;
+    /**
+     * retrieves item to save
+     * called before seeing whether it can save
+     */
+    onGetSaveAsync?: OnDoSuccessAsync;
+    /**Will override the default store post/patch action */
+    onSaveAsync?: OnDoSuccessAsync;
+    /**Called after save succeeds */
+    onSaveSuccessAsync?: OnDoSuccessAsync;
+    store?: BTStore;
+}
+export interface ApiActionOptions extends PathOptions, DoActionOptions {
+    api: BTApi;
+}
+export interface UseActionsOptions extends DoActionOptions {
+    nav?: string;
+    proxyID?: string;
+    refresh?: boolean;
+    store?: BTStore;
+    throwError?: boolean;
+    url?: string;
+}
+export interface BTActions {
+    apiGet: (doOptions: ApiActionOptions) => Promise<any>;
+    apiPost: (doOptions: ApiActionOptions) => Promise<any>;
+    actionLoadingMsg: ShallowRef<string | undefined>;
+    actionErrorMsg: ShallowRef<string | undefined>;
+    clearErrors: () => void;
+    deleteItem: (doOptions: DeleteOptions) => Promise<any>;
+    doAction: (action: any, options?: DoActionOptions) => Promise<any>;
+    getAllItems: (doOptions: GetOptions) => Promise<any>;
+    getItem: (doOptions: GetOptions) => Promise<any>;
+    isLoading: ComputedRef<boolean>;
+    logError: (err?: string | Error) => void;
+    restoreItem: (doOptions: RestoreOptions) => Promise<any>;
+    saveItem: (doOptions: SaveOptions) => Promise<any>;
+}
+export declare function useActions(options?: UseActionsOptions): BTActions;

package/dist/composables/api.d.ts

@@ -0,0 +1,85 @@
+import { BTAuth } from './auth';
+
+export interface QueryParams {
+    filterBy?: string;
+    includeCount?: boolean;
+    includeDetails?: boolean;
+    includeInactive?: boolean;
+    lastUpdate?: string;
+    other?: any;
+    properties?: string[] | string;
+    query?: string;
+    searchString?: string;
+    sortOrder?: string;
+    sortBy?: string;
+    takeFrom?: number;
+    takeAmount?: number;
+}
+export interface PathOptions {
+    /**always added to end before query {url}/{additionalUrl}?{query} */
+    additionalUrl?: string;
+    /**application/json or other options */
+    contentType?: string;
+    /**that data to send in the body for POST, PATCH, and DELETE requests */
+    data?: any;
+    /** resulting url after building {nav | url}/{additionalUrl}?{params} */
+    finalUrl?: string;
+    /**override default headers */
+    headers?: HeadersInit;
+    /**id will be added as a url paramter (/{id}?) rather than as a query parameter */
+    id?: string;
+    /**where to find the url */
+    nav?: string;
+    /**headers will not be calculated.  Only the given headers in these options will be used */
+    overrideHeaders?: boolean;
+    /**query parameters */
+    params?: QueryParams;
+    /**attaches a proxyID to the request */
+    proxyID?: string;
+    /**whether to refresh the store data and go straight to the server */
+    refresh?: boolean;
+    /**returns result as a json object.  Defaults to true. */
+    returnJson?: boolean;
+    /**returns result as a string */
+    returnText?: boolean;
+    /**If false, returns response no matter the status code */
+    throwError?: boolean;
+    /**if exists then overrides default nav */
+    url?: string;
+    /**whether to preference using the local cache */
+    useLocalCache?: boolean;
+}
+type FindPath = (navName?: string) => string | undefined;
+export interface UseApiOptions {
+    auth?: BTAuth;
+    /**overrides the default */
+    buildHeaders?: (path: PathOptions) => HeadersInit;
+    /**build a query.  Overrides the default */
+    buildQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**defaults to 'application/json' */
+    defaultContentType?: string;
+    /**returns result as a json object.  Defaults to true. */
+    defaultReturnJson?: boolean;
+    /**returns result as a string */
+    defaultReturnText?: boolean;
+    /**defaults to true.  Will throw an error on fail */
+    defaultThrowError?: boolean;
+    /**defaults to a function that returns '' */
+    findPath?: FindPath;
+    /**if true and logged in then will set an authorization header with 'bearer [token]' */
+    useBearerToken?: boolean;
+}
+export interface BTApi {
+    buildHeaders: (options: PathOptions) => HeadersInit;
+    buildQuery: (params: any) => string;
+    buildUrl: (path: PathOptions) => string;
+    deleteItem: (pathOptions: PathOptions) => Promise<string | undefined>;
+    get: <T>(pathOptions: PathOptions) => Promise<T>;
+    getAll: <T>(pathOptions: PathOptions) => Promise<T>;
+    post: <T>(pathOptions: PathOptions) => Promise<T | undefined>;
+    patch: <T>(pathOptions: PathOptions) => Promise<T | undefined>;
+}
+export declare function createApi(options?: UseApiOptions): BTApi;
+export {};

package/dist/composables/auth.d.ts

@@ -0,0 +1,58 @@
+import { BTDemo } from '../composables/demo';
+import { RemovableRef } from '@vueuse/core';
+
+export interface AuthItem {
+    children?: AuthItem[];
+    ignoreSuspension?: boolean;
+    permissions?: string[];
+    requiresAuth?: boolean;
+    subscriptions?: string[];
+}
+export interface AuthSubscription {
+    code: string;
+    value: number;
+}
+export interface BaseAuthCredentials {
+    expiresOn?: string;
+    isGlobalAdmin?: boolean;
+    isLoggedIn?: boolean;
+    isSuspended?: boolean;
+    permissions?: string;
+    subscriptionCode?: string;
+    timeZone?: string;
+    token?: string;
+    userID?: string;
+    userPermissions?: string[];
+}
+export type GetAuthUrl = (redirectPath?: string, state?: string) => string;
+export interface CreateAuthOptions {
+    defaultTimeZone?: string;
+    demo?: BTDemo;
+    /**expiry token date format.  Defaults to 'd/MM/yyyy h:mm:ss a' */
+    expiryTokenFormat?: string;
+    /**retrieve the auth item */
+    getAuthItem: (navName?: string | AuthItem) => AuthItem | null;
+    /**retrieve the url to navigate to for the OAuth 2.0 process */
+    getAuthUrl: GetAuthUrl;
+    /**sets current credentials on top of default function*/
+    setCredentials?: (state: RemovableRef<any>, payload: any) => void;
+    /**suboptions */
+    subscriptionOptions?: AuthSubscription[];
+}
+export interface BTAuth {
+    authState: string;
+    canEdit: (navName?: string) => boolean;
+    canEditPermit: (permit: string) => boolean;
+    canView: (navName?: string) => boolean;
+    canViewPermit: (permit: string) => boolean;
+    credentials: any;
+    doShow: (subcodes?: string[], permissions?: string[], action?: 'view' | 'edit') => boolean;
+    doShowByNav: (navName?: string | AuthItem, includeChildren?: boolean) => boolean;
+    getAuthUrl: (redirectPath?: string) => string;
+    getTimeZone: () => string;
+    login: (redirectPath?: string) => void;
+    logout: (navNameRedirect?: string) => void;
+    setAuth: (jwtToken?: string) => void;
+    tryLogin: () => boolean | undefined;
+}
+export declare function createAuth(options: CreateAuthOptions): BTAuth;

package/dist/composables/cosmetics.d.ts

@@ -0,0 +1,34 @@
+interface CosmeticData {
+    dark?: BaseCosmeticTheme;
+    drawer?: boolean;
+    drawerStick?: boolean;
+    light?: BaseCosmeticTheme;
+    theme?: string;
+}
+export interface BaseCosmeticTheme {
+    primary: string;
+    secondary: string;
+    accent: string;
+    error: string;
+    info: string;
+    success: string;
+    warning: string;
+}
+export interface UseCosmeticsOptions<T extends BaseCosmeticTheme> {
+    defaultDarkTheme?: T;
+    defaultLightTheme?: T;
+    defaultDrawer?: boolean;
+    defaultDrawerStick?: boolean;
+    defaultTheme?: string;
+}
+export interface BTCosmetics {
+    state: CosmeticData;
+    resetCosmetics: (toDefault: boolean) => void;
+    setTemporaryColor: (color: string) => void;
+    toggleDrawer: () => void;
+    toggleDrawerStick: () => void;
+    toggleLightDark: () => void;
+    undoTemporaryColor: () => void;
+}
+export declare function createCosmetics<T extends BaseCosmeticTheme>(options: UseCosmeticsOptions<T>): BTCosmetics;
+export {};

package/dist/composables/csv.d.ts

@@ -0,0 +1,20 @@
+export interface CSVProps {
+    canExportCSV?: boolean;
+}
+export declare const csvDefaults: {
+    canExportCSV: boolean;
+};
+export interface UseCSVPropsReturn {
+    exportToCSV: Function;
+}
+export interface CSVItem {
+    header: string;
+    itemText?: string;
+    value: any;
+}
+declare global {
+    interface Navigator {
+        msSaveOrOpenBlob: (blob: Blob, fileName: string) => boolean;
+    }
+}
+export declare function useCSV(): UseCSVPropsReturn;

package/dist/composables/dates.d.ts

@@ -0,0 +1,14 @@
+import { DateTime } from 'luxon';
+
+export interface BTDates {
+    getToday: () => string;
+    getTomorrow: () => string;
+    tzDate: (val?: string, fromFormat?: string) => DateTime;
+    tzString: (val?: string, format?: string, fromFormat?: string) => string;
+    utcDate: (val?: string, fromFormat?: string) => DateTime;
+    utcString: (val?: string, format?: string, fromFormat?: string) => string;
+}
+export interface CreateDatesOptions {
+    getTimeZone: () => string;
+}
+export declare function createDates(options: CreateDatesOptions): BTDates;

package/dist/composables/demo.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+
+export interface BTDemo {
+    endDemo: () => void;
+    isDemoing: Ref<boolean>;
+    startDemo: () => void;
+}
+export declare function createDemo(): BTDemo;

package/dist/composables/dialogs.d.ts

@@ -0,0 +1,75 @@
+import { ListProps } from '../composables/list';
+
+export interface ConfirmDialogProps {
+    cancelText?: string;
+    cancelValue?: any;
+    confirmText?: string;
+    confirmValue?: any;
+    msg?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    title?: string;
+}
+export interface SelectDateProps {
+    cancelText?: string;
+    cancelValue?: any;
+    confirmText?: string;
+    dateFrom?: string;
+    dateRules?: Function | unknown[];
+    format?: string;
+    fromNow?: boolean;
+    height?: string;
+    msg?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    range?: boolean;
+    required?: boolean;
+    requireTime?: boolean;
+    title?: string;
+    useTime?: boolean;
+}
+export interface SelectDialogProps extends ListProps {
+    cancelText?: string;
+    cancelValue?: any;
+    canUnselect?: boolean;
+    confirmText?: string;
+    height?: string;
+    itemSubtext?: string;
+    itemText?: string;
+    itemValue?: string;
+    msg?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    multiple?: boolean;
+    nav?: string;
+    onFilter?: Function;
+    required?: boolean;
+    subtextFilter?: string;
+    subtextFunction?: Function;
+    textFilter?: string;
+    textFunction?: Function;
+    title?: string;
+}
+export interface TextDialogProps extends ListProps {
+    cancelText?: string;
+    confirmText?: string;
+    height?: string;
+    label?: string;
+    msg?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    required?: boolean;
+    title?: string;
+    value?: any;
+}
+export declare function useRequireConfirmation(action: any, props: ConfirmDialogProps, requireConfirm: boolean): void;
+export declare function useConfirmAsync(text: string): Promise<boolean>;
+/**
+ * Returns undefined if cancelled
+ * [] if multiple
+ * Null | Obj if single
+ * @param opts
+ */
+export declare function useSelectDialog(opts?: SelectDialogProps): Promise<any>;
+export declare function useSelectDate(opts?: SelectDateProps): Promise<any>;
+export declare function useTextDialog(opts?: TextDialogProps): Promise<any>;

package/dist/composables/document-meta.d.ts

@@ -0,0 +1,11 @@
+import { BTDemo } from '../composables/demo';
+import { RouteLocationNormalized } from 'vue-router';
+
+export interface UseDocumentMetaOptions {
+    demo?: BTDemo;
+}
+export interface BTDocumentMeta {
+    updateMeta: (to: RouteLocationNormalized) => void;
+}
+/**routes with meta object */
+export declare function useDocumentMeta(options?: UseDocumentMetaOptions): BTDocumentMeta;

package/dist/composables/draggable.d.ts

@@ -0,0 +1,56 @@
+import { Position } from '@vueuse/core';
+import { ComponentPublicInstance, MaybeRefOrGetter, Ref } from 'vue';
+
+export interface UseDraggableOptions {
+    /**
+     * Only start the dragging when click on the element directly
+     *
+     * @default false
+     */
+    preventDefault?: MaybeRefOrGetter<boolean>;
+    stopPropagation?: MaybeRefOrGetter<boolean>;
+    /**
+     * Whether dispatch events in capturing phase
+     *
+     * @default true
+     */
+    capture?: boolean;
+    /**
+     * Element to attach `pointermove` and `pointerup` events to.
+     *
+     * @default window
+     */
+    draggingElement?: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>;
+    /**
+     * Element for calculating bounds (If not set, it will use the event's target).
+     *
+     * @default undefined
+     */
+    /**
+     * Handle that triggers the drag event
+     *
+     * @default target
+     */
+    handle?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;
+    /**
+     * Initial position of the element.
+     *
+     * @default { x: 0, y: 0 }
+     */
+    initialValue?: MaybeRefOrGetter<Position>;
+    onStart?: (position: Position, event: PointerEvent) => void | false;
+    onMove?: (position: Position, event: PointerEvent) => void;
+    onEnd?: (position: Position, event: PointerEvent) => void;
+    /**
+     * Axis to drag on.
+     *
+     * @default 'both'
+     */
+    axis?: 'x' | 'y' | 'both';
+}
+export declare function useDraggable(target: MaybeRefOrGetter<ComponentPublicInstance | null>, //HTMLElement | SVGElement | null | undefined>,
+handle: MaybeRefOrGetter<ComponentPublicInstance | null>, options?: UseDraggableOptions): {
+    draggingIsOn: Ref<boolean>;
+    turnDraggableOff: () => void;
+    turnDraggableOn: () => void;
+};

package/dist/composables/filters.d.ts

@@ -0,0 +1,10 @@
+import { BTDates } from './dates';
+
+export interface BTFilters {
+    findFilter: (mFilter: string | undefined) => Function;
+}
+export interface UseFiltersOptions {
+    dates: BTDates;
+}
+export declare function createFilters(options: UseFiltersOptions): BTFilters;
+export type Textfilter = 'toLocationLine' | 'toLocationLineNoCommas' | 'toLongDate' | 'toLongDateAndTime' | 'toPercent' | 'toPrettyCSV' | 'toShortDate' | 'toShortDateAndTime' | 'toTime' | 'toTimeOfDay' | 'toCompanyNameAndLocationLine' | 'toCurrency' | 'toDayDate' | 'toDayMonth' | 'toDayOfWeek' | 'toDayShortDate' | 'toDayShortDateAndTime' | 'toDisplayNumber' | 'toDisplayNumberOver' | 'toDisplayNumberSigned' | 'toFormat';

package/dist/composables/forage.d.ts

@@ -0,0 +1,7 @@
+export declare function useLocalDb(): LocalForage;
+export declare function useLocalCache(): {
+    clearAsync: (storeName: string) => Promise<void>;
+    getAsync: <T>(key: string) => Promise<T | null>;
+    removeAsync: (key: string) => Promise<void>;
+    saveAsync: <T_1>(data: T_1, key: string) => Promise<void>;
+};