@type-dom/ui 0.1.0 → 0.1.2

package/src/components/form/td-time-picker/time-picker-com/basic-time-spinner.class.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicTimeSpinner = void 0;
+const framework_1 = require("@type-dom/framework");
+const signals_1 = require("@type-dom/signals");
+const utils_1 = require("@type-dom/utils");
+const svgs_1 = require("@type-dom/svgs");
+const use_namespace_1 = require("../../../../hooks/use-namespace");
+const td_scrollbar_class_1 = require("../../../basic/td-scrollbar/td-scrollbar.class");
+const basic_time_spinner_1 = require("../props/basic-time-spinner");
+const use_time_picker_1 = require("../composables/use-time-picker");
+const constants_1 = require("../constants");
+const utils_2 = require("../utils");
+const td_icon_class_1 = require("../../../basic/td-icon/td-icon.class");
+class BasicTimeSpinner extends framework_1.TypeDiv {
+    constructor(params = {}) {
+        super();
+        this.className = 'BasicTimeSpinner';
+        this.assignProps(basic_time_spinner_1.basicTimeSpinnerProps);
+        this.props = this.useParams(params);
+    }
+    setup() {
+        var _a, _b;
+        const props = this.props;
+        const pickerBase = (0, framework_1.inject)('EP_PICKER_BASE');
+        const { isRange } = pickerBase.props;
+        // const emit = defineEmits(['change', 'select-range', 'set-option'])
+        const emit = this.emit;
+        const ns = (0, use_namespace_1.useNamespace)('time');
+        const { getHoursList, getMinutesList, getSecondsList } = (0, use_time_picker_1.getTimeLists)(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
+        // data
+        let isScrolling = false;
+        const currentScrollbar = (0, signals_1.signal)();
+        const listHoursRef = (0, signals_1.signal)();
+        const listMinutesRef = (0, signals_1.signal)();
+        const listSecondsRef = (0, signals_1.signal)();
+        const listRefsMap = {
+            hours: listHoursRef,
+            minutes: listMinutesRef,
+            seconds: listSecondsRef,
+        };
+        // computed
+        const spinnerItems = (0, signals_1.computed)(() => {
+            return props.showSeconds ? constants_1.timeUnits : constants_1.timeUnits.slice(0, 2);
+        });
+        const timePartials = (0, signals_1.computed)(() => {
+            const { spinnerDate } = props;
+            if (!spinnerDate)
+                return;
+            const hours = spinnerDate.hour();
+            const minutes = spinnerDate.minute();
+            const seconds = spinnerDate.second();
+            return { hours, minutes, seconds };
+        });
+        const timeList = (0, signals_1.computed)(() => {
+            const { hours, minutes } = (0, signals_1.unref)(timePartials);
+            const { role, spinnerDate } = props;
+            const compare = !isRange ? spinnerDate : undefined;
+            return {
+                hours: getHoursList(role, compare),
+                minutes: getMinutesList(hours, role, compare),
+                seconds: getSecondsList(hours, minutes, role, compare),
+            };
+        });
+        const arrowControlTimeList = (0, signals_1.computed)(() => {
+            const { hours, minutes, seconds } = (0, signals_1.unref)(timePartials);
+            return {
+                hours: (0, utils_2.buildTimeList)(hours, 23),
+                minutes: (0, utils_2.buildTimeList)(minutes, 59),
+                seconds: (0, utils_2.buildTimeList)(seconds, 59),
+            };
+        });
+        const debouncedResetScroll = (0, utils_1.debounce)((type) => {
+            isScrolling = false;
+            adjustCurrentSpinner(type);
+        }, 200);
+        const getAmPmFlag = (hour) => {
+            const shouldShowAmPm = !!props.amPmMode;
+            if (!shouldShowAmPm)
+                return '';
+            const isCapital = props.amPmMode === 'A';
+            // todo locale
+            let content = hour < 12 ? ' am' : ' pm';
+            if (isCapital)
+                content = content.toUpperCase();
+            return content;
+        };
+        const emitSelectRange = (type) => {
+            let range;
+            switch (type) {
+                case 'hours':
+                    range = [0, 2];
+                    break;
+                case 'minutes':
+                    range = [3, 5];
+                    break;
+                case 'seconds':
+                    range = [6, 8];
+                    break;
+            }
+            const [left, right] = range;
+            emit('select-range', left, right);
+            currentScrollbar.set(type);
+        };
+        const adjustCurrentSpinner = (type) => {
+            adjustSpinner(type, (0, signals_1.unref)(timePartials)[type]);
+        };
+        const adjustSpinners = () => {
+            adjustCurrentSpinner('hours');
+            adjustCurrentSpinner('minutes');
+            adjustCurrentSpinner('seconds');
+        };
+        const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.get()}-scrollbar__wrap`);
+        const adjustSpinner = (type, value) => {
+            if (props.arrowControl)
+                return;
+            const scrollbar = (0, signals_1.unref)(listRefsMap[type]);
+            if (scrollbar && scrollbar.dom) {
+                getScrollbarElement(scrollbar.dom).scrollTop = Math.max(0, value * typeItemHeight(type));
+            }
+        };
+        const typeItemHeight = (type) => {
+            var _a;
+            const scrollbar = (0, signals_1.unref)(listRefsMap[type]);
+            const listItem = (_a = scrollbar === null || scrollbar === void 0 ? void 0 : scrollbar.dom) === null || _a === void 0 ? void 0 : _a.querySelector('li');
+            if (listItem) {
+                return Number.parseFloat((0, utils_1.getStyle)(listItem, 'height')) || 0;
+            }
+            return 0;
+        };
+        const onIncrement = () => {
+            scrollDown(1);
+        };
+        const onDecrement = () => {
+            scrollDown(-1);
+        };
+        const scrollDown = (step) => {
+            if (!currentScrollbar.get()) {
+                emitSelectRange('hours');
+            }
+            const label = currentScrollbar.get();
+            const now = (0, signals_1.unref)(timePartials)[label];
+            const total = currentScrollbar.get() === 'hours' ? 24 : 60;
+            const next = findNextUnDisabled(label, now, step, total);
+            modifyDateField(label, next);
+            adjustSpinner(label, next);
+            (0, framework_1.nextTick)(() => emitSelectRange(label));
+        };
+        const findNextUnDisabled = (type, now, step, total) => {
+            let next = (now + step + total) % total;
+            const list = (0, signals_1.unref)(timeList)[type];
+            while (list[next] && next !== now) {
+                next = (next + step + total) % total;
+            }
+            return next;
+        };
+        const modifyDateField = (type, value) => {
+            var _a, _b, _c;
+            const list = (0, signals_1.unref)(timeList)[type];
+            const isDisabled = list[value];
+            if (isDisabled)
+                return;
+            const { hours, minutes, seconds } = (0, signals_1.unref)(timePartials);
+            let changeTo;
+            switch (type) {
+                case 'hours':
+                    changeTo = (_a = props.spinnerDate) === null || _a === void 0 ? void 0 : _a.hour(value).minute(minutes).second(seconds);
+                    break;
+                case 'minutes':
+                    changeTo = (_b = props.spinnerDate) === null || _b === void 0 ? void 0 : _b.hour(hours).minute(value).second(seconds);
+                    break;
+                case 'seconds':
+                    changeTo = (_c = props.spinnerDate) === null || _c === void 0 ? void 0 : _c.hour(hours).minute(minutes).second(value);
+                    break;
+            }
+            emit('change', changeTo);
+        };
+        const handleClick = (type, { value, disabled }) => {
+            if (!disabled) {
+                modifyDateField(type, value);
+                emitSelectRange(type);
+                adjustSpinner(type, value);
+            }
+        };
+        const handleScroll = (type) => {
+            const scrollbar = (0, signals_1.unref)(listRefsMap[type]);
+            if (!scrollbar)
+                return;
+            isScrolling = true;
+            debouncedResetScroll(type);
+            const value = Math.min(Math.round((getScrollbarElement(scrollbar.dom).scrollTop -
+                (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) +
+                3) /
+                typeItemHeight(type)), type === 'hours' ? 23 : 59);
+            modifyDateField(type, value);
+        };
+        const scrollBarHeight = (type) => {
+            var _a;
+            return (_a = (0, signals_1.unref)(listRefsMap[type]).dom) === null || _a === void 0 ? void 0 : _a.offsetHeight;
+        };
+        const bindScrollEvent = () => {
+            const bindFunction = (type) => {
+                const scrollbar = (0, signals_1.unref)(listRefsMap[type]);
+                if (scrollbar && scrollbar.dom) {
+                    getScrollbarElement(scrollbar.dom).onscroll = () => {
+                        // TODO: scroll is emitted when set scrollTop programmatically
+                        // should find better solutions in the future!
+                        handleScroll(type);
+                    };
+                }
+            };
+            bindFunction('hours');
+            bindFunction('minutes');
+            bindFunction('seconds');
+        };
+        (0, framework_1.onMounted)(() => {
+            (0, framework_1.nextTick)(() => {
+                !props.arrowControl && bindScrollEvent();
+                adjustSpinners();
+                // set selection on the first hour part
+                if (props.role === 'start')
+                    emitSelectRange('hours');
+            });
+        });
+        const setRef = (scrollbar, type) => {
+            listRefsMap[type].set(scrollbar !== null && scrollbar !== void 0 ? scrollbar : undefined);
+        };
+        emit('set-option', [`${props.role}_scrollDown`, scrollDown]);
+        emit('set-option', [`${props.role}_emitSelectRange`, emitSelectRange]);
+        (0, signals_1.watch)(() => props.spinnerDate, () => {
+            if (isScrolling)
+                return;
+            adjustSpinners();
+        });
+        this.assignProps({
+            // todo
+            class: (0, signals_1.computed)(() => [
+                ns.b('spinner'),
+                { 'has-seconds': props.showSeconds },
+            ]),
+        });
+        if (!props.arrowControl) {
+            for (const item of spinnerItems === null || spinnerItems === void 0 ? void 0 : spinnerItems.get()) {
+                this.addChild(new td_scrollbar_class_1.TdScrollbar({
+                    // ref: (scrollbar: unknown) => setRef(scrollbar as any, item), // todo
+                    class: ns.be('spinner', 'wrapper'),
+                    wrapStyle: { maxHeight: 'inherit' },
+                    // viewStyle: ns.be('spinner', 'list'), // todo
+                    noresize: true,
+                    tag: 'ul',
+                    events: {
+                        mouseenter: (evt) => emitSelectRange(item),
+                        mousemove: (evt) => adjustCurrentSpinner(item),
+                    },
+                    slot: (_a = timeList.get()) === null || _a === void 0 ? void 0 : _a[item].map((disabled, key) => {
+                        var _a;
+                        return new framework_1.LI({
+                            class: [
+                                ns.be('spinner', 'item'),
+                                ns.is('active', key === ((_a = timePartials.get()) === null || _a === void 0 ? void 0 : _a[item])),
+                                ns.is('disabled', disabled),
+                            ],
+                            events: {
+                                click: () => handleClick(item, { value: key, disabled }),
+                            },
+                            slot: new framework_1.Fragment({
+                                vIf: item === 'hours',
+                                slot: ('0' + (props.amPmMode ? key % 12 || 12 : key)).slice(-2) +
+                                    getAmPmFlag(key),
+                            }),
+                        });
+                    }),
+                }));
+            }
+        }
+        else {
+            for (const item of spinnerItems.get()) {
+                // 这样就没有双向绑定的效果了
+                this.addChild(new framework_1.Div({
+                    class: [ns.be('spinner', 'wrapper'), ns.is('arrow')],
+                    events: {
+                        mouseenter: () => emitSelectRange(item),
+                    },
+                    slot: [
+                        new td_icon_class_1.TdIcon({
+                            // vRepeatClick: onDecrement, // todo
+                            class: ['arrow-up', ns.be('spinner', 'arrow')],
+                            slot: new svgs_1.ElArrowUpSvg(),
+                        }),
+                        new td_icon_class_1.TdIcon({
+                            // vRepeatClick: onIncrement, // todo
+                            class: ['arrow-down', ns.be('spinner', 'arrow')],
+                            slot: new svgs_1.ElArrowDownSvg(),
+                        }),
+                        new framework_1.UL({
+                            class: ns.be('spinner', 'list'),
+                            slot: (_b = arrowControlTimeList.get()) === null || _b === void 0 ? void 0 : _b[item].map((time, key) => {
+                                var _a, _b;
+                                return new framework_1.LI({
+                                    class: [
+                                        ns.be('spinner', 'item'),
+                                        ns.is('active', key === ((_a = timePartials.get()) === null || _a === void 0 ? void 0 : _a[item])),
+                                        ns.is('disabled', (_b = timeList.get()) === null || _b === void 0 ? void 0 : _b[item][time]),
+                                    ],
+                                    slot: new framework_1.Fragment({
+                                        vIf: (0, utils_1.isNumber)(item),
+                                        slot: [
+                                            new framework_1.Fragment({
+                                                vIf: item === 'hours',
+                                                slot: ('0' + (props.amPmMode ? time % 12 || 12 : time)).slice(-2) + getAmPmFlag(time),
+                                            }),
+                                            new framework_1.Fragment({
+                                                vIf: item !== 'hours',
+                                                slot: ('0' + time).slice(-2),
+                                            }),
+                                        ],
+                                    }),
+                                });
+                            }),
+                        }),
+                    ],
+                }));
+            }
+        }
+    }
+}
+exports.BasicTimeSpinner = BasicTimeSpinner;

package/src/components/form/td-time-picker/time-picker-com/panel-time-pick.class.d.ts

@@ -0,0 +1,8 @@
+import { TypeFragmentProps, TypeFragment } from '@type-dom/framework';
+import { PanelTimePickerProps } from '../props/panel-time-picker';
+export declare class PanelTimePick extends TypeFragment {
+    className: 'PanelTimePick';
+    props: PanelTimePickerProps & TypeFragmentProps;
+    constructor(params?: PanelTimePickerProps);
+    setup(): void;
+}

package/src/components/form/td-time-picker/time-picker-com/panel-time-pick.class.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PanelTimePick = void 0;
+const framework_1 = require("@type-dom/framework");
+const dayjs_1 = require("dayjs");
+const signals_1 = require("@type-dom/signals");
+const utils_1 = require("@type-dom/utils");
+const aria_1 = require("../../../../constants/aria");
+const use_namespace_1 = require("../../../../hooks/use-namespace");
+const use_locale_1 = require("../../../../hooks/use-locale");
+const use_time_panel_1 = require("../composables/use-time-panel");
+const use_time_picker_1 = require("../composables/use-time-picker");
+class PanelTimePick extends framework_1.TypeFragment {
+    constructor(params = {}) {
+        super();
+        this.className = 'PanelTimePick';
+        // this.assignProps(panelTimePickerProps);
+        this.props = this.useParams(params);
+    }
+    setup() {
+        const props = this.props;
+        const emit = this.emit; // defineEmits(['pick', 'select-range', 'set-picker-option'])
+        // Injections
+        const pickerBase = (0, framework_1.inject)('EP_PICKER_BASE');
+        const { arrowControl, disabledHours, disabledMinutes, disabledSeconds, defaultValue, } = pickerBase.props;
+        const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = (0, use_time_picker_1.buildAvailableTimeSlotGetter)(disabledHours, disabledMinutes, disabledSeconds);
+        const ns = (0, use_namespace_1.useNamespace)('time');
+        const { t, lang } = (0, use_locale_1.useLocale)();
+        // data
+        const selectionRange = (0, signals_1.signal)([0, 2]);
+        const oldValue = (0, use_time_picker_1.useOldValue)(props);
+        // computed
+        const transitionName = (0, signals_1.computed)(() => {
+            return (0, utils_1.isUndefined)(props.actualVisible)
+                ? `${ns.namespace.get()}-zoom-in-top`
+                : '';
+        });
+        const showSeconds = (0, signals_1.computed)(() => {
+            var _a;
+            return (_a = props.format) === null || _a === void 0 ? void 0 : _a.includes('ss');
+        });
+        const amPmMode = (0, signals_1.computed)(() => {
+            var _a, _b;
+            if ((_a = props.format) === null || _a === void 0 ? void 0 : _a.includes('A'))
+                return 'A';
+            if ((_b = props.format) === null || _b === void 0 ? void 0 : _b.includes('a'))
+                return 'a';
+            return '';
+        });
+        // method
+        const isValidValue = (_date) => {
+            const parsedDate = (0, dayjs_1.default)(_date).locale(lang.get());
+            const result = getRangeAvailableTime(parsedDate);
+            return parsedDate.isSame(result);
+        };
+        const handleCancel = () => {
+            emit('pick', oldValue.get(), false);
+        };
+        const handleConfirm = (visible = false, first = false) => {
+            if (first)
+                return;
+            emit('pick', props.parsedValue, visible);
+        };
+        const handleChange = (_date) => {
+            // visible avoids edge cases, when use scrolls during panel closing animation
+            if (!props.visible) {
+                return;
+            }
+            const result = getRangeAvailableTime(_date).millisecond(0);
+            emit('pick', result, true);
+        };
+        const setSelectionRange = (start, end) => {
+            emit('select-range', start, end);
+            selectionRange.set([start, end]);
+        };
+        const changeSelectionRange = (step) => {
+            const list = [0, 3].concat(showSeconds.get() ? [6] : []);
+            const mapping = ['hours', 'minutes'].concat(showSeconds.get() ? ['seconds'] : []);
+            const index = list.indexOf(selectionRange.get()[0]);
+            const next = (index + step + list.length) % list.length;
+            timePickerOptions['start_emitSelectRange'](mapping[next]);
+        };
+        const handleKeydown = (event) => {
+            const code = event.code;
+            const { left, right, up, down } = aria_1.EVENT_CODE;
+            if ([left, right].includes(code)) {
+                const step = code === left ? -1 : 1;
+                changeSelectionRange(step);
+                event.preventDefault();
+                return;
+            }
+            if ([up, down].includes(code)) {
+                const step = code === up ? -1 : 1;
+                timePickerOptions['start_scrollDown'](step);
+                event.preventDefault();
+                return;
+            }
+        };
+        const { timePickerOptions, onSetOption, getAvailableTime } = (0, use_time_panel_1.useTimePanel)({
+            getAvailableHours,
+            getAvailableMinutes,
+            getAvailableSeconds,
+        });
+        const getRangeAvailableTime = (date) => {
+            return getAvailableTime(date, props.datetimeRole || '', true);
+        };
+        const parseUserInput = (value) => {
+            if (!value)
+                return null;
+            return (0, dayjs_1.default)(value, props.format).locale(lang.get());
+        };
+        const formatToString = (value) => {
+            if (!value)
+                return null;
+            return value.format(props.format);
+        };
+        const getDefaultValue = () => {
+            return (0, dayjs_1.default)(defaultValue).locale(lang.get());
+        };
+        emit('set-picker-option', ['isValidValue', isValidValue]);
+        emit('set-picker-option', ['formatToString', formatToString]);
+        emit('set-picker-option', ['parseUserInput', parseUserInput]);
+        emit('set-picker-option', ['handleKeydownInput', handleKeydown]);
+        emit('set-picker-option', ['getRangeAvailableTime', getRangeAvailableTime]);
+        emit('set-picker-option', ['getDefaultValue', getDefaultValue]);
+    }
+}
+exports.PanelTimePick = PanelTimePick;

package/src/components/form/td-time-picker/types.d.ts

@@ -0,0 +1,4 @@
+import type { Dayjs } from 'dayjs';
+export type GetDisabledHoursState = (role: string, comparingDate?: Dayjs) => number[];
+export type GetDisabledMinutesState = (hour: number, role: string, comparingDate?: Dayjs) => number[];
+export type GetDisabledSecondsState = (hour: number, minute: number, role: string, comparingDate?: Dayjs) => number[];

package/src/components/form/td-time-picker/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/components/form/td-time-picker/utils.d.ts

@@ -0,0 +1,14 @@
+import dayjs from 'dayjs';
+import type { Dayjs } from 'dayjs';
+import type { DateOrDates, DayOrDays } from './common/props';
+export type TimeList = [number | undefined, number, undefined | number];
+export declare const buildTimeList: (value: number, bound: number) => TimeList;
+export declare const rangeArr: (n: number) => number[];
+export declare const extractDateFormat: (format: string) => string;
+export declare const extractTimeFormat: (format: string) => string;
+export declare const dateEquals: (a: Date | unknown, b: Date | unknown) => boolean;
+export declare const valueEquals: (a: Array<Date> | unknown, b: Array<Date> | unknown) => boolean;
+export declare const parseDate: (date: string | number | Date, format: string | undefined, lang: string) => dayjs.Dayjs | undefined;
+export declare const formatter: (date: string | number | Date | Dayjs, format: string | undefined, lang: string) => string | number | dayjs.Dayjs | Date;
+export declare const makeList: (total: number, method?: () => number[]) => boolean[];
+export declare const dayOrDaysToDate: (dayOrDays: DayOrDays) => DateOrDates;

package/src/components/form/td-time-picker/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dayOrDaysToDate = exports.makeList = exports.formatter = exports.parseDate = exports.valueEquals = exports.dateEquals = exports.extractTimeFormat = exports.extractDateFormat = exports.rangeArr = exports.buildTimeList = void 0;
+const dayjs_1 = require("dayjs");
+const utils_1 = require("@type-dom/utils");
+const buildTimeList = (value, bound) => {
+    return [
+        value > 0 ? value - 1 : undefined,
+        value,
+        value < bound ? value + 1 : undefined,
+    ];
+};
+exports.buildTimeList = buildTimeList;
+const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
+exports.rangeArr = rangeArr;
+const extractDateFormat = (format) => {
+    return format
+        .replace(/\W?m{1,2}|\W?ZZ/g, '')
+        .replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, '')
+        .trim();
+};
+exports.extractDateFormat = extractDateFormat;
+const extractTimeFormat = (format) => {
+    return format
+        .replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, '')
+        .trim();
+};
+exports.extractTimeFormat = extractTimeFormat;
+const dateEquals = function (a, b) {
+    const aIsDate = (0, utils_1.isDate)(a);
+    const bIsDate = (0, utils_1.isDate)(b);
+    if (aIsDate && bIsDate) {
+        return a.getTime() === b.getTime();
+    }
+    if (!aIsDate && !bIsDate) {
+        return a === b;
+    }
+    return false;
+};
+exports.dateEquals = dateEquals;
+const valueEquals = function (a, b) {
+    const aIsArray = (0, utils_1.isArray)(a);
+    const bIsArray = (0, utils_1.isArray)(b);
+    if (aIsArray && bIsArray) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, index) => (0, exports.dateEquals)(item, b[index]));
+    }
+    if (!aIsArray && !bIsArray) {
+        return (0, exports.dateEquals)(a, b);
+    }
+    return false;
+};
+exports.valueEquals = valueEquals;
+const parseDate = function (date, format, lang) {
+    const day = (0, utils_1.isEmpty)(format) || format === 'x'
+        ? (0, dayjs_1.default)(date).locale(lang)
+        : (0, dayjs_1.default)(date, format).locale(lang);
+    return day.isValid() ? day : undefined;
+};
+exports.parseDate = parseDate;
+const formatter = function (date, format, lang) {
+    if ((0, utils_1.isEmpty)(format))
+        return date;
+    if (format === 'x')
+        return +date;
+    return (0, dayjs_1.default)(date).locale(lang).format(format);
+};
+exports.formatter = formatter;
+const makeList = (total, method) => {
+    var _a;
+    const arr = [];
+    const disabledArr = method === null || method === void 0 ? void 0 : method();
+    for (let i = 0; i < total; i++) {
+        arr.push((_a = disabledArr === null || disabledArr === void 0 ? void 0 : disabledArr.includes(i)) !== null && _a !== void 0 ? _a : false);
+    }
+    return arr;
+};
+exports.makeList = makeList;
+const dayOrDaysToDate = (dayOrDays) => {
+    return (0, utils_1.isArray)(dayOrDays)
+        ? dayOrDays.map((d) => d.toDate())
+        : dayOrDays.toDate();
+};
+exports.dayOrDaysToDate = dayOrDaysToDate;

package/src/components/form/td-upload/ajax.d.ts

@@ -0,0 +1,9 @@
+import { UploadRequestHandler } from './td-upload.interface';
+export declare class UploadAjaxError extends Error {
+    name: string;
+    status: number;
+    method: string;
+    url: string;
+    constructor(message: string, status: number, method: string, url: string);
+}
+export declare const ajaxUpload: UploadRequestHandler;