dtable-ui-component 6.0.38-alpha.2 → 6.0.39-alp41

package/lib/utils/dateFormat.js

@@ -0,0 +1,211 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.currentYear = exports.currentTime = exports.DATE_FORMATS = void 0;
+exports.delimate = delimate;
+exports.formatDateLocal = formatDateLocal;
+exports.fullValidYear = fullValidYear;
+exports.getDay = getDay;
+exports.getMonth = getMonth;
+exports.getYear = getYear;
+exports.renderDisplayContent = renderDisplayContent;
+exports.renderFilterInputFormat = renderFilterInputFormat;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _utc = _interopRequireDefault(require("dayjs/plugin/utc"));
+_dayjs.default.extend(_utc.default);
+const currentTime = exports.currentTime = (0, _dayjs.default)().format('HH:mm');
+const currentYear = exports.currentYear = (0, _dayjs.default)().year();
+const DATE_FORMATS = exports.DATE_FORMATS = {
+  ISO: 'yyyy-mm-dd',
+  ISOAndTime: 'yyyy-mm-dd hh:mm',
+  US: 'm/d/yyyy',
+  USAndTime: 'm/d/yyyy hh:mm',
+  European: 'dd/mm/yyyy',
+  EuropeanAndTime: 'dd/mm/yyyy hh:mm',
+  Germany_Russia_etc: 'dd.mm.yyyy',
+  Germany_Russia_etcAndTime: 'dd.mm.yyyy hh:mm'
+};
+function fullValidYear(yearStr) {
+  const year = yearStr;
+  if (!year || isNaN(year)) return currentYear;
+  if (year.length === 2) {
+    if (Number(year) >= 0 && Number(year) < 69) {
+      return year ? "20".concat(year) : currentYear;
+    } else if (Number(year) >= 69 && Number(year) < 100) {
+      return year ? "19".concat(year) : currentYear;
+    }
+  }
+  if (year.length === 4) {
+    return year;
+  }
+  return year ? year.padStart(4, '0') : currentYear;
+}
+function formatDateLocal(formatStr, localeFormat) {
+  const str = formatStr || '';
+  const format = String(localeFormat).toLowerCase();
+  let cleanStr;
+  switch (format) {
+    case DATE_FORMATS.ISO:
+    case DATE_FORMATS.ISOAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '-');
+      return cleanStr.split('-').filter(Boolean).map(String);
+    case DATE_FORMATS.US:
+    case DATE_FORMATS.USAndTime:
+    case DATE_FORMATS.European:
+    case DATE_FORMATS.EuropeanAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '/');
+      return cleanStr.split('/').filter(Boolean).map(String);
+    case DATE_FORMATS.Germany_Russia_etc:
+    case DATE_FORMATS.Germany_Russia_etcAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '.');
+      return cleanStr.split('.').filter(Boolean).map(String);
+    default:
+      return [];
+  }
+}
+function delimate(localeFormat) {
+  const formatPrefix = String(localeFormat).toLowerCase();
+  let delimiter;
+  if (formatPrefix === DATE_FORMATS.Germany_Russia_etc || formatPrefix === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    delimiter = '.';
+  } else if (formatPrefix === DATE_FORMATS.ISO || formatPrefix === DATE_FORMATS.ISOAndTime) {
+    delimiter = '-';
+  } else {
+    delimiter = '/';
+  }
+  return delimiter;
+}
+function renderDisplayContent(str, localeFormat, delimiter) {
+  const format = String(localeFormat).toLowerCase();
+  const parts = formatDateLocal(str, localeFormat);
+  if (parts.length < 3) {
+    return '';
+  }
+  let day = parts[2];
+  let month = parts[1];
+  let year = String(fullValidYear(parts[0])).padStart(4, '0');
+  let time = "".concat(parts[3], ":").concat(parts[4]) || currentTime;
+  if (format === DATE_FORMATS.ISO) {
+    return "".concat(year).concat(delimiter).concat(month).concat(delimiter).concat(day);
+  }
+  if (format === DATE_FORMATS.ISOAndTime) {
+    return "".concat(year).concat(delimiter).concat(month).concat(delimiter).concat(day, " ").concat(time);
+  }
+  if (format === DATE_FORMATS.US) {
+    return "".concat(Number(month)).concat(delimiter).concat(Number(day)).concat(delimiter).concat(year);
+  }
+  if (format === DATE_FORMATS.USAndTime) {
+    return "".concat(Number(month)).concat(delimiter).concat(Number(day)).concat(delimiter).concat(year, " ").concat(time);
+  }
+  if (format === DATE_FORMATS.European || format === DATE_FORMATS.Germany_Russia_etc) {
+    return "".concat(Number(day)).concat(delimiter).concat(Number(month)).concat(delimiter).concat(year);
+  }
+  if (format === DATE_FORMATS.EuropeanAndTime || format === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    return "".concat(Number(day)).concat(delimiter).concat(Number(month)).concat(delimiter).concat(year, " ").concat(time);
+  }
+}
+function renderFilterInputFormat(str, localeFormat, delimiter) {
+  const format = String(localeFormat).toLowerCase();
+  const parts = formatDateLocal(str, localeFormat);
+  // console.log('parts', str, parts);
+  if (parts.length < 3) {
+    return '';
+  }
+  let day;
+  let month;
+  let year;
+  let time = "".concat(parts[3], ":").concat(parts[4]) || currentTime;
+  if (format === DATE_FORMATS.ISO) {
+    day = parts[2];
+    month = parts[1];
+    year = String(fullValidYear(parts[0])).padStart(4, '0');
+    return "".concat(year).concat(delimiter).concat(month).concat(delimiter).concat(day);
+  }
+  if (format === DATE_FORMATS.ISOAndTime) {
+    day = parts[2];
+    month = parts[1];
+    year = String(fullValidYear(parts[0])).padStart(4, '0');
+    return "".concat(year).concat(delimiter).concat(month).concat(delimiter).concat(day, " ").concat(time);
+  }
+  if (format === DATE_FORMATS.US) {
+    day = parts[1];
+    month = parts[0];
+    year = String(fullValidYear(parts[2])).padStart(4, '0');
+    return "".concat(Number(month)).concat(delimiter).concat(Number(day)).concat(delimiter).concat(year);
+  }
+  if (format === DATE_FORMATS.USAndTime) {
+    day = parts[1];
+    month = parts[0];
+    year = String(fullValidYear(parts[2])).padStart(4, '0');
+    return "".concat(Number(month)).concat(delimiter).concat(Number(day)).concat(delimiter).concat(year, " ").concat(time);
+  }
+  if (format === DATE_FORMATS.European || format === DATE_FORMATS.Germany_Russia_etc) {
+    day = parts[0];
+    month = parts[1];
+    year = String(fullValidYear(parts[2])).padStart(4, '0');
+    return "".concat(Number(day)).concat(delimiter).concat(Number(month)).concat(delimiter).concat(year);
+  }
+  if (format === DATE_FORMATS.EuropeanAndTime || format === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    day = parts[0];
+    month = parts[1];
+    year = String(fullValidYear(parts[2])).padStart(4, '0');
+    return "".concat(Number(day)).concat(delimiter).concat(Number(month)).concat(delimiter).concat(year, " ").concat(time);
+  }
+}
+function getDay(str, localeFormat, mode) {
+  const format = String(localeFormat).toLowerCase();
+  const parts = formatDateLocal(str, format);
+  if (parts.length < 3) {
+    return '';
+  }
+  if (!mode) {
+    if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+      return String(parts[2]).padStart(2, '0');
+    }
+    return String(Number(parts[2]));
+  }
+  if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+    return String(parts[2]).padStart(2, '0');
+  }
+  if (format === DATE_FORMATS.US || format === DATE_FORMATS.USAndTime) {
+    return String(Number(parts[1]));
+  }
+  return String(Number(parts[0]));
+}
+function getMonth(str, localeFormat, mode) {
+  const format = String(localeFormat).toLowerCase();
+  const parts = formatDateLocal(str, format);
+  if (parts.length < 3) {
+    return '';
+  }
+  if (!mode) {
+    if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+      return String(Number(parts[1]) - 1).padStart(2, '0');
+    }
+    return String(Number(parts[1]) - 1);
+  }
+  if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+    return String(Number(parts[1]) - 1).padStart(2, '0');
+  }
+  if (format === DATE_FORMATS.US || format === DATE_FORMATS.USAndTime) {
+    return String(Number(parts[0]) - 1);
+  }
+  return String(Number(parts[1]) - 1);
+}
+function getYear(str, localeFormat, mode) {
+  const format = String(localeFormat).toLowerCase();
+  const parts = formatDateLocal(str, format);
+  if (parts.length < 3) {
+    return '';
+  }
+  if (!mode) {
+    return String(fullValidYear(parts[0])).padStart(4, '0');
+  }
+  if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+    return String(fullValidYear(parts[0])).padStart(4, '0');
+  }
+  return String(fullValidYear(parts[2])).padStart(4, '0');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtable-ui-component",
-  "version": "6.0.38-alpha.2",
+  "version": "6.0.39-alp41",
   "main": "./lib/index.js",
   "dependencies": {
     "@seafile/react-image-lightbox": "4.0.2",
@@ -153,7 +153,7 @@
     "url-loader": "^4.1.1",
     "web-vitals": "2.1.4",
     "webpack": "^5.94.0",
-    "webpack-dev-server": "^4.6.0",
+    "webpack-dev-server": "^5.2.2",
     "webpack-manifest-plugin": "^4.0.2",
     "workbox-webpack-plugin": "^6.4.1",
     "worker-loader": "3.0.8"

package/lib/DTableFiltersPopover/widgets/filter-group.js

@@ -1,185 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _classnames = _interopRequireDefault(require("classnames"));
-var _dtableUtils = require("dtable-utils");
-var _DTableCustomizeSelect = _interopRequireDefault(require("../../DTableCustomizeSelect"));
-var _filterItem = _interopRequireDefault(require("./filter-item"));
-var _filterItemUtils = _interopRequireDefault(require("../utils/filter-item-utils"));
-var _constants = require("../constants");
-var _utils = require("../utils");
-var _DTableCommonAddTool = _interopRequireDefault(require("../../DTableCommonAddTool"));
-var _lang = require("../../lang");
-class FilterGroup extends _react.Component {
-  constructor() {
-    super(...arguments);
-    this.onSelectGroupConjunction = conjunctionOption => {
-      const {
-        filterConjunction
-      } = this.props;
-      const {
-        filterConjunction: newConjunction
-      } = conjunctionOption;
-      if (newConjunction === filterConjunction) {
-        return;
-      }
-      this.props.modifyFilterConjunction(newConjunction);
-    };
-    this.deleteFilterGroup = event => {
-      event.nativeEvent.stopImmediatePropagation();
-      const {
-        index
-      } = this.props;
-      this.props.deleteFilterGroup(index);
-    };
-    this.modifyConjunctionInGroup = new_filter_conjunction => {
-      const {
-        index
-      } = this.props;
-      this.props.modifyConjunctionInGroup(index, new_filter_conjunction);
-    };
-    this.addFilterIntoGroup = () => {
-      const {
-        columns,
-        index
-      } = this.props;
-      const newFilter = (0, _utils.getDefaultFilter)(columns);
-      if (!newFilter) {
-        return;
-      }
-      this.props.addFilterIntoGroup(index, newFilter);
-    };
-    this.deleteFilterInGroup = filter_index => {
-      const {
-        index
-      } = this.props;
-      this.props.deleteFilterInGroup(index, filter_index);
-    };
-    this.updateFilterInGroup = (filter_index, new_filter) => {
-      const {
-        index
-      } = this.props;
-      this.props.updateFilterInGroup(index, filter_index, new_filter);
-    };
-    this.renderConjunction = () => {
-      const {
-        index,
-        filterConjunction,
-        conjunctionOptions
-      } = this.props;
-      switch (index) {
-        case 0:
-          {
-            return null;
-          }
-        case 1:
-          {
-            const activeConjunction = _filterItemUtils.default.getActiveConjunctionOption(filterConjunction, conjunctionOptions);
-            return /*#__PURE__*/_react.default.createElement(_DTableCustomizeSelect.default, {
-              value: activeConjunction,
-              options: conjunctionOptions,
-              onSelectOption: this.onSelectGroupConjunction
-            });
-          }
-        default:
-          {
-            return /*#__PURE__*/_react.default.createElement("span", {
-              className: "selected-conjunction-show"
-            }, (0, _lang.getLocale)(filterConjunction));
-          }
-      }
-    };
-    this.renderGroupFilters = () => {
-      const {
-        columns,
-        conjunctionOptions,
-        columnOptions,
-        filter,
-        index: groupIndex,
-        collaborators,
-        lang,
-        userDepartmentIdsMap,
-        departments,
-        firstDayOfWeek
-      } = this.props;
-      const {
-        filters: subFilters,
-        filter_conjunction
-      } = filter;
-      const subFilterConjunction = _constants.SUPPORT_CONJUNCTIONS.includes(filter_conjunction) ? filter_conjunction : _dtableUtils.FILTER_CONJUNCTION_TYPE.AND;
-      const subFiltersLength = Array.isArray(subFilters) ? subFilters.length : 0;
-      if (subFiltersLength === 0) {
-        return null;
-      }
-      return subFilters.map((currentFilter, subFilterIndex) => {
-        const {
-          column_key: sub_filter_column_key
-        } = currentFilter;
-        const {
-          error_message
-        } = _dtableUtils.ValidateFilter.validate(currentFilter, columns);
-        const filterColumn = columns.find(column => column.key === sub_filter_column_key) || {};
-        return /*#__PURE__*/_react.default.createElement(_filterItem.default, {
-          key: "filter-in-group-".concat(groupIndex, "-").concat(subFilterIndex),
-          isInModal: this.props.isInModal,
-          lang: lang,
-          index: subFilterIndex,
-          filter: currentFilter,
-          errorMessage: error_message,
-          filterColumn: filterColumn,
-          filterConjunction: subFilterConjunction,
-          conjunctionOptions: conjunctionOptions,
-          filterColumnOptions: columnOptions,
-          collaborators: collaborators,
-          userDepartmentIdsMap: userDepartmentIdsMap,
-          departments: departments,
-          firstDayOfWeek: firstDayOfWeek,
-          updateConjunction: this.modifyConjunctionInGroup,
-          deleteFilter: this.deleteFilterInGroup,
-          updateFilter: this.updateFilterInGroup
-        });
-      });
-    };
-  }
-  render() {
-    const {
-      level,
-      index
-    } = this.props;
-    return /*#__PURE__*/_react.default.createElement("div", {
-      className: (0, _classnames.default)('filter-item', 'filter-group', "level-".concat(level))
-    }, /*#__PURE__*/_react.default.createElement("div", {
-      className: "delete-filter",
-      onClick: this.deleteFilterGroup,
-      role: "button",
-      tabIndex: 0,
-      "aria-label": (0, _lang.getLocale)('Delete')
-    }, /*#__PURE__*/_react.default.createElement("i", {
-      "aria-hidden": "true",
-      className: "dtable-font dtable-icon-fork-number"
-    })), /*#__PURE__*/_react.default.createElement("div", {
-      className: "filter-group-wrapper"
-    }, /*#__PURE__*/_react.default.createElement("div", {
-      className: (0, _classnames.default)('filter-conjunction', {
-        'conjunction-text': index > 1
-      })
-    }, this.renderConjunction()), /*#__PURE__*/_react.default.createElement("div", {
-      className: "filter-group-container"
-    }, this.renderGroupFilters(), /*#__PURE__*/_react.default.createElement(_DTableCommonAddTool.default, {
-      className: "group-filter-add-tool",
-      callBack: this.addFilterIntoGroup,
-      footerName: (0, _lang.getLocale)('Add_filter'),
-      addIconClassName: "popover-add-icon"
-    }))));
-  }
-}
-FilterGroup.defaultProps = {
-  level: 1
-};
-var _default = exports.default = FilterGroup;