@birdnet/advanced-react-dates 0.0.0-stage → 1.0.0

package/src/utils/isBeforeDay.js

@@ -0,0 +1,18 @@
+import moment from 'moment';
+
+export default function isBeforeDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+
+  const aYear = a.year();
+  const aMonth = a.month();
+
+  const bYear = b.year();
+  const bMonth = b.month();
+
+  const isSameYear = aYear === bYear;
+  const isSameMonth = aMonth === bMonth;
+
+  if (isSameYear && isSameMonth) return a.date() < b.date();
+  if (isSameYear) return aMonth < bMonth;
+  return aYear < bYear;
+}

package/src/utils/isDayVisible.js

@@ -0,0 +1,57 @@
+import moment from 'moment';
+
+import isBeforeDay from './isBeforeDay';
+import isAfterDay from './isAfterDay';
+import toISOMonthString from './toISOMonthString';
+
+const startCacheOutsideDays = new Map();
+const endCacheOutsideDays = new Map();
+
+const startCacheInsideDays = new Map();
+const endCacheInsideDays = new Map();
+
+export default function isDayVisible(day, month, numberOfMonths, enableOutsideDays) {
+  if (!moment.isMoment(day)) return false;
+
+  // Cloning is a little expensive, so we want to do it as little as possible.
+
+  const startKey = toISOMonthString(month);
+  // eslint-disable-next-line prefer-template
+  const endKey = startKey + '+' + numberOfMonths;
+
+  if (enableOutsideDays) {
+    if (!startCacheOutsideDays.has(startKey)) {
+      startCacheOutsideDays.set(startKey, month.clone().startOf('month').startOf('week').hour(12));
+    }
+
+    if (isBeforeDay(day, startCacheOutsideDays.get(startKey))) return false;
+
+    if (!endCacheOutsideDays.has(endKey)) {
+      endCacheOutsideDays.set(
+        endKey,
+        month.clone().endOf('week').add(numberOfMonths - 1, 'months').endOf('month')
+          .endOf('week')
+          .hour(12),
+      );
+    }
+
+    return !isAfterDay(day, endCacheOutsideDays.get(endKey));
+  }
+
+  // !enableOutsideDays
+
+  if (!startCacheInsideDays.has(startKey)) {
+    startCacheInsideDays.set(startKey, month.clone().startOf('month').hour(12));
+  }
+
+  if (isBeforeDay(day, startCacheInsideDays.get(startKey))) return false;
+
+  if (!endCacheInsideDays.has(endKey)) {
+    endCacheInsideDays.set(
+      endKey,
+      month.clone().add(numberOfMonths - 1, 'months').endOf('month').hour(12),
+    );
+  }
+
+  return !isAfterDay(day, endCacheInsideDays.get(endKey));
+}

package/src/utils/isInclusivelyAfterDay.js

@@ -0,0 +1,8 @@
+import moment from 'moment';
+
+import isBeforeDay from './isBeforeDay';
+
+export default function isInclusivelyAfterDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return !isBeforeDay(a, b);
+}

package/src/utils/isInclusivelyBeforeDay.js

@@ -0,0 +1,8 @@
+import moment from 'moment';
+
+import isAfterDay from './isAfterDay';
+
+export default function isInclusivelyBeforeDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return !isAfterDay(a, b);
+}

package/src/utils/isNextDay.js

@@ -0,0 +1,9 @@
+import moment from 'moment';
+
+import isSameDay from './isSameDay';
+
+export default function isNextDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  const nextDay = moment(a).add(1, 'day');
+  return isSameDay(nextDay, b);
+}

package/src/utils/isNextMonth.js

@@ -0,0 +1,8 @@
+import moment from 'moment';
+
+import isSameMonth from './isSameMonth';
+
+export default function isNextMonth(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return isSameMonth(a.clone().add(1, 'month'), b);
+}

package/src/utils/isPrevMonth.js

@@ -0,0 +1,8 @@
+import moment from 'moment';
+
+import isSameMonth from './isSameMonth';
+
+export default function isPrevMonth(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  return isSameMonth(a.clone().subtract(1, 'month'), b);
+}

package/src/utils/isPreviousDay.js

@@ -0,0 +1,9 @@
+import moment from 'moment';
+
+import isSameDay from './isSameDay';
+
+export default function isPreviousDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  const dayBefore = moment(a).subtract(1, 'day');
+  return isSameDay(dayBefore, b);
+}

package/src/utils/isSameDay.js

@@ -0,0 +1,10 @@
+import moment from 'moment';
+
+export default function isSameDay(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  // Compare least significant, most likely to change units first
+  // Moment's isSame clones moment inputs and is a tad slow
+  return a.date() === b.date()
+    && a.month() === b.month()
+    && a.year() === b.year();
+}

package/src/utils/isSameMonth.js

@@ -0,0 +1,9 @@
+import moment from 'moment';
+
+export default function isSameMonth(a, b) {
+  if (!moment.isMoment(a) || !moment.isMoment(b)) return false;
+  // Compare least significant, most likely to change units first
+  // Moment's isSame clones moment inputs and is a tad slow
+  return a.month() === b.month()
+    && a.year() === b.year();
+}

package/src/utils/isTransitionEndSupported.js

@@ -0,0 +1,3 @@
+export default function isTransitionEndSupported() {
+  return !!(typeof window !== 'undefined' && 'TransitionEvent' in window);
+}

package/src/utils/modifiers.js

@@ -0,0 +1,116 @@
+import isDayVisible from './isDayVisible';
+import toISODateString from './toISODateString';
+import toISOMonthString from './toISOMonthString';
+import getPreviousMonthMemoLast from './getPreviousMonthMemoLast';
+
+import { VERTICAL_SCROLLABLE } from '../constants';
+
+export function addModifier(updatedDays, day, modifier, props, state) {
+  const { numberOfMonths: numberOfVisibleMonths, enableOutsideDays, orientation } = props;
+  const { currentMonth: firstVisibleMonth, visibleDays } = state;
+
+  let currentMonth = firstVisibleMonth;
+  let numberOfMonths = numberOfVisibleMonths;
+  if (orientation === VERTICAL_SCROLLABLE) {
+    numberOfMonths = Object.keys(visibleDays).length;
+  } else {
+    currentMonth = getPreviousMonthMemoLast(currentMonth);
+    numberOfMonths += 2;
+  }
+  if (!day || !isDayVisible(day, currentMonth, numberOfMonths, enableOutsideDays)) {
+    return updatedDays;
+  }
+
+  const iso = toISODateString(day);
+
+  let updatedDaysAfterAddition = { ...updatedDays };
+  if (enableOutsideDays) {
+    const monthsToUpdate = Object.keys(visibleDays).filter((monthKey) => (
+      Object.keys(visibleDays[monthKey]).indexOf(iso) > -1
+    ));
+
+    updatedDaysAfterAddition = monthsToUpdate.reduce((acc, monthIso) => {
+      const month = updatedDays[monthIso] || visibleDays[monthIso];
+
+      if (!month[iso] || !month[iso].has(modifier)) {
+        const modifiers = new Set(month[iso]);
+        modifiers.add(modifier);
+        acc[monthIso] = {
+          ...month,
+          [iso]: modifiers,
+        };
+      }
+
+      return acc;
+    }, updatedDaysAfterAddition);
+  } else {
+    const monthIso = toISOMonthString(day);
+    const month = updatedDays[monthIso] || visibleDays[monthIso] || {};
+
+    if (!month[iso] || !month[iso].has(modifier)) {
+      const modifiers = new Set(month[iso]);
+      modifiers.add(modifier);
+      updatedDaysAfterAddition[monthIso] = {
+        ...month,
+        [iso]: modifiers,
+      };
+    }
+  }
+
+  return updatedDaysAfterAddition;
+}
+
+export function deleteModifier(updatedDays, day, modifier, props, state) {
+  const { numberOfMonths: numberOfVisibleMonths, enableOutsideDays, orientation } = props;
+  const { currentMonth: firstVisibleMonth, visibleDays } = state;
+
+  let currentMonth = firstVisibleMonth;
+  let numberOfMonths = numberOfVisibleMonths;
+  if (orientation === VERTICAL_SCROLLABLE) {
+    numberOfMonths = Object.keys(visibleDays).length;
+  } else {
+    currentMonth = getPreviousMonthMemoLast(currentMonth);
+    numberOfMonths += 2;
+  }
+  if (!day || !isDayVisible(day, currentMonth, numberOfMonths, enableOutsideDays)) {
+    return updatedDays;
+  }
+
+  const iso = toISODateString(day);
+
+  let updatedDaysAfterDeletion = { ...updatedDays };
+  if (enableOutsideDays) {
+    const monthsToUpdate = Object.keys(visibleDays).filter((monthKey) => (
+      Object.keys(visibleDays[monthKey]).indexOf(iso) > -1
+    ));
+
+    updatedDaysAfterDeletion = monthsToUpdate.reduce((acc, monthIso) => {
+      const month = updatedDays[monthIso] || visibleDays[monthIso];
+
+      if (month[iso] && month[iso].has(modifier)) {
+        const modifiers = new Set(month[iso]);
+        modifiers.delete(modifier);
+        acc[monthIso] = {
+          ...month,
+          [iso]: modifiers,
+        };
+      }
+
+      return acc;
+    }, updatedDaysAfterDeletion);
+  } else {
+    const monthIso = toISOMonthString(day);
+    const month = updatedDays[monthIso] || visibleDays[monthIso] || {};
+
+    if (month[iso] && month[iso].has(modifier)) {
+      const modifiers = new Set(month[iso]);
+      modifiers.delete(modifier);
+      updatedDaysAfterDeletion[monthIso] = {
+        ...month,
+        [iso]: modifiers,
+      };
+    }
+  }
+
+  return updatedDaysAfterDeletion;
+}

package/src/utils/noflip.js

@@ -0,0 +1,11 @@
+const NOFLIP = '/* @noflip */';
+
+// Appends a noflip comment to a style rule in order to prevent it from being automatically
+// flipped in RTL contexts. This should be used only in situations where the style must remain
+// unflipped regardless of direction context. See: https://github.com/kentcdodds/rtl-css-js#usage
+export default function noflip(value) {
+  if (typeof value === 'number') return `${value}px ${NOFLIP}`;
+  if (typeof value === 'string') return `${value} ${NOFLIP}`;
+
+  throw new TypeError('noflip expects a string or a number');
+}

package/src/utils/registerCSSInterfaceWithDefaultTheme.js

@@ -0,0 +1,7 @@
+import CSSInterface from 'react-with-styles-interface-css';
+
+import registerInterfaceWithDefaultTheme from './registerInterfaceWithDefaultTheme';
+
+export default function registerCSSInterfaceWithDefaultTheme() {
+  registerInterfaceWithDefaultTheme(CSSInterface);
+}

package/src/utils/registerInterfaceWithDefaultTheme.js

@@ -0,0 +1,7 @@
+import ThemedStyleSheet from 'react-with-styles/lib/ThemedStyleSheet';
+import DefaultTheme from '../theme/DefaultTheme';
+
+export default function registerInterfaceWithDefaultTheme(reactWithStylesInterface) {
+  ThemedStyleSheet.registerInterface(reactWithStylesInterface);
+  ThemedStyleSheet.registerTheme(DefaultTheme);
+}

package/src/utils/toISODateString.js

@@ -0,0 +1,14 @@
+import moment from 'moment';
+
+import toMomentObject from './toMomentObject';
+
+export default function toISODateString(date, currentFormat) {
+  const dateObj = moment.isMoment(date) ? date : toMomentObject(date, currentFormat);
+  if (!dateObj) return null;
+
+  // Template strings compiled in strict mode uses concat, which is slow. Since
+  // this code is in a hot path and we want it to be as fast as possible, we
+  // want to use old-fashioned +.
+  // eslint-disable-next-line prefer-template
+  return dateObj.year() + '-' + String(dateObj.month() + 1).padStart(2, '0') + '-' + String(dateObj.date()).padStart(2, '0');
+}

package/src/utils/toISOMonthString.js

@@ -0,0 +1,14 @@
+import moment from 'moment';
+
+import toMomentObject from './toMomentObject';
+
+export default function toISOMonthString(date, currentFormat) {
+  const dateObj = moment.isMoment(date) ? date : toMomentObject(date, currentFormat);
+  if (!dateObj) return null;
+
+  // Template strings compiled in strict mode uses concat, which is slow. Since
+  // this code is in a hot path and we want it to be as fast as possible, we
+  // want to use old-fashioned +.
+  // eslint-disable-next-line prefer-template
+  return dateObj.year() + '-' + String(dateObj.month() + 1).padStart(2, '0');
+}

package/src/utils/toLocalizedDateString.js

@@ -0,0 +1,12 @@
+import moment from 'moment';
+
+import toMomentObject from './toMomentObject';
+
+import { DISPLAY_FORMAT } from '../constants';
+
+export default function toLocalizedDateString(date, currentFormat) {
+  const dateObj = moment.isMoment(date) ? date : toMomentObject(date, currentFormat);
+  if (!dateObj) return null;
+
+  return dateObj.format(DISPLAY_FORMAT);
+}

package/src/utils/toMomentObject.js

@@ -0,0 +1,12 @@
+import moment from 'moment';
+
+import { DISPLAY_FORMAT, ISO_FORMAT } from '../constants';
+
+export default function toMomentObject(dateString, customFormat) {
+  const dateFormats = customFormat
+    ? [customFormat, DISPLAY_FORMAT, ISO_FORMAT]
+    : [DISPLAY_FORMAT, ISO_FORMAT];
+
+  const date = moment(dateString, dateFormats, true);
+  return date.isValid() ? date.hour(12) : null;
+}