@synerise/ds-date-range-picker 1.6.11 → 1.6.13

package/dist/RangeFilter/utils.js

@@ -1,239 +1,218 @@
-var _denormalizers, _validators;
-var _excluded = ["start", "stop", "day"],
-  _excluded2 = ["from", "to", "day"],
-  _excluded3 = ["restricted", "display"],
-  _excluded4 = ["restricted", "display"];
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-import groupBy from 'lodash.groupby';
-import omit from 'lodash.omit';
-import range from 'lodash.range';
-import { COUNTED_FROM_ENUM, DAYS_OF_PERIOD_ENUM, TYPES } from './constants';
-
-/*
- * Map field from components to datefilter schema
- * start => from
- * stop => to
- * 0-based => 1-based indexed days
- * */
-
-export var mapTimeSchema = function mapTimeSchema(item) {
-  var start = item.start,
-    stop = item.stop,
-    day = item.day,
-    rest = _objectWithoutPropertiesLoose(item, _excluded);
-  return _extends({
+import groupBy from "lodash.groupby";
+import omit from "lodash.omit";
+import range from "lodash.range";
+import { TYPES, DAYS_OF_PERIOD_ENUM, COUNTED_FROM_ENUM } from "./constants.js";
+const mapTimeSchema = (item) => {
+  const {
+    start,
+    stop,
+    day,
+    ...rest
+  } = item;
+  return {
     from: start,
     to: stop,
-    day: day === undefined || day !== undefined && Number.isNaN(+day) ? undefined : +day + 1
-  }, rest);
+    day: day === void 0 || day !== void 0 && Number.isNaN(+day) ? void 0 : +day + 1,
+    ...rest
+  };
 };
-
-/*
- * Map field from datefilter to components schema
- * from => start
- * to => stop
- * 1-based => 0-based indexed days
- * */
-export var denormMapTimeSchema = function denormMapTimeSchema(item) {
-  var from = item.from,
-    to = item.to,
-    day = item.day,
-    rest = _objectWithoutPropertiesLoose(item, _excluded2);
-  return _extends({
+const denormMapTimeSchema = (item) => {
+  const {
+    from,
+    to,
+    day,
+    ...rest
+  } = item;
+  return {
     start: from,
     stop: to,
-    day: day === undefined || day !== undefined && Number.isNaN(+day) || Number.isNaN(+day) ? undefined : +day - 1
-  }, rest);
+    day: day === void 0 || day !== void 0 && Number.isNaN(+day) || Number.isNaN(+day) ? void 0 : +day - 1,
+    ...rest
+  };
 };
-export var normalizeValue = function normalizeValue(_ref) {
-  var type = _ref.type,
-    definition = _ref.definition;
-  var result = {
-    type: type,
-    nestingType: 'IN_PLACE'
+const normalizeValue = ({
+  type,
+  definition
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}) => {
+  const result = {
+    type,
+    nestingType: "IN_PLACE"
   };
-  var days;
-  var rules = [];
+  let days;
+  let rules = [];
   switch (type) {
     case TYPES.DAILY:
-      return _extends({}, mapTimeSchema(definition), result);
+      return {
+        ...mapTimeSchema(definition),
+        ...result
+      };
     case TYPES.WEEKLY:
-      days = Object.values(definition).filter(function (day) {
-        return day.restricted;
-      }).map(function (item) {
-        return mapTimeSchema(item);
-      });
+      days = Object.values(definition).filter((day) => day.restricted).map((item) => mapTimeSchema(item));
       break;
     case TYPES.MONTHLY:
       rules = [];
-      definition.map(function (def) {
-        days = Object.values(def.definition).filter(function (day) {
-          return day.restricted;
-        }).map(function (_ref2) {
-          var restricted = _ref2.restricted,
-            display = _ref2.display,
-            rest = _objectWithoutPropertiesLoose(_ref2, _excluded3);
-          return mapTimeSchema(rest);
-        });
+      definition.map((def) => {
+        days = Object.values(def.definition).filter((day) => day.restricted).map(({
+          restricted,
+          display,
+          ...rest
+        }) => mapTimeSchema(rest));
         if (def.period === DAYS_OF_PERIOD_ENUM.DAY_OF_WEEK) {
           rules.push({
-            weeks: Object.entries(groupBy(days, 'week')).map(function (_ref3) {
-              var week = _ref3[0],
-                daysArray = _ref3[1];
-              return {
-                week: +week + 1,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                days: daysArray.map(function (day) {
-                  var dayOfWeek = (day.day - 1) % 7 + 1;
-                  return _extends({}, omit(day, ['week']), {
-                    type: type,
-                    day: dayOfWeek
-                  });
-                })
-              };
-            }),
+            weeks: Object.entries(groupBy(days, "week")).map(([week, daysArray]) => ({
+              week: +week + 1,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              days: daysArray.map((day) => {
+                const dayOfWeek = (day.day - 1) % 7 + 1;
+                return {
+                  ...omit(day, ["week"]),
+                  type,
+                  day: dayOfWeek
+                };
+              })
+            })),
             type: def.period,
             inverted: def.periodType !== COUNTED_FROM_ENUM.BEGINNING
           });
         } else {
           rules.push({
-            days: days,
+            days,
             type: def.period,
             inverted: def.periodType !== COUNTED_FROM_ENUM.BEGINNING
           });
         }
         return rules;
       });
-      return _extends({}, result, {
-        rules: rules
-      });
+      return {
+        ...result,
+        rules
+      };
     default:
       days = [];
       break;
   }
-
-  // @ts-expect-error days doesnt exist in type
   result.days = days.map(
-  // @ts-expect-error types mismatch
-  function (_ref4) {
-    var restricted = _ref4.restricted,
-      display = _ref4.display,
-      rest = _objectWithoutPropertiesLoose(_ref4, _excluded4);
-    return rest;
-  });
+    // @ts-expect-error types mismatch
+    ({
+      restricted,
+      display,
+      ...rest
+    }) => rest
+  );
   return result;
 };
-export var createWeeklyRange = function createWeeklyRange(days) {
-  return range(0, 8).reduce(function (acc, i) {
-    var _extends2;
-    var day = days.find(function (d) {
-      return d.day === i;
-    });
-    return day ? _extends({}, acc, (_extends2 = {}, _extends2[i - 1] = _extends({}, denormMapTimeSchema(day), {
+const createWeeklyRange = (days) => range(0, 8).reduce((acc, i) => {
+  const day = days.find((d) => d.day === i);
+  return day ? {
+    ...acc,
+    [i - 1]: {
+      ...denormMapTimeSchema(day),
       restricted: true,
       display: true
-    }), _extends2)) : acc;
-  }, {});
-};
-export var createMonthlyWeekDayRange = function createMonthlyWeekDayRange(rules) {
-  return (
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    range(0, 7 * 5 + 1).reduce(function (acc, i) {
-      var _extends3;
-      var weekStartIndex = Math.floor(i / 7);
-      var week = weekStartIndex;
-      var dayOfWeek = i - weekStartIndex * 7;
-
-      // @ts-expect-error: FIXME: Type 'undefined' is not assignable to type 'NormalizedFilter[]'.ts(2322)
-      var days = rules.weeks && rules.weeks.reduce(
+    }
+  } : acc;
+}, {});
+const createMonthlyWeekDayRange = (rules) => (
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  range(0, 7 * 5 + 1).reduce((acc, i) => {
+    const weekStartIndex = Math.floor(i / 7);
+    const week = weekStartIndex;
+    const dayOfWeek = i - weekStartIndex * 7;
+    const days = rules.weeks && rules.weeks.reduce(
       // @ts-expect-error: FIXME: Type 'undefined' is not assignable to type 'NormalizedFilter[]'.ts(2322)
-      function (prev, item) {
-        return [].concat(prev, item.days.map(function (day) {
-          return _extends({}, denormMapTimeSchema(day), {
-            week: item.week - 1
-          });
-        }));
-      }, []);
-      var day = days.find(function (d) {
-        return d.week === week && d.day === dayOfWeek;
-      });
-      return day ? _extends({}, acc, (_extends3 = {}, _extends3[i] = _extends({}, day, {
+      (prev, item) => [
+        ...prev,
+        // @ts-expect-error: days doesn't exist in type
+        ...item.days.map((day2) => ({
+          ...denormMapTimeSchema(day2),
+          week: item.week - 1
+        }))
+      ],
+      []
+    );
+    const day = days.find((d) => d.week === week && d.day === dayOfWeek);
+    return day ? {
+      ...acc,
+      [i]: {
+        ...day,
         restricted: true,
         display: true
-      }), _extends3)) : acc;
-    }, {})
-  );
-};
-export var createMonthlyDayRange = function createMonthlyDayRange(rules) {
-  return (
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    range(0, 32).reduce(function (acc, i) {
-      var _extends4;
-      var day = rules.days && rules.days.find(function (d) {
-        return d.day === i;
-      });
-      return day ? _extends({}, acc, (_extends4 = {}, _extends4[i - 1] = _extends({}, denormMapTimeSchema(day), {
+      }
+    } : acc;
+  }, {})
+);
+const createMonthlyDayRange = (rules) => (
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  range(0, 32).reduce((acc, i) => {
+    const day = rules.days && rules.days.find((d) => d.day === i);
+    return day ? {
+      ...acc,
+      [i - 1]: {
+        ...denormMapTimeSchema(day),
         restricted: true,
         display: true
-      }), _extends4)) : acc;
-    }, {})
-  );
-};
-export var denormalizers = (_denormalizers = {}, _denormalizers[TYPES.DAILY] = function (values) {
-  return denormMapTimeSchema(values);
-}, _denormalizers[TYPES.WEEKLY] = function (values) {
-  return createWeeklyRange(values.days);
-}, _denormalizers[TYPES.MONTHLY] = function (values) {
-  var _monthlyDenormalizers;
-  var monthlyDenormalizers = (_monthlyDenormalizers = {}, _monthlyDenormalizers[DAYS_OF_PERIOD_ENUM.DAY_OF_MONTH] = createMonthlyDayRange, _monthlyDenormalizers[DAYS_OF_PERIOD_ENUM.DAY_OF_WEEK] = createMonthlyWeekDayRange, _monthlyDenormalizers);
-  return values.rules.map(function (value) {
-    return {
+      }
+    } : acc;
+  }, {})
+);
+const denormalizers = {
+  [TYPES.DAILY]: (values) => denormMapTimeSchema(values),
+  [TYPES.WEEKLY]: (values) => createWeeklyRange(values.days),
+  [TYPES.MONTHLY]: (values) => {
+    const monthlyDenormalizers = {
+      [DAYS_OF_PERIOD_ENUM.DAY_OF_MONTH]: createMonthlyDayRange,
+      [DAYS_OF_PERIOD_ENUM.DAY_OF_WEEK]: createMonthlyWeekDayRange
+    };
+    return values.rules.map((value) => ({
       period: value.type,
       id: Math.random(),
       periodType: value.inverted ? COUNTED_FROM_ENUM.ENDING : COUNTED_FROM_ENUM.BEGINNING,
       // @ts-ignore
       definition: monthlyDenormalizers[value.type](value)
-    };
-  });
-}, _denormalizers);
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export var validators = (_validators = {}, _validators[TYPES.DAILY] = function (values) {
-  var _values$definition, _values$definition2;
-  return Boolean(!!(values != null && (_values$definition = values.definition) != null && _values$definition.start) && !!(values != null && (_values$definition2 = values.definition) != null && _values$definition2.stop));
-}, _validators[TYPES.WEEKLY] = function (values) {
-  return Boolean((values == null ? void 0 : values.definition) && !!Object.keys(values.definition).length);
-}, _validators[TYPES.MONTHLY] = function (values) {
-  return Boolean((values == null ? void 0 : values.definition) && !!Object.keys(values.definition) &&
-  // @ts-expect-error requires type refactor
-  Object.keys(values.definition[0].definition).length > 0);
-}, _validators);
-export var denormalizeValue = function denormalizeValue(values) {
-  return {
-    type: values.type,
-    definition: denormalizers[values.type](values)
-  };
+    }));
+  }
 };
-var alwaysValid = function alwaysValid() {
-  return true;
+const validators = {
+  [TYPES.DAILY]: (values) => Boolean(!!values?.definition?.start && !!values?.definition?.stop),
+  [TYPES.WEEKLY]: (values) => Boolean(values?.definition && !!Object.keys(values.definition).length),
+  [TYPES.MONTHLY]: (values) => Boolean(values?.definition && !!Object.keys(values.definition) && // @ts-expect-error requires type refactor
+  Object.keys(values.definition[0].definition).length > 0)
 };
-export var isValidValue = function isValidValue(value) {
-  var validator = typeof validators[value == null ? void 0 : value.type] === 'function' ? validators[value.type] : alwaysValid;
+const denormalizeValue = (values) => ({
+  type: values.type,
+  definition: denormalizers[values.type](values)
+});
+const alwaysValid = () => true;
+const isValidValue = (value) => {
+  const validator = typeof validators[value?.type] === "function" ? validators[value.type] : alwaysValid;
   return validator(value);
 };
-export var isDuplicate = function isDuplicate(itemsList, item) {
-  return itemsList.some(function (i) {
-    return i.name.toLowerCase() === item.name.toLowerCase() && i.id !== item.id;
-  });
+const isDuplicate = (itemsList, item) => {
+  return itemsList.some((i) => i.name.toLowerCase() === item.name.toLowerCase() && i.id !== item.id);
 };
-var DEFAULT_NAME = 'Filter';
-export var addSuffixToDuplicate = function addSuffixToDuplicate(itemsList, editedItem) {
-  var newItem = editedItem;
+const DEFAULT_NAME = "Filter";
+const addSuffixToDuplicate = (itemsList, editedItem) => {
+  let newItem = editedItem;
   while (isDuplicate(itemsList, newItem)) {
-    newItem = _extends({}, newItem, {
-      name: (newItem.name || DEFAULT_NAME) + " (1)"
-    });
+    newItem = {
+      ...newItem,
+      name: `${newItem.name || DEFAULT_NAME} (1)`
+    };
   }
   return newItem;
-};
+};
+export {
+  addSuffixToDuplicate,
+  createMonthlyDayRange,
+  createMonthlyWeekDayRange,
+  createWeeklyRange,
+  denormMapTimeSchema,
+  denormalizeValue,
+  denormalizers,
+  isDuplicate,
+  isValidValue,
+  mapTimeSchema,
+  normalizeValue,
+  validators
+};

package/dist/RangePicker/RangePicker.d.ts

@@ -1,4 +1,4 @@
-import { type FC } from 'react';
-import { type RangePickerProps as Props } from './RangePicker.types';
+import { FC } from 'react';
+import { RangePickerProps as Props } from './RangePicker.types';
 declare const _default: FC<Props>;
 export default _default;