@loadsmart/loadsmart-ui 7.6.0 → 7.7.0-beta.1

package/src/components/Calendar/Date.helper.ts

@@ -1,461 +0,0 @@
-import { isFunction } from '@loadsmart/utils-function'
-import isEmpty from 'utils/toolset/isEmpty'
-
-export type DateHelperOptions = {
-  normalize?: boolean
-}
-
-export const DEFAULT_OPTIONS: DateHelperOptions = {
-  normalize: true,
-}
-
-export type InputDate = string | number | Date
-
-type Unit = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'
-type Operator = '>=' | '>' | '=' | '<' | '<='
-
-export type DateConstraint =
-  | InputDate
-  | [InputDate, InputDate]
-  | [null, InputDate]
-  | [InputDate, null]
-
-export type FunctionConstraint = (day: CalendarDate) => boolean
-
-export type CalendarConstraint = DateConstraint | FunctionConstraint
-
-export interface CalendarDate {
-  /**
-   * Get `Date` object representing this date.
-   * @returns {Date}
-   */
-  get(): Date
-  /**
-   * Get the year using Universal Coordinated Time (UTC).
-   * @returns {number}
-   */
-  getYear(): number
-  /**
-   * Gets the month using Universal Coordinated Time (UTC).
-   * @returns {number}
-   */
-  getMonth(): number
-  /**
-   * Get the day-of-the-month, using Universal Coordinated Time (UTC).
-   * @returns {number}
-   */
-  getDate(): number
-  /**
-   * Get the time value in milliseconds.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getTime(): number
-  /**
-   * Get the day of the week.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getWeekday(): number
-  /**
-   * Get the hours value.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getHours(): number
-  /**
-   * Get the minutes value.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getMinutes(): number
-  /**
-   * Get the seconds value.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getSeconds(): number
-  /**
-   * Get the milliseconds value.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @returns {number}
-   */
-  getMilliseconds(): number
-  /**
-   * Check if the current date matches **at least one** of the provided constraints.
-   *
-   * [!] Be aware that all dates in this comparison will be normalized to 12:00:00 (UTC).
-   *
-   * @param {...CalendarConstraint[]} constraintsArg
-   * @returns {boolean}
-   */
-  matches(...constraints: CalendarConstraint[]): boolean
-  /**
-   * Set the given `value` to the `unit` property of this instance.
-   * This function mutates the internal date instance.
-   * @param {Unit} unit
-   * @param {number} value
-   * @returns {CalendarDate}
-   */
-  set(unit: Unit, value: number): CalendarDate
-  /**
-   * Return a copy of this instance, adding the given `value` to the `unit` property.
-   * @param {Unit} unit
-   * @param {number} value
-   * @returns {CalendarDate}
-   */
-  add(unit: Unit, value: number): CalendarDate
-  /**
-   * Return a copy of this instance, subtracting the given `value` from the `unit` property.
-   * @param {Unit} unit
-   * @param {number} value
-   * @returns {CalendarDate}
-   */
-  subtract(unit: Unit, value: number): CalendarDate
-  /**
-   * Compare this date with the given `other`.
-   *
-   * [!] Be aware that it might be normalized to 12:00:00 (UTC), if you did not call the helper with
-   * `options.normalize: false`.
-   *
-   * @param {Operator} operator - type of comparison to be performed.
-   * @param {CalendarDate} other - Other `CalendarDate` to compare with.
-   * @param {Unit} [precision] - notice that the precision increases with the evaluated period, so year < month < day < hour < minute < second < millisecond. Default is 'day'.
-   * @return {boolean} comparison result
-   */
-  is(operator: Operator, other: CalendarDate, precision?: string): boolean
-  /**
-   * Return this date as a string value in ISO format.
-   * @returns {string}
-   */
-  toString(): string
-}
-
-export type CalendarDateRange = [CalendarDate | null, CalendarDate | null]
-
-/**
- * Ideally, follow the date/time string formats:
- * * `YYYY-MM-DD`
- * * `YYYY-MM-DDTHH:mm:ss.sssZ`
- * * `YYYY-MM-DDTHH:mm:ss.sss+00:00`
- *
- * `dateArg` is expected to have timezone information or to be UTC.
- *
- * By default, we normalize the input date to 12:00:00 (UTC); this simplifies comparison of dates; be mindful
- * of this when using this helper for time relate logic.
- * You can disable this behavior by passing `options.normalize: false`.
- *
- * @param {InputDate} [dateArg]
- * @return {CalendarDate}
- */
-function DateHelper(dateArg?: InputDate, optionsArg = DEFAULT_OPTIONS): CalendarDate {
-  const options = { ...DEFAULT_OPTIONS, ...optionsArg }
-  const utcDate = (function normalizeToUTC() {
-    let date = new Date()
-
-    if (dateArg != null) {
-      date = new Date(dateArg)
-    }
-
-    // create a date with local timezone based on the UTC input date
-    const utcDate = new Date(
-      Date.UTC(
-        date.getUTCFullYear(),
-        date.getUTCMonth(),
-        date.getUTCDate(),
-        options.normalize ? 12 : date.getUTCHours(),
-        options.normalize ? 0 : date.getUTCMinutes(),
-        options.normalize ? 0 : date.getUTCSeconds(),
-        options.normalize ? 0 : date.getUTCMilliseconds()
-      )
-    )
-
-    return utcDate
-  })()
-
-  return {
-    get() {
-      return utcDate
-    },
-    getYear() {
-      return utcDate.getUTCFullYear()
-    },
-    getMonth() {
-      return utcDate.getUTCMonth()
-    },
-    getDate() {
-      return utcDate.getUTCDate()
-    },
-    getTime() {
-      return utcDate.getTime()
-    },
-    getWeekday() {
-      return utcDate.getUTCDay()
-    },
-    getHours() {
-      return utcDate.getUTCHours()
-    },
-    getMinutes() {
-      return utcDate.getUTCMinutes()
-    },
-    getSeconds() {
-      return utcDate.getUTCSeconds()
-    },
-    getMilliseconds() {
-      return utcDate.getUTCMilliseconds()
-    },
-    matches(...constraints: CalendarConstraint[]): boolean {
-      if (isEmpty(constraints)) {
-        return false
-      }
-
-      const constraintEvaluators = constraints.map(getConstraintEvaluator)
-      const date = DateHelper(utcDate)
-
-      return constraintEvaluators.some((evaluator) => {
-        return evaluator(date)
-      })
-    },
-    add(unit: Unit, value: number) {
-      return add(utcDate, unit, value)
-    },
-    subtract(unit: Unit, value: number) {
-      return add(utcDate, unit, -1 * value)
-    },
-    set(unit: Unit, value: number) {
-      const newValue = {
-        year: utcDate.getUTCFullYear(),
-        month: utcDate.getUTCMonth(),
-        day: utcDate.getUTCDate(),
-        hour: utcDate.getUTCHours(),
-        minute: utcDate.getUTCMinutes(),
-        second: utcDate.getUTCSeconds(),
-        millisecond: utcDate.getUTCMilliseconds(),
-        [unit]: value,
-      }
-
-      utcDate.setUTCFullYear(newValue.year)
-      utcDate.setUTCMonth(newValue.month)
-      utcDate.setUTCDate(newValue.day)
-      utcDate.setUTCHours(newValue.hour)
-      utcDate.setUTCMinutes(newValue.minute)
-      utcDate.setUTCSeconds(newValue.second)
-      utcDate.setUTCMilliseconds(newValue.millisecond)
-
-      return this
-    },
-    is(operator: Operator, other: CalendarDate, precision?: Unit): boolean {
-      function compare(a: number, b: number) {
-        let result
-
-        switch (operator) {
-          case '>=':
-            result = a >= b
-            break
-          case '>':
-            result = a > b
-            break
-          case '<':
-            result = a < b
-            break
-          case '<=':
-            result = a <= b
-            break
-          default:
-            result = a === b
-            break
-        }
-
-        return result
-      }
-
-      return compare(
-        getComparableDate(utcDate, precision),
-        getComparableDate(other.get(), precision)
-      )
-    },
-    toString(): string {
-      return utcDate.toISOString()
-    },
-  }
-}
-
-/**
- * This method takes a date and a unit of precision and then normalizes the given date based on that precision.
- * The return will be the timestamp of the normalized date
- *
- * @example
- * ```js
- * getComparableDate(new Date('2022-10-13T17:42:19.948Z'), 'hour')) // returns 1665680400000
- *
- * // '2022-10-13T17:42:19.948Z' will be normalized to '2022-10-13T17:00:00.000Z'
- * // 1665680400000 is equal to: new Date('2022-10-13T17:00:00.000Z').getTime()
- * ```
- *
- * @param {Date} date
- * @param {Unit} precision
- * @returns {number}
- */
-export function getComparableDate(date: Date, precision: Unit = 'day'): number {
-  const DATE_ZERO = MIN_SUPPORTED_DATE.toString()
-  const COMPARE_TO = {
-    year: 4,
-    month: 7,
-    day: 10,
-    hour: 13,
-    minute: 16,
-    second: 19,
-    millisecond: 24,
-  }
-  const sliceIndex = COMPARE_TO[precision]
-
-  if (sliceIndex == null) {
-    throw new Error(`precision ${precision} is not supported`)
-  }
-
-  const normalizedPart = DATE_ZERO.slice(sliceIndex)
-  const datePart = date.toISOString().slice(0, sliceIndex)
-  const normalizedDate = `${datePart}${normalizedPart}`
-
-  return new Date(normalizedDate).getTime()
-}
-
-/**
- * Constraints represent ranges of dates, inclusive in both ends.
- * Returns an array representing the initial and final timestamps (after the transformations applied by `DateHelper`).
- *
- * @example
- * ```js
- * // to represent a range that starts and ends in the same date
- * getConstraintRange(1643371200000) // returns [1643371200000, 1643371200000]
- * getConstraintRange([1643371200000, 1643371200000]) // returns [1643371200000, 1643371200000]
- * getConstraintRange('2022-01-28T12:00:00.000Z') // returns [1643371200000, 1643371200000]
- * getConstraintRange(['2022-01-28T12:00:00.000Z', '2022-01-28T12:00:00.000Z']) // returns [1643371200000, 1643371200000]
- *
- * // to represent a range that starts at one date and ends at another
- * getConstraintRange([1641038400000, 1643371200000]) // returns [1641038400000, 1643371200000]
- * getConstraintRange(['2022-01-01T12:00:00.000Z', '2022-01-28T12:00:00.000Z']) // returns [1641038400000, 1643371200000]
- *
- * // to represent a range that starts at one date and has no end
- * getConstraintRange([1641038400000, null]) // returns [1641038400000, `MAX_SUPPORTED_DATE`]
- * getConstraintRange(['2022-01-01T12:00:00.000Z', null]) // returns [1641038400000, `MAX_SUPPORTED_DATE`]
- *
- * // to represent a range that ends at one date and has no start
- * getConstraintRange([null, 1643371200000]) // returns [0, 1643371200000]
- * getConstraintRange([null, '2022-01-28T12:00:00.000Z']) // returns [0, 1643371200000]
- * ```
- * @param rangeArg
- * @returns
- */
-export function getConstraintRange(rangeArg: DateConstraint): [number, number] {
-  let range: [number, number]
-
-  if (!Array.isArray(rangeArg)) {
-    const timestamp = DateHelper(rangeArg).getTime()
-    range = [timestamp, timestamp]
-  } else {
-    const rangeStart = rangeArg[0] != null ? DateHelper(rangeArg[0]) : MIN_SUPPORTED_DATE
-    const rangeEnd = rangeArg[1] != null ? DateHelper(rangeArg[1]) : MAX_SUPPORTED_DATE
-
-    range = [rangeStart.getTime(), rangeEnd.getTime()]
-  }
-
-  return range
-}
-
-/**
- * Add the given `value` to the provided `unit` of the provided `date`.
- * @param {Date} date - Date where the operation should be performed.
- * @param {Unit} unit - period
- * @param {number} value - value to be added
- * @returns {Date} new date after the operation.
- */
-function add(date: Date, unit: Unit, value: number): CalendarDate {
-  const increment = {
-    year: 0,
-    month: 0,
-    day: 0,
-    hour: 0,
-    minute: 0,
-    second: 0,
-    millisecond: 0,
-    [unit]: value,
-  }
-
-  const newDate = new Date(
-    Date.UTC(
-      date.getUTCFullYear() + increment.year,
-      date.getUTCMonth() + increment.month,
-      date.getUTCDate() + increment.day,
-      date.getUTCHours() + increment.hour,
-      date.getUTCMinutes() + increment.minute,
-      date.getUTCSeconds() + increment.second,
-      date.getUTCMilliseconds() + increment.millisecond
-    )
-  )
-
-  // Do not normalize the clone since all units must be preserved.
-  return DateHelper(newDate, { normalize: false })
-}
-
-/**
- * Wrap range constraint into a function and return a function constraint untouched.
- * @param {CalendarConstraint} constraint
- * @returns {(day: CalendarDate) => boolean}
- */
-export function getConstraintEvaluator(
-  constraint: CalendarConstraint
-): (day: CalendarDate) => boolean {
-  if (isFunction(constraint)) {
-    return constraint
-  }
-
-  const [start, end] = getConstraintRange(constraint)
-
-  return function matches(day: CalendarDate): boolean {
-    if (start > end) {
-      throw new InvalidDateConstraintError([start, end])
-    }
-
-    return start <= day.getTime() && day.getTime() <= end
-  }
-}
-
-export function padded(value: number | string, maxLength = 2): string {
-  return String(value).padStart(maxLength, '0')
-}
-
-export class InvalidDateConstraintError extends Error {
-  constructor([start, end]: [number, number]) {
-    super(`Invalid constraint: [${start}, ${end}]`)
-  }
-}
-
-export const TODAY = DateHelper()
-
-/**
- * Maximum and minimum supported `Date`.
- * Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#the_ecmascript_epoch_and_timestamps
- */
-export const MIN_SUPPORTED_DATE = DateHelper(0, { normalize: false })
-export const MAX_SUPPORTED_DATE = DateHelper(8.64e15 - 1)
-
-export default DateHelper

package/src/components/Calendar/DateFormat.helper.test.ts

@@ -1,171 +0,0 @@
-import DateFormatHelper, { tokenizer } from './DateFormat.helper'
-import DateHelper from './Date.helper'
-
-describe('DateFormatHelper', () => {
-  describe('tokenizer', () => {
-    it('gets fundamental tokens', () => {
-      expect(tokenizer('MM')).toEqual(['MM'])
-      expect(tokenizer('MMM')).toEqual(['MMM'])
-      expect(tokenizer('MMMM')).toEqual(['MMMM'])
-
-      expect(tokenizer('DD')).toEqual(['DD'])
-
-      expect(tokenizer('ddd')).toEqual(['ddd'])
-      expect(tokenizer('dddd')).toEqual(['dddd'])
-
-      expect(tokenizer('YYYY')).toEqual(['YYYY'])
-
-      expect(tokenizer('HH')).toEqual(['HH'])
-
-      expect(tokenizer('mm')).toEqual(['mm'])
-
-      expect(tokenizer('ss')).toEqual(['ss'])
-    })
-
-    it('gets fundamental tokens compositions', () => {
-      expect(tokenizer('YYYY-MM')).toEqual(['YYYY', '-', 'MM'])
-      expect(tokenizer('YYYY-MM-DD')).toEqual(['YYYY', '-', 'MM', '-', 'DD'])
-      expect(tokenizer('MM/DD/YYYY')).toEqual(['MM', '/', 'DD', '/', 'YYYY'])
-      expect(tokenizer('YYYYMMDD')).toEqual(['YYYY', 'MM', 'DD'])
-      expect(tokenizer('YYYY MM DD')).toEqual(['YYYY', ' ', 'MM', ' ', 'DD'])
-      expect(tokenizer('HH:mm:ss')).toEqual(['HH', ':', 'mm', ':', 'ss'])
-    })
-
-    it('gets fundamental tokens and escaping compositions', () => {
-      expect(tokenizer('[T]')).toEqual(['T'])
-      expect(tokenizer('[Today is] MM/DD/YYYY')).toEqual([
-        'Today is ',
-        'MM',
-        '/',
-        'DD',
-        '/',
-        'YYYY',
-      ])
-
-      expect(tokenizer('dddd, DD [de] MMMM, YYYY')).toEqual([
-        'dddd',
-        ', ',
-        'DD',
-        ' de ',
-        'MMMM',
-        ', ',
-        'YYYY',
-      ])
-
-      expect(tokenizer('MM/DD/YYYY HH:mm:ss')).toEqual([
-        'MM',
-        '/',
-        'DD',
-        '/',
-        'YYYY',
-        ' ',
-        'HH',
-        ':',
-        'mm',
-        ':',
-        'ss',
-      ])
-    })
-  })
-
-  describe('formatting', () => {
-    it('formats pure-token format correctly', () => {
-      expect(DateFormatHelper('YYYY-MM').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '2022-02'
-      )
-
-      expect(DateFormatHelper('YYYY-MMM').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '2022-Feb'
-      )
-
-      expect(DateFormatHelper('YYYY-MM-DD').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '2022-02-01'
-      )
-
-      expect(DateFormatHelper('MM/DD/YYYY').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '02/01/2022'
-      )
-
-      expect(DateFormatHelper('YYYYMMDD').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '20220201'
-      )
-
-      expect(DateFormatHelper('YYYY MM DD').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe(
-        '2022 02 01'
-      )
-    })
-
-    it('formats token and escaping compositions correctly', () => {
-      expect(DateFormatHelper('[T]').format(DateHelper('2022-02-01T12:00:00.000Z'))).toBe('T')
-
-      expect(
-        DateFormatHelper('[Today is] MM/DD/YYYY').format(DateHelper('2022-02-01T12:00:00.000Z'))
-      ).toBe('Today is 02/01/2022')
-
-      expect(
-        DateFormatHelper('dddd, DD [de] MMMM, YYYY').format(DateHelper('2022-02-01T12:00:00.000Z'))
-      ).toBe('Tuesday, 01 de February, 2022')
-
-      expect(
-        DateFormatHelper('ddd, MM/DD/YYYY').format(DateHelper('2022-02-01T12:00:00.000Z'))
-      ).toBe('Tue, 02/01/2022')
-
-      expect(
-        DateFormatHelper('MM/DD/YYYY HH:mm:ss').format(DateHelper('2022-02-01T12:00:00.000Z'))
-      ).toBe('02/01/2022 12:00:00')
-
-      expect(
-        DateFormatHelper('MM/DD/YYYY HH:mm:ss').format(
-          DateHelper('2022-02-01T00:00:00.000Z', { normalize: false })
-        )
-      ).toBe('02/01/2022 00:00:00')
-
-      expect(
-        DateFormatHelper('MM/DD/YYYY, hh:mm A').format(
-          DateHelper('2022-02-01T10:30:00.000Z', { normalize: false })
-        )
-      ).toBe('02/01/2022, 10:30 AM')
-
-      expect(
-        DateFormatHelper('MM/DD/YYYY, hh:mm a').format(
-          DateHelper('2022-02-01T14:30:00.000Z', { normalize: false })
-        )
-      ).toBe('02/01/2022, 02:30 pm')
-
-      expect(
-        DateFormatHelper('MM/DD/YYYY HH:mm:ss').format(
-          DateHelper('2022-02-01T11:22:33.000Z', {
-            normalize: false,
-          })
-        )
-      ).toBe('02/01/2022 11:22:33')
-    })
-
-    it('formats compound tokens', () => {
-      expect(
-        DateFormatHelper('ddd, Do, MMM').format(
-          DateHelper('2021-05-04T04:00:00Z', {
-            normalize: false,
-          })
-        )
-      ).toBe('Tue, 4th, May')
-      expect(
-        DateFormatHelper('ddd, DDo, MMM').format(
-          DateHelper('2021-05-05T04:00:00Z', {
-            normalize: false,
-          })
-        )
-      ).toBe('Wed, 05th, May')
-    })
-
-    it('does not formats a compound token when the previous token is invalid', () => {
-      expect(
-        DateFormatHelper('ddd, YYYYo, MMM').format(
-          DateHelper('2021-05-10T04:00:00Z', {
-            normalize: false,
-          })
-        )
-      ).toBe('Mon, 2021o, May')
-    })
-  })
-})