@signal24/vue-foundation 3.8.0 → 4.0.0

package/.eslintrc.cjs

@@ -0,0 +1,35 @@
+/* eslint-env node */
+require('@rushstack/eslint-patch/modern-module-resolution');
+
+module.exports = {
+    root: true,
+    extends: ['plugin:vue/vue3-essential', 'eslint:recommended', '@vue/eslint-config-typescript', '@vue/eslint-config-prettier'],
+    overrides: [
+        {
+            files: ['cypress/e2e/**/*.{cy,spec}.{js,ts,jsx,tsx}'],
+            extends: ['plugin:cypress/recommended']
+        },
+        {
+            files: ['vite.config.*', 'vitest.config.*', 'cypress.config.*', 'playwright.config.*'],
+            env: {
+                node: true
+            }
+        }
+    ],
+    parserOptions: {
+        ecmaVersion: 'latest'
+    },
+    plugins: ['unused-imports', 'simple-import-sort'],
+    rules: {
+        'no-console': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+        'no-debugger': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+        'simple-import-sort/imports': 'error',
+        'simple-import-sort/exports': 'error',
+        'prettier/prettier': 'warn',
+        'no-unused-vars': 'off',
+        'unused-imports/no-unused-imports': 'error',
+        'unused-imports/no-unused-vars': ['warn', { vars: 'all', varsIgnorePattern: '^_', args: 'all', argsIgnorePattern: '^_' }],
+        'vue/multi-word-component-names': 'off',
+        'vue/no-reserved-component-names': 'off'
+    }
+};

package/.prettierrc.json

@@ -1,7 +1,9 @@
 {
+    "$schema": "https://json.schemastore.org/prettierrc",
+    "semi": true,
     "arrowParens": "avoid",
-    "printWidth": 120,
-    "singleQuote": true,
     "tabWidth": 4,
+    "singleQuote": true,
+    "printWidth": 150,
     "trailingComma": "none"
 }

package/dist/src/components/ajax-select.vue.d.ts

@@ -0,0 +1,21 @@
+type GenericObject = {
+    [key: string]: any;
+};
+declare const _default: import("vue").DefineComponent<{}, {
+    props: Readonly<Omit<{
+        modelValue: any;
+        loadFn: () => Promise<GenericObject[]>;
+        nullText?: string | undefined;
+        loadingText?: string | undefined;
+        displayKey?: string | undefined;
+        preprocesor?: ((option: GenericObject) => string) | undefined;
+    }, "modelValue"> & {
+        modelValue: any;
+    }>;
+    options: import("vue").Ref<GenericObject[] | null>;
+    renderOptions: import("vue").ComputedRef<any[] | null>;
+    selectedItem: import("vue").Ref<GenericObject | null>;
+}, {}, {}, {
+    load(): Promise<void>;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/dist/src/components/alert-helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function showAlert(title: string, message: string | Error): Promise<void>;
+export declare function showAlert(message: string | Error): Promise<void>;
+export declare function showConfirm(title: string, message: string): Promise<boolean>;
+export declare function showConfirm(message: string): Promise<boolean>;
+export declare function showConfirmDestroy(title: string, message: string): Promise<boolean>;
+export declare function showConfirmDestroy(message: string): Promise<boolean>;
+export declare function showWait(title: string, message: string): () => void;
+export declare function showWait(message: string): () => void;

package/dist/src/components/alert-modal.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    isBare?: boolean | undefined;
+    isHtml?: boolean | undefined;
+    classes?: string[] | undefined;
+    title?: string | undefined;
+    message: string | Error;
+    shouldConfirm?: boolean | undefined;
+    callback: (ok: boolean) => void;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    isBare?: boolean | undefined;
+    isHtml?: boolean | undefined;
+    classes?: string[] | undefined;
+    title?: string | undefined;
+    message: string | Error;
+    shouldConfirm?: boolean | undefined;
+    callback: (ok: boolean) => void;
+}>>>, {}>;
+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/src/components/ez-smart-select.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    modelValue: string | null | undefined;
+    nullTitle?: string | undefined;
+    placeholder?: string | undefined;
+    options: string[] | Record<string, string>;
+    formatter?: ((value: any) => string) | undefined;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | null) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    modelValue: string | null | undefined;
+    nullTitle?: string | undefined;
+    placeholder?: string | undefined;
+    options: string[] | Record<string, string>;
+    formatter?: ((value: any) => string) | undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}, {}>;
+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/src/components/index.d.ts

@@ -0,0 +1,8 @@
+import VfAjaxSelect from './ajax-select.vue';
+import VfAlertModal from './alert-modal.vue';
+import VfEzSmartSelect from './ez-smart-select.vue';
+import VfModal from './modal.vue';
+import VfSmartSelect from './smart-select.vue';
+export * from './alert-helpers';
+export * from './modal-container';
+export { VfAjaxSelect, VfAlertModal, VfEzSmartSelect, VfModal, VfSmartSelect };

package/dist/src/components/modal-container.d.ts

@@ -0,0 +1,33 @@
+import type { Writable } from 'type-fest';
+import { type AllowedComponentProps, type ComponentInternalInstance, type ComponentPublicInstance, type ComputedOptions, type MethodOptions, type Raw, type VNode, type VNodeProps } from 'vue';
+interface ModalInjection<C extends Vue__ComponentPublicInstanceConstructor> {
+    id: string;
+    component: Raw<C>;
+    props: ComponentProps<C>;
+    vnode: VNode;
+}
+export declare const ModalContainer: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export type Vue__ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    new (...args: any[]): T;
+};
+export type ComponentConfig<T extends Vue__ComponentPublicInstanceConstructor> = T extends Vue__ComponentPublicInstanceConstructor<infer P> ? P : never;
+export type ComponentProps<T extends Vue__ComponentPublicInstanceConstructor> = Writable<Omit<ComponentConfig<T>['$props'], keyof VNodeProps | keyof AllowedComponentProps>>;
+export type AnyComponentPublicInstance = {
+    $: ComponentInternalInstance;
+};
+interface PropsWithCallback<T> {
+    callback?: (result: T) => void;
+}
+type ComponentReturn<C extends Vue__ComponentPublicInstanceConstructor> = ComponentProps<C> extends PropsWithCallback<infer R> ? R : never;
+export declare function createModalInjection<C extends Vue__ComponentPublicInstanceConstructor>(component: C, props: ComponentProps<C>): ModalInjection<C>;
+export declare function removeModalInjection(injection: ModalInjection<any>): void;
+export declare function removeModalInjectionByInstance(instance: AnyComponentPublicInstance): void;
+export declare function removeModalInjectionByInternalInstance(instance: ComponentInternalInstance): void;
+export declare function removeModalInjectionByVnode(vnode: VNode): boolean;
+export declare function presentModal<C extends Vue__ComponentPublicInstanceConstructor, R extends ComponentReturn<C>>(component: C, props: Omit<ComponentProps<C>, 'callback'>): Promise<R | undefined>;
+export {};

package/dist/src/components/modal.vue.d.ts

@@ -0,0 +1,34 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    id?: string | undefined;
+    closeOnMaskClick?: boolean | undefined;
+    scrolls?: boolean | undefined;
+    closeX?: boolean | undefined;
+    class?: string | undefined;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "formSubmit"[], "formSubmit", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    id?: string | undefined;
+    closeOnMaskClick?: boolean | undefined;
+    scrolls?: boolean | undefined;
+    closeX?: boolean | undefined;
+    class?: string | undefined;
+}>>> & {
+    onFormSubmit?: ((...args: any[]) => any) | undefined;
+}, {}>, Partial<Record<"header", (_: {}) => any>> & Partial<Record<"default", (_: {}) => any>> & Partial<Record<"footer", (_: {}) => 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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+        $props: __VLS_PropsChildren<S>;
+    };
+};
+type __VLS_PropsChildren<S> = {
+    [K in keyof (boolean extends (JSX.ElementChildrenAttribute extends never ? true : false) ? never : JSX.ElementChildrenAttribute)]?: S;
+};

package/dist/src/components/smart-select.vue.d.ts

@@ -0,0 +1,121 @@
+import type { PropType } from 'vue';
+export type GenericObject = {
+    [key: string]: any;
+};
+export interface OptionDescriptor {
+    key: string | Symbol;
+    title: string;
+    subtitle?: string | null;
+    searchContent?: string;
+    ref?: GenericObject;
+}
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<any>;
+        default: null;
+    };
+    loadOptions: PropType<(searchText: string | null) => Promise<GenericObject[]>>;
+    options: PropType<GenericObject[]>;
+    prependOptions: PropType<GenericObject[]>;
+    appendOptions: PropType<GenericObject[]>;
+    onCreateItem: PropType<(searchText: string) => void>;
+    preload: PropType<boolean>;
+    remoteSearch: PropType<boolean>;
+    searchFields: PropType<string[]>;
+    placeholder: PropType<string>;
+    keyExtractor: PropType<(option: any) => string | symbol>;
+    valueExtractor: PropType<(option: any) => any>;
+    formatter: {
+        type: PropType<(option: any) => string>;
+        required: true;
+    };
+    subtitleFormatter: PropType<(option: any) => string>;
+    nullTitle: PropType<string>;
+    noResultsText: PropType<string>;
+    disabled: PropType<boolean>;
+    optionsListId: PropType<string>;
+    debug: PropType<boolean>;
+}, unknown, {
+    isLoading: boolean;
+    isLoaded: boolean;
+    loadedOptions: GenericObject[];
+    isSearching: boolean;
+    searchText: string;
+    selectedOption: GenericObject | null;
+    selectedOptionTitle: string | null;
+    shouldDisplayOptions: boolean;
+    highlightedOptionKey: string | Symbol | null;
+    shouldShowCreateOption: boolean;
+}, {
+    /**
+     * EFFECTIVE PROPS
+     */
+    effectivePrependOptions(): GenericObject[];
+    effectiveAppendOptions(): GenericObject[];
+    effectiveDisabled(): boolean;
+    effectivePlaceholder(): string;
+    effectiveNoResultsText(): string;
+    effectiveKeyExtractor(): ((option: any) => any) | undefined;
+    /**
+     * OPTIONS GENERATION
+     */
+    allOptions(): GenericObject[];
+    optionsDescriptors(): OptionDescriptor[];
+    effectiveOptions(): OptionDescriptor[];
+}, {
+    loadRemoteOptions(): Promise<void>;
+    handleSourceUpdate(): Promise<void> | undefined;
+    reloadOptions(): Promise<void>;
+    reloadOptionsIfSearching(): void;
+    handleKeyDown(e: KeyboardEvent): void;
+    handleInputFocused(): void;
+    setHighlightedOptionKey(useFirstItemAsFallback?: boolean): void;
+    getOptionKey(option: GenericObject): string | Symbol;
+    getOptionDescriptor(option: GenericObject): OptionDescriptor | null;
+    handleInputBlurred(): void;
+    handleOptionsDisplayed(): void;
+    teleportOptionsContainer(): void;
+    highlightInitialOption(): void;
+    handleOptionHover(option: OptionDescriptor): void;
+    incrementHighlightedOption(increment: number): void;
+    selectOption(option: OptionDescriptor): void;
+    handleValueChanged(): void;
+    addRemoteOption(option: GenericObject): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    optionsLoaded: (options: any[]) => void;
+    createItem: (searchText: string) => void;
+    'update:modelValue': (value: any) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<any>;
+        default: null;
+    };
+    loadOptions: PropType<(searchText: string | null) => Promise<GenericObject[]>>;
+    options: PropType<GenericObject[]>;
+    prependOptions: PropType<GenericObject[]>;
+    appendOptions: PropType<GenericObject[]>;
+    onCreateItem: PropType<(searchText: string) => void>;
+    preload: PropType<boolean>;
+    remoteSearch: PropType<boolean>;
+    searchFields: PropType<string[]>;
+    placeholder: PropType<string>;
+    keyExtractor: PropType<(option: any) => string | symbol>;
+    valueExtractor: PropType<(option: any) => any>;
+    formatter: {
+        type: PropType<(option: any) => string>;
+        required: true;
+    };
+    subtitleFormatter: PropType<(option: any) => string>;
+    nullTitle: PropType<string>;
+    noResultsText: PropType<string>;
+    disabled: PropType<boolean>;
+    optionsListId: PropType<string>;
+    debug: PropType<boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    onOptionsLoaded?: ((options: any[]) => any) | undefined;
+    onCreateItem?: ((searchText: string) => any) | undefined;
+}, {
+    modelValue: any;
+}>;
+export default _default;

package/dist/src/config.d.ts

@@ -0,0 +1,8 @@
+interface IOptions {
+    unhandledErrorSupportText: string;
+    errorHandler: (err: Error) => void;
+    defaultDateTimeFormat: string;
+}
+export declare const VfOptions: IOptions;
+export declare function configureVf(options: Partial<IOptions>): void;
+export {};

package/dist/src/directives/autofocus.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vAutofocus: ObjectDirective<HTMLElement, void>;

package/dist/src/directives/confirm-button.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vConfirmButton: ObjectDirective<HTMLElement, void>;

package/dist/src/directives/date-input.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vDateInput: ObjectDirective<HTMLInputElement, void>;

package/dist/src/directives/datetime.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vDatetime: ObjectDirective<HTMLElement, string>;

package/dist/src/directives/disabled.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vDisabled: ObjectDirective<HTMLElement, boolean>;

package/dist/src/directives/duration.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vDuration: ObjectDirective<HTMLElement, number>;

package/dist/src/directives/index.d.ts

@@ -0,0 +1,24 @@
+import type { App } from 'vue';
+import { vAutofocus } from './autofocus';
+import { vConfirmButton } from './confirm-button';
+import { vDateInput } from './date-input';
+import { vDatetime } from './datetime';
+import { vDisabled } from './disabled';
+import { vDuration } from './duration';
+import { vInfiniteScroll } from './infinite-scroll';
+import { vReadonly } from './readonly';
+import { vTooltip } from './tooltip';
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        vAutofocus: typeof vAutofocus;
+        vConfirmButton: typeof vConfirmButton;
+        vDateInput: typeof vDateInput;
+        vDatetime: typeof vDatetime;
+        vDisabled: typeof vDisabled;
+        vDuration: typeof vDuration;
+        vInfiniteScroll: typeof vInfiniteScroll;
+        vReadonly: typeof vReadonly;
+        vTooltip: typeof vTooltip;
+    }
+}
+export declare function registerDirectives(app: App<Element>): void;

package/dist/src/directives/infinite-scroll.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectDirective } from 'vue';
+import { type IInfiniteScrollOptions } from '../hooks/infinite-scroll';
+export declare const vInfiniteScroll: ObjectDirective<Element, IInfiniteScrollOptions>;

package/dist/src/directives/readonly.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vReadonly: ObjectDirective<HTMLElement, boolean>;

package/dist/src/directives/tooltip.d.ts

@@ -0,0 +1,41 @@
+import type { ObjectDirective } from 'vue';
+type TooltipValue = string | null | false | undefined;
+export declare const vTooltip: ObjectDirective<TooltipElement, TooltipValue>;
+declare const TooltipState: unique symbol;
+interface ITooltipState {
+    [TooltipState]?: VfTooltip;
+}
+type TooltipElement = HTMLElement & ITooltipState;
+interface ITooltipOptions {
+    content: string;
+    title?: string;
+    delay?: number;
+    html?: boolean;
+    class?: string | string[];
+}
+declare class VfTooltip {
+    private el;
+    private config;
+    private lastMoveEvt?;
+    private checkInterval?;
+    private shouldShow;
+    private tipEl?;
+    private titleEl?;
+    private contentEl?;
+    private mouseMoveBound;
+    private handleMouseMoveWithContext;
+    private handleTargetMouseEnterWithContext;
+    private handleTargetMouseLeaveWithContext;
+    constructor(el: HTMLElement, config: ITooltipOptions);
+    configure(config: ITooltipOptions): void;
+    handleTargetMouseEnter(e: MouseEvent): void;
+    handleTargetMouseLeave(): void;
+    show(e?: MouseEvent): void;
+    renderTooltip(): void;
+    getClasses(): string[];
+    removeTooltip(): void;
+    handleMouseMove(e: MouseEvent): void;
+    checkMoveEvent(): void;
+    destroy(): void;
+}
+export {};

package/dist/src/filters/index.d.ts

@@ -0,0 +1,39 @@
+declare function bytes(value: number): string;
+declare function dash(value: any): any;
+declare function dashZeros(value: number | null): number | "-";
+declare function number(value: string | number | null): string | null;
+declare function phone(value: string | null): string | null;
+declare function upperFirst(value: null): null;
+declare function upperFirst(value: string): string;
+declare function startCase(value: null): null;
+declare function startCase(value: string): string;
+declare function upperCase(value: null): null;
+declare function upperCase(value: string): string;
+declare function desnake(value: null): null;
+declare function desnake(value: string): string;
+declare function usCurrency(value: string | number): string;
+declare const FilterFns: {
+    bytes: typeof bytes;
+    dash: typeof dash;
+    dashZeros: typeof dashZeros;
+    number: typeof number;
+    phone: typeof phone;
+    upperFirst: typeof upperFirst;
+    startCase: typeof startCase;
+    upperCase: typeof upperCase;
+    desnake: typeof desnake;
+    usCurrency: typeof usCurrency;
+};
+export declare const createFilters: <T>(factory: (baseFilters: typeof FilterFns) => T) => {
+    bytes: typeof bytes;
+    dash: typeof dash;
+    dashZeros: typeof dashZeros;
+    number: typeof number;
+    phone: typeof phone;
+    upperFirst: typeof upperFirst;
+    startCase: typeof startCase;
+    upperCase: typeof upperCase;
+    desnake: typeof desnake;
+    usCurrency: typeof usCurrency;
+} & T;
+export {};

package/dist/src/helpers/array.d.ts

@@ -0,0 +1,3 @@
+type ArraySearchPredicate<T> = Parameters<T[]['findIndex']>[0];
+export declare function replaceElement<T>(array: T[], oldElement: T | ArraySearchPredicate<T>, newElement: T): boolean;
+export {};

package/dist/src/helpers/context-menu.d.ts

@@ -0,0 +1,13 @@
+interface ContextMenuItem {
+    title: string;
+    handler: () => void;
+    class?: string;
+    shouldConfirm?: boolean;
+}
+interface ContextMenuConfig {
+    targetClass?: string;
+    class?: string;
+    items: (ContextMenuItem | '-')[];
+}
+export declare function showContextMenu(e: MouseEvent, config: ContextMenuConfig): void;
+export {};

package/dist/src/helpers/delay.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const sleepSecs: (secs: number) => Promise<unknown>;

package/dist/src/helpers/error.d.ts

@@ -0,0 +1,7 @@
+export declare class UserError extends Error {
+    constructor(message: string);
+}
+export declare function formatError(err: any): string;
+export declare function toError(err: any): Error;
+export declare function handleErrorAndAlert(errIn: any, alertTitle?: string): Promise<void>;
+export declare function handleError(errIn: any): Promise<void>;

package/dist/src/helpers/index.d.ts

@@ -0,0 +1,9 @@
+export * from './array';
+export * from './context-menu';
+export * from './delay';
+export * from './error';
+export * from './mask';
+export * from './number';
+export * from './object';
+export * from './openapi';
+export * from './string';

package/dist/src/helpers/mask.d.ts

@@ -0,0 +1,15 @@
+import type { AnyComponentPublicInstance } from '@/components';
+declare const MaskState: unique symbol;
+interface IMaskState {
+    [MaskState]?: {
+        maskEl: HTMLElement;
+    };
+}
+type MaskElement = Element & IMaskState;
+export declare function maskComponent(cmp: AnyComponentPublicInstance, message?: string): () => void;
+export declare function unmaskComponent(cmp: AnyComponentPublicInstance): void;
+export declare function maskEl(el: MaskElement, message?: string): () => void;
+export declare function unmaskEl(el: MaskElement): void;
+export declare function maskForm(formOrCmp: Element | AnyComponentPublicInstance, buttonSelector?: string | Element, buttonText?: string): () => void;
+export declare function unmaskForm(formOrCmp: Element | AnyComponentPublicInstance): void;
+export {};

package/dist/src/helpers/number.d.ts

@@ -0,0 +1 @@
+export declare function formatNumber(value: number): string;

package/dist/src/helpers/object.d.ts

@@ -0,0 +1,2 @@
+export declare function cloneProp<T>(prop: T | undefined | null, fallback: T): T;
+export declare function nullifyEmptyInputs<T extends Record<string, unknown>, K extends keyof T>(obj: T, fields: K[]): T;

package/dist/src/helpers/openapi.d.ts

@@ -0,0 +1,34 @@
+interface IRequestOptions {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+}
+interface IBaseHttpRequest {
+    request<T>(options: IRequestOptions): ICancelablePromise<T>;
+}
+interface IApiClient {
+    request: IBaseHttpRequest;
+}
+declare class ICancelablePromise<T = any> {
+    constructor(executor: (resolve: (value: any) => void, reject: (reason: any) => void, onCancel: (cancel: () => void) => void) => void);
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+    cancel(): void;
+}
+interface IWrappedApiClientOptions<P extends ICancelablePromise = ICancelablePromise, Arguments extends unknown[] = any[]> {
+    apiClient: IApiClient;
+    onRequest?: (options: IRequestOptions) => IRequestOptions;
+    onError?: (err: Error, options: IRequestOptions) => Error | null | void;
+    CancelablePromise: new (...arguments_: Arguments) => P;
+}
+export declare function installApiClientInterceptors({ apiClient, onRequest, onError, CancelablePromise }: IWrappedApiClientOptions): void;
+export {};

package/dist/src/helpers/string.d.ts

@@ -0,0 +1,5 @@
+export { escapeHtml } from '@vue/shared';
+export declare function nl2br(value: string): string;
+export declare function desnakeCase(value: string): string;
+export declare function formatPhone(value: string): string;
+export declare function formatUSCurrency(value: string | number): string;

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useInfiniteScroll } from './infinite-scroll';
+export { useResizeWatcher } from './resize-watcher';

package/dist/src/hooks/infinite-scroll.d.ts

@@ -0,0 +1,30 @@
+import { type ComponentInternalInstance } from 'vue';
+declare const HookState: unique symbol;
+interface IHookState {
+    el?: InfiniteScrollHandler;
+    ancestor?: InfiniteScrollHandler;
+    window?: InfiniteScrollHandler;
+}
+type InfiniteScrollComponent = ComponentInternalInstance & {
+    [HookState]?: IHookState;
+};
+export interface IInfiniteScrollOptions {
+    elScrolledToBottom?: () => void;
+    ancestorScrolledToBottom?: () => void;
+    windowScrolledToBottom?: () => void;
+}
+export declare function useInfiniteScroll(options: IInfiniteScrollOptions, instance?: ComponentInternalInstance): void;
+export declare function installScrollHook(cmp: InfiniteScrollComponent, options: IInfiniteScrollOptions): void;
+export declare function reinstallScrollHook(cmp: InfiniteScrollComponent): void;
+export declare function uninstallScrollHook(cmp: InfiniteScrollComponent): void;
+export declare class InfiniteScrollHandler {
+    private el;
+    private handler;
+    isTripped: boolean;
+    constructor(el: Element, handler: (e: Event) => void);
+    install(): void;
+    uninstall(): void;
+    onScrollWithContext: (e: Event) => void;
+    onScroll(e: Event): void;
+}
+export {};

package/dist/src/hooks/resize-watcher.d.ts

@@ -0,0 +1 @@
+export declare function useResizeWatcher(fn: () => void): void;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+import type { App } from 'vue';
+export * from './components';
+export { configureVf } from './config';
+export * from './filters';
+export * from './helpers';
+export * from './hooks';
+export * from './types';
+export declare function installVf(app: App): void;