@mailstep/design-system 0.8.26 → 0.8.27

package/ui/Elements/DatePicker/Datetime/views/DaysView.js

@@ -0,0 +1,340 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import { DateRepeater } from "../components/DateRepeater";
+import { Timepicker } from "../components/Timepicker";
+import ViewNavigation from "../components/ViewNavigation";
+var DaysView = /*#__PURE__*/ function(_React_Component) {
+    "use strict";
+    _inherits(DaysView, _React_Component);
+    function DaysView() {
+        _class_call_check(this, DaysView);
+        var _this;
+        _this = _call_super(this, DaysView, arguments);
+        _this._setDate = function(e) {
+            _this.props.updateDate(e);
+        };
+        return _this;
+    }
+    _create_class(DaysView, [
+        {
+            key: "render",
+            value: function render() {
+                return /* @__PURE__ */ jsx("div", {
+                    className: "rdtDays",
+                    children: /* @__PURE__ */ jsxs("table", {
+                        children: [
+                            /* @__PURE__ */ jsxs("thead", {
+                                children: [
+                                    this.renderNavigation(),
+                                    this.renderDayHeaders()
+                                ]
+                            }),
+                            /* @__PURE__ */ jsx("tbody", {
+                                children: this.renderDays()
+                            }),
+                            this.renderFooter()
+                        ]
+                    })
+                });
+            }
+        },
+        {
+            key: "renderNavigation",
+            value: function renderNavigation() {
+                var _this = this;
+                var date = this.props.viewDate;
+                var locale = date.localeData();
+                var label = this.props.label;
+                return /* @__PURE__ */ jsx(ViewNavigation, {
+                    onClickPrev: function onClickPrev() {
+                        return _this.props.navigate(-1, "months");
+                    },
+                    onClickSwitch: function onClickSwitch() {
+                        return _this.props.showView("months");
+                    },
+                    onClickNext: function onClickNext() {
+                        return _this.props.navigate(1, "months");
+                    },
+                    switchContent: locale.months(date, "DD[]MMMM") + " " + date.year(),
+                    switchColSpan: 3,
+                    label: label,
+                    switchProps: {
+                        "data-value": this.props.viewDate.month()
+                    }
+                });
+            }
+        },
+        {
+            key: "renderDayHeaders",
+            value: function renderDayHeaders() {
+                var locale = this.props.viewDate.localeData();
+                var dayItems = getDaysOfWeek(locale).map(function(day, index) {
+                    return /* @__PURE__ */ jsx("th", {
+                        className: "dow",
+                        children: day
+                    }, day + index);
+                });
+                return /* @__PURE__ */ jsx("tr", {
+                    children: dayItems
+                });
+            }
+        },
+        {
+            key: "renderDays",
+            value: function renderDays() {
+                var date = this.props.viewDate;
+                var startOfMonth = date.clone().startOf("month");
+                var endOfMonth = date.clone().endOf("month");
+                var rows = [
+                    [],
+                    [],
+                    [],
+                    [],
+                    [],
+                    []
+                ];
+                var startDate = date.clone().subtract(1, "months");
+                startDate.date(startDate.daysInMonth()).startOf("week");
+                var endDate = startDate.clone().add(42, "d");
+                var i = 0;
+                while(startDate.isBefore(endDate)){
+                    var row = getRow(rows, i++);
+                    row.push(this.renderDay(startDate, startOfMonth, endOfMonth));
+                    startDate.add(1, "d");
+                }
+                return rows.map(function(r, i2) {
+                    return /* @__PURE__ */ jsx("tr", {
+                        children: r
+                    }, "".concat(endDate.month(), "_").concat(i2));
+                });
+            }
+        },
+        {
+            key: "renderDay",
+            value: function renderDay(date, startOfMonth, endOfMonth) {
+                var _this_props_others, _this_props_others1;
+                var selectedDate = this.props.selectedDate;
+                var secondValue = this.props.secondValue;
+                var dayProps = {
+                    key: date.format("M_D"),
+                    "data-value": date.date(),
+                    "data-month": date.month(),
+                    "data-year": date.year()
+                };
+                var className = "rdtDay";
+                if (date.isBefore(startOfMonth)) {
+                    className += " rdtOld";
+                } else if (date.isAfter(endOfMonth)) {
+                    className += " rdtNew";
+                }
+                if (secondValue && date.isBefore(secondValue) && date.isAfter(selectedDate)) {
+                    className += " rdtActiveRange";
+                }
+                if (secondValue && date.isAfter(secondValue) && date.isBefore(selectedDate)) {
+                    className += " rdtActiveRange";
+                }
+                if (selectedDate && date.isSame(selectedDate, "day")) {
+                    className += " rdtActive";
+                }
+                if (secondValue && date.isSame(secondValue, "day")) {
+                    className += " rdtActiveSecond";
+                }
+                if (date.isSame(this.props.moment(), "day")) {
+                    className += " rdtToday";
+                }
+                if (this.props.isValidDate(date) && !((_this_props_others = this.props.others) === null || _this_props_others === void 0 ? void 0 : _this_props_others.dateTypeRepeater) && !this.props.disabled) {
+                    dayProps.onClick = this._setDate;
+                } else {
+                    className += " rdtDisabled";
+                }
+                if (((_this_props_others1 = this.props.others) === null || _this_props_others1 === void 0 ? void 0 : _this_props_others1.dateTypeRepeater) || this.props.disabled) {
+                    className += " rdtDisabled";
+                }
+                dayProps.className = className;
+                return this.props.renderDay(dayProps, date.clone(), selectedDate && selectedDate.clone());
+            }
+        },
+        {
+            key: "renderFooter",
+            value: function renderFooter() {
+                var setTime = this.props.setTime;
+                var onChangeOthers = this.props.onChangeOthers;
+                var reset = this.props.reset;
+                var value = this.props.value;
+                var others = this.props.others;
+                var disabled = this.props.disabled;
+                return /* @__PURE__ */ jsx("tfoot", {
+                    children: /* @__PURE__ */ jsx("tr", {
+                        children: /* @__PURE__ */ jsxs("td", {
+                            colSpan: 7,
+                            children: [
+                                onChangeOthers && /* @__PURE__ */ jsx(DateRepeater, {
+                                    onChangeOthers: onChangeOthers,
+                                    others: others,
+                                    reset: reset
+                                }),
+                                this.props.timeFormat && /* @__PURE__ */ jsx(Timepicker, {
+                                    setTime: setTime,
+                                    value: value,
+                                    disabled: disabled || !value && !(others === null || others === void 0 ? void 0 : others.dateTypeRepeater),
+                                    others: others,
+                                    onChangeOthers: onChangeOthers,
+                                    isSecondDatePicker: this.props.isSecondDatePicker
+                                })
+                            ]
+                        })
+                    })
+                });
+            }
+        }
+    ]);
+    return DaysView;
+}(React.Component);
+DaysView.defaultProps = {
+    isValidDate: function isValidDate() {
+        return true;
+    },
+    renderDay: function renderDay(props, date) {
+        return /* @__PURE__ */ jsx("td", _object_spread_props(_object_spread({}, props), {
+            children: date.date()
+        }));
+    }
+};
+function getRow(rows, day) {
+    return rows[Math.floor(day / 7)];
+}
+function getDaysOfWeek(locale) {
+    var first = locale.firstDayOfWeek();
+    var dow = [];
+    var i = 0;
+    locale._weekdaysMin.forEach(function(day) {
+        dow[(7 + i++ - first) % 7] = day;
+    });
+    return dow;
+}
+export { DaysView as default };

package/ui/Elements/DatePicker/Datetime/views/MonthsView.d.ts

@@ -1,5 +1,4 @@
-import { default as React } from 'react';
-
+import React from 'react';
 export default class MonthsView extends React.Component {
     render(): import("react/jsx-runtime").JSX.Element;
     renderNavigation(): import("react/jsx-runtime").JSX.Element;

package/ui/Elements/DatePicker/Datetime/views/MonthsView.js

@@ -0,0 +1,271 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import ViewNavigation from "../components/ViewNavigation";
+var MonthsView = /*#__PURE__*/ function(_React_Component) {
+    "use strict";
+    _inherits(MonthsView, _React_Component);
+    function MonthsView() {
+        _class_call_check(this, MonthsView);
+        var _this;
+        _this = _call_super(this, MonthsView, arguments);
+        _this._updateSelectedMonth = function(event) {
+            _this.props.updateDate(event);
+        };
+        return _this;
+    }
+    _create_class(MonthsView, [
+        {
+            key: "render",
+            value: function render() {
+                return /* @__PURE__ */ jsxs("div", {
+                    className: "rdtMonths",
+                    children: [
+                        /* @__PURE__ */ jsx("table", {
+                            children: /* @__PURE__ */ jsx("thead", {
+                                children: this.renderNavigation()
+                            })
+                        }),
+                        /* @__PURE__ */ jsx("table", {
+                            children: /* @__PURE__ */ jsx("tbody", {
+                                children: this.renderMonths()
+                            })
+                        })
+                    ]
+                });
+            }
+        },
+        {
+            key: "renderNavigation",
+            value: function renderNavigation() {
+                var _this = this;
+                var year = this.props.viewDate.year();
+                return /* @__PURE__ */ jsx(ViewNavigation, {
+                    onClickPrev: function onClickPrev() {
+                        return _this.props.navigate(-1, "years");
+                    },
+                    onClickSwitch: function onClickSwitch() {
+                        return _this.props.showView("years");
+                    },
+                    onClickNext: function onClickNext() {
+                        return _this.props.navigate(1, "years");
+                    },
+                    switchContent: year,
+                    switchColSpan: "2"
+                });
+            }
+        },
+        {
+            key: "renderMonths",
+            value: function renderMonths() {
+                var rows = [
+                    [],
+                    [],
+                    []
+                ];
+                for(var month = 0; month < 12; month++){
+                    var row = getRow(rows, month);
+                    row.push(this.renderMonth(month));
+                }
+                return rows.map(function(months, i) {
+                    return /* @__PURE__ */ jsx("tr", {
+                        children: months
+                    }, i);
+                });
+            }
+        },
+        {
+            key: "renderMonth",
+            value: function renderMonth(month) {
+                var selectedDate = this.props.selectedDate;
+                var className = "rdtMonth";
+                var onClick;
+                if (this.isDisabledMonth(month)) {
+                    className += " rdtDisabled";
+                } else {
+                    onClick = this._updateSelectedMonth;
+                }
+                if (selectedDate && selectedDate.year() === this.props.viewDate.year() && selectedDate.month() === month) {
+                    className += " rdtActive";
+                }
+                var props = {
+                    key: month,
+                    className: className,
+                    "data-value": month,
+                    onClick: onClick
+                };
+                if (this.props.renderMonth) {
+                    return this.props.renderMonth(props, month, this.props.viewDate.year(), this.props.selectedDate && this.props.selectedDate.clone());
+                }
+                return /* @__PURE__ */ jsx("td", _object_spread_props(_object_spread({}, props), {
+                    children: this.getMonthText(month)
+                }));
+            }
+        },
+        {
+            key: "isDisabledMonth",
+            value: function isDisabledMonth(month) {
+                var isValidDate = this.props.isValidDate;
+                if (!isValidDate) {
+                    return false;
+                }
+                var date = this.props.viewDate.clone().set({
+                    month: month
+                });
+                var day = date.endOf("month").date() + 1;
+                while(day-- > 1){
+                    if (isValidDate(date.date(day))) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        },
+        {
+            key: "getMonthText",
+            value: function getMonthText(month) {
+                var localMoment = this.props.viewDate;
+                var monthStr = localMoment.localeData().monthsShort(localMoment.month(month));
+                return capitalize(monthStr.substring(0, 3));
+            }
+        }
+    ]);
+    return MonthsView;
+}(React.Component);
+function getRow(rows, year) {
+    if (year < 4) {
+        return rows[0];
+    }
+    if (year < 8) {
+        return rows[1];
+    }
+    return rows[2];
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+export { MonthsView as default };

package/ui/Elements/DatePicker/Datetime/views/YearsView.d.ts

@@ -1,5 +1,4 @@
-import { default as React } from 'react';
-
+import React from 'react';
 export default class YearsView extends React.Component {
     static defaultProps: {
         renderYear: (props: any, year: any) => import("react/jsx-runtime").JSX.Element;