bge-ui 1.3.4 → 1.3.6

package/dist/datePicker/components/shared/month-quarter-picker.d.ts

@@ -0,0 +1,29 @@
+import type { ComputedRef, WritableComputedRef, Ref } from 'vue';
+import type { InternalModuleValue, MultiCalendarsOptions, ICalendarData, OverlayGridItem, VueEmit, Highlight, HighlightFn, PropDates, DateFilter, RangeConfig } from '../../interfaces';
+import type { PickerBasePropsType } from '../../props';
+interface Opts {
+    multiCalendars: ComputedRef<MultiCalendarsOptions>;
+    calendars: Ref<ICalendarData[]>;
+    modelValue: WritableComputedRef<InternalModuleValue>;
+    props: PickerBasePropsType;
+    year: ComputedRef<(instance: number) => number>;
+    month: ComputedRef<(instance: number) => number>;
+    highlight: ComputedRef<Highlight | HighlightFn>;
+    propDates: ComputedRef<PropDates>;
+    filters: ComputedRef<DateFilter>;
+    range: ComputedRef<RangeConfig>;
+    emit: VueEmit;
+}
+/**
+ * Both modes shared logic
+ */
+export declare const useMonthOrQuarterPicker: ({ multiCalendars, range, highlight, propDates, calendars, modelValue, props, filters, year, month, emit, }: Opts) => {
+    isDisabled: ComputedRef<(instance: number, next: boolean) => boolean>;
+    groupedYears: ComputedRef<(instance: number) => OverlayGridItem[][]>;
+    showYearPicker: Ref<boolean[]>;
+    selectYear: (year: number, instance: number) => void;
+    toggleYearPicker: (instance: number, flow?: boolean, show?: boolean) => void;
+    handleYearSelect: (year: number, instance: number) => void;
+    handleYear: (instance: number, increment?: boolean) => void;
+};
+export {};

package/dist/datePicker/composables/arrow-navigate.d.ts

@@ -0,0 +1,26 @@
+export declare const useArrowNavigation: () => {
+    buildMatrix: (elements: Array<HTMLElement | null>, set: 'monthYear' | 'time' | 'actionRow') => void;
+    buildMultiLevelMatrix: (elements: HTMLElement[][], set: 'calendar' | 'selectionGrid' | 'monthPicker') => void;
+    setTimePickerBackRef: (el: HTMLElement | null) => void;
+    setSelectionGrid: (value: boolean) => void;
+    setTimePicker: (value: boolean, mode?: boolean) => void;
+    setTimePickerElements: (elements: HTMLElement[][], order?: 0 | 1) => void;
+    arrowRight: () => void;
+    arrowLeft: () => void;
+    arrowUp: () => void;
+    arrowDown: () => void;
+    clearArrowNav: () => void;
+    setMonthPicker: (value: boolean) => void;
+    refSets: {
+        monthYear: (HTMLElement | null)[];
+        calendar: (HTMLElement | null)[][];
+        time: (HTMLElement | null)[];
+        actionRow: (HTMLElement | null)[];
+        selectionGrid: (HTMLElement | null)[][];
+        timePicker: {
+            '0': (HTMLElement | null)[][];
+            '1': (HTMLElement | null)[][];
+        };
+        monthPicker: (HTMLElement | null)[][];
+    };
+};

package/dist/datePicker/composables/calendar-class.d.ts

@@ -0,0 +1,8 @@
+import type { UnwrapRef, WritableComputedRef } from 'vue';
+import type { ICalendarDay, InternalModuleValue } from '../interfaces';
+import type { PickerBasePropsType } from '../props';
+export declare const useCalendarClass: (modelValue: WritableComputedRef<InternalModuleValue>, props: PickerBasePropsType) => {
+    setHoverDate: (day: UnwrapRef<ICalendarDay>) => void;
+    clearHoverDate: () => void;
+    getDayClassData: (day: ICalendarDay) => Record<string, boolean>;
+};

package/dist/datePicker/composables/common.d.ts

@@ -0,0 +1,6 @@
+import type { Flow, MultiCalendarsOptions } from '../interfaces';
+export declare const useCommon: () => {
+    hideNavigationButtons: import("vue").ComputedRef<(hideNavigation: Flow[] | undefined, key: Flow) => boolean | undefined>;
+    showLeftIcon: import("vue").ComputedRef<(multiCalendars: MultiCalendarsOptions, instance: number) => boolean>;
+    showRightIcon: import("vue").ComputedRef<(multiCalendars: MultiCalendarsOptions, instance: number) => boolean>;
+};

package/dist/datePicker/composables/defaults.d.ts

@@ -0,0 +1,37 @@
+import type { TimeModel } from '../interfaces';
+import type { AllPropsType, PickerBasePropsType } from '../props';
+export declare const useDefaults: (props: AllPropsType | PickerBasePropsType) => {
+    defaultedTransitions: import("vue").ComputedRef<import("../interfaces").Transition>;
+    defaultedMultiCalendars: import("vue").ComputedRef<import("../interfaces").MultiCalendarsOptions>;
+    defaultedStartTime: import("vue").ComputedRef<TimeModel | TimeModel[] | null>;
+    defaultedAriaLabels: import("vue").ComputedRef<import("../interfaces").AriaLabels>;
+    defaultedFilters: import("vue").ComputedRef<import("../interfaces").DateFilter>;
+    defaultedActionRow: import("vue").ComputedRef<import("../interfaces").ActionRowData>;
+    defaultedPreviewFormat: import("vue").ComputedRef<import("../interfaces").IFormat>;
+    defaultedTextInput: import("vue").ComputedRef<import("../interfaces").TextInputOptions & {
+        enabled: boolean;
+    }>;
+    defaultedInline: import("vue").ComputedRef<import("../interfaces").InlineOptions>;
+    defaultedConfig: import("vue").ComputedRef<import("../interfaces").Config>;
+    defaultedHighlight: import("vue").ComputedRef<import("../interfaces").Highlight | import("../interfaces").HighlightFn>;
+    defaultedWeekNumbers: import("vue").ComputedRef<import("../interfaces").WeekNumbersOpts>;
+    defaultedRange: import("vue").ComputedRef<import("../interfaces").RangeConfig>;
+    propDates: import("vue").ComputedRef<import("../interfaces").PropDates>;
+    defaultedTz: import("vue").ComputedRef<{
+        timezone: undefined;
+        exactMatch: boolean;
+        emitTimezone: undefined;
+        dateInTz?: undefined;
+        convertModel?: undefined;
+    } | {
+        timezone: string | undefined;
+        exactMatch: boolean;
+        dateInTz: string | undefined;
+        emitTimezone: string | undefined;
+        convertModel: boolean;
+    }>;
+    defaultedMultiDates: import("vue").ComputedRef<import("../interfaces").MultiDatesDefault>;
+    defaultedUI: import("vue").ComputedRef<import("../interfaces").UIParsed>;
+    getDefaultPattern: () => string;
+    getDefaultStartTime: () => TimeModel | TimeModel[] | null;
+};

package/dist/datePicker/composables/external-internal-mapper.d.ts

@@ -0,0 +1,14 @@
+import type { ModelValue, VueEmit } from '../interfaces';
+import type { AllPropsType } from '../props';
+import type { Ref } from 'vue';
+/**
+ * Handles values from external to internal and vise versa
+ */
+export declare const useExternalInternalMapper: (emit: VueEmit, props: AllPropsType, isInputFocused: Ref<boolean>) => {
+    inputValue: Ref<string>;
+    internalModelValue: Ref<any>;
+    checkBeforeEmit: () => boolean;
+    parseExternalModelValue: (value: ModelValue) => void;
+    formatInputValue: () => void;
+    emitModelValue: (returnOnly?: boolean) => void | ModelValue | Date[][];
+};

package/dist/datePicker/composables/flow.d.ts

@@ -0,0 +1,10 @@
+import type { Ref } from 'vue';
+import type { VueEmit } from '../interfaces';
+import type { AllPropsType } from '../props';
+export declare const useFlow: (props: AllPropsType, emit: VueEmit, dynCmpRef: Ref<any>) => {
+    childMount: (cmp: unknown) => void;
+    updateFlowStep: () => void;
+    resetFlow: () => void;
+    handleFlow: (skipStep?: number) => void;
+    flowStep: Ref<number>;
+};

package/dist/datePicker/composables/index.d.ts

@@ -0,0 +1,14 @@
+export * from './state';
+export * from './arrow-navigate';
+export * from './external-internal-mapper';
+export * from './month-year';
+export * from './position';
+export * from './slots';
+export * from './transition';
+export * from './model';
+export * from './defaults';
+export * from './calendar-class';
+export * from './validation';
+export * from './common';
+export * from './flow';
+export * from './month-year';

package/dist/datePicker/composables/model.d.ts

@@ -0,0 +1,17 @@
+import type { InternalModuleValue, VueEmit } from '../interfaces';
+import type { PickerBasePropsType } from '../props';
+export declare const useModel: (props: PickerBasePropsType, emit: VueEmit, reMap?: () => void) => {
+    calendars: import("vue").Ref<{
+        month: number;
+        year: number;
+    }[]>;
+    time: {
+        hours: number | number[];
+        minutes: number | number[];
+        seconds: number | number[];
+    };
+    modelValue: import("vue").WritableComputedRef<InternalModuleValue>;
+    month: import("vue").ComputedRef<(instance: number) => number>;
+    year: import("vue").ComputedRef<(instance: number) => number>;
+    today: Date;
+};

package/dist/datePicker/composables/month-year.d.ts

@@ -0,0 +1,10 @@
+import type { VueEmit } from '../interfaces';
+import type { PickerBasePropsType } from '../props';
+export declare const useMonthYearPick: (props: {
+    month: number;
+    year: number;
+} & PickerBasePropsType, emit: VueEmit) => {
+    handleMonthYearChange: (isNext: boolean, fromNav?: boolean) => void;
+    isDisabled: import("vue").ComputedRef<(next: boolean) => boolean>;
+    updateMonthYear: (month: number, year: number, fromNav: boolean) => void;
+};

package/dist/datePicker/composables/position.d.ts

@@ -0,0 +1,25 @@
+import { type DatepickerInputRef, type DatepickerMenuRef, type InlineOptions, type VueEmit } from '../interfaces';
+import type { Component, ComputedRef, Ref, Slots } from 'vue';
+import type { AllPropsType } from '../props';
+/**
+ * Extracted code from the main component, used for calculating the position of the menu
+ */
+interface Params {
+    menuRef: Ref<HTMLElement | null>;
+    menuRefInner: Ref<DatepickerMenuRef | null>;
+    inputRef: Ref<DatepickerInputRef | null>;
+    pickerWrapperRef: Ref<HTMLElement | null>;
+    inline: ComputedRef<InlineOptions>;
+    emit: VueEmit;
+    props: AllPropsType;
+    slots: Slots;
+}
+export declare const usePosition: ({ menuRef, menuRefInner, inputRef, pickerWrapperRef, inline, emit, props, slots, }: Params) => {
+    openOnTop: Ref<boolean>;
+    menuStyle: Ref<Record<string, string>>;
+    xCorrect: Ref<boolean>;
+    setMenuPosition: (recalculate?: boolean) => void;
+    getScrollableParent: (el: HTMLElement | null) => Window | HTMLElement;
+    shadowRender: (DPMenu: Component, props: AllPropsType) => void;
+};
+export {};

package/dist/datePicker/composables/shared.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, WritableComputedRef } from 'vue';
+import type { InternalModuleValue, RangeConfig, VueEmit } from '../interfaces';
+export declare const handleMultiDatesSelect: (date: Date, modelValue: WritableComputedRef<InternalModuleValue>, multiDatesLimit?: number | string | null) => void;
+export declare const setMonthOrYearRange: (modelValue: WritableComputedRef<InternalModuleValue>, date: Date, emit: VueEmit) => Date[];
+export declare const checkRangeAutoApply: (range: Date[], emit: VueEmit, autoApply: boolean, modelAuto: boolean) => void;
+export declare const setPresetDate: (opts: {
+    value: Date[] | string[] | Date | string;
+    range: boolean;
+    timezone?: string;
+    modelValue: WritableComputedRef<InternalModuleValue>;
+}) => void;
+export declare const getRangeWithFixedDate: (date: Date, modelValue: WritableComputedRef<InternalModuleValue>, emit: VueEmit, defaultedRange: ComputedRef<RangeConfig>) => Date[];

package/dist/datePicker/composables/slots.d.ts

@@ -0,0 +1,10 @@
+import type { Slots } from 'vue';
+import type { PresetDate } from '../interfaces';
+export declare const slots: {
+    name: string;
+    use: string[];
+}[];
+export declare const inputSlots: {
+    name: string;
+}[];
+export declare const mapSlots: (slots: Slots, usage: 'all' | 'monthYear' | 'timePicker' | 'input' | 'action' | 'calendar' | 'menu' | 'shared' | 'yearMode', presetDates?: PresetDate[]) => string[];

package/dist/datePicker/composables/state.d.ts

@@ -0,0 +1,8 @@
+export declare const useState: () => {
+    control: import("vue").ComputedRef<{
+        shiftKeyInMenu: boolean;
+        menuFocused: boolean;
+    }>;
+    setMenuFocused: (value: boolean) => void;
+    setShiftKey: (value: boolean) => void;
+};

package/dist/datePicker/composables/transition.d.ts

@@ -0,0 +1,7 @@
+import type { Transition } from '../interfaces';
+import type { ComputedRef } from 'vue';
+export declare const useTransitions: (transitions: ComputedRef<Transition>) => {
+    transitionName: ComputedRef<(isOpen: boolean) => string>;
+    showTransition: boolean;
+    menuTransition: ComputedRef<(openOnTop: boolean) => string>;
+};

package/dist/datePicker/composables/validation.d.ts

@@ -0,0 +1,12 @@
+import type { InternalModuleValue } from '../interfaces';
+import type { PickerBasePropsType, AllPropsType } from '../props';
+export declare const useValidation: (props: PickerBasePropsType | AllPropsType) => {
+    isDisabled: (date: Date) => boolean;
+    validateDate: (date: Date) => boolean;
+    validateMonthYearInRange: (month: number, year: number, isNext: boolean, preventNav: boolean) => boolean;
+    isDateRangeAllowed: (range: Date[]) => boolean;
+    checkMinMaxRange: (secondDate: Date, modelValue: InternalModuleValue, index?: number) => boolean;
+    isValidTime: (date: InternalModuleValue) => boolean;
+    isTimeValid: import("vue").ComputedRef<(internalModelValue: InternalModuleValue) => boolean>;
+    isMonthValid: import("vue").ComputedRef<(internalModelValue: InternalModuleValue) => boolean>;
+};

package/dist/datePicker/constants/index.d.ts

@@ -0,0 +1,43 @@
+export declare enum HeaderPicker {
+    month = "month",
+    year = "year"
+}
+export declare enum MenuPlacement {
+    top = "top",
+    bottom = "bottom"
+}
+export declare enum CMP {
+    header = "header",
+    calendar = "calendar",
+    timePicker = "timePicker"
+}
+export declare enum FlowStep {
+    month = "month",
+    year = "year",
+    calendar = "calendar",
+    time = "time",
+    minutes = "minutes",
+    hours = "hours",
+    seconds = "seconds"
+}
+export declare const modelTypePredefined: string[];
+export declare enum ArrowDirection {
+    up = "up",
+    down = "down",
+    left = "left",
+    right = "right"
+}
+export declare enum EventKey {
+    arrowUp = "ArrowUp",
+    arrowDown = "ArrowDown",
+    arrowLeft = "ArrowLeft",
+    arrowRight = "ArrowRight",
+    enter = "Enter",
+    space = " ",
+    esc = "Escape",
+    tab = "Tab",
+    home = "Home",
+    end = "End",
+    pageUp = "PageUp",
+    pageDown = "PageDown"
+}