@checkdigit/time 3.0.0-PR.17-5aaf → 4.0.0-PR.18-81a3

package/src/date-fns/setWeek/test.mts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest';
+import { setWeek } from './index';
+
+describe('setWeek', () => {
+  it('sets the local week', () => {
+    const result = setWeek(new Date(2005, 0 /* Jan */, 2), 1);
+    expect(result).toEqual(new Date(2004, 11 /* Dec */, 26));
+  });
+
+  it('accepts a timestamp', () => {
+    const result = setWeek(new Date(2009, 11 /* Dec */, 2).getTime(), 1);
+    expect(result).toEqual(new Date(2008, 11 /* Dec */, 31));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 6 /* Jul */, 2);
+    setWeek(date, 52);
+    expect(date).toEqual(new Date(2014, 6 /* Jul */, 2));
+  });
+
+  it('handles dates before 100 AD', () => {
+    const initialDate = new Date(0);
+    initialDate.setFullYear(4, 0 /* Jan */, 4);
+    initialDate.setHours(0, 0, 0, 0);
+    const expectedResult = new Date(0);
+    expectedResult.setFullYear(4, 11 /* Dec */, 19);
+    expectedResult.setHours(0, 0, 0, 0);
+    const result = setWeek(initialDate, 52);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = setWeek(new Date(NaN), 53);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it('returns `Invalid Date` if the given amount is NaN', () => {
+    const result = setWeek(new Date(2004, 7 /* Aug */, 7), NaN);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it('allows to specify `weekStartsOn` and `firstWeekContainsDate` in locale', () => {
+    const date = new Date(2005, 0 /* Jan */, 2);
+    const result = setWeek(date, 1, {
+      locale: {
+        options: { weekStartsOn: 1, firstWeekContainsDate: 4 },
+      },
+    });
+    expect(result).toEqual(new Date(2004, 0 /* Jan */, 4));
+  });
+
+  it('`options.weekStartsOn` overwrites the first day of the week specified in locale', () => {
+    const date = new Date(2005, 0 /* Jan */, 2);
+    const result = setWeek(date, 1, {
+      weekStartsOn: 1,
+      firstWeekContainsDate: 4,
+      locale: {
+        options: { weekStartsOn: 0, firstWeekContainsDate: 1 },
+      },
+    });
+    expect(result).toEqual(new Date(2004, 0 /* Jan */, 4));
+  });
+});

package/src/date-fns/setWeekYear/index.ts

@@ -1,14 +1,14 @@
-import constructFrom from '../constructFrom/index';
-import differenceInCalendarDays from '../differenceInCalendarDays/index';
-import startOfWeekYear from '../startOfWeekYear/index';
-import toDate from '../toDate/index';
-import type { FirstWeekContainsDateOptions, LocaleOptions, WeekStartOptions } from '../types';
+import { constructFrom } from '../constructFrom/index';
+import { differenceInCalendarDays } from '../differenceInCalendarDays/index';
+import { startOfWeekYear } from '../startOfWeekYear/index';
+import { toDate } from '../toDate/index';
+import type { FirstWeekContainsDateOptions, LocalizedOptions, WeekOptions } from '../types';
 import { getDefaultOptions } from '../_lib/defaultOptions/index';
 
 /**
  * The {@link setWeekYear} function options.
  */
-export interface SetWeekYearOptions extends LocaleOptions, WeekStartOptions, FirstWeekContainsDateOptions {}
+export interface SetWeekYearOptions extends LocalizedOptions<'options'>, WeekOptions, FirstWeekContainsDateOptions {}
 
 /**
  * @name setWeekYear
@@ -23,12 +23,15 @@ export interface SetWeekYearOptions extends LocaleOptions, WeekStartOptions, Fir
  * and `options.firstWeekContainsDate` (which is the day of January, which is always in
  * the first week of the week-numbering year)
  *
- * Week numbering: https://en.wikipedia.org/wiki/Week#Week_numbering
+ * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
  *
- * @param date - the date to be changed
- * @param weekYear - the local week-numbering year of the new date
- * @param options - an object with options.
- * @returns the new date with the local week-numbering year set
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param weekYear - The local week-numbering year of the new date
+ * @param options - An object with options
+ *
+ * @returns The new date with the local week-numbering year set
  *
  * @example
  * // Set the local week-numbering year 2004 to 2 January 2010 with default options:
@@ -45,8 +48,8 @@ export interface SetWeekYearOptions extends LocaleOptions, WeekStartOptions, Fir
  * })
  * //=> Sat Jan 01 2005 00:00:00
  */
-export default function setWeekYear<DateType extends Date>(
-  dirtyDate: DateType | number,
+export function setWeekYear<DateType extends Date>(
+  date: DateType | number | string,
   weekYear: number,
   options?: SetWeekYearOptions,
 ): DateType {
@@ -58,12 +61,12 @@ export default function setWeekYear<DateType extends Date>(
     defaultOptions.locale?.options?.firstWeekContainsDate ??
     1;
 
-  let date = toDate(dirtyDate);
-  const diff = differenceInCalendarDays(date, startOfWeekYear(date, options));
-  const firstWeek = constructFrom(dirtyDate, 0);
+  let _date = toDate(date);
+  const diff = differenceInCalendarDays(_date, startOfWeekYear(_date, options));
+  const firstWeek = constructFrom(date, 0);
   firstWeek.setFullYear(weekYear, 0, firstWeekContainsDate);
   firstWeek.setHours(0, 0, 0, 0);
-  date = startOfWeekYear(firstWeek, options);
-  date.setDate(date.getDate() + diff);
-  return date;
+  _date = startOfWeekYear(firstWeek, options);
+  _date.setDate(_date.getDate() + diff);
+  return _date;
 }

package/src/date-fns/setWeekYear/test.mts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { setWeekYear } from './index';
+
+describe('setWeekYear', () => {
+  it('sets the local week-numbering year, saving the week and the day of the week', () => {
+    const result = setWeekYear(new Date(2010, 0 /* Jan */, 2), 2004);
+    expect(result).toEqual(new Date(2004, 0 /* Jan */, 3));
+  });
+
+  it('accepts a timestamp', () => {
+    const result = setWeekYear(new Date(2008, 11 /* Dec */, 29).getTime(), 2007);
+    expect(result).toEqual(new Date(2007, 0 /* Jan */, 1));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2008, 11 /* Dec */, 29);
+    setWeekYear(date, 2000);
+    expect(date).toEqual(new Date(2008, 11 /* Dec */, 29));
+  });
+
+  it('sets local week-numbering years less than 100', () => {
+    const initialDate = new Date(2008, 11 /* Dec */, 29);
+    const expectedResult = new Date(0);
+    expectedResult.setFullYear(7, 0 /* Jan */, 1);
+    expectedResult.setHours(0, 0, 0, 0);
+    const result = setWeekYear(initialDate, 7);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('handles dates before 100 AD', () => {
+    const initialDate = new Date(0);
+    initialDate.setFullYear(8, 11 /* Dec */, 29);
+    initialDate.setHours(0, 0, 0, 0);
+    const expectedResult = new Date(0);
+    expectedResult.setFullYear(7, 0 /* Jan */, 1);
+    expectedResult.setHours(0, 0, 0, 0);
+    const result = setWeekYear(initialDate, 7);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = setWeekYear(new Date(NaN), 2007);
+    expect(result instanceof Date && isNaN(result.getDate())).toBe(true);
+  });
+
+  it('returns `Invalid Date` if the given amount is NaN', () => {
+    const result = setWeekYear(new Date(2008, 11 /* Dec */, 29), NaN);
+    expect(result instanceof Date && isNaN(result.getDate())).toBe(true);
+  });
+
+  it('allows to specify `weekStartsOn` and `firstWeekContainsDate` in locale', () => {
+    const date = new Date(2010, 0 /* Jan */, 2);
+    const result = setWeekYear(date, 2004, {
+      locale: {
+        options: { weekStartsOn: 1, firstWeekContainsDate: 4 },
+      },
+    });
+    expect(result).toEqual(new Date(2005, 0 /* Jan */, 1));
+  });
+
+  it('`options.weekStartsOn` overwrites the first day of the week specified in locale', () => {
+    const date = new Date(2010, 0 /* Jan */, 2);
+    const result = setWeekYear(date, 2004, {
+      weekStartsOn: 1,
+      firstWeekContainsDate: 4,
+      locale: {
+        options: { weekStartsOn: 0, firstWeekContainsDate: 1 },
+      },
+    });
+    expect(result).toEqual(new Date(2005, 0 /* Jan */, 1));
+  });
+});

package/src/date-fns/setYear/index.ts

@@ -1,5 +1,5 @@
-import constructFrom from '../constructFrom/index';
-import toDate from '../toDate/index';
+import { constructFrom } from '../constructFrom/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name setYear
@@ -9,23 +9,26 @@ import toDate from '../toDate/index';
  * @description
  * Set the year to the given date.
  *
- * @param date - the date to be changed
- * @param year - the year of the new date
- * @returns the new date with the year set
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The date to be changed
+ * @param year - The year of the new date
+ *
+ * @returns The new date with the year set
  *
  * @example
  * // Set year 2013 to 1 September 2014:
  * const result = setYear(new Date(2014, 8, 1), 2013)
  * //=> Sun Sep 01 2013 00:00:00
  */
-export default function setYear<DateType extends Date>(dirtyDate: DateType | number, year: number): DateType {
-  const date = toDate(dirtyDate);
+export function setYear<DateType extends Date>(date: DateType | number | string, year: number): DateType {
+  const _date = toDate(date);
 
   // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
-  if (isNaN(date.getTime())) {
-    return constructFrom(dirtyDate, NaN);
+  if (isNaN(+_date)) {
+    return constructFrom(date, NaN);
   }
 
-  date.setFullYear(year);
-  return date;
+  _date.setFullYear(year);
+  return _date;
 }

package/src/date-fns/setYear/test.mts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { setYear } from './index';
+
+describe('setYear', () => {
+  it('sets the year', () => {
+    const result = setYear(new Date(2014, 8 /* Sep */, 1), 2013);
+    expect(result).toEqual(new Date(2013, 8 /* Sep */, 1));
+  });
+
+  it('accepts a timestamp', () => {
+    const result = setYear(new Date(2014, 8 /* Sep */, 1).getTime(), 2016);
+    expect(result).toEqual(new Date(2016, 8 /* Sep */, 1));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 8 /* Sep */, 1);
+    setYear(date, 2011);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = setYear(new Date(NaN), 2013);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it('returns `Invalid Date` if the given amount is NaN', () => {
+    const result = setYear(new Date(2014, 8 /* Sep */, 1), NaN);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

package/src/date-fns/startOfDay/index.ts

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name startOfDay
@@ -9,16 +9,19 @@ import toDate from '../toDate/index';
  * Return the start of a day for the given date.
  * The result will be in the local timezone.
  *
- * @param date - the original date
- * @returns the start of a day
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of a day
  *
  * @example
  * // The start of a day for 2 September 2014 11:55:00:
  * const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
  * //=> Tue Sep 02 2014 00:00:00
  */
-export default function startOfDay<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  const date = toDate(dirtyDate);
-  date.setHours(0, 0, 0, 0);
-  return date;
+export function startOfDay<DateType extends Date>(date: DateType | number | string): DateType {
+  const _date = toDate(date);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
 }

package/src/date-fns/startOfDay/test.mts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { startOfDay } from './index';
+
+describe('startOfDay', () => {
+  it('returns the date with the time set to 00:00:00', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55, 0);
+    const result = startOfDay(date);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 2, 0, 0, 0, 0));
+  });
+
+  it('accepts a timestamp', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55, 0).getTime();
+    const result = startOfDay(date);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 2, 0, 0, 0, 0));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55, 0);
+    startOfDay(date);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 2, 11, 55, 0));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = startOfDay(new Date(NaN));
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

package/src/date-fns/startOfDecade/index.ts

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name startOfDecade
@@ -8,19 +8,25 @@ import toDate from '../toDate/index';
  * @description
  * Return the start of a decade for the given date.
  *
- * @param date - the original date
- * @returns the start of a decade
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of a decade
  *
  * @example
  * // The start of a decade for 21 October 2015 00:00:00:
  * const result = startOfDecade(new Date(2015, 9, 21, 00, 00, 00))
  * //=> Jan 01 2010 00:00:00
  */
-export default function startOfDecade<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  const date = toDate(dirtyDate);
-  const year = date.getFullYear();
+export function startOfDecade<DateType extends Date>(date: DateType | number | string): DateType {
+  // TODO: Switch to more technical definition in of decades that start with 1
+  // end with 0. I.e. 2001-2010 instead of current 2000-2009. It's a breaking
+  // change, so it can only be done in 4.0.
+  const _date = toDate(date);
+  const year = _date.getFullYear();
   const decade = Math.floor(year / 10) * 10;
-  date.setFullYear(decade, 0, 1);
-  date.setHours(0, 0, 0, 0);
-  return date;
+  _date.setFullYear(decade, 0, 1);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
 }

package/src/date-fns/startOfDecade/test.mts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { startOfDecade } from './index';
+
+describe('startOfDecade', () => {
+  it('returns the date with the time set to 00:00:00 and the date set to the first day of a year', () => {
+    const date = new Date(1953, 3 /* Apr */, 13);
+    const result = startOfDecade(date);
+    expect(result).toEqual(new Date(1950, 0 /* Jan */, 1));
+  });
+
+  it('accepts a timestamp', () => {
+    const date = new Date(1984, 9 /* Oct */, 14).getTime();
+    const result = startOfDecade(date);
+    expect(result).toEqual(new Date(1980, 0 /* Jan */, 1));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(1978, 10 /* Nov */, 14);
+    startOfDecade(date);
+    expect(date).toEqual(new Date(1978, 10 /* Nov */, 14));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = startOfDecade(new Date(NaN));
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it('properly works with negative numbers', () => {
+    expect(startOfDecade(new Date(2009, 0, 1))).toEqual(new Date(2000, 0, 1));
+    expect(startOfDecade(new Date(-2001, 0, 1))).toEqual(new Date(-2010, 0, 1));
+  });
+});

package/src/date-fns/startOfHour/index.ts

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name startOfHour
@@ -9,16 +9,19 @@ import toDate from '../toDate/index';
  * Return the start of an hour for the given date.
  * The result will be in the local timezone.
  *
- * @param date - the original date
- * @returns the start of an hour
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of an hour
  *
  * @example
  * // The start of an hour for 2 September 2014 11:55:00:
  * const result = startOfHour(new Date(2014, 8, 2, 11, 55))
  * //=> Tue Sep 02 2014 11:00:00
  */
-export default function startOfHour<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  const date = toDate(dirtyDate);
-  date.setMinutes(0, 0, 0);
-  return date;
+export function startOfHour<DateType extends Date>(date: DateType | number | string): DateType {
+  const _date = toDate(date);
+  _date.setMinutes(0, 0, 0);
+  return _date;
 }

package/src/date-fns/startOfHour/test.mts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { startOfHour } from './index';
+
+describe('startOfHour', () => {
+  it('returns the date with the time set to the first millisecond of an hour', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55);
+    const result = startOfHour(date);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 2, 11));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55);
+    startOfHour(date);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 2, 11, 55));
+  });
+
+  it('accepts a timestamp', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55).getTime();
+    const result = startOfHour(date);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 2, 11));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = startOfHour(new Date(NaN));
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

package/src/date-fns/startOfISOWeek/index.ts

@@ -1,4 +1,4 @@
-import startOfWeek from '../startOfWeek/index';
+import { startOfWeek } from '../startOfWeek/index';
 
 /**
  * @name startOfISOWeek
@@ -11,14 +11,17 @@ import startOfWeek from '../startOfWeek/index';
  *
  * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
  *
- * @param date - the original date
- * @returns the start of an ISO week
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of an ISO week
  *
  * @example
  * // The start of an ISO week for 2 September 2014 11:55:00:
  * const result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
  * //=> Mon Sep 01 2014 00:00:00
  */
-export default function startOfISOWeek<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  return startOfWeek(dirtyDate, { weekStartsOn: 1 });
+export function startOfISOWeek<DateType extends Date>(date: DateType | number | string): DateType {
+  return startOfWeek(date, { weekStartsOn: 1 });
 }

package/src/date-fns/startOfISOWeek/test.mts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { startOfISOWeek } from './index';
+
+describe('startOfISOWeek', () => {
+  it('returns the date with the time set to 00:00:00 and the date set to the first day of an ISO week', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55, 0);
+    const result = startOfISOWeek(date);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it('accepts a timestamp', () => {
+    const date = new Date(2014, 1 /* Feb */, 11, 11, 55, 0).getTime();
+    const result = startOfISOWeek(date);
+    expect(result).toEqual(new Date(2014, 1 /* Feb */, 10));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 8 /* Sep */, 2, 11, 55, 0);
+    startOfISOWeek(date);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 2, 11, 55, 0));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = startOfISOWeek(new Date(NaN));
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

package/src/date-fns/startOfISOWeekYear/index.ts

@@ -1,6 +1,6 @@
-import getISOWeekYear from '../getISOWeekYear/index';
-import startOfISOWeek from '../startOfISOWeek/index';
-import constructFrom from '../constructFrom/index';
+import { getISOWeekYear } from '../getISOWeekYear/index';
+import { startOfISOWeek } from '../startOfISOWeek/index';
+import { constructFrom } from '../constructFrom/index';
 
 /**
  * @name startOfISOWeekYear
@@ -14,19 +14,21 @@ import constructFrom from '../constructFrom/index';
  *
  * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
  *
- * @param date - the original date
- * @returns the start of an ISO week-numbering year
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of an ISO week-numbering year
  *
  * @example
  * // The start of an ISO week-numbering year for 2 July 2005:
  * const result = startOfISOWeekYear(new Date(2005, 6, 2))
  * //=> Mon Jan 03 2005 00:00:00
  */
-export default function startOfISOWeekYear<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  const year = getISOWeekYear(dirtyDate);
-  const fourthOfJanuary = constructFrom(dirtyDate, 0);
+export function startOfISOWeekYear<DateType extends Date>(date: DateType | number | string): DateType {
+  const year = getISOWeekYear(date);
+  const fourthOfJanuary = constructFrom(date, 0);
   fourthOfJanuary.setFullYear(year, 0, 4);
   fourthOfJanuary.setHours(0, 0, 0, 0);
-  const date = startOfISOWeek(fourthOfJanuary);
-  return date;
+  return startOfISOWeek(fourthOfJanuary);
 }

package/src/date-fns/startOfISOWeekYear/test.mts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { startOfISOWeekYear } from './index';
+
+describe('startOfISOWeekYear', () => {
+  it('returns the date with the time set to 00:00:00 and the date set to the first day of an ISO year', () => {
+    const result = startOfISOWeekYear(new Date(2009, 0 /* Jan */, 1, 16, 0));
+    expect(result).toEqual(new Date(2008, 11 /* Dec */, 29, 0, 0, 0, 0));
+  });
+
+  it('accepts a timestamp', () => {
+    const result = startOfISOWeekYear(new Date(2005, 0 /* Jan */, 1, 6, 0).getTime());
+    expect(result).toEqual(new Date(2003, 11 /* Dec */, 29, 0, 0, 0, 0));
+  });
+
+  it('does not mutate the original date', () => {
+    const date = new Date(2014, 6 /* Jul */, 2);
+    startOfISOWeekYear(date);
+    expect(date).toEqual(new Date(2014, 6 /* Jul */, 2));
+  });
+
+  it('handles dates before 100 AD', () => {
+    const initialDate = new Date(0);
+    initialDate.setFullYear(9, 0 /* Jan */, 1);
+    initialDate.setHours(0, 0, 0, 0);
+    const expectedResult = new Date(0);
+    expectedResult.setFullYear(8, 11 /* Dec */, 29);
+    expectedResult.setHours(0, 0, 0, 0);
+    const result = startOfISOWeekYear(initialDate);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('correctly handles years in which 4 January is Sunday', () => {
+    const result = startOfISOWeekYear(new Date(2009, 6 /* Jul */, 2));
+    expect(result).toEqual(new Date(2008, 11 /* Dec */, 29));
+  });
+
+  it('returns `Invalid Date` if the given date is invalid', () => {
+    const result = startOfISOWeekYear(new Date(NaN));
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

package/src/date-fns/startOfMinute/index.ts

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from '../toDate/index';
 
 /**
  * @name startOfMinute
@@ -9,16 +9,19 @@ import toDate from '../toDate/index';
  * Return the start of a minute for the given date.
  * The result will be in the local timezone.
  *
- * @param date - the original date
- * @returns the start of a minute
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The original date
+ *
+ * @returns The start of a minute
  *
  * @example
  * // The start of a minute for 1 December 2014 22:15:45.400:
  * const result = startOfMinute(new Date(2014, 11, 1, 22, 15, 45, 400))
  * //=> Mon Dec 01 2014 22:15:00
  */
-export default function startOfMinute<DateType extends Date>(dirtyDate: DateType | number): DateType {
-  const date = toDate(dirtyDate);
-  date.setSeconds(0, 0);
-  return date;
+export function startOfMinute<DateType extends Date>(date: DateType | number | string): DateType {
+  const _date = toDate(date);
+  _date.setSeconds(0, 0);
+  return _date;
 }