@hapiboo/date 2.0.0

package/dist/class.d.ts

@@ -0,0 +1,49 @@
+export declare class DateObject {
+    private val;
+    private constructor();
+    static set(epochMilliseconds: number): DateObject;
+    static now(): DateObject;
+    static today(): DateObject;
+    static yesterday(): DateObject;
+    static startOfWeek(): DateObject;
+    static startOfMonth(): DateObject;
+    static startOfYear(): DateObject;
+    get _value(): string;
+    get hour(): number;
+    get day(): number;
+    get month(): number;
+    get year(): number;
+    get weekday(): number;
+    toString(): string;
+    toUtc(): string;
+    toLocalDateShort(locale: string): string;
+    toMonthShortString(): string;
+    toWeekdayString(): string;
+    private clone;
+    addMilisecond(count: number): DateObject;
+    addSecond(count: number): DateObject;
+    addMinute(count: number): DateObject;
+    addHour(count: number): DateObject;
+    addDay(count: number): DateObject;
+    addMonth(count: number): DateObject;
+    addYear(count: number): DateObject;
+    resetYear(): DateObject;
+    resetDay(): DateObject;
+    removeMinutes(): DateObject;
+    removeHours(): DateObject;
+    removeDays(): DateObject;
+    equals(dateToCompare: DateObject): boolean;
+    sameDay(dateToCompare: DateObject): boolean;
+    isDateBetween(startDate: DateObject, endDate: DateObject): boolean;
+    isGreater(dateToCompare: DateObject): boolean;
+    isGreaterOrEqual(dateToCompare: DateObject): boolean;
+    isSmaller(dateToCompare: DateObject): boolean;
+    isSmallerOrEqual(dateToCompare: DateObject): boolean;
+    compare(dateToCompare: DateObject): number;
+    isWeekday(): boolean;
+    isWeekend(): boolean;
+    isHoliday(): boolean;
+    valueOf(): number;
+    getDaysDifference(dateToCompare: DateObject): number;
+    getHoursDifference(dateToCompare: DateObject): number;
+}

package/dist/class.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateObject = void 0;
+const luxon_1 = require("luxon");
+const service_1 = require("./service");
+const holiday_1 = require("./holiday");
+class DateObject {
+    constructor(val) {
+        this.val = val;
+    }
+    static set(epochMilliseconds) {
+        return new DateObject(luxon_1.DateTime.fromMillis(epochMilliseconds));
+    }
+    static now() {
+        return new DateObject(luxon_1.DateTime.local());
+    }
+    static today() {
+        const now = luxon_1.DateTime.local();
+        return service_1.dateService.date(now.year, now.month, now.day);
+    }
+    static yesterday() {
+        return DateObject.today().addDay(-1);
+    }
+    static startOfWeek() {
+        const today = DateObject.today();
+        return today.addDay(1 - today.weekday);
+    }
+    static startOfMonth() {
+        const now = luxon_1.DateTime.local();
+        return service_1.dateService.date(now.year, now.month, 1);
+    }
+    static startOfYear() {
+        const now = luxon_1.DateTime.local();
+        return service_1.dateService.date(now.year, 1, 1);
+    }
+    get _value() {
+        return this.toString();
+    }
+    get hour() {
+        return this.val.hour;
+    }
+    get day() {
+        return this.val.day;
+    }
+    get month() {
+        return this.val.month;
+    }
+    get year() {
+        return this.val.year;
+    }
+    get weekday() {
+        return this.val.weekday;
+    }
+    toString() {
+        return this.val.toString();
+    }
+    toUtc() {
+        return this.val.toUTC().toString();
+    }
+    toLocalDateShort(locale) {
+        return this.val.setLocale(locale).toLocaleString(luxon_1.DateTime.DATE_SHORT);
+    }
+    toMonthShortString() {
+        return this.val.toFormat('LLL').toUpperCase();
+    }
+    toWeekdayString() {
+        return this.val.toFormat('ccc');
+    }
+    clone() {
+        return luxon_1.DateTime.local(this.val.year, this.val.month, this.val.day, this.val.hour, this.val.minute, this.val.second, this.val.millisecond);
+    }
+    addMilisecond(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ milliseconds: count })));
+    }
+    addSecond(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ seconds: count })));
+    }
+    addMinute(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ minutes: count })));
+    }
+    addHour(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ hours: count })));
+    }
+    addDay(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ days: count })));
+    }
+    addMonth(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ months: count })));
+    }
+    addYear(count) {
+        return new DateObject(this.clone().plus(luxon_1.Duration.fromObject({ years: count })));
+    }
+    resetYear() {
+        return new DateObject(this.clone().set({ year: 2000 }));
+    }
+    resetDay() {
+        return new DateObject(this.resetYear().val.set({ month: 1, day: 1 }));
+    }
+    removeMinutes() {
+        return new DateObject(this.clone().set({ minute: 0, second: 0, millisecond: 0 }));
+    }
+    removeHours() {
+        return new DateObject(this.removeMinutes().val.set({ hour: 0 }));
+    }
+    removeDays() {
+        return new DateObject(this.removeHours().val.set({ day: 1 }));
+    }
+    equals(dateToCompare) {
+        return +this.val === +dateToCompare.val;
+    }
+    sameDay(dateToCompare) {
+        return this.val.hasSame(dateToCompare.val, 'day') &&
+            this.val.hasSame(dateToCompare.val, 'month') &&
+            this.val.hasSame(dateToCompare.val, 'year');
+    }
+    isDateBetween(startDate, endDate) {
+        return this.val >= startDate.val && this.val <= endDate.val;
+    }
+    isGreater(dateToCompare) {
+        return this.val > dateToCompare.val;
+    }
+    isGreaterOrEqual(dateToCompare) {
+        return this.val >= dateToCompare.val;
+    }
+    isSmaller(dateToCompare) {
+        return this.val < dateToCompare.val;
+    }
+    isSmallerOrEqual(dateToCompare) {
+        return this.val <= dateToCompare.val;
+    }
+    compare(dateToCompare) {
+        if (this.equals(dateToCompare)) {
+            return 0;
+        }
+        else if (this.isGreater(dateToCompare)) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    isWeekday() {
+        return this.weekday < 6;
+    }
+    isWeekend() {
+        return this.weekday > 5;
+    }
+    isHoliday() {
+        return holiday_1.holidayService.isHoliday(this);
+    }
+    valueOf() {
+        return this.val.valueOf();
+    }
+    getDaysDifference(dateToCompare) {
+        return luxon_1.Interval.fromDateTimes(this.val, dateToCompare.val).count('day');
+    }
+    getHoursDifference(dateToCompare) {
+        return luxon_1.Interval.fromDateTimes(this.val, dateToCompare.val).toDuration(['hours', 'minutes']).hours;
+    }
+}
+exports.DateObject = DateObject;

package/dist/holiday.d.ts

@@ -0,0 +1,34 @@
+import { DateObject } from './class';
+export declare class Holiday {
+    name: string;
+    month: number;
+    day: number | {
+        weekday: number;
+        count: number;
+    };
+    constructor(name: string, month: number, day: number | {
+        weekday: number;
+        count: number;
+    });
+}
+export declare namespace holidayService {
+    type KnownHolidays = {
+        ChristmasEve: Holiday;
+        ChristmasDay: Holiday;
+        Christmas2ndDay: Holiday;
+        NewYearDay: Holiday;
+        USIndependenceDay: Holiday;
+        USThanksgivingDay: Holiday;
+        USMemorialDay: Holiday;
+        USLaborDay: Holiday;
+        PLIndependenceDay: Holiday;
+        PLLaborDay: Holiday;
+        PLConstitutionDay: Holiday;
+        PLAllSaintsDay: Holiday;
+    };
+    export const known: KnownHolidays;
+    export function registerHoliday(holiday: Holiday): void;
+    export function isHoliday(date: DateObject): boolean;
+    export function checkHoliday(date: DateObject, holiday: Holiday): boolean;
+    export {};
+}

package/dist/holiday.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.holidayService = exports.Holiday = void 0;
+const service_1 = require("./service");
+class Holiday {
+    constructor(name, month, day) {
+        this.name = name;
+        this.month = month;
+        this.day = day;
+    }
+}
+exports.Holiday = Holiday;
+function getNthDay(year, month, weekday, count) {
+    const firstDayOfMonth = service_1.dateService.date(year, month, 1);
+    // is target day before or after first day
+    const offsetThreshold = firstDayOfMonth.weekday - weekday;
+    let offsetFromTargetDay;
+    if (offsetThreshold > 0) {
+        // get to target day if target is after first day
+        offsetFromTargetDay = 7 - offsetThreshold;
+    }
+    else {
+        // reverse threshold to get to target from first day
+        offsetFromTargetDay = offsetThreshold * -1;
+    }
+    const firstOccurenceOfTargetDay = firstDayOfMonth.addDay(offsetFromTargetDay);
+    const nthDay = firstOccurenceOfTargetDay.addDay((count - 1) * 7);
+    return nthDay;
+}
+var holidayService;
+(function (holidayService) {
+    const _list = [];
+    holidayService.known = {
+        ChristmasEve: new Holiday('Christmas Day', 12, 24),
+        ChristmasDay: new Holiday('Christmas Day', 12, 25),
+        Christmas2ndDay: new Holiday('Christmas Day', 12, 26),
+        NewYearDay: new Holiday('New Year\'s Day', 1, 2),
+        USIndependenceDay: new Holiday('Independence Day', 7, 4),
+        USThanksgivingDay: new Holiday('Thanksgiving Day', 11, { weekday: 4, count: 4 }),
+        USMemorialDay: new Holiday('Memorial Day', 5, { weekday: 1, count: -1 }),
+        USLaborDay: new Holiday('Labor Day', 9, { weekday: 1, count: 1 }),
+        PLIndependenceDay: new Holiday('Independence Day', 11, 11),
+        PLConstitutionDay: new Holiday('Constitution Day', 5, 3),
+        PLLaborDay: new Holiday('Labor Day', 5, 1),
+        PLAllSaintsDay: new Holiday('All Saints Day', 11, 1),
+    };
+    function registerHoliday(holiday) {
+        _list.push(holiday);
+    }
+    holidayService.registerHoliday = registerHoliday;
+    function isHoliday(date) {
+        return _list.some((holiday) => {
+            return checkHoliday(date, holiday);
+        });
+    }
+    holidayService.isHoliday = isHoliday;
+    function checkHoliday(date, holiday) {
+        const justDate = date.removeHours();
+        let holy;
+        if (typeof holiday.day === 'number') {
+            //fixed holiday
+            holy = service_1.dateService.date(justDate.year, holiday.month, holiday.day);
+        }
+        else {
+            //moveable holiday
+            if (holiday.day.count > 1) {
+                //we're counting from beginning
+                //let's get nth weekday in specific month
+                holy = getNthDay(justDate.year, holiday.month, holiday.day.weekday, holiday.day.count);
+            }
+            else {
+                //we're counting from the end
+                //let's get started from the first weekday in next month
+                holy = getNthDay(holiday.month === 12 ? justDate.year + 1 : justDate.year, holiday.month === 12 ? 1 : holiday.month + 1, holiday.day.weekday, 1).addDay(7 * holiday.day.count);
+            }
+        }
+        return justDate.sameDay(holy);
+    }
+    holidayService.checkHoliday = checkHoliday;
+})(holidayService || (exports.holidayService = holidayService = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { dateService } from './service';
+import { DateObject } from './class';
+import { dateUtils } from './utils';
+import { holidayService, Holiday } from './holiday';
+export { DateObject, Holiday, dateService, holidayService, dateUtils };

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateUtils = exports.holidayService = exports.dateService = exports.Holiday = exports.DateObject = void 0;
+const service_1 = require("./service");
+Object.defineProperty(exports, "dateService", { enumerable: true, get: function () { return service_1.dateService; } });
+const class_1 = require("./class");
+Object.defineProperty(exports, "DateObject", { enumerable: true, get: function () { return class_1.DateObject; } });
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "dateUtils", { enumerable: true, get: function () { return utils_1.dateUtils; } });
+const holiday_1 = require("./holiday");
+Object.defineProperty(exports, "holidayService", { enumerable: true, get: function () { return holiday_1.holidayService; } });
+Object.defineProperty(exports, "Holiday", { enumerable: true, get: function () { return holiday_1.Holiday; } });

package/dist/service.d.ts

@@ -0,0 +1,8 @@
+import { DateObject } from './class';
+export declare namespace dateService {
+    function initialize(defaultZoneName: string, defaultLocaleName: string): void;
+    function parseUtcDate(datetime: string): DateObject | undefined;
+    function date(year: number, month: number, day: number): DateObject;
+    function datetime(year: number, month: number, day: number, hour: number, minute: number): DateObject;
+    function daytime(day: DateObject, hour?: number, minute?: number): DateObject;
+}

package/dist/service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateService = void 0;
+const luxon_1 = require("luxon");
+const class_1 = require("./class");
+luxon_1.Settings.defaultZone = 'utc';
+var dateService;
+(function (dateService) {
+    function initialize(defaultZoneName, defaultLocaleName) {
+        luxon_1.Settings.defaultZone = defaultZoneName;
+        luxon_1.Settings.defaultLocale = defaultLocaleName;
+    }
+    dateService.initialize = initialize;
+    function parseUtcDate(datetime) {
+        if (datetime) {
+            const temp = luxon_1.DateTime.fromISO(datetime);
+            if (temp) {
+                if (temp.isValid) {
+                    return class_1.DateObject.set(temp.setZone(luxon_1.Settings.defaultZone).valueOf());
+                }
+                else {
+                    console.error(`Invalid date parsing value: '${datetime}'`);
+                    console.error(temp.invalidReason);
+                    console.error(temp.invalidExplanation);
+                    return undefined;
+                }
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    dateService.parseUtcDate = parseUtcDate;
+    function date(year, month, day) {
+        return class_1.DateObject.set(luxon_1.DateTime.local(year, month, day).valueOf());
+    }
+    dateService.date = date;
+    function datetime(year, month, day, hour, minute) {
+        return class_1.DateObject.set(luxon_1.DateTime.local(year, month, day, hour, minute).valueOf());
+    }
+    dateService.datetime = datetime;
+    function daytime(day, hour = 0, minute = 0) {
+        return datetime(day.year, day.month, day.day, hour, minute);
+    }
+    dateService.daytime = daytime;
+})(dateService || (exports.dateService = dateService = {}));

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { DateObject } from './class';
+export declare namespace dateUtils {
+    function checkPeriod(value: DateObject, start: DateObject, stop?: DateObject): boolean;
+    function checkDatePeriod(value: DateObject, start: DateObject, stop: DateObject): boolean;
+    function checkSameYearPeriod(value: DateObject, start: DateObject, stop: DateObject): boolean;
+    function checkSameDayPeriod(value: DateObject, start: DateObject, stop: DateObject): boolean;
+}

package/dist/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateUtils = void 0;
+const service_1 = require("./service");
+var dateUtils;
+(function (dateUtils) {
+    function checkPeriod(value, start, stop) {
+        if (!stop) {
+            stop = service_1.dateService.date(3000, 12, 31);
+        }
+        return checkDatePeriod(value, start, stop);
+    }
+    dateUtils.checkPeriod = checkPeriod;
+    function checkDatePeriod(value, start, stop) {
+        return value >= start && value <= stop;
+    }
+    dateUtils.checkDatePeriod = checkDatePeriod;
+    function checkSameYearPeriod(value, start, stop) {
+        return checkDatePeriod(value, start, stop);
+    }
+    dateUtils.checkSameYearPeriod = checkSameYearPeriod;
+    function checkSameDayPeriod(value, start, stop) {
+        const val = value.resetDay();
+        const str = start.resetDay();
+        const stp = stop.resetDay();
+        return checkDatePeriod(val, str, stp);
+    }
+    dateUtils.checkSameDayPeriod = checkSameDayPeriod;
+})(dateUtils || (exports.dateUtils = dateUtils = {}));

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+    ...tseslint.configs.recommended,
+    {
+        files: ["**/*.{ts,mts,cts}"],
+        rules: {
+            "@typescript-eslint/no-namespace": "off",
+            indent: ['error', 4],
+            'linebreak-style': ['error', 'unix'],
+            quotes: ['error', 'single'],
+            semi: ['error', 'always'],
+        },
+    },
+]);

package/package.dev.json

@@ -0,0 +1,30 @@
+{
+    "name": "@hapiboo/date",
+    "version": "2.0.1-dev",
+    "description": "MK13 Studio Hapiboo - date services",
+    "author": "MK13 Studio",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "s_public": "cp package.public.json package.json",
+        "s_dev": "cp package.dev.json package.json",
+        "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+        "s_dependency": "cd .. && cd __core && pnpm s_build",
+        "s_build": "tsc --project tsconfig.dev.json",
+        "s_lint": "eslint 'src/*.ts'",
+        "s_lint_fix": "eslint 'src/*.ts' --fix",
+        "s_prepare": "pnpm s_clean && pnpm i && pnpm s_lint && pnpm s_build"
+    },
+    "dependencies": {
+        "luxon": "^3.7.1"
+    },
+    "devDependencies": {
+        "@types/luxon": "^3.6.2",
+        "@typescript-eslint/eslint-plugin": "^8.38.0",
+        "@typescript-eslint/parser": "^8.38.0",
+        "eslint": "^9.32.0",
+        "typescript": "5.8.3",
+        "typescript-eslint": "^8.38.0"
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hapiboo/date",
+  "version": "2.0.0",
+  "description": "MK13 Studio Hapiboo - date services",
+  "author": "MK13 Studio",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "luxon": "^3.7.1"
+  },
+  "devDependencies": {
+    "@types/luxon": "^3.6.2",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.32.0",
+    "typescript": "5.8.3",
+    "typescript-eslint": "^8.38.0"
+  },
+  "scripts": {
+    "s_public": "cp package.public.json package.json",
+    "s_dev": "cp package.dev.json package.json",
+    "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+    "s_build": "tsc --project tsconfig.public.json",
+    "s_lint": "eslint 'src/*.ts'",
+    "s_check": "bash ../../scripts/publish.sh ./",
+    "s_publish": "pnpm s_clean && pnpm i -w=false && pnpm s_lint && pnpm s_build && pnpm s_check && pnpm s_dev"
+  }
+}

package/package.public.json

@@ -0,0 +1,29 @@
+{
+    "name": "@hapiboo/date",
+    "version": "2.0.0",
+    "description": "MK13 Studio Hapiboo - date services",
+    "author": "MK13 Studio",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "s_public": "cp package.public.json package.json",
+        "s_dev": "cp package.dev.json package.json",
+        "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+        "s_build": "tsc --project tsconfig.public.json",
+        "s_lint": "eslint 'src/*.ts'",
+        "s_check": "bash ../../scripts/publish.sh ./",
+        "s_publish": "pnpm s_clean && pnpm i -w=false && pnpm s_lint && pnpm s_build && pnpm s_check && pnpm s_dev"
+    },
+    "dependencies": {
+        "luxon": "^3.7.1"
+    },
+    "devDependencies": {
+        "@types/luxon": "^3.6.2",
+        "@typescript-eslint/eslint-plugin": "^8.38.0",
+        "@typescript-eslint/parser": "^8.38.0",
+        "eslint": "^9.32.0",
+        "typescript": "5.8.3",
+        "typescript-eslint": "^8.38.0"
+    }
+}

package/src/class.ts

@@ -0,0 +1,171 @@
+import { DateTime, Duration, Interval }  from 'luxon';
+import { dateService } from './service';
+import { holidayService } from './holiday';
+
+export class DateObject {
+    private val: DateTime;
+
+    private constructor(val: DateTime) {
+        this.val = val;
+    }
+
+    static set(epochMilliseconds: number): DateObject {
+        return new DateObject(DateTime.fromMillis(epochMilliseconds));
+    }
+    static now(): DateObject {
+        return new DateObject(DateTime.local());
+    }
+    static today(): DateObject {
+        const now = DateTime.local();
+        return dateService.date(now.year, now.month, now.day);
+    }
+    static yesterday(): DateObject {
+        return DateObject.today().addDay(-1);
+    }
+    static startOfWeek(): DateObject {
+        const today = DateObject.today();
+        return today.addDay(1 - today.weekday);
+    }
+    static startOfMonth(): DateObject {
+        const now = DateTime.local();
+        return dateService.date(now.year, now.month, 1);
+    }
+    static startOfYear(): DateObject {
+        const now = DateTime.local();
+        return dateService.date(now.year, 1, 1);
+    }
+
+    get _value(): string {
+        return this.toString();
+    }
+    get hour(): number {
+        return this.val.hour;
+    }
+    get day(): number {
+        return this.val.day;
+    }
+    get month(): number {
+        return this.val.month;
+    }
+    get year(): number {
+        return this.val.year;
+    }
+    get weekday(): number {
+        return this.val.weekday;
+    }
+
+    toString(): string {
+        return this.val.toString();
+    }
+    toUtc(): string {
+        return this.val.toUTC().toString();
+    }
+    toLocalDateShort(locale: string): string {
+        return this.val.setLocale(locale).toLocaleString(DateTime.DATE_SHORT);
+    }
+    toMonthShortString(): string {
+        return this.val.toFormat('LLL').toUpperCase();
+    }
+    toWeekdayString(): string {
+        return this.val.toFormat('ccc');
+    }
+
+    private clone() : DateTime {
+        return DateTime.local(this.val.year, this.val.month, this.val.day, this.val.hour, this.val.minute, this.val.second, this.val.millisecond);
+    }
+
+    addMilisecond(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({milliseconds: count})));
+    }
+    addSecond(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({seconds: count})));
+    }
+    addMinute(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({minutes: count})));
+    }
+    addHour(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({hours: count})));
+    }
+    addDay(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({days: count})));
+    }
+    addMonth(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({months: count})));
+    }
+    addYear(count: number): DateObject {
+        return new DateObject(this.clone().plus(Duration.fromObject({years: count})));
+    }
+
+    resetYear(): DateObject {
+        return new DateObject(this.clone().set({ year: 2000 }));
+    }
+    resetDay(): DateObject {
+        return new DateObject(this.resetYear().val.set({ month: 1, day: 1 }));
+    }
+
+    removeMinutes(): DateObject {
+        return new DateObject(this.clone().set({ minute: 0, second: 0, millisecond: 0 }));
+    }
+    removeHours(): DateObject {
+        return new DateObject(this.removeMinutes().val.set({ hour: 0 }));
+    }
+    removeDays(): DateObject {
+        return new DateObject(this.removeHours().val.set({ day: 1 }));
+    }
+
+    equals(dateToCompare: DateObject): boolean {
+        return +this.val === +dateToCompare.val;
+    }
+    sameDay(dateToCompare: DateObject): boolean {
+        return this.val.hasSame(dateToCompare.val, 'day') &&
+            this.val.hasSame(dateToCompare.val, 'month') && 
+            this.val.hasSame(dateToCompare.val, 'year');
+    } 
+    isDateBetween(startDate: DateObject, endDate: DateObject): boolean {
+        return this.val >= startDate.val && this.val <= endDate.val;
+    }
+    isGreater(dateToCompare: DateObject): boolean {
+        return this.val > dateToCompare.val;
+    }
+    isGreaterOrEqual(dateToCompare: DateObject): boolean {
+        return this.val >= dateToCompare.val;
+    }
+    isSmaller(dateToCompare: DateObject): boolean {
+        return this.val < dateToCompare.val;
+    }
+    isSmallerOrEqual(dateToCompare: DateObject): boolean {
+        return this.val <= dateToCompare.val;
+    }
+
+    compare(dateToCompare: DateObject): number {
+        if (this.equals(dateToCompare)) {
+            return 0;
+        } else if (this.isGreater(dateToCompare)) {
+            return 1;
+        } else {
+            return -1;
+        }
+    }
+
+    isWeekday(): boolean {
+        return this.weekday < 6;
+    }
+    isWeekend(): boolean {
+        return this.weekday > 5;
+    }
+
+    isHoliday(): boolean {
+        return holidayService.isHoliday(this);
+    }
+
+    valueOf(): number {
+        return this.val.valueOf();
+    }
+
+    getDaysDifference(dateToCompare: DateObject): number {
+        return Interval.fromDateTimes(this.val, dateToCompare.val).count('day');
+    }
+    getHoursDifference(dateToCompare: DateObject): number {
+        return Interval.fromDateTimes(this.val, dateToCompare.val).toDuration(['hours', 'minutes']).hours;
+    }
+}

package/src/holiday.ts

@@ -0,0 +1,102 @@
+import { dateService } from './service';
+import { DateObject } from './class';
+
+export class Holiday {
+    name: string;
+    month: number;
+    day: number | { weekday: number, count: number};
+
+    constructor(name: string, month: number, day: number | { weekday: number, count: number}) {
+        this.name = name;
+        this.month = month;
+        this.day = day;
+    }
+}
+
+function getNthDay(year: number, month: number, weekday: number, count: number): DateObject {
+    const firstDayOfMonth = dateService.date(year, month, 1);
+    
+    // is target day before or after first day
+    const offsetThreshold = firstDayOfMonth.weekday - weekday;
+
+    let offsetFromTargetDay: number;
+    if (offsetThreshold > 0) {
+        // get to target day if target is after first day
+        offsetFromTargetDay = 7 - offsetThreshold;
+    } else {
+        // reverse threshold to get to target from first day
+        offsetFromTargetDay = offsetThreshold * -1;
+    }
+    
+    const firstOccurenceOfTargetDay = firstDayOfMonth.addDay(offsetFromTargetDay);
+    const nthDay = firstOccurenceOfTargetDay.addDay((count - 1) * 7);
+    
+    return nthDay;
+}
+
+export namespace holidayService {
+    const _list: Holiday[] = [];
+
+    type KnownHolidays = {
+        ChristmasEve: Holiday;
+        ChristmasDay: Holiday;
+        Christmas2ndDay: Holiday;
+        NewYearDay: Holiday;
+        USIndependenceDay: Holiday;
+        USThanksgivingDay: Holiday;
+        USMemorialDay: Holiday;
+        USLaborDay: Holiday;
+        PLIndependenceDay: Holiday;
+        PLLaborDay: Holiday;
+        PLConstitutionDay: Holiday;
+        PLAllSaintsDay: Holiday;
+    };
+
+    export const known: KnownHolidays = {
+        ChristmasEve: new Holiday('Christmas Day', 12, 24),
+        ChristmasDay: new Holiday('Christmas Day', 12, 25),
+        Christmas2ndDay: new Holiday('Christmas Day', 12, 26),
+        NewYearDay: new Holiday('New Year\'s Day', 1, 2),
+        USIndependenceDay: new Holiday('Independence Day', 7, 4),
+        USThanksgivingDay: new Holiday('Thanksgiving Day', 11, { weekday: 4, count: 4 }),
+        USMemorialDay: new Holiday('Memorial Day', 5, { weekday: 1, count: -1 }),
+        USLaborDay: new Holiday('Labor Day', 9, { weekday: 1, count: 1 }),
+        PLIndependenceDay: new Holiday('Independence Day', 11, 11),
+        PLConstitutionDay: new Holiday('Constitution Day', 5, 3),
+        PLLaborDay: new Holiday('Labor Day', 5, 1),
+        PLAllSaintsDay: new Holiday('All Saints Day', 11, 1),
+    };
+
+    export function registerHoliday(holiday: Holiday){
+        _list.push(holiday);
+    }
+    export function isHoliday(date: DateObject): boolean {
+        return _list.some((holiday) => {
+            return checkHoliday(date, holiday);
+        });
+    }
+    export function checkHoliday(date: DateObject, holiday: Holiday): boolean{
+        const justDate = date.removeHours();
+        let holy: DateObject;
+
+        if (typeof holiday.day === 'number') {
+            //fixed holiday
+            holy = dateService.date(justDate.year, holiday.month, holiday.day);
+        } else {
+            //moveable holiday
+            if (holiday.day.count > 1) {
+                //we're counting from beginning
+                //let's get nth weekday in specific month
+                holy = getNthDay(justDate.year, holiday.month, holiday.day.weekday, holiday.day.count);
+            } else {
+                //we're counting from the end
+                //let's get started from the first weekday in next month
+                holy = getNthDay(
+                    holiday.month === 12 ? justDate.year + 1 : justDate.year, 
+                    holiday.month === 12 ? 1 : holiday.month + 1, 
+                    holiday.day.weekday, 1).addDay(7 * holiday.day.count);
+            }
+        }
+        return justDate.sameDay(holy);
+    }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { dateService } from './service';
+import { DateObject } from './class';
+import { dateUtils } from './utils';
+import { holidayService, Holiday } from './holiday';
+
+export { DateObject, Holiday, dateService, holidayService, dateUtils };

package/src/service.ts

@@ -0,0 +1,43 @@
+import { DateTime, Settings }  from 'luxon';
+import { DateObject } from './class';
+
+Settings.defaultZone = 'utc';
+
+export namespace dateService {
+    
+    export function initialize(defaultZoneName: string, defaultLocaleName: string) {
+        Settings.defaultZone = defaultZoneName;
+        Settings.defaultLocale = defaultLocaleName;
+    }
+
+    export function parseUtcDate(datetime: string) : DateObject | undefined {
+        if (datetime) {
+            const temp = DateTime.fromISO(datetime);
+            if (temp) {
+                if (temp.isValid) {
+                    return DateObject.set(temp.setZone(Settings.defaultZone).valueOf());    
+                } else {
+                    console.error(`Invalid date parsing value: '${datetime}'`);
+                    console.error(temp.invalidReason);
+                    console.error(temp.invalidExplanation);
+
+                    return undefined;
+                }
+            } else {
+                return undefined;
+            }
+        } else {
+            return undefined;
+        }   
+    }
+
+    export function date(year: number, month: number, day: number) : DateObject {
+        return DateObject.set(DateTime.local(year, month, day).valueOf());
+    }
+    export function datetime(year: number, month: number, day: number, hour: number, minute: number): DateObject {
+        return DateObject.set(DateTime.local(year, month, day, hour, minute).valueOf());
+    }
+    export function daytime(day: DateObject, hour: number = 0, minute: number = 0): DateObject {
+        return datetime(day.year, day.month, day.day, hour, minute);
+    }
+}

package/src/utils.ts

@@ -0,0 +1,26 @@
+import { dateService } from './service';
+import { DateObject } from './class';
+
+export namespace dateUtils {
+
+    export function checkPeriod(value: DateObject, start: DateObject, stop?: DateObject): boolean {
+        if (!stop) {
+            stop = dateService.date(3000, 12, 31);
+        }
+
+        return checkDatePeriod(value, start, stop);
+    }
+    export function checkDatePeriod(value: DateObject, start: DateObject, stop: DateObject): boolean {
+        return value >= start && value <= stop;
+    }
+    export function checkSameYearPeriod(value: DateObject, start: DateObject, stop: DateObject): boolean {
+        return checkDatePeriod(value, start, stop);
+    }
+    export function checkSameDayPeriod(value: DateObject, start: DateObject, stop: DateObject): boolean {
+        const val = value.resetDay();
+        const str = start.resetDay();
+        const stp = stop.resetDay();
+
+        return checkDatePeriod(val, str, stp);
+    }
+}

package/tsconfig.base.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": ["ES2020"],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "declaration": true,
+        },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+} 

package/tsconfig.dev.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "sourceMap": true,
+        "declarationMap": true
+    } 
+}

package/tsconfig.public.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "sourceMap": false,
+        "declarationMap": false
+    }
+}