@qrvey/utils 1.1.8 → 1.2.1

package/src/dates/constants/index.ts

@@ -0,0 +1,40 @@
+export * from './DATE_DAY_HOURS';
+
+export * from './DATE_DISTINCT_ALL_PROPERTIES';
+export * from './DATE_DISTINCT_PROPERTIES';
+export * from './DATE_DISTINCT_PROPERTY_INFO_LIST';
+export * from './DATE_DISTINCT_PROPERTY_INFO';
+export * from './DATE_DISTINCT_PROPERTY_LABEL';
+export * from './DATE_DISTINCT_PROPERTY_VALUES';
+export * from './DATE_DISTINCT_PROPERTY';
+
+export * from './DATE_DISTINCT_TIME_PROPERTIES';
+export * from './DATE_DISTINCT_TIME_PROPERTY_INFO_LIST';
+export * from './DATE_DISTINCT_TIME_PROPERTY_INFO';
+export * from './DATE_DISTINCT_TIME_PROPERTY_LABEL';
+export * from './DATE_DISTINCT_TIME_PROPERTY';
+
+export * from './DATE_FORMAT';
+
+export * from './DATE_GROUPING_PROPERTIES';
+export * from './DATE_GROUPING_PROPERTY_INFO_LIST';
+export * from './DATE_GROUPING_PROPERTY_INFO';
+export * from './DATE_GROUPING_PROPERTY_LABEL';
+export * from './DATE_GROUPING_PROPERTY';
+
+export * from './DATE_GROUPING_TIME_PROPERTIES';
+export * from './DATE_GROUPING_TIME_PROPERTY_INFO_LIST';
+export * from './DATE_GROUPING_TIME_PROPERTY_INFO';
+export * from './DATE_GROUPING_TIME_PROPERTY_LABEL';
+export * from './DATE_GROUPING_TIME_PROPERTY';
+
+export * from './DATE_HOUR_MINUTES';
+export * from './DATE_MINUTE_SECONDS';
+export * from './DATE_MONTH_DAYS';
+
+export * from './DATE_REGULAR_EXPRESSION';
+
+export * from './DATE_WEEK_DAYS';
+export * from './DATE_YEAR_DAYS';
+export * from './DATE_YEAR_MONTHS';
+export * from './DATE_YEAR_QUARTERS';

package/src/dates/index.ts

@@ -0,0 +1,4 @@
+export * from './constants/index';
+export * from './interfaces/index';
+export * from './range/index';
+export * from './relative/index';

package/src/dates/interfaces/IDateFormat.ts

@@ -0,0 +1,3 @@
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+
+export type IDateFormat = typeof DATE_FORMAT[keyof typeof DATE_FORMAT];

package/src/dates/interfaces/IDateGroupingProperty.ts

@@ -0,0 +1,5 @@
+import { DATE_GROUPING_PROPERTY } from "../constants/DATE_GROUPING_PROPERTY";
+import { DATE_GROUPING_TIME_PROPERTY } from "../constants/DATE_GROUPING_TIME_PROPERTY";
+
+// export type IDateGroupingProperty = typeof DATE_GROUPING_PROPERTY[keyof typeof DATE_GROUPING_PROPERTY] | typeof DATE_GROUPING_TIME_PROPERTY[keyof typeof DATE_GROUPING_TIME_PROPERTY];
+export type IDateGroupingProperty = DATE_GROUPING_PROPERTY | DATE_GROUPING_TIME_PROPERTY;

package/src/dates/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './IDateFormat';
+export * from './IDateGroupingProperty';

package/src/dates/range/getDateRange.ts

@@ -0,0 +1,218 @@
+import { capitalize } from "../../general/string/capitalize";
+import { isTokenLabel } from "../../tokens/isTokenLabel";
+
+/**
+ * Get date range object from a string date value
+ * 
+ * @param {String} value string date value
+ * @param {String} dateGroupLabel could be 'YEAR', 'QUARTER', 'MONTH' or 'DAY'. Deafult is 'DAY'
+ * @param {Boolean} withTime determines if the date range will include time. Default is true
+ * 
+ * @returns {Object} an object with the date range with two string date properties: from and to
+ * 
+ * @example
+ * // 1) Year:
+ * getDateRange('2020', 'YEAR');
+ * // Will return:
+ * {
+ *    from: '01/01/2020 00:00:00',
+ *    to: '12/31/2020 23:59:59'
+ * }
+ * 
+ * // 2) Quarter:
+ * getDateRange('Q3 2020', 'QUARTER');
+ * // Will return:
+ * {
+ *    from: '07/01/2020 00:00:00',
+ *    to: '09/30/2020 23:59:59'
+ * }
+ * 
+ * // 3) Month:
+ * getDateRange('Oct 2020', 'MONTH');
+ * // Will return:
+ * {
+ *    from: '10/01/2020 00:00:00',
+ *    to: '10/31/2020 23:59:59'
+ * }
+ */
+export function getDateRange(value: string, dateGroupLabel = 'DAY', withTime = true): { from?: string; to?: string } {
+  const range: { from?: string, to?: string } = {};
+  const upperCaseDateGroup = dateGroupLabel.toUpperCase();
+  const [ timeFrom, timeTo ] = withTime ? getStringTimeRange(value, upperCaseDateGroup) : [ '', '' ];
+  const isToken = isTokenLabel(value);
+
+
+  switch (upperCaseDateGroup) {
+    case 'YEAR': {
+      const yearRange = !isToken ? getYearRange(value) : { from: `01/01/${value}`, to: `12/31/${value}` };
+      range.from = `${yearRange.from}${timeFrom}`;
+      range.to = `${yearRange.to}${timeTo}`; 
+      break;
+    }
+    case 'QUARTER': {
+      const quarterRange = !isToken ? getQuarterRange(value) : { from: value, to: value };
+      range.from = `${quarterRange.from}${timeFrom}`;
+      range.to = `${quarterRange.to}${timeTo}`;
+      break;
+    }
+    case 'MONTH': {
+      const monthRange = monthInclideTokens(value) ? getMonthRangeWithToken(value) : getMonthRange(value);
+      range.from = `${monthRange.from}${timeFrom}`;
+      range.to = `${monthRange.to}${timeTo}`;
+      break;
+    }
+    case 'WEEK': {
+      const weekRange = !isToken ?  getWeekRange(value) : { from: value, to: value };
+      range.from = `${weekRange.from}${timeFrom}`;
+      range.to = `${weekRange.to}${timeTo}`;
+      break;
+    }
+    case 'HOUR': {
+      const hourRange = !isToken ? getHourRange(value) : { from: value, to: value };
+      range.from = hourRange.from;
+      range.to = hourRange.to;
+      break;
+    }
+    case 'MINUTE': {
+      const minuteRange = !isToken ? getMinuteRange(value) : { from: value, to: value };
+      range.from = minuteRange.from;
+      range.to = minuteRange.to;
+      break;
+    }
+    default: {
+      const dayFrom = new Date(value);
+      const dayTo = new Date(value);
+      const includTokens  = includeTokens(value, '/');
+      range.from = `${ !includTokens ? getStringDate(dayFrom) : value }${timeFrom}`;
+      range.to = `${ !includTokens  ? getStringDate(dayTo) : value }${timeTo}`;
+      break;
+    }
+  }
+  return range;
+}
+
+function getStringTimeRange(value: string, dateGroupLabel: string) {
+  const addLeadingZero = (unit: number): string => `${unit < 10 ? '0': ''}${unit}`;
+  const dateValue = new Date(value);
+  const hours = addLeadingZero(dateValue.getHours());
+  const minutes = addLeadingZero(dateValue.getMinutes());
+
+  switch (dateGroupLabel) {
+    case 'HOUR':
+      return [` ${hours}:00:00`, ` ${hours}:59:59`];
+    case 'MINUTE':
+      return [` ${hours}:${minutes}:00`, ` ${hours}:${minutes}:59`];
+    default:
+      return [' 00:00:00', ' 23:59:59'];
+  }
+}
+
+function getStringDate(dt: Date) {
+  if (dt.getTime() !== dt.getTime()) return '01/01/0000';
+  return `${('0' + (dt.getMonth() + 1)).slice(-2)}/${('0' + dt.getDate()).slice(-2)}/${dt.getFullYear()}`;
+}
+
+function getYearRange(value: string) {
+  const dateFrom = new Date(Number(value), 0, 1);
+  const dateTo = new Date(Number(value), 11, 31);
+  return {
+    from: getStringDate(dateFrom),
+    to: getStringDate(dateTo)
+  };
+}
+
+function getQuarterRange(value: string) {
+  const [quarter, year] = value.toUpperCase().split(' ');
+  const quarterStartMonths = [0, 3, 6, 9];
+  const quarterIndex = Number(capitalize(quarter).replace('Q', '')) - 1;
+  const monthValue = quarterStartMonths[quarterIndex];
+  const dateFrom = new Date(Number(year), monthValue || monthValue === 0 ? monthValue : NaN, 1);
+  const dateTo = new Date(Number(year), (monthValue || monthValue === 0 ? monthValue : NaN) + 3, 0);
+  return {
+    from: getStringDate(dateFrom),
+    to: getStringDate(dateTo)
+  };
+}
+
+function getMonthRange(value: string) {
+  const [month, year] = value.split(' ');
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  let monthIndex = months.indexOf(capitalize(month));
+  if (monthIndex === -1) monthIndex = NaN;
+  const dateFrom = new Date(Number(year), monthIndex, 1);
+  const dateTo = new Date(Number(year), monthIndex + 1, 0);
+  return {
+    from: getStringDate(dateFrom),
+    to: getStringDate(dateTo)
+  };
+}
+
+function getWeekRange(value: string) {
+  const [week, year] = value.split(' ');
+  const weekNo = Number(capitalize(week).replace('W', '')) - 1;
+
+  const d1 = year ? new Date(Number(year), 1, 1) : new Date();
+  const numOfdaysPastSinceLastSunday = d1.getDay();
+  d1.setDate(d1.getDate() - numOfdaysPastSinceLastSunday);
+  const weekNoToday = getWeek(d1);
+  const weeksInTheFuture = weekNo - weekNoToday;
+  d1.setDate(d1.getDate() + (7 * weeksInTheFuture));
+  const from = new Date((d1.getMonth() + 1) + '/' + d1.getDate() + '/' + d1.getFullYear());
+  d1.setDate(d1.getDate() + 6);
+  const to = new Date((d1.getMonth() + 1) + '/' + d1.getDate() + '/' + d1.getFullYear());
+  return { from: getStringDate(from), to: getStringDate(to) };
+}
+
+function getWeek(date) {
+  const target = new Date(date.valueOf());
+  const dayNr = (date.getDay() + 6) % 7;
+  target.setDate(target.getDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setMonth(0, 1);
+  if (target.getDay() !== 4) {
+    target.setMonth(0, 1 + ((4 - target.getDay()) + 7) % 7);
+  }
+  return 1 + Math.ceil((firstThursday - +target) / 604800000);
+}
+
+function getHourRange(date) {
+  const target = new Date(date.valueOf());
+  const stringDate = getStringDate(target);
+  const [ timeFrom, timeTo ] = getStringTimeRange(date, 'HOUR');
+  return { from: `${stringDate}${timeFrom}`, to: `${stringDate}${timeTo}` };
+}
+
+function getMinuteRange(date) {
+  const target = new Date(date.valueOf());
+  const stringDate = getStringDate(target);
+  const [ timeFrom, timeTo ] = getStringTimeRange(date, 'MINUTE');
+  return { from: `${stringDate}${timeFrom}`, to: `${stringDate}${timeTo}` };
+}
+
+function getMonthRangeWithToken(value: string) {
+  const [month, year] = value.split(' ');
+  let monthToReturn = month;
+
+  if(!isTokenLabel(month)) {
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const monthIndex = months.indexOf(monthToReturn) + 1;
+    monthToReturn = `${monthIndex <= 9 ? '0': ''}${monthIndex}`;
+  }
+
+  return {
+      from: `${monthToReturn}/01/${year}`,
+      to: `${monthToReturn}/{{LAST_DAY_MONTH}}/${year}`
+  };
+}
+
+function monthInclideTokens(value:string) {
+  const [month, year] = value.split(' ');
+  return isTokenLabel(month) || isTokenLabel(year);
+}
+
+function includeTokens(date: string, separator: string) {
+  const dateSeparet = date.split(separator);
+  for (const iterator of dateSeparet) {
+      if (isTokenLabel(iterator)) return true;
+  }
+}

package/src/dates/relative/Adapter.ts

@@ -0,0 +1,250 @@
+import { OpUnitType } from "dayjs";
+import { AbsoluteStatement } from "./interfaces/AbsoluteStatement";
+import { _get } from "../../general/object/get";
+import { RELATIVE_CURSOR } from "./constants/RELATIVE_CURSOR";
+import { formatStatement } from "./helpers/formatStatement";
+import { RelativeInput } from "./interfaces/RelativeInput";
+import { COMMON_CONSTANTS } from "./constants/COMMON";
+import { getStatementCase } from "./helpers/getStatementCase";
+import { DATE_GROUPING_PROPERTY } from "../constants/DATE_GROUPING_PROPERTY";
+import { parseDate } from "./helpers/parseDate";
+import { DATETIME_FORMAT } from "./constants/DATE_FORMATS";
+import { RelativeToAbsoluteStruct } from "./interfaces/RelativeToAbsoluteStruct";
+
+
+export default class RelativeStatementAdapter {
+  statement: RelativeInput;
+  now: Date;
+
+  constructor(statement: RelativeInput, now = new Date()) {
+    this.statement = typeof statement === 'string' ? statement : formatStatement(statement);
+    this.now = now;
+  }
+
+  get cursor() {
+    return this.get('cursor');
+  }
+
+  get unit() {
+    return this.get('unit');
+  }
+
+  get anchor() {
+    return this.get('anchor');
+  }
+
+  get number() {
+    return this.get('number');
+  }
+
+  get includeCurrent() {
+    return this.get('includeCurrent');
+  }
+
+  get isCalendarDate() {
+    return this.get('isCalendarDate');
+  }
+
+  get(prop: string) {
+    if (typeof this.statement === 'string')
+      return null;
+    return this.statement[prop];
+  }
+
+  /**
+   * Resolves statement and returns statement value
+   * @returns {AbsoluteRange|string}
+   */
+  value() {
+    return typeof this.statement === 'string' ?
+      RelativeStatementAdapter.replaceNowToken(this.statement, this.now):
+      this._statementToRange();
+  }
+
+
+  /**
+   * Resolves statement as an anchor
+   * @returns {string}
+   */
+  valueAsAnchor(): string {
+    if (typeof this.statement === 'string')
+      return RelativeStatementAdapter.replaceNowToken(this.statement, this.now);
+
+    const value = this._statementToRange();
+    const path = this.cursor === RELATIVE_CURSOR.LAST ? 'gte'
+      : this.cursor === RELATIVE_CURSOR.NEXT ? 'lte'
+      : '';
+
+    return _get(value, path, new Date());
+  }
+
+
+  /**
+   * Convert verbal statement to range value
+   * @private
+   * @returns {AbsoluteRange}
+   */
+  private _statementToRange(): AbsoluteStatement {
+    switch (this.cursor) {
+      case RELATIVE_CURSOR.LAST:
+        return this._resolveAsTheLast();
+      case RELATIVE_CURSOR.NEXT:
+        return this._resolveAsTheNext();
+      case RELATIVE_CURSOR.THIS:
+      default:
+        return this._resolveAsThis();
+    }
+  }
+
+
+  /**
+   * Apply 'this' cursor logic to statement
+   * @private
+   * @returns {AbsoluteStatement}
+   */
+  private _resolveAsThis(): AbsoluteStatement {
+    const gte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      unit: this.unit,
+      pivot: this.now,
+      setTo: COMMON_CONSTANTS.START
+    });
+
+    const lte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      unit: this.unit,
+      pivot: this.now,
+      setTo: COMMON_CONSTANTS.END
+    });
+
+    return { gte, lte };
+  }
+
+
+  /**
+   * Apply 'the last' cursor logic to statement
+   * @private
+   * @returns {AbsoluteStatement}
+   */
+  private _resolveAsTheLast(): AbsoluteStatement {
+    const statementCase = getStatementCase(this.includeCurrent, this.isCalendarDate);
+    const pivot = new RelativeStatementAdapter(this.anchor, this.now).valueAsAnchor();
+    const args = {
+      pivot,
+      unit: this.unit,
+      resolveAsCalendar: this.isCalendarDate
+    };
+
+    const gte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      ...args,
+      setTo: COMMON_CONSTANTS.START,
+      steps: - this.number + (
+        statementCase === COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR ||
+          this.includeCurrent && this.unit === DATE_GROUPING_PROPERTY.DAY ? 1 : 0
+      )
+    });
+
+    const lte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      ...args,
+      setTo: COMMON_CONSTANTS.END,
+      steps: statementCase === COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR ? -1 : 0
+    });
+
+    return {
+      gte,
+      lte: statementCase === COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING ? RelativeStatementAdapter.convertRelativeToAbsolute({
+        pivot: lte,
+        steps: -1,
+        setTo: COMMON_CONSTANTS.END,
+        unit: DATE_GROUPING_PROPERTY.DAY
+      }) : lte
+    };
+  }
+
+
+  /**
+   * Apply 'the next' cursor logic to statement
+   * @private
+   * @returns {AbsoluteStatement}
+   */
+  private _resolveAsTheNext(): AbsoluteStatement {
+    const statementCase = getStatementCase(this.includeCurrent, this.isCalendarDate);
+    const pivot = new RelativeStatementAdapter(this.anchor, this.now).valueAsAnchor();
+    const args = {
+      pivot,
+      unit: this.unit,
+      resolveAsCalendar: this.isCalendarDate
+    };
+
+    const gte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      ...args,
+      setTo: COMMON_CONSTANTS.START,
+      steps: statementCase === COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR ? 1 : 0
+    });
+
+    const lte = RelativeStatementAdapter.convertRelativeToAbsolute({
+      ...args,
+      setTo: COMMON_CONSTANTS.END,
+      steps: this.number + (
+        statementCase === COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR ||
+          this.includeCurrent && this.unit === DATE_GROUPING_PROPERTY.DAY ? -1 : 0
+      )
+    });
+
+    return {
+      lte,
+      gte: statementCase === COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING ? RelativeStatementAdapter.convertRelativeToAbsolute({
+        pivot: gte,
+        steps: 1,
+        setTo: COMMON_CONSTANTS.START,
+        unit: DATE_GROUPING_PROPERTY.DAY
+      }) : gte
+    };
+  }
+
+
+  /**
+   * Replace '@now' token inside a string
+   * @param {string} value 
+   * @param {Date} now 
+   * @returns {string}
+   */
+  static replaceNowToken(value: string, now: Date) {
+    return value.replace(
+      COMMON_CONSTANTS.NOW_TOKEN,
+      parseDate(now).format(DATETIME_FORMAT)
+    );
+  }
+
+
+  /**
+   * Returns a range object (date) from a group of statement params
+   * @example
+   * pivot = '2021-03-03T12:30:40'
+   * unit = month
+   * steps = 2
+   * setTo = END
+   * resolverAsCalendar: true
+   * => Returns  '2021-05-31T23:59:59'
+   * 
+   * @example
+   * pivot = '2021-03-03T12:30:40'
+   * unit = month
+   * steps = -2
+   * setTo = START
+   * resolverAsCalendar: false
+   * => Returns '2021-01-03T00:00:00'
+   * 
+   * @param {RelativeToAbsoluteStruct} args
+   * @returns {string}
+   */
+  static convertRelativeToAbsolute(args: RelativeToAbsoluteStruct): string {
+    const { pivot, unit, steps = 0, setTo, resolveAsCalendar = true } = args;
+    const loweredUnit = unit.toLowerCase();
+    const date = parseDate(pivot).add(steps, loweredUnit as OpUnitType);
+
+    const startOrEndOf = (resolveAsCalendar ? loweredUnit : DATE_GROUPING_PROPERTY.DAY) as OpUnitType;
+    return (setTo === COMMON_CONSTANTS.START ? date.startOf(startOrEndOf):
+      setTo === COMMON_CONSTANTS.END ? date.endOf(startOrEndOf):
+      date
+    ).format(DATETIME_FORMAT);
+  }
+}

package/src/dates/relative/constants/COMMON.ts

@@ -0,0 +1,9 @@
+export enum COMMON_CONSTANTS {
+  INCLUSIVE_AND_CALENDAR = 1,
+  EXCLUSIVE_AND_CALENDAR,
+  EXCLUSIVE_AND_ROLLING,
+  INCLUSIVE_AND_ROLLING,
+  START = 'START',
+  END = 'END',
+  NOW_TOKEN = '@now'
+}

package/src/dates/relative/constants/RELATIVE_CURSOR.ts

@@ -0,0 +1,5 @@
+export enum RELATIVE_CURSOR {
+    THIS = 'this',
+    NEXT = 'the_next',
+    LAST = 'the_last'
+}

package/src/dates/relative/constants/RELATIVE_CURSOR_INFO.ts

@@ -0,0 +1,7 @@
+import { RELATIVE_CURSOR } from "./RELATIVE_CURSOR";
+
+export const RELATIVE_CURSOR_INFO = {
+    [RELATIVE_CURSOR.THIS]: { label: 'This', value: 'this' },
+    [RELATIVE_CURSOR.NEXT]: { label: 'The next', value: 'the next' },
+    [RELATIVE_CURSOR.LAST]: { label: 'The last', value: 'the last' },
+};

package/src/dates/relative/constants/index.ts

@@ -0,0 +1,6 @@
+export * from './COMMON';
+export * from './DATE_FORMATS';
+export * from './RELATIVE_CURSOR';
+export * from './RELATIVE_CURSOR_INFO';
+
+export * from './ui/index';

package/src/dates/relative/constants/ui/RELATIVE_MODE.ts

@@ -0,0 +1,4 @@
+export enum RELATIVE_MODE {
+    SINGLE = 'single',
+    RANGE = 'range'
+}

package/src/dates/relative/helpers/formatStatement.ts

@@ -0,0 +1,24 @@
+import { RELATIVE_CURSOR } from "../constants/RELATIVE_CURSOR";
+import { _get } from "../../../general/object/get";
+import { mapValues } from "../../../general/object/mapValues";
+import { RelativeStatement } from "../interfaces/RelativeStatement";
+import { DATE_GROUPING_PROPERTY } from "../../constants/DATE_GROUPING_PROPERTY";
+import { COMMON_CONSTANTS } from "../constants/COMMON";
+
+
+/**
+ * Build a proper relative date statement type
+ * @param {RelativeStatement} statement
+ * @returns {RelativeStatement}
+ */
+export function formatStatement(statement: RelativeStatement): RelativeStatement {
+  const loweredStatement = mapValues(statement, s => typeof s === 'string' ? s.toLowerCase() : s);
+  return {
+    cursor: _get(loweredStatement, 'cursor', RELATIVE_CURSOR.THIS),
+    unit: _get(loweredStatement, 'unit', DATE_GROUPING_PROPERTY.DAY),
+    number: _get(loweredStatement, 'number', 0),
+    anchor: _get(loweredStatement, 'anchor', COMMON_CONSTANTS.NOW_TOKEN),
+    isCalendarDate: _get(loweredStatement, 'isCalendarDate', true),
+    includeCurrent: _get(loweredStatement, 'includeCurrent', true)
+  };
+}

package/src/dates/relative/interfaces/Anchor.ts

@@ -0,0 +1,9 @@
+import { RELATIVE_CURSOR } from "../constants/RELATIVE_CURSOR";
+import { IDateGroupingProperty } from "../../interfaces/IDateGroupingProperty";
+
+export interface Anchor {
+    cursor: RELATIVE_CURSOR;
+    unit: IDateGroupingProperty;
+    number: string | number;
+    anchor?: Anchor | string;
+}

package/src/dates/relative/interfaces/RelativeCursor.ts

@@ -0,0 +1,3 @@
+import { RELATIVE_CURSOR } from "../constants/RELATIVE_CURSOR";
+
+export type RelativeCursor = RELATIVE_CURSOR;

package/src/dates/relative/interfaces/RelativeStatement.ts

@@ -0,0 +1,12 @@
+import { IDateGroupingProperty } from '../../interfaces/IDateGroupingProperty';
+import { RELATIVE_CURSOR } from '../constants/RELATIVE_CURSOR';
+import { Anchor } from './Anchor';
+
+export interface RelativeStatement {
+  cursor: RELATIVE_CURSOR;
+  unit: IDateGroupingProperty;
+  number?: number;
+  includeCurrent?: boolean;
+  isCalendarDate?: boolean;
+  anchor?: Anchor | string;
+}

package/src/dates/relative/interfaces/RelativeToAbsoluteStruct.ts

@@ -0,0 +1,10 @@
+import { Dayjs } from '../helpers/dayjs-module';
+import { COMMON_CONSTANTS } from '../constants/COMMON';
+
+export interface RelativeToAbsoluteStruct {
+    pivot: string | Date | Dayjs; // Base/reference/anchor data
+    unit: string, // Time/Date unit
+    steps?: number; // Number of units to add to the respective date part
+    setTo?: COMMON_CONSTANTS; // Determines whether to perform a startOf/endOf over the response.
+    resolveAsCalendar?: boolean; // Resolve startOf/endOf as calendar/rolling date.
+}

package/src/dates/relative/interfaces/ui/IRelativeSectionItem.ts

@@ -0,0 +1,8 @@
+import { RelativeCursor } from "../RelativeCursor";
+import { IDateGroupingProperty } from "../../../interfaces/IDateGroupingProperty";
+
+export interface IRelativeSectionItem {
+    cursor: RelativeCursor;
+    unit: IDateGroupingProperty;
+    number: string | number;
+}