bt-core-app 1.1.3 → 1.1.4

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 './actions-tracker';
+import { BTApi, PathOptions } from './api';
+import { BTStore } from './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;
+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 './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 './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,10 @@
+import { BTDemo } from './demo';
+import { RouteLocationNormalized } from 'vue-router';
+
+export interface UseDocumentMetaOptions {
+    demo?: BTDemo;
+}
+/**routes with meta object */
+export declare function useDocumentMeta(options?: UseDocumentMetaOptions): {
+    updateMeta: (to: RouteLocationNormalized) => void;
+};

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

package/dist/composables/helpers.d.ts

@@ -0,0 +1,102 @@
+import { MaybeRefOrGetter } from 'vue';
+
+export declare function appendUrl(originalVal?: string, additionalVal?: string): string;
+export declare function extensionExists(elementId?: string): boolean;
+interface GeoCoordinate {
+    lat: number;
+    lng: number;
+}
+/**
+ * get area around a certain location with a space of the given size
+ * @param location
+ * @param radius
+ * @returns
+ */
+export declare function getAreaAround(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+/**get square area using the location as the far right line */
+export declare function getAreaToLeft(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+/**get square area using the location as the far left line */
+export declare function getAreaToRight(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+/**
+ *
+ * @param value converts location to a single string and standardizes state and road names, etc.
+ * @returns
+ */
+export declare function getGoogleMapsLocationLine(value: any): any;
+export declare function getLocationLine(value: any, forGoogle?: boolean): any;
+export declare function checkImage(url?: string, goodCallback?: any, badCallback?: any): void;
+export declare function getImageData(url?: string, throwErrorOnFail?: boolean): Promise<unknown>;
+/**
+ *
+ * @param val Converts string from camel case to every word being capitalized and spaces between
+ * @returns
+ */
+export declare function fromCamelCase(val?: string): string | undefined;
+/**
+ * Converts props to camel casing
+ * @param value
+ * @returns
+ */
+export declare function toCamelCase(value: any): any;
+export declare function capitalizeWords(val?: string): string | undefined;
+export declare const weekdayPairs: {
+    value: number;
+    short: string;
+    values: (string | null | undefined)[];
+}[];
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayValue(wkDay?: string): number;
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayShortName(wkDay?: string): string | undefined;
+/**whether the csv string contains the weekday
+ * returns true if either prop is undefined
+ */
+export declare function containsWeekday(weekdays?: string, wkDay?: string): boolean;
+/**adds and sorts the weekday string */
+export declare function addWeekday(weekdays?: string, day?: string): string | undefined;
+export declare function removeWeekday(weekdays?: string, day?: string): string | undefined;
+export declare function isArrayOfLength(val: any, l: number): boolean;
+export declare function isLengthyArray(val: any, greaterThan?: number): boolean;
+export declare function isMinDate(d?: string): boolean;
+export declare function getMinDate(): number;
+export declare function getMinDateString(): string;
+/**
+ * rounds the given value to a certain number of decimal places
+ * @param v
+ * @param dPlaces
+ * @returns
+ */
+export declare function roundTo(v: MaybeRefOrGetter<number>, dPlaces: number): number;
+export declare function toggleCSV(value?: string, tag?: string): string | null;
+export declare function csvContains(value?: string, tag?: string): boolean;
+/**copies object and all descendant properties */
+export declare function copyDeep(aObject: any): any;
+/**copies object and returns copied object with descendant properties placed in alphabetical order */
+export declare function copyItemByAlphabet(aObject: any): any;
+/**whether string is contained somewhere in this value */
+export declare function containsSearch(value?: string, str?: string): boolean;
+/**must be an object.  Returns a flat map of all items in the prop selector */
+export declare function deepSelect(obj: any, propSelector?: Function): any[];
+export declare function DataURIToBlob(dataURI: any): Blob;
+export declare function extractErrorDescription(error: any): string;
+export declare function getRandomColor(): string;
+/**tests for whether string is contains in any of the given props of the given value */
+export declare function hasSearch(value: any, str?: string, props?: string[]): boolean;
+export declare function toCompareString(str?: string): string | null;
+export declare function twiddleThumbs(mSec?: number): Promise<void>;
+export declare function nestedValue(obj: any, path?: string): any;
+export declare function validEmail(email?: string): boolean;
+export {};

package/dist/composables/id.d.ts

@@ -0,0 +1 @@
+export declare function useId(pattern?: string): string;

package/dist/composables/navigation.d.ts

@@ -0,0 +1,89 @@
+import { AuthItem } from './auth';
+import { Ref } from 'vue';
+
+export interface ExternalParty {
+    party?: string;
+    property?: string;
+}
+export interface ExternalNavigation {
+    canPull?: boolean;
+    canPush?: boolean;
+    convertFunc?: Function;
+    name?: string;
+    localNavigation?: string;
+    localDisplayPath?: string;
+    localComparePath?: string;
+    syncComparePath?: string;
+    syncDisplayPath?: string;
+    syncIDPath?: string;
+}
+export interface NavigationItem extends AuthItem {
+    /**aliases are other names that could use this navigation item's set of permissions, etc.*/
+    aliases?: string[];
+    /**potentially the nav that leads to the archive */
+    archiveName?: string;
+    /**the name of the background img to show when the route opens this nav */
+    background?: string;
+    /**how long until locally cached data is refreshed */
+    cacheExpiryHours?: number;
+    /**any children of this nav item */
+    children?: NavigationItem[];
+    /**the name that will be displayed in the navigation menu */
+    displayName?: string;
+    /**where credentials can be found for external parties*/
+    externalPartyCredentialNavigation?: string;
+    /**possible external parties to connect to and sync with */
+    externalParties?: ExternalParty[];
+    /**possible external party navigation items and how to connect/sync */
+    externalNavigations?: ExternalNavigation[];
+    /**will hide app bar if set to true when the route opens this nav */
+    hideAppBar?: boolean;
+    /**will hide the nav sidebar if set to true when the route opens this nav */
+    hideNavigation?: boolean;
+    /**will open a dialog box to confirm navigating away from this route */
+    hesitate?: boolean;
+    /**the mdi icon that goes with this nav item.  Will show in places like the nav menu */
+    icon?: string;
+    /**default to false. True will mean that even is account is suspended, this will still allow navigation */
+    ignoreSuspension?: boolean;
+    /**default to true.  When false will hide from nav menu */
+    isInNavMenu?: boolean;
+    /**the microservice the leads to the default url to obtain data from.  Defaults to 'default'. */
+    microservice?: string;
+    /**the name of this nav item. */
+    name?: string;
+    /**the url path on top of the base microservice url */
+    path?: string;
+    /**permissions that are required for this navItem.  All these permissions must be met. */
+    permissions?: string[];
+    /**default to true.  When false will allow universal access regardless of permission */
+    requiresAuth?: boolean;
+    /**the name of the route to access individual items */
+    singleName?: string;
+    /**this nav item is restricted to these subscriptions.  So the user needs to have at least one of these subscription codes. */
+    subscriptions?: string[];
+    /**this nav item is preferred in this subscription codes. */
+    subFilters?: string[];
+}
+export interface BTNavigation {
+    showAppBar: Ref<boolean>;
+    showAppNavigation: Ref<boolean>;
+    backgroundName: Ref<string | undefined>;
+    hesitate: Ref<boolean>;
+    navigationItems: NavigationItem[];
+    findArchiveName: (navName?: string) => string | undefined;
+    findCacheHours: (navName?: string) => number;
+    findDisplay: (navName?: string) => string | undefined;
+    findIcon: (navName?: string) => string | undefined;
+    findItem: (navName?: string | NavigationItem) => NavigationItem | null;
+    findStoreName: (navName?: string) => string;
+    findPath: (navName?: string) => string | undefined;
+    findSingleDisplay: (navName?: string) => string | undefined;
+    updateNavigationProperties: (navName?: string | NavigationItem) => void;
+}
+interface UseNavigationOptions {
+    defaultCacheExpiryHours?: number;
+    navItems?: NavigationItem[];
+}
+export declare function createNavigation(options: UseNavigationOptions): BTNavigation;
+export {};

package/dist/composables/presets.d.ts

@@ -0,0 +1,7 @@
+export interface BTPresets {
+    usePresets(preset?: string): any;
+}
+export interface CreatePresetsOptions {
+    presets: any;
+}
+export declare function createPresets(options: CreatePresetsOptions): BTPresets;

package/dist/composables/pwa.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+
+export interface SWEvent extends Event {
+    detail: any;
+}
+export interface BTPWA {
+    canInstallApp: Ref<boolean>;
+    canUpdateApp: Ref<boolean>;
+    installApp: () => void;
+    isInstalled: () => boolean;
+    updateApp: () => void;
+}
+export declare function createPWA(): BTPWA;

package/dist/composables/resizable.d.ts

@@ -0,0 +1,35 @@
+import { BladeVariant } from '../types';
+import { Position, MaybeRefOrGetter } from '@vueuse/core';
+import { ComponentPublicInstance, Ref } from 'vue';
+
+export type ResizeHandle = 't' | 'r' | 'b' | 'l' | 'tr' | 'br' | 'bl' | 'tl';
+export interface PointerOrTouchEvent extends PointerEvent, TouchEvent {
+}
+export interface UseResizeOptions {
+    preventDefault?: MaybeRefOrGetter<boolean>;
+    stopPropagation?: MaybeRefOrGetter<boolean>;
+    handles?: ResizeHandle[];
+    /**
+     * Callback when the dragging starts. Return `false` to prevent dragging.
+     */
+    onStart?: (position: Position, event: PointerEvent) => void | false;
+    /**
+     * Callback during dragging.
+     */
+    onMove?: (position: Position, event: PointerEvent) => void;
+    /**
+     * Callback when dragging end.
+     */
+    onEnd?: (position: Position, event: PointerEvent) => void;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    handleWidth?: number;
+    handleZIndex?: number;
+}
+export declare function useResizable(target: MaybeRefOrGetter<ComponentPublicInstance | null>, options?: UseResizeOptions): {
+    resizingIsOn: Ref<boolean>;
+    turnResizingOn: (handles?: ResizeHandle[], variant?: BladeVariant) => void;
+    turnResizingOff: (variant?: BladeVariant | undefined) => void;
+};

package/dist/composables/rules.d.ts

@@ -0,0 +1,8 @@
+interface UseRulesOptions {
+    forEmail?: boolean;
+    forPassword?: boolean;
+    otherRules?: any;
+    required?: boolean;
+}
+export declare function useRules(options?: UseRulesOptions): any[];
+export {};

package/dist/composables/stores.d.ts

@@ -0,0 +1,100 @@
+import { BTAuth } from './auth';
+import { BaseModel } from '../types';
+import { PathOptions, BTApi } from './api';
+import { StoreDefinition } from 'pinia';
+
+export type StoreMode = 'whole-last-updated' | 'partial-last-updated' | 'session';
+export type StorageMode = 'session' | 'local-cache';
+export interface LocalMeta {
+    storedOn: string;
+    isDetailed?: boolean;
+    earliestData?: string;
+    lastUpdate?: string;
+}
+export interface LocallyStoredItem<T> {
+    meta: LocalMeta;
+    data: T;
+    count?: number;
+    filters?: string[];
+}
+export interface StoreGetAllReturn<T> {
+    data: T[];
+    count?: number;
+    filters?: string[];
+}
+export interface StoreGetReturn<T> {
+    data: T;
+}
+export interface BTStore extends StoreDefinition<any, {}, {}, {
+    deleteItem: (dOptions: PathOptions) => Promise<string | undefined>;
+    get: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetReturn<T>>;
+    getAll: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetAllReturn<T>>;
+    patch: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    post: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    restore: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+}> {
+}
+export interface ApiError {
+    message: string;
+}
+interface UseStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**build a query.  Overrides the default */
+    builderQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**particularly what store syle to use */
+    storeMode: StoreMode;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: StorageMode;
+    /**the name of this store */
+    storeName: string;
+}
+export interface CreateStoreBuilderOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**build a query.  Overrides the default */
+    builderQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+}
+export interface CreateStoreOptions {
+    /**particularly what store syle to use */
+    storeMode: StoreMode;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: StorageMode;
+    /**the name of this store */
+    storeName: string;
+}
+export declare function createStoreBuilder(options: CreateStoreBuilderOptions): (opt: CreateStoreOptions) => BTStore;
+export declare function createStore(options: UseStoreOptions): BTStore;
+interface UseSessionStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: 'session' | 'local-cache';
+    /**build a query.  Overrides the default */
+    buildQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**the name of this store */
+    storeName: string;
+}
+export declare function createSessionStore(options: UseSessionStoreOptions): BTStore;
+interface UseWholeLastUpdateStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    storageMode: 'session' | 'local-cache';
+    storeName: string;
+}
+export declare function createWholeLastUpdateStore(options: UseWholeLastUpdateStoreOptions): BTStore;
+export {};

package/dist/composables/track.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+
+export interface UseTrackerOptions {
+    propsToIgnore?: string[];
+    propsToTrack?: string[];
+    useTracker?: boolean;
+}
+export declare function useTracker(data: MaybeRefOrGetter<any>, options?: UseTrackerOptions): {
+    asyncItem: Ref<any>;
+    isChanged: Ref<boolean>;
+    restartTracker: () => void;
+};

package/dist/composables/urls.d.ts

@@ -0,0 +1,7 @@
+export type Environment = 'production' | 'staging' | 'development';
+/**
+ * ms: BASE_AUTH_URL, BASE_DATA_URL, WEB_APP_URL, Microservice, LOCAL_DB_NAME
+ * @param microservice
+ * @returns
+ */
+export declare function useUrl(microservice?: string): string | undefined;

package/dist/core.d.ts

@@ -0,0 +1,18 @@
+import { RemovableRef } from '@vueuse/core';
+import { NavigationItem } from './composables/navigation';
+import { BaseCosmeticTheme, UseCosmeticsOptions } from './composables/cosmetics';
+import { GetAuthUrl, AuthSubscription } from './composables/auth';
+import { App } from '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 declare function createCore(options: CreateCoreOptions): CoreApp;

package/dist/index.d.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/dist/types.d.ts

@@ -0,0 +1,11 @@
+/**
+    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/dist/useApi.d.ts

@@ -0,0 +1,30 @@
+import { BTStore, CreateStoreOptions } from './composables/stores';
+import { BTPWA } from './composables/pwa';
+import { BTNavigation } from './composables/navigation';
+import { BTFilters } from './composables/filters';
+import { BTDemo } from './composables/demo';
+import { BTDates } from './composables/dates';
+import { BTCosmetics } from './composables/cosmetics';
+import { BTApi } from './composables/api';
+import { BTAuth } from './composables/auth';
+
+/**returns a singleton */
+export declare function useApi(): BTApi;
+/**returns a singleton */
+export declare function useAuth(): BTAuth;
+/**returns a singleton */
+export declare function useCosmetics(): BTCosmetics;
+/**returns a singleton */
+export declare function useDates(): BTDates;
+/**returns a singleton */
+export declare function useDemo(): BTDemo;
+/**returns a singleton */
+export declare function useFilters(): BTFilters;
+/**returns a singleton */
+export declare function useNavigation(): BTNavigation;
+/**returns a singleton */
+export declare function usePresets(preset?: string): any;
+/**returns a singleton */
+export declare function usePWA(): BTPWA;
+/**returns a new instance */
+export declare function useStore(): (opt: CreateStoreOptions) => BTStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bt-core-app",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Core app tools for some basic features like navigation, authentication, server apis, and cosmetics",
   "homepage": "https://github.com/BlitzItTech/bt-core",
   "bugs": {
@@ -37,6 +37,7 @@
     "msw": "^2.2.10",
     "typescript": "^5.2.2",
     "vite": "^5.1.6",
+    "vite-plugin-dts": "^3.8.1",
     "vitest": "^1.4.0",
     "vue": "^3.4.21",
     "vue-tsc": "^1.8.27"

package/vite.config.ts

@@ -2,6 +2,7 @@
 import { defineConfig } from 'vite'
 import path from 'path'
 import vue from '@vitejs/plugin-vue'
+import dts from 'vite-plugin-dts'
 
 // https://vitejs.dev/config/
 
@@ -16,7 +17,10 @@ export default defineConfig({
       formats: ['es']
     }
   },
-  plugins: [vue()],
+  plugins: [
+    vue(),
+    dts({ include: ['src'] })
+  ],
   resolve: {
     alias: {
       '@': path.resolve(__dirname, './src')