From 4fb69e440205d6a74a0aeb3ca25d25da711e393e Mon Sep 17 00:00:00 2001 From: Lucas Silva <45002716+LucasHFS@users.noreply.github.com> Date: Thu, 16 Sep 2021 02:19:54 -0300 Subject: [PATCH] Adding `previousDay` and its variations (#2522) Added new functions: `previousDay`, `previousMonday`, `previousTuesday`, `previousWednesday`, `previousThursday`, `previousFriday`, `previousSaturday` and `previousSunday`. Co-authored-by: Lucas Silva Co-authored-by: Tetiana Co-authored-by: Sasha Koss --- src/index.js | 8 ++++ src/previousDay/index.ts | 36 +++++++++++++++ src/previousDay/test.ts | 80 ++++++++++++++++++++++++++++++++++ src/previousFriday/index.ts | 24 ++++++++++ src/previousFriday/test.ts | 42 ++++++++++++++++++ src/previousMonday/index.ts | 24 ++++++++++ src/previousMonday/test.ts | 42 ++++++++++++++++++ src/previousSaturday/index.ts | 24 ++++++++++ src/previousSaturday/test.ts | 42 ++++++++++++++++++ src/previousSunday/index.ts | 24 ++++++++++ src/previousSunday/test.ts | 42 ++++++++++++++++++ src/previousThursday/index.ts | 24 ++++++++++ src/previousThursday/test.ts | 42 ++++++++++++++++++ src/previousTuesday/index.ts | 24 ++++++++++ src/previousTuesday/test.ts | 42 ++++++++++++++++++ src/previousWednesday/index.ts | 24 ++++++++++ src/previousWednesday/test.ts | 42 ++++++++++++++++++ 17 files changed, 586 insertions(+) mode change 100644 => 100755 src/index.js create mode 100755 src/previousDay/index.ts create mode 100755 src/previousDay/test.ts create mode 100755 src/previousFriday/index.ts create mode 100755 src/previousFriday/test.ts create mode 100755 src/previousMonday/index.ts create mode 100755 src/previousMonday/test.ts create mode 100755 src/previousSaturday/index.ts create mode 100755 src/previousSaturday/test.ts create mode 100755 src/previousSunday/index.ts create mode 100755 src/previousSunday/test.ts create mode 100755 src/previousThursday/index.ts create mode 100755 src/previousThursday/test.ts create mode 100755 src/previousTuesday/index.ts create mode 100755 src/previousTuesday/test.ts create mode 100755 src/previousWednesday/index.ts create mode 100755 src/previousWednesday/test.ts diff --git a/src/index.js b/src/index.js old mode 100644 new mode 100755 index bbf7fb1c4f..1a0f0fafd6 --- a/src/index.js +++ b/src/index.js @@ -175,6 +175,14 @@ export { default as nextWednesday } from './nextWednesday/index' export { default as parse } from './parse/index' export { default as parseISO } from './parseISO/index' export { default as parseJSON } from './parseJSON/index' +export { default as previousDay } from './previousDay/index' +export { default as previousMonday } from './previousMonday/index' +export { default as previousTuesday } from './previousTuesday/index' +export { default as previousWednesday } from './previousWednesday/index' +export { default as previousThursday } from './previousThursday/index' +export { default as previousFriday } from './previousFriday/index' +export { default as previousSaturday } from './previousSaturday/index' +export { default as previousSunday } from './previousSunday/index' export { default as quartersToMonths } from './quartersToMonths/index' export { default as quartersToYears } from './quartersToYears/index' export { default as roundToNearestMinutes } from './roundToNearestMinutes/index' diff --git a/src/previousDay/index.ts b/src/previousDay/index.ts new file mode 100755 index 0000000000..43d905da45 --- /dev/null +++ b/src/previousDay/index.ts @@ -0,0 +1,36 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import getDay from '../getDay/index' +import subDays from '../subDays/index' +import type { Day } from '../types' + +/** + * @name previousDay + * @category Weekday Helpers + * @summary When is the previous day of the week? + * + * @description + * When is the previous day of the week? 0-6 the day of the week, 0 represents Sunday. + * + * @param {Date | number} date - the date to check + * @param {number} day - day of the week + * @returns {Date} - the date is the previous day of week + * @throws {TypeError} - 2 arguments required + * + * @example + * // When is the previous Monday before Mar, 20, 2020? + * const result = previousDay(new Date(2020, 2, 20), 1) + * //=> Mon Mar 16 2020 00:00:00 + * + * @example + * // When is the previous Tuesday before Mar, 21, 2020? + * const result = previousDay(new Date(2020, 2, 21), 2) + * //=> Tue Mar 17 2020 00:00:00 + */ +export default function previousDay(date: Date | number, day: Day): Date { + requiredArgs(2, arguments) + + let delta = getDay(date) - day + if (delta <= 0) delta += 7 + + return subDays(date, delta) +} diff --git a/src/previousDay/test.ts b/src/previousDay/test.ts new file mode 100755 index 0000000000..e8639dceb2 --- /dev/null +++ b/src/previousDay/test.ts @@ -0,0 +1,80 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousDay from '.' + +describe('previousDay', function () { + it('returns the previous Monday given various dates after the same', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 18), 1), + new Date(2021, 5 /* Jun */, 14) + ) + + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 17), 1), + new Date(2021, 5 /* Jun */, 14) + ) + + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 14), 1), + new Date(2021, 5 /* Jun */, 7) + ) + + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 9), 1), + new Date(2021, 5 /* Jun */, 7) + ) + + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 8), 1), + new Date(2021, 5 /* Jun */, 7) + ) + + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 7), 1), + new Date(2021, 4 /* May */, 31) + ) + }) + + it('returns the previous Tuesday given the Saturday after it', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 26), 2), + new Date(2021, 5 /* Jun */, 22) + ) + }) + + it('returns the previous Wednesday given the Saturday after it', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 26), 3), + new Date(2021, 5 /* Jun */, 23) + ) + }) + + it('returns the previous Thursday given the Saturday after it', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 26), 4), + new Date(2021, 5 /* Jun */, 24) + ) + }) + + it('returns the previous Friday given the Saturday after it', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 26), 5), + new Date(2021, 5 /* Jun */, 25) + ) + }) + + it('returns the previous Saturday given the Saturday after it', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 26), 6), + new Date(2021, 5 /* Jun */, 19) + ) + }) + + it('returns the previous Sunday given the day is Sunday', function () { + assert.deepStrictEqual( + previousDay(new Date(2021, 5 /* Jun */, 27), 0), + new Date(2021, 5 /* Jun */, 20) + ) + }) +}) diff --git a/src/previousFriday/index.ts b/src/previousFriday/index.ts new file mode 100755 index 0000000000..8321f3ba34 --- /dev/null +++ b/src/previousFriday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousFriday + * @category Weekday Helpers + * @summary When is the previous Friday? + * + * @description + * When is the previous Friday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Friday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Friday before Jun, 19, 2021? + * const result = previousFriday(new Date(2021, 5, 19)) + * //=> Fri June 18 2021 00:00:00 + */ +export default function previousFriday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 5) +} diff --git a/src/previousFriday/test.ts b/src/previousFriday/test.ts new file mode 100755 index 0000000000..478fe01e47 --- /dev/null +++ b/src/previousFriday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousFriday from '.' + +describe('previousFriday', function () { + it('returns the previous Friday given various dates after the same', function () { + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 5)), + new Date(2021, 5 /* Jun */, 4) + ) + + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 6)), + new Date(2021, 5 /* Jun */, 4) + ) + + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 11)), + new Date(2021, 5 /* Jun */, 4) + ) + + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 14)), + new Date(2021, 5 /* Jun */, 11) + ) + + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 15)), + new Date(2021, 5 /* Jun */, 11) + ) + + assert.deepStrictEqual( + previousFriday(new Date(2021, 5 /* Jun */, 24)), + new Date(2021, 5 /* Jun */, 18) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousFriday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousMonday/index.ts b/src/previousMonday/index.ts new file mode 100755 index 0000000000..a506de4ae7 --- /dev/null +++ b/src/previousMonday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousMonday + * @category Weekday Helpers + * @summary When is the previous Monday? + * + * @description + * When is the previous Monday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Monday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Monday before Jun, 18, 2021? + * const result = previousMonday(new Date(2021, 5, 18)) + * //=> Mon June 14 2021 00:00:00 + */ +export default function previousMonday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 1) +} diff --git a/src/previousMonday/test.ts b/src/previousMonday/test.ts new file mode 100755 index 0000000000..8d19f0fc24 --- /dev/null +++ b/src/previousMonday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousMonday from '.' + +describe('previousMonday', function () { + it('returns the previous Monday given various dates after the same', function () { + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 5)), + new Date(2021, 4 /* May */, 31) + ) + + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 6)), + new Date(2021, 4 /* May */, 31) + ) + + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 7)), + new Date(2021, 4 /* May */, 31) + ) + + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 14)), + new Date(2021, 5 /* Jun */, 7) + ) + + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 15)), + new Date(2021, 5 /* Jun */, 14) + ) + + assert.deepStrictEqual( + previousMonday(new Date(2021, 5 /* Jun */, 16)), + new Date(2021, 5 /* Jun */, 14) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousMonday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousSaturday/index.ts b/src/previousSaturday/index.ts new file mode 100755 index 0000000000..16e4f7350f --- /dev/null +++ b/src/previousSaturday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousSaturday + * @category Weekday Helpers + * @summary When is the previous Saturday? + * + * @description + * When is the previous Saturday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Saturday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Saturday before Jun, 20, 2021? + * const result = previousSaturday(new Date(2021, 5, 20)) + * //=> Sat June 19 2021 00:00:00 + */ +export default function previousSaturday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 6) +} diff --git a/src/previousSaturday/test.ts b/src/previousSaturday/test.ts new file mode 100755 index 0000000000..6283c31f8e --- /dev/null +++ b/src/previousSaturday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousSaturday from '.' + +describe('previousSaturday', function () { + it('returns the previous Saturday given various dates after the same', function () { + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 7)), + new Date(2021, 5 /* Jun */, 5) + ) + + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 8)), + new Date(2021, 5 /* Jun */, 5) + ) + + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 12)), + new Date(2021, 5 /* Jun */, 5) + ) + + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 16)), + new Date(2021, 5 /* Jun */, 12) + ) + + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 17)), + new Date(2021, 5 /* Jun */, 12) + ) + + assert.deepStrictEqual( + previousSaturday(new Date(2021, 5 /* Jun */, 24)), + new Date(2021, 5 /* Jun */, 19) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousSaturday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousSunday/index.ts b/src/previousSunday/index.ts new file mode 100755 index 0000000000..a110d9d4e9 --- /dev/null +++ b/src/previousSunday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousSunday + * @category Weekday Helpers + * @summary When is the previous Sunday? + * + * @description + * When is the previous Sunday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Sunday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Sunday before Jun, 21, 2021? + * const result = previousSunday(new Date(2021, 5, 21)) + * //=> Sun June 20 2021 00:00:00 + */ +export default function previousSunday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 0) +} diff --git a/src/previousSunday/test.ts b/src/previousSunday/test.ts new file mode 100755 index 0000000000..7e5eef945e --- /dev/null +++ b/src/previousSunday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousSunday from '.' + +describe('previousSunday', function () { + it('returns the previous Sunday given various dates after the same', function () { + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 7)), + new Date(2021, 5 /* Jun */, 6) + ) + + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 8)), + new Date(2021, 5 /* Jun */, 6) + ) + + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 13)), + new Date(2021, 5 /* Jun */, 6) + ) + + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 16)), + new Date(2021, 5 /* Jun */, 13) + ) + + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 17)), + new Date(2021, 5 /* Jun */, 13) + ) + + assert.deepStrictEqual( + previousSunday(new Date(2021, 5 /* Jun */, 24)), + new Date(2021, 5 /* Jun */, 20) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousSunday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousThursday/index.ts b/src/previousThursday/index.ts new file mode 100755 index 0000000000..ed1693c433 --- /dev/null +++ b/src/previousThursday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousThursday + * @category Weekday Helpers + * @summary When is the previous Thursday? + * + * @description + * When is the previous Thursday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Thursday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Thursday before Jun, 18, 2021? + * const result = previousThursday(new Date(2021, 5, 18)) + * //=> Thu June 17 2021 00:00:00 + */ +export default function previousThursday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 4) +} diff --git a/src/previousThursday/test.ts b/src/previousThursday/test.ts new file mode 100755 index 0000000000..7b1d0bb1f2 --- /dev/null +++ b/src/previousThursday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousThursday from '.' + +describe('previousThursday', function () { + it('returns the previous Thursday given various dates after the same', function () { + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 5)), + new Date(2021, 5 /* Jun */, 3) + ) + + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 6)), + new Date(2021, 5 /* Jun */, 3) + ) + + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 10)), + new Date(2021, 5 /* Jun */, 3) + ) + + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 14)), + new Date(2021, 5 /* Jun */, 10) + ) + + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 15)), + new Date(2021, 5 /* Jun */, 10) + ) + + assert.deepStrictEqual( + previousThursday(new Date(2021, 5 /* Jun */, 24)), + new Date(2021, 5 /* Jun */, 17) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousThursday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousTuesday/index.ts b/src/previousTuesday/index.ts new file mode 100755 index 0000000000..57aa625e10 --- /dev/null +++ b/src/previousTuesday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousTuesday + * @category Weekday Helpers + * @summary When is the previous Tuesday? + * + * @description + * When is the previous Tuesday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Tuesday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Tuesday before Jun, 18, 2021? + * const result = previousTuesday(new Date(2021, 5, 18)) + * //=> Tue June 15 2021 00:00:00 + */ +export default function previousTuesday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 2) +} diff --git a/src/previousTuesday/test.ts b/src/previousTuesday/test.ts new file mode 100755 index 0000000000..c19a4b67ee --- /dev/null +++ b/src/previousTuesday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousTuesday from '.' + +describe('previousTuesday', function () { + it('returns the previous Tuesday given various dates after the same', function () { + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 5)), + new Date(2021, 5 /* Jun */, 1) + ) + + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 6)), + new Date(2021, 5 /* Jun */, 1) + ) + + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 8)), + new Date(2021, 5 /* Jun */, 1) + ) + + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 15)), + new Date(2021, 5 /* Jun */, 8) + ) + + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 17)), + new Date(2021, 5 /* Jun */, 15) + ) + + assert.deepStrictEqual( + previousTuesday(new Date(2021, 5 /* Jun */, 18)), + new Date(2021, 5 /* Jun */, 15) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousTuesday(new Date(NaN)) instanceof Date) + }) +}) diff --git a/src/previousWednesday/index.ts b/src/previousWednesday/index.ts new file mode 100755 index 0000000000..b1251f0a98 --- /dev/null +++ b/src/previousWednesday/index.ts @@ -0,0 +1,24 @@ +import requiredArgs from '../_lib/requiredArgs/index' +import previousDay from '../previousDay/index' + +/** + * @name previousWednesday + * @category Weekday Helpers + * @summary When is the previous Wednesday? + * + * @description + * When is the previous Wednesday? + * + * @param {Date | number} date - the date to start counting from + * @returns {Date} the previous Wednesday + * @throws {TypeError} 1 argument required + * + * @example + * // When is the previous Wednesday before Jun, 18, 2021? + * const result = previousWednesday(new Date(2021, 5, 18)) + * //=> Wed June 16 2021 00:00:00 + */ +export default function previousWednesday(date: Date | number): Date { + requiredArgs(1, arguments) + return previousDay(date, 3) +} diff --git a/src/previousWednesday/test.ts b/src/previousWednesday/test.ts new file mode 100755 index 0000000000..71a57a6000 --- /dev/null +++ b/src/previousWednesday/test.ts @@ -0,0 +1,42 @@ +/* eslint-env mocha */ + +import assert from 'assert' +import previousWednesday from '.' + +describe('previousWednesday', function () { + it('returns the previous Wednesday given various dates after the same', function () { + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 5)), + new Date(2021, 5 /* Jun */, 2) + ) + + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 6)), + new Date(2021, 5 /* Jun */, 2) + ) + + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 9)), + new Date(2021, 5 /* Jun */, 2) + ) + + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 17)), + new Date(2021, 5 /* Jun */, 16) + ) + + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 18)), + new Date(2021, 5 /* Jun */, 16) + ) + + assert.deepStrictEqual( + previousWednesday(new Date(2021, 5 /* Jun */, 25)), + new Date(2021, 5 /* Jun */, 23) + ) + }) + + it('returns `Invalid Date` if the given date is invalid', function () { + assert(previousWednesday(new Date(NaN)) instanceof Date) + }) +})