chronos-ts 1.0.2 → 1.1.0

package/README.md

@@ -2,24 +2,36 @@
 Chronos-ts from the name is inspired by the Greek god of time, Chronos. It is a comprehensive TypeScript package for handling time periods, intervals, and date-related operations.
 
 ## Table of Contents
-- [Installation](#installation)
-- [Overview](#overview)
-- [Usage](#usage)
-- [API Reference](#api-reference)
+- [Chronos-ts ⏰](#chronos-ts-)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Overview](#overview)
+  - [Usage](#usage)
+    - [Creating and Manipulating Periods](#creating-and-manipulating-periods)
+    - [Working with Intervals](#working-with-intervals)
+    - [Using Utility Functions](#using-utility-functions)
+  - [API Reference](#api-reference)
     - [Classes](#classes)
-        - [Period](#period)
-        - [Interval](#interval)
-    - [Enums](#enums)
-    - [Precision](#precision)
+      - [Period](#period)
+        - [Constructor](#constructor)
+        - [Methods](#methods)
+        - [Fluent API Methods](#fluent-api-methods)
+      - [Interval](#interval)
+        - [Methods](#methods-1)
+      - [Enums](#enums)
+        - [Precision](#precision)
     - [Utility Function](#utility-function)
     - [Real-world Scenarios](#real-world-scenarios)
-        - [Event Planning and Management](#event-planning-and-management)
-        - [Financial Reporting Periods](#financial-reporting-periods)
-        - [Employee Leave Management](#employee-leave-management)
-        - [Project Timeline Management](#project-timeline-management)
-        - [Subscription Billing Cycle Management](#subscription-billing-cycle-management)
-        - [Employee Shift Management](#employee-shift-management)
-        - [Travel Itinerary Planning](#travel-itinerary-planning)
+      - [**1. Event Planning and Management**](#1-event-planning-and-management)
+      - [**2. Financial  Reporting Periods**](#2-financial--reporting-periods)
+      - [**3. Employee Leave Management**](#3-employee-leave-management)
+      - [**4.  Project Timeline Management**](#4--project-timeline-management)
+      - [**5. Subscription Billing Cycle Management**](#5-subscription-billing-cycle-management)
+      - [**6. Employee Shift Management**](#6-employee-shift-management)
+      - [**7. Travel Itinerary Planning**](#7-travel-itinerary-planning)
+  - [Contributing 🤝](#contributing-)
+  - [License 📝](#license-)
+  - [Acknowledgements 🙏](#acknowledgements-)
 
 ## Installation
 ```bash
@@ -48,7 +60,7 @@ Whether you're building scheduling systems, financial applications, or any proje
 
 ## Usage
 ### Creating and Manipulating Periods
-````typescript
+```typescript
 import { Period, Precision, Interval } from 'chronos-ts';
 
 // Create a period for the year 2023
@@ -70,8 +82,8 @@ console.log(overlap?.getStartDate(), overlap?.getEndDate()); // 2023-04-01, 2023
 // Subtract a period
 const remainingPeriods = year2023.subtract(q2_2023);
 console.log(remainingPeriods.length); // 2
-console.log(remainingPeriods[0].getStartDate(), remainingPeriods[0].getEndDate()); // 2023-01-01, 2023-03-31
-console.log(remainingPeriods[1].getStartDate(), remainingPeriods[1].getEndDate()); // 2023-07-01, 2023-12-31
+console.log(remainingPeriods[0].getStartDate(), remainingPeriods[0].getEndDate()); // 2023-01-01, 2023-04-01
+console.log(remainingPeriods[1].getStartDate(), remainingPeriods[1].getEndDate()); // 2023-06-30, 2023-12-31
 
 // Create a period with an interval
 const weeklyPeriod = new Period('2023-01-01', '2023-12-31', Precision.WEEK, Interval.weeks(1));
@@ -80,7 +92,7 @@ const weeklyPeriod = new Period('2023-01-01', '2023-12-31', Precision.WEEK, Inte
 const weeklyDates = weeklyPeriod.getDatesInInterval();
 console.log(weeklyDates?.length); // 53 (number of weeks in 2023)
 
-// Renew a period
+// Renew a period - FIXED: Use getter methods
 const nextYear = year2023.renew();
 console.log(nextYear.getStartDate(), nextYear.getEndDate()); // 2024-01-01, 2024-12-31
 
@@ -90,7 +102,7 @@ const customPeriod = new Period('2023-01-01', '2023-12-31')
   .setInterval(Interval.months(3));
 
 console.log(customPeriod.getDatesInInterval()?.length); // 5 (Jan, Apr, Jul, Oct, Jan)
-````
+```
 
 ### Working with Intervals
 ``` typescript
@@ -218,7 +230,7 @@ The package includes various utility functions for working with dates:
 - `range(start: number, end: number, step: number = 1): number[]` - Returns an array of numbers within the specified range.
 
 ### Real-world Scenarios
-**1. Event Planning and Management**
+#### **1. Event Planning and Management**
 The `Period` class can be used to represent events, while the `Interval` class can help manage recurring events.
 ``` typescript
 import { Period, Interval, Precision } from 'chronos-ts';
@@ -240,7 +252,7 @@ const conflictingMeetings = meetingDates?.filter(date => conference.contains(dat
 console.log(`There are ${conflictingMeetings.length} conflicting meetings during the conference.`);
 ```
 
-**2. Financial  Reporting Periods**
+#### **2. Financial  Reporting Periods**
 Use the `Period` class to represent financial quarters and calculate year-to-date periods.
 ``` typescript
 import { Period, Precision } from 'chronos-ts';
@@ -250,9 +262,9 @@ const q2_2023 = new Period('2023-04-01', '2023-06-30', Precision.DAY);
 const q3_2023 = new Period('2023-07-01', '2023-09-30', Precision.DAY);
 const q4_2023 = new Period('2023-10-01', '2023-12-31', Precision.DAY);
 
-// Calculate Year-to-Date period
+// Calculate Year-to-Date period - FIXED: Use getter method
 const ytd = (currentQuarter: Period): Period => {
-  return new Period('2023-01-01', currentQuarter.endDate, Precision.DAY);
+  return new Period('2023-01-01', currentQuarter.getEndDate(), Precision.DAY);
 };
 
 const q3YTD = ytd(q3_2023);
@@ -269,7 +281,7 @@ const q3Revenue = 1200000;
 console.log(`Q3 QoQ Growth: ${calculateQoQGrowth(q3Revenue, q2Revenue)}`);
 ```
 
-**3. Employee Leave Management**
+#### **3. Employee Leave Management**
 Use the `Period` class to manage employee leave requests and calculate leave balances.
 ``` typescript
 import { Period, Precision } from 'chronos-ts';
@@ -298,7 +310,7 @@ console.log(`Next year's leave balance: ${nextYearLeaveBalance ? nextYearLeaveBa
 
 ```
 
-**4.  Project Timeline Management**
+#### **4.  Project Timeline Management**
 Use the Period class to manage project timelines and track overlapping tasks.
 ``` typescript
 import { Period, Precision } from 'chronos-ts';
@@ -339,7 +351,7 @@ const currentProgress = calculateProgress(new Date('2023-06-15'));
 console.log(`Project progress: ${currentProgress.toFixed(2)}%`);
 ```
 
-**5. Subscription Billing Cycle Management**
+#### **5. Subscription Billing Cycle Management**
 Use the Period class to manage subscription periods and calculate renewal dates.
 ``` typescript
 import { Period, Precision, addToDate } from 'chronos-ts';
@@ -384,7 +396,7 @@ const renewedPeriod = monthlySubscription.getCurrentPeriod();
 console.log(`Monthly subscription renewed. New period: ${renewedPeriod.getStartDate().toDateString()} - ${renewedPeriod.getEndDate().toDateString()}`);
 ```
 
-**6. Employee Shift Management**
+#### **6. Employee Shift Management**
 
 Use the `Period` and `Interval` classes to manage employee shifts and calculate overtime.
 
@@ -446,7 +458,7 @@ const hasConflict = (shifts: Shift[]): boolean => {
 console.log(`Shifts have conflicts: ${hasConflict(employeeShifts)}`);
 ```
 
-**7. Travel Itinerary Planning**
+#### **7. Travel Itinerary Planning**
 Use the `Period` class to manage travel itineraries and check for scheduling conflicts.
 ``` typescript
 import { Period, Precision, addToDate } from 'chronos-ts';
@@ -510,4 +522,4 @@ Contributions, issues and feature requests are welcome. After cloning & setting
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 ## Acknowledgements 🙏
-- [spatie/period]((https://github.com/spatie/period)
+- [spatie/period](https://github.com/spatie/period)

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { Period } from './period';
 export { Precision } from './precision';
 export { Interval } from './interval';
+export * from './utils';

package/dist/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interval = exports.Precision = exports.Period = void 0;
 var period_1 = require("./period");
@@ -7,3 +21,4 @@ var precision_1 = require("./precision");
 Object.defineProperty(exports, "Precision", { enumerable: true, get: function () { return precision_1.Precision; } });
 var interval_1 = require("./interval");
 Object.defineProperty(exports, "Interval", { enumerable: true, get: function () { return interval_1.Interval; } });
+__exportStar(require("./utils"), exports);

package/dist/period.d.ts

@@ -12,8 +12,17 @@ export declare class Period {
      * @param end - The end date of the period, either as a string or a Date object.
      * @param precision - The precision level of the period, defaulting to Precision.DAY.
      * @param interval - An optional interval associated with the period, defaulting to null.
+     * @throws {Error} If start date is after end date or if dates are invalid.
      */
     constructor(start: string | Date, end: string | Date, precision?: Precision, interval?: Interval | null);
+    /**
+     * Validates and converts a date input to a Date object.
+     *
+     * @param date - The date to validate, either as a string or Date object.
+     * @returns A valid Date object.
+     * @throws {Error} If the date is invalid.
+     */
+    private validateDate;
     /**
      * Retrieves the start date of the period.
      *
@@ -159,6 +168,7 @@ export declare class Period {
      *
      * @param start - The start date, which can be a string or a Date object.
      * @returns The current instance for method chaining.
+     * @throws {Error} If the new start date is after the current end date.
      */
     setStart(start: string | Date): this;
     /**
@@ -166,6 +176,7 @@ export declare class Period {
      *
      * @param end - The end date as a string or Date object.
      * @returns The current instance for method chaining.
+     * @throws {Error} If the new end date is before the current start date.
      */
     setEnd(end: string | Date): this;
     /**

package/dist/period.js

@@ -11,13 +11,31 @@ class Period {
      * @param end - The end date of the period, either as a string or a Date object.
      * @param precision - The precision level of the period, defaulting to Precision.DAY.
      * @param interval - An optional interval associated with the period, defaulting to null.
+     * @throws {Error} If start date is after end date or if dates are invalid.
      */
     constructor(start, end, precision = precision_1.Precision.DAY, interval = null) {
-        this.startDate = new Date(start);
-        this.endDate = new Date(end);
+        this.startDate = this.validateDate(start);
+        this.endDate = this.validateDate(end);
+        if (this.startDate > this.endDate) {
+            throw new Error('Start date must be before or equal to end date');
+        }
         this.precision = precision;
         this.interval = interval;
     }
+    /**
+     * Validates and converts a date input to a Date object.
+     *
+     * @param date - The date to validate, either as a string or Date object.
+     * @returns A valid Date object.
+     * @throws {Error} If the date is invalid.
+     */
+    validateDate(date) {
+        const result = new Date(date);
+        if (isNaN(result.getTime())) {
+            throw new Error(`Invalid date: ${date}`);
+        }
+        return result;
+    }
     /**
      * Retrieves the start date of the period.
      *
@@ -41,7 +59,7 @@ class Period {
      * @returns `true` if the date is within the period, `false` otherwise.
      */
     contains(date) {
-        const checkDate = new Date(date);
+        const checkDate = this.validateDate(date);
         return checkDate >= this.startDate && checkDate <= this.endDate;
     }
     /**
@@ -138,7 +156,7 @@ class Period {
         if (this.endDate.getDate() < this.startDate.getDate()) {
             months--;
         }
-        return months;
+        return Math.max(0, months);
     }
     /**
      * Calculates the number of whole years in the interval.
@@ -184,13 +202,13 @@ class Period {
             return [this];
         }
         const periods = [];
+        // Add period before the overlap (if any)
         if (this.startDate < other.startDate) {
-            const endDate = new Date(other.startDate.getTime() - 1);
-            periods.push(new Period(this.startDate, endDate, this.precision));
+            periods.push(new Period(this.startDate, other.startDate, this.precision));
         }
+        // Add period after the overlap (if any)
         if (this.endDate > other.endDate) {
-            const startDate = new Date(other.endDate.getTime() + 1);
-            periods.push(new Period(startDate, this.endDate, this.precision));
+            periods.push(new Period(other.endDate, this.endDate, this.precision));
         }
         return periods;
     }
@@ -206,10 +224,20 @@ class Period {
         if (this.overlapsWith(other) || this.isAdjacentTo(other)) {
             return null;
         }
-        const precisionMs = (0, precision_1.getPrecisionInMilliseconds)(this.precision);
-        const start = this.endDate < other.startDate ? this.endDate : other.endDate;
-        const end = this.startDate > other.startDate ? this.startDate : other.startDate;
-        return new Period(new Date(start.getTime() + precisionMs), new Date(end.getTime() - precisionMs), this.precision);
+        let start, end;
+        if (this.endDate < other.startDate) {
+            start = this.endDate;
+            end = other.startDate;
+        }
+        else {
+            start = other.endDate;
+            end = this.startDate;
+        }
+        // Ensure start is before end for valid Period creation
+        if (start >= end) {
+            return null;
+        }
+        return new Period(start, end, this.precision);
     }
     /**
      * Computes the symmetric difference between this period and another period.
@@ -261,8 +289,9 @@ class Period {
      */
     renew() {
         const length = this.length();
-        const newStart = new Date(this.endDate.getTime() + (0, precision_1.getPrecisionInMilliseconds)(this.precision));
-        const newEnd = new Date(newStart.getTime() + length * (0, precision_1.getPrecisionInMilliseconds)(this.precision));
+        const precisionMs = (0, precision_1.getPrecisionInMilliseconds)(this.precision);
+        const newStart = new Date(this.endDate.getTime() + precisionMs);
+        const newEnd = new Date(newStart.getTime() + length * precisionMs);
         return new Period(newStart, newEnd, this.precision, this.interval);
     }
     /**
@@ -287,9 +316,14 @@ class Period {
      *
      * @param start - The start date, which can be a string or a Date object.
      * @returns The current instance for method chaining.
+     * @throws {Error} If the new start date is after the current end date.
      */
     setStart(start) {
-        this.startDate = new Date(start);
+        const newStartDate = this.validateDate(start);
+        if (newStartDate > this.endDate) {
+            throw new Error('Start date must be before or equal to end date');
+        }
+        this.startDate = newStartDate;
         return this;
     }
     /**
@@ -297,9 +331,14 @@ class Period {
      *
      * @param end - The end date as a string or Date object.
      * @returns The current instance for method chaining.
+     * @throws {Error} If the new end date is before the current start date.
      */
     setEnd(end) {
-        this.endDate = new Date(end);
+        const newEndDate = this.validateDate(end);
+        if (newEndDate < this.startDate) {
+            throw new Error('End date must be after or equal to start date');
+        }
+        this.endDate = newEndDate;
         return this;
     }
     /**

package/dist/utils.d.ts

@@ -169,6 +169,7 @@ export declare function formatDate(date: Date, format: string): string;
  * @param dateString - The date string to parse.
  * @param format - The format of the date string. Supported format parts are YYYY, MM, DD, HH, mm, ss.
  * @returns A Date object representing the parsed date.
+ * @throws {Error} If the date string doesn't match the specified format.
  *
  * @example
  * ```typescript
@@ -184,5 +185,6 @@ export declare function parseDate(dateString: string, format: string): Date;
  * @param end - The ending number of the range.
  * @param step - The step between each number in the range. Defaults to 1.
  * @returns An array of numbers from start to end, incremented by step.
+ * @throws {Error} If step is zero or has the wrong sign.
  */
 export declare function range(start: number, end: number, step?: number): number[];

package/dist/utils.js

@@ -47,15 +47,14 @@ function getDatesWithInterval(start, end, interval) {
  */
 function getWeeksWithInterval(start, end, interval) {
     const weeks = [];
-    let current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate()));
+    const current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate()));
     // Move to the start of the week (Sunday)
     current.setUTCDate(current.getUTCDate() - current.getUTCDay());
+    const weekIncrement = Math.max(1, Math.round(interval.getMinutesInterval() / (7 * 24 * 60)));
     while (current <= end) {
         weeks.push(new Date(current));
-        // Add the interval in minutes, converted to milliseconds
-        current = new Date(current.getTime() + interval.getMinutesInterval() * 60000);
-        // Ensure we're at the start of the week
-        current.setUTCDate(current.getUTCDate() - current.getUTCDay());
+        // Add weeks based on the interval
+        current.setUTCDate(current.getUTCDate() + weekIncrement * 7);
     }
     return weeks;
 }
@@ -72,9 +71,10 @@ function getDaysWithInterval(start, end, interval) {
     const days = [];
     const current = new Date(start);
     current.setUTCHours(0, 0, 0, 0);
+    const dayIncrement = Math.max(1, Math.round(interval.getMinutesInterval() / (24 * 60)));
     while (current <= end) {
         days.push(new Date(current));
-        current.setUTCDate(current.getUTCDate() + interval.getMinutesInterval() / (24 * 60));
+        current.setUTCDate(current.getUTCDate() + dayIncrement);
     }
     return days;
 }
@@ -91,9 +91,10 @@ function getHoursWithInterval(start, end, interval) {
     const hours = [];
     const current = new Date(start);
     current.setMinutes(0, 0, 0);
+    const hourIncrement = Math.max(1, Math.round(interval.getMinutesInterval() / 60));
     while (current <= end) {
         hours.push(new Date(current));
-        current.setHours(current.getHours() + interval.getMinutesInterval() / 60);
+        current.setHours(current.getHours() + hourIncrement);
     }
     return hours;
 }
@@ -110,9 +111,10 @@ function getMinutesWithInterval(start, end, interval) {
     const minutes = [];
     const current = new Date(start);
     current.setSeconds(0, 0);
+    const minuteIncrement = Math.max(1, interval.getMinutesInterval());
     while (current <= end) {
         minutes.push(new Date(current));
-        current.setMinutes(current.getMinutes() + interval.getMinutesInterval());
+        current.setMinutes(current.getMinutes() + minuteIncrement);
     }
     return minutes;
 }
@@ -128,9 +130,11 @@ function getMinutesWithInterval(start, end, interval) {
 function getMonthsWithInterval(start, end, interval) {
     const months = [];
     const current = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), 1));
+    // Use approximation of 30 days per month for interval calculation
+    const monthIncrement = Math.max(1, Math.round(interval.getMinutesInterval() / (30 * 24 * 60)));
     while (current <= end) {
         months.push(new Date(current));
-        current.setUTCMonth(current.getUTCMonth() + interval.getMinutesInterval() / (30 * 24 * 60));
+        current.setUTCMonth(current.getUTCMonth() + monthIncrement);
     }
     return months;
 }
@@ -146,10 +150,10 @@ function getMonthsWithInterval(start, end, interval) {
 function getYearsWithInterval(start, end, interval) {
     const years = [];
     const current = new Date(Date.UTC(start.getUTCFullYear(), 0, 1));
+    // Calculate the number of years to add based on the interval
+    const yearsToAdd = Math.max(1, Math.round(interval.getMinutesInterval() / 525600)); // 525600 minutes in a year
     while (current <= end) {
         years.push(new Date(current));
-        // Calculate the number of years to add based on the interval
-        const yearsToAdd = Math.max(1, Math.round(interval.getMinutesInterval() / 525600)); // 525600 minutes in a year
         current.setUTCFullYear(current.getUTCFullYear() + yearsToAdd);
     }
     return years;
@@ -187,13 +191,20 @@ function addToDate(date, amount, unit) {
             break;
         case precision_1.Precision.MONTH:
             newDate.setUTCMonth(newDate.getUTCMonth() + amount);
+            // Handle month overflow for dates that don't exist in the target month
             if (newDate.getUTCDate() !== date.getUTCDate()) {
                 newDate.setUTCDate(0); // Set to last day of previous month
             }
             break;
         case precision_1.Precision.YEAR:
             newDate.setUTCFullYear(newDate.getUTCFullYear() + amount);
+            // Handle leap year edge case (Feb 29 -> Feb 28)
+            if (newDate.getUTCMonth() !== date.getUTCMonth()) {
+                newDate.setUTCDate(0); // Set to last day of previous month
+            }
             break;
+        default:
+            throw new Error(`Unsupported precision unit: ${unit}`);
     }
     return newDate;
 }
@@ -291,7 +302,10 @@ function getDaysInMonth(year, month) {
  * @returns The formatted date string.
  */
 function formatDate(date, format) {
-    const pad = (n) => n.toString().padStart(2, '0');
+    const pad = (n) => {
+        const str = n.toString();
+        return str.length < 2 ? '0' + str : str;
+    };
     const map = {
         YYYY: date.getFullYear().toString(),
         MM: pad(date.getMonth() + 1),
@@ -308,6 +322,7 @@ function formatDate(date, format) {
  * @param dateString - The date string to parse.
  * @param format - The format of the date string. Supported format parts are YYYY, MM, DD, HH, mm, ss.
  * @returns A Date object representing the parsed date.
+ * @throws {Error} If the date string doesn't match the specified format.
  *
  * @example
  * ```typescript
@@ -316,13 +331,27 @@ function formatDate(date, format) {
  * ```
  */
 function parseDate(dateString, format) {
-    const map = {};
     const formatParts = format.match(/YYYY|MM|DD|HH|mm|ss/gi) || [];
     const dateParts = dateString.match(/\d+/g) || [];
+    if (formatParts.length !== dateParts.length) {
+        throw new Error(`Date string "${dateString}" does not match the specified format "${format}"`);
+    }
+    const map = {};
     formatParts.forEach((part, index) => {
-        map[part] = parseInt(dateParts[index]);
+        map[part] = parseInt(dateParts[index], 10);
     });
-    return new Date(map['YYYY'] || 0, (map['MM'] || 1) - 1, map['DD'] || 1, map['HH'] || 0, map['mm'] || 0, map['ss'] || 0);
+    const year = map['YYYY'] || 0;
+    const month = (map['MM'] || 1) - 1; // JavaScript months are 0-indexed
+    const day = map['DD'] || 1;
+    const hour = map['HH'] || 0;
+    const minute = map['mm'] || 0;
+    const second = map['ss'] || 0;
+    const result = new Date(year, month, day, hour, minute, second);
+    // Validate the resulting date
+    if (isNaN(result.getTime())) {
+        throw new Error(`Invalid date components parsed from "${dateString}"`);
+    }
+    return result;
 }
 /**
  * Generates an array of numbers within a specified range.
@@ -331,7 +360,15 @@ function parseDate(dateString, format) {
  * @param end - The ending number of the range.
  * @param step - The step between each number in the range. Defaults to 1.
  * @returns An array of numbers from start to end, incremented by step.
+ * @throws {Error} If step is zero or has the wrong sign.
  */
 function range(start, end, step = 1) {
-    return Array.from({ length: Math.floor((end - start) / step) + 1 }, (_, i) => start + i * step);
+    if (step === 0) {
+        throw new Error('Step cannot be zero');
+    }
+    if ((end > start && step < 0) || (end < start && step > 0)) {
+        throw new Error('Step direction must match the range direction');
+    }
+    const length = Math.floor(Math.abs(end - start) / Math.abs(step)) + 1;
+    return Array.from({ length }, (_, i) => start + i * step);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronos-ts",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "A comprehensive TypeScript package for handling time periods, intervals, and date-related operations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",