colombian-holidays 5.0.2 → 5.0.5

package/README.md

@@ -1,9 +1,6 @@
 # Colombian Holidays 🎆
 
 [![npm version](https://badge.fury.io/js/colombian-holidays.svg)](https://badge.fury.io/js/colombian-holidays)
-[![codecov](https://codecov.io/gh/MauricioRobayo/colombian-holidays/branch/master/graph/badge.svg)](https://codecov.io/gh/MauricioRobayo/colombian-holidays)
-[![CodeFactor](https://www.codefactor.io/repository/github/mauriciorobayo/colombian-holidays/badge)](https://www.codefactor.io/repository/github/mauriciorobayo/colombian-holidays)
-[![](https://badgen.net/badge/Run%20with%20/VS%20Code/5B3ADF?icon=https://runme.dev/img/logo.svg)](git@github.com:MauricioRobayo/colombian-holidays.git)
 
 TypeScript module to calculate colombian holidays for any given year.
 
@@ -280,9 +277,10 @@ This function is equivalent to calling:
 colombianHolidays({ year: 2025 });
 ```
 
-But exposed as a named utility function for convenience.
+But uses an in-memory cache.
 
-This function uses a shared in-memory cache and is a preferable option to `colombianHolidays` when the same year is requested multiple times, such as in loops or build processes.
+> [!TIP]
+> Use `getHolidaysByYear` instead of `colombianHolidays` when possible. It includes built-in caching, which improves performance and avoids redundant computations when accessing holidays by year. It is used under the hood by all other helpers, providing a shared in-memory cache.
 
 ### isHoliday
 

package/dist/index.d.mts

@@ -0,0 +1,62 @@
+interface BasicHoliday {
+    name: {
+        en: string;
+        es: string;
+    };
+    nextMonday: boolean;
+}
+interface ColombianHoliday extends BasicHoliday {
+    date: string;
+    celebrationDate: string;
+}
+interface ColombianHolidayWithNativeDate extends BasicHoliday {
+    date: Date;
+    celebrationDate: Date;
+}
+
+declare function getHolidaysForYear(year: number, options?: {
+    valueAsDate: false | undefined;
+}): ColombianHoliday[];
+declare function getHolidaysForYear(year: number, options?: {
+    valueAsDate: true;
+}): ColombianHolidayWithNativeDate[];
+
+declare function isHoliday(date: Date): boolean;
+
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate: false | undefined;
+}): ColombianHoliday[];
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate: true;
+}): ColombianHolidayWithNativeDate[];
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate?: boolean;
+}): ColombianHoliday[] | ColombianHolidayWithNativeDate[];
+
+declare const FIRST_HOLIDAY_YEAR = 1583;
+declare const LAST_HOLIDAY_YEAR = 4099;
+type MonthNumbers = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+type Month = MonthNumbers | Omit<number, MonthNumbers>;
+declare function colombianHolidays(options?: undefined | {
+    year?: number;
+    month?: Month;
+    valueAsDate: false | undefined;
+}): ColombianHoliday[];
+declare function colombianHolidays(options?: {
+    year?: number;
+    month?: Month;
+    valueAsDate: true;
+}): ColombianHolidayWithNativeDate[];
+declare function colombianHolidays(options?: {
+    year?: number;
+    month?: Month;
+    valueAsDate?: boolean;
+}): ColombianHoliday[] | ColombianHolidayWithNativeDate[];
+
+export { FIRST_HOLIDAY_YEAR, LAST_HOLIDAY_YEAR, type Month, colombianHolidays, colombianHolidays as default, getHolidaysForYear, holidaysWithinInterval, isHoliday };

package/dist/index.d.ts

@@ -1,24 +1,62 @@
-import { ColombianHoliday, ColombianHolidayWithNativeDate } from "./types";
-export declare const FIRST_HOLIDAY_YEAR = 1583;
-export declare const LAST_HOLIDAY_YEAR = 4099;
+interface BasicHoliday {
+    name: {
+        en: string;
+        es: string;
+    };
+    nextMonday: boolean;
+}
+interface ColombianHoliday extends BasicHoliday {
+    date: string;
+    celebrationDate: string;
+}
+interface ColombianHolidayWithNativeDate extends BasicHoliday {
+    date: Date;
+    celebrationDate: Date;
+}
+
+declare function getHolidaysForYear(year: number, options?: {
+    valueAsDate: false | undefined;
+}): ColombianHoliday[];
+declare function getHolidaysForYear(year: number, options?: {
+    valueAsDate: true;
+}): ColombianHolidayWithNativeDate[];
+
+declare function isHoliday(date: Date): boolean;
+
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate: false | undefined;
+}): ColombianHoliday[];
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate: true;
+}): ColombianHolidayWithNativeDate[];
+declare function holidaysWithinInterval(options: {
+    start: Date;
+    end: Date;
+    valueAsDate?: boolean;
+}): ColombianHoliday[] | ColombianHolidayWithNativeDate[];
+
+declare const FIRST_HOLIDAY_YEAR = 1583;
+declare const LAST_HOLIDAY_YEAR = 4099;
 type MonthNumbers = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-export type Month = MonthNumbers | Omit<number, MonthNumbers>;
-export declare function colombianHolidays(options?: undefined | {
+type Month = MonthNumbers | Omit<number, MonthNumbers>;
+declare function colombianHolidays(options?: undefined | {
     year?: number;
     month?: Month;
     valueAsDate: false | undefined;
 }): ColombianHoliday[];
-export declare function colombianHolidays(options?: {
+declare function colombianHolidays(options?: {
     year?: number;
     month?: Month;
     valueAsDate: true;
 }): ColombianHolidayWithNativeDate[];
-export declare function colombianHolidays(options?: {
+declare function colombianHolidays(options?: {
     year?: number;
     month?: Month;
     valueAsDate?: boolean;
 }): ColombianHoliday[] | ColombianHolidayWithNativeDate[];
-export default colombianHolidays;
-export { getHolidaysForYear } from "./utils/getHolidaysByYear";
-export { isHoliday } from "./utils/isHoliday";
-export { holidaysWithinInterval } from "./utils/holidaysWithinInterval";
+
+export { FIRST_HOLIDAY_YEAR, LAST_HOLIDAY_YEAR, type Month, colombianHolidays, colombianHolidays as default, getHolidaysForYear, holidaysWithinInterval, isHoliday };

package/dist/index.js

@@ -1,47 +1,337 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.holidaysWithinInterval = exports.isHoliday = exports.getHolidaysForYear = exports.colombianHolidays = exports.LAST_HOLIDAY_YEAR = exports.FIRST_HOLIDAY_YEAR = void 0;
-const helpers_1 = __importDefault(require("./helpers"));
-const holidays_1 = __importDefault(require("./holidays"));
-// pascua package year limits
-exports.FIRST_HOLIDAY_YEAR = 1583;
-exports.LAST_HOLIDAY_YEAR = 4099;
-function colombianHolidays({ year = new Date().getUTCFullYear(), month, valueAsDate = false, } = {}) {
-    if (year < exports.FIRST_HOLIDAY_YEAR || year > exports.LAST_HOLIDAY_YEAR) {
-        throw new Error(`The year should be between ${exports.FIRST_HOLIDAY_YEAR} and ${exports.LAST_HOLIDAY_YEAR}`);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FIRST_HOLIDAY_YEAR: () => FIRST_HOLIDAY_YEAR,
+  LAST_HOLIDAY_YEAR: () => LAST_HOLIDAY_YEAR,
+  colombianHolidays: () => colombianHolidays,
+  default: () => index_default,
+  getHolidaysForYear: () => getHolidaysForYear,
+  holidaysWithinInterval: () => holidaysWithinInterval,
+  isHoliday: () => isHoliday
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/helpers.ts
+var import_pascua = __toESM(require("pascua"));
+var NEW_HOLIDAY_SCHEMA_START_YEAR = 1984;
+function getNextDayOfWeek(date, dayOfWeek) {
+  const resultDate = new Date(date);
+  resultDate.setUTCDate(
+    date.getUTCDate() + (7 + dayOfWeek - date.getUTCDay()) % 7
+  );
+  return resultDate;
+}
+function getNextMonday(date) {
+  const MONDAY = 1;
+  return getNextDayOfWeek(date, MONDAY);
+}
+function isEasterHoliday(holiday) {
+  return "offset" in holiday;
+}
+function getHolidayDate(holiday, year) {
+  if (isEasterHoliday(holiday)) {
+    const { month, day } = (0, import_pascua.default)(year);
+    const date = new Date(generateUtcStringFromDateParts(year, month, 1));
+    date.setUTCDate(day + holiday.offset);
+    return date;
+  }
+  return new Date(
+    generateUtcStringFromDateParts(year, holiday.month, holiday.day)
+  );
+}
+function generateUtcStringFromDateParts(year, month, day) {
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(
+    2,
+    "0"
+  )}`;
+}
+function getHoliday(holiday, {
+  year = (/* @__PURE__ */ new Date()).getUTCFullYear(),
+  valueAsDate = false
+} = {}) {
+  const holidayDate = getHolidayDate(holiday, year);
+  const celebrationDate = year >= NEW_HOLIDAY_SCHEMA_START_YEAR && holiday.nextMonday ? getNextMonday(holidayDate) : holidayDate;
+  return {
+    date: valueAsDate ? holidayDate : holidayDate.toISOString().slice(0, 10),
+    celebrationDate: valueAsDate ? celebrationDate : celebrationDate.toISOString().slice(0, 10),
+    name: holiday.name,
+    nextMonday: year >= NEW_HOLIDAY_SCHEMA_START_YEAR && holiday.nextMonday
+  };
+}
+var helpers_default = getHoliday;
+
+// src/holidays.ts
+var dateHolidays = [
+  {
+    month: 1,
+    day: 1,
+    name: {
+      es: "A\xF1o Nuevo",
+      en: "New Year's Day"
+    },
+    nextMonday: false
+  },
+  {
+    month: 1,
+    day: 6,
+    name: {
+      es: "Reyes Magos",
+      en: "Epiphany"
+    },
+    nextMonday: true
+  },
+  {
+    month: 3,
+    day: 19,
+    name: {
+      es: "San Jos\xE9",
+      en: "Saint Joseph's Day"
+    },
+    nextMonday: true
+  },
+  {
+    month: 5,
+    day: 1,
+    name: {
+      es: "D\xEDa del Trabajo",
+      en: "Labour Day"
+    },
+    nextMonday: false
+  },
+  {
+    month: 6,
+    day: 29,
+    name: {
+      es: "San Pedro y San Pablo",
+      en: "Saint Peter and Saint Paul"
+    },
+    nextMonday: true
+  },
+  {
+    month: 7,
+    day: 20,
+    name: {
+      es: "Grito de la Independencia",
+      en: "Declaration of Independence"
+    },
+    nextMonday: false
+  },
+  {
+    month: 8,
+    day: 7,
+    name: {
+      es: "Batalla de Boyac\xE1",
+      en: "Battle of Boyac\xE1"
+    },
+    nextMonday: false
+  },
+  {
+    month: 8,
+    day: 15,
+    name: {
+      es: "Asunci\xF3n de la Virgen",
+      en: "Assumption of Mary"
+    },
+    nextMonday: true
+  },
+  {
+    month: 10,
+    day: 12,
+    name: {
+      es: "D\xEDa de la Raza",
+      en: "Columbus Day"
+    },
+    nextMonday: true
+  },
+  {
+    month: 11,
+    day: 1,
+    name: {
+      es: "Todos los Santos",
+      en: "All Saints\u2019 Day"
+    },
+    nextMonday: true
+  },
+  {
+    month: 11,
+    day: 11,
+    name: { es: "Independencia de Cartagena", en: "Independence of Cartagena" },
+    nextMonday: true
+  },
+  {
+    month: 12,
+    day: 8,
+    name: { es: "Inmaculada Concepci\xF3n", en: "Immaculate Conception" },
+    nextMonday: false
+  },
+  {
+    month: 12,
+    day: 25,
+    name: { es: "Navidad", en: "Christmas" },
+    nextMonday: false
+  }
+];
+var easterHolidays = [
+  {
+    offset: -3,
+    name: { es: "Jueves Santo", en: "Maundy Thursday" },
+    nextMonday: false
+  },
+  {
+    offset: -2,
+    name: { es: "Viernes Santo", en: "Good Friday" },
+    nextMonday: false
+  },
+  {
+    offset: 39,
+    name: { es: "Ascensi\xF3n del Se\xF1or", en: "Ascension of Jesus" },
+    nextMonday: true
+  },
+  {
+    offset: 60,
+    name: { es: "Corpus Christi", en: "Corpus Christi" },
+    nextMonday: true
+  },
+  {
+    offset: 68,
+    name: { es: "Sagrado Coraz\xF3n de Jes\xFAs", en: "Sacred Heart" },
+    nextMonday: true
+  }
+];
+var holidays_default = [...dateHolidays, ...easterHolidays];
+
+// src/utils/getHolidaysByYear.ts
+var holidaysWithNativeDateCache = /* @__PURE__ */ new Map();
+var holidaysCache = /* @__PURE__ */ new Map();
+function getHolidaysForYear(year, { valueAsDate = false } = {}) {
+  if (valueAsDate) {
+    const cachedHolidays2 = holidaysWithNativeDateCache.get(year);
+    if (cachedHolidays2) {
+      return cachedHolidays2;
+    }
+    const holidays2 = index_default({ year, valueAsDate });
+    holidaysWithNativeDateCache.set(year, holidays2);
+    return holidays2;
+  }
+  const cachedHolidays = holidaysCache.get(year);
+  if (cachedHolidays) {
+    return cachedHolidays;
+  }
+  const holidays = index_default({ year, valueAsDate });
+  holidaysCache.set(year, holidays);
+  return holidays;
+}
+
+// src/utils/helpers.ts
+function isSameDate(date1, date2) {
+  return date1.getUTCDate() === date2.getUTCDate() && date1.getUTCMonth() === date2.getUTCMonth() && date1.getUTCFullYear() === date2.getUTCFullYear();
+}
+
+// src/utils/isHoliday.ts
+function isHoliday(date) {
+  const holidays = getHolidaysForYear(date.getUTCFullYear(), {
+    valueAsDate: true
+  });
+  return holidays.some(
+    ({ celebrationDate }) => isSameDate(celebrationDate, date)
+  );
+}
+
+// src/utils/holidaysWithinInterval.ts
+function holidaysWithinInterval({
+  start,
+  end,
+  valueAsDate = false
+}) {
+  if (start >= end) {
+    throw new Error("end date should be greater than start date");
+  }
+  const yearEnd = end.getUTCFullYear();
+  const yearStart = start.getUTCFullYear();
+  const holidays = Array.from(
+    { length: yearEnd - yearStart + 1 },
+    (_, i) => getHolidaysForYear(i + yearStart, { valueAsDate: true })
+  ).flat();
+  const holidaysWithin = holidays.filter(
+    ({ celebrationDate }) => celebrationDate >= start && celebrationDate <= end
+  );
+  if (valueAsDate) {
+    return holidaysWithin;
+  }
+  return holidaysWithin.map((holiday) => ({
+    ...holiday,
+    date: holiday.date.toISOString().slice(0, 10),
+    celebrationDate: holiday.celebrationDate.toISOString().slice(0, 10)
+  }));
+}
+
+// src/index.ts
+var FIRST_HOLIDAY_YEAR = 1583;
+var LAST_HOLIDAY_YEAR = 4099;
+function colombianHolidays({
+  year = (/* @__PURE__ */ new Date()).getUTCFullYear(),
+  month,
+  valueAsDate = false
+} = {}) {
+  if (year < FIRST_HOLIDAY_YEAR || year > LAST_HOLIDAY_YEAR) {
+    throw new Error(
+      `The year should be between ${FIRST_HOLIDAY_YEAR} and ${LAST_HOLIDAY_YEAR}`
+    );
+  }
+  return holidays_default.map((holiday) => helpers_default(holiday, { year, valueAsDate })).filter((holiday) => {
+    if (month === void 0) {
+      return true;
     }
-    return holidays_1.default
-        .map((holiday) => (0, helpers_1.default)(holiday, { year, valueAsDate }))
-        .filter((holiday) => {
-        if (month === undefined) {
-            return true;
-        }
-        if (typeof holiday.celebrationDate === "string") {
-            return Number(holiday.celebrationDate.slice(5, 7)) === month;
-        }
-        return holiday.celebrationDate.getUTCMonth() + 1 === month;
-    })
-        .sort((a, b) => {
-        if (a.celebrationDate instanceof Date &&
-            b.celebrationDate instanceof Date) {
-            return a.celebrationDate.getTime() - b.celebrationDate.getTime();
-        }
-        if (typeof a.celebrationDate === "string" &&
-            typeof b.celebrationDate === "string") {
-            return a.celebrationDate.localeCompare(b.celebrationDate);
-        }
-        throw new Error("Invariant violation: this state is not possible.");
-    });
-}
-exports.colombianHolidays = colombianHolidays;
-exports.default = colombianHolidays;
-var getHolidaysByYear_1 = require("./utils/getHolidaysByYear");
-Object.defineProperty(exports, "getHolidaysForYear", { enumerable: true, get: function () { return getHolidaysByYear_1.getHolidaysForYear; } });
-var isHoliday_1 = require("./utils/isHoliday");
-Object.defineProperty(exports, "isHoliday", { enumerable: true, get: function () { return isHoliday_1.isHoliday; } });
-var holidaysWithinInterval_1 = require("./utils/holidaysWithinInterval");
-Object.defineProperty(exports, "holidaysWithinInterval", { enumerable: true, get: function () { return holidaysWithinInterval_1.holidaysWithinInterval; } });
-//# sourceMappingURL=index.js.map
+    if (typeof holiday.celebrationDate === "string") {
+      return Number(holiday.celebrationDate.slice(5, 7)) === month;
+    }
+    return holiday.celebrationDate.getUTCMonth() + 1 === month;
+  }).sort((a, b) => {
+    if (a.celebrationDate instanceof Date && b.celebrationDate instanceof Date) {
+      return a.celebrationDate.getTime() - b.celebrationDate.getTime();
+    }
+    if (typeof a.celebrationDate === "string" && typeof b.celebrationDate === "string") {
+      return a.celebrationDate.localeCompare(b.celebrationDate);
+    }
+    throw new Error("Invariant violation: this state is not possible.");
+  });
+}
+var index_default = colombianHolidays;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FIRST_HOLIDAY_YEAR,
+  LAST_HOLIDAY_YEAR,
+  colombianHolidays,
+  getHolidaysForYear,
+  holidaysWithinInterval,
+  isHoliday
+});