chronos-ts 2.0.0 → 2.0.2

package/dist/core/period.d.ts

@@ -322,6 +322,7 @@ export declare class ChronosPeriod implements Iterable<Chronos> {
     union(other: ChronosPeriod): ChronosPeriod | null;
     /**
      * Get the difference between two periods
+     * Returns the parts of this period that don't overlap with the other period
      */
     diff(other: ChronosPeriod): ChronosPeriod[];
     /**

package/dist/core/period.js

@@ -55,6 +55,32 @@ class ChronosPeriod {
             interval instanceof interval_1.ChronosInterval
                 ? interval
                 : interval_1.ChronosInterval.create(interval || { days: 1 });
+        // Validate interval is not zero to prevent infinite loops
+        if (this._interval.isZero()) {
+            throw new Error('ChronosPeriod: Interval cannot be zero');
+        }
+        // Validate interval is not negative
+        if (this._interval.isNegative()) {
+            throw new Error('ChronosPeriod: Interval cannot be negative');
+        }
+        // Warn about potentially large iterations (optional safety check)
+        if (this._end !== null) {
+            const durationMs = Math.abs(this._end.valueOf() - this._start.valueOf());
+            const intervalMs = Math.abs(this._interval.totalMilliseconds());
+            if (intervalMs > 0) {
+                const estimatedIterations = durationMs / intervalMs;
+                // Warn if period would generate more than 1 million iterations
+                if (estimatedIterations > 1000000) {
+                    console.warn(`ChronosPeriod: Large number of iterations detected (~${Math.floor(estimatedIterations).toLocaleString()}). ` +
+                        `This may cause performance issues. Consider using a larger interval or setting a recurrence limit.`);
+                }
+                // Hard limit: throw error if more than 10 million iterations
+                if (estimatedIterations > 10000000) {
+                    throw new Error(`ChronosPeriod: Period would generate ~${Math.floor(estimatedIterations).toLocaleString()} iterations, ` +
+                        `which exceeds the safety limit of 10 million. Use a larger interval or set explicit recurrence limits.`);
+                }
+            }
+        }
         this._recurrences = null;
         this._options = {
             excludeStart: (_a = options.excludeStart) !== null && _a !== void 0 ? _a : false,
@@ -372,10 +398,18 @@ class ChronosPeriod {
      */
     setInterval(interval) {
         const period = this._cloneForModification();
-        period._interval =
-            interval instanceof interval_1.ChronosInterval
-                ? interval
-                : interval_1.ChronosInterval.create(interval);
+        const newInterval = interval instanceof interval_1.ChronosInterval
+            ? interval
+            : interval_1.ChronosInterval.create(interval);
+        // Validate interval is not zero to prevent infinite loops
+        if (newInterval.isZero()) {
+            throw new Error('ChronosPeriod: Interval cannot be zero');
+        }
+        // Validate interval is not negative
+        if (newInterval.isNegative()) {
+            throw new Error('ChronosPeriod: Interval cannot be negative');
+        }
+        period._interval = newInterval;
         return period;
     }
     /**
@@ -390,6 +424,10 @@ class ChronosPeriod {
      * Set interval by unit
      */
     every(amount, unit) {
+        // Validate amount is positive
+        if (amount <= 0) {
+            throw new Error('ChronosPeriod: Amount must be positive');
+        }
         const normalizedUnit = (0, utils_1.normalizeUnit)(unit);
         const duration = {};
         switch (normalizedUnit) {
@@ -607,8 +645,11 @@ class ChronosPeriod {
      * Get the last date in the period
      */
     last() {
-        const array = this.toArray();
-        return array.length > 0 ? array[array.length - 1] : null;
+        let lastDate = null;
+        for (const date of this) {
+            lastDate = date;
+        }
+        return lastDate;
     }
     /**
      * Get a date at a specific index
@@ -628,7 +669,12 @@ class ChronosPeriod {
      */
     contains(date) {
         const target = chronos_1.Chronos.parse(date);
-        return this.toArray().some((d) => d.isSame(target, 'day'));
+        for (const d of this) {
+            if (d.isSame(target, 'day')) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * For each iteration
@@ -720,6 +766,7 @@ class ChronosPeriod {
     }
     /**
      * Get the difference between two periods
+     * Returns the parts of this period that don't overlap with the other period
      */
     diff(other) {
         var _a, _b;
@@ -728,14 +775,14 @@ class ChronosPeriod {
         }
         const results = [];
         const thisEnd = (_a = this._end) !== null && _a !== void 0 ? _a : this.last();
-        // Before the other period starts
+        const otherEnd = (_b = other._end) !== null && _b !== void 0 ? _b : other.last();
+        // Before the other period starts - create gap from this start to other start
         if (this._start.isBefore(other._start)) {
-            results.push(new ChronosPeriod(this._start, other._start.subtract(this._interval.toDuration()), this._interval));
+            results.push(new ChronosPeriod(this._start, other._start, this._interval));
         }
-        // After the other period ends
-        const otherEnd = (_b = other._end) !== null && _b !== void 0 ? _b : other.last();
+        // After the other period ends - create gap from other end to this end
         if (otherEnd && thisEnd && thisEnd.isAfter(otherEnd)) {
-            results.push(new ChronosPeriod(otherEnd.add(this._interval.toDuration()), thisEnd, this._interval));
+            results.push(new ChronosPeriod(otherEnd, thisEnd, this._interval));
         }
         return results;
     }
@@ -832,6 +879,14 @@ class ChronosPeriod {
         const splitInterval = interval instanceof interval_1.ChronosInterval
             ? interval
             : interval_1.ChronosInterval.create(interval);
+        // Validate that the interval is not zero
+        if (splitInterval.isZero()) {
+            throw new Error('Cannot split by zero interval');
+        }
+        // Validate that the interval is positive
+        if (splitInterval.isNegative()) {
+            throw new Error('Cannot split by negative interval');
+        }
         const chunks = [];
         let current = this._start.clone();
         while (current.isSameOrBefore(this._end)) {

package/dist/core/timezone.d.ts

@@ -101,6 +101,7 @@ export type TimezoneId = keyof typeof TIMEZONES | string;
 export declare class ChronosTimezone {
     private _identifier;
     private _originalOffset;
+    private _extraMinutes;
     private _cachedOffset;
     private _cachedDate;
     /**

package/dist/core/timezone.js

@@ -120,11 +120,13 @@ class ChronosTimezone {
      */
     constructor(identifier = 'UTC') {
         this._originalOffset = null;
+        this._extraMinutes = 0; // For non-whole-hour offsets like +05:30
         this._cachedOffset = null;
         this._cachedDate = null;
         const normalized = this._normalizeIdentifier(identifier);
         this._identifier = normalized.identifier;
         this._originalOffset = normalized.originalOffset;
+        this._extraMinutes = normalized.extraMinutes;
     }
     /**
      * Normalize timezone identifier
@@ -133,16 +135,21 @@ class ChronosTimezone {
         // Handle UTC aliases
         if (identifier.toUpperCase() === 'Z' ||
             identifier.toUpperCase() === 'GMT') {
-            return { identifier: 'UTC', originalOffset: null };
+            return { identifier: 'UTC', originalOffset: null, extraMinutes: 0 };
         }
         // Handle offset strings like +05:30, -08:00
         if (/^[+-]\d{2}:\d{2}$/.test(identifier)) {
             // Store original offset and convert to Etc/GMT for internal use
             const offsetHours = this._parseOffsetString(identifier);
-            const etcGmt = `Etc/GMT${offsetHours >= 0 ? '-' : '+'}${Math.abs(Math.floor(offsetHours))}`;
-            return { identifier: etcGmt, originalOffset: identifier };
+            const sign = offsetHours >= 0 ? 1 : -1;
+            const absHours = Math.abs(offsetHours);
+            const wholeHours = Math.floor(absHours);
+            // Calculate extra minutes for non-whole-hour offsets (e.g., +05:30 has 30 extra minutes)
+            const extraMinutes = Math.round((absHours - wholeHours) * 60) * sign;
+            const etcGmt = `Etc/GMT${offsetHours >= 0 ? '-' : '+'}${wholeHours}`;
+            return { identifier: etcGmt, originalOffset: identifier, extraMinutes };
         }
-        return { identifier, originalOffset: null };
+        return { identifier, originalOffset: null, extraMinutes: 0 };
     }
     /**
      * Parse offset string to hours
@@ -286,10 +293,11 @@ class ChronosTimezone {
             const tzParts = this._parseIntlParts(tzFormatter.formatToParts(date));
             const utcDate = new Date(Date.UTC(utcParts.year, utcParts.month - 1, utcParts.day, utcParts.hour, utcParts.minute));
             const tzDate = new Date(Date.UTC(tzParts.year, tzParts.month - 1, tzParts.day, tzParts.hour, tzParts.minute));
-            return (tzDate.getTime() - utcDate.getTime()) / 60000;
+            // Add extra minutes for non-whole-hour offsets (e.g., +05:30)
+            return ((tzDate.getTime() - utcDate.getTime()) / 60000 + this._extraMinutes);
         }
         catch (_a) {
-            return 0;
+            return this._extraMinutes;
         }
     }
     /**

package/dist/utils/index.js

@@ -158,7 +158,8 @@ const UNIT_ALIASES = {
  */
 function normalizeUnit(unit) {
     var _a;
-    const normalized = (_a = UNIT_ALIASES[unit.toLowerCase()]) !== null && _a !== void 0 ? _a : UNIT_ALIASES[unit];
+    // Check original case first for case-sensitive short codes (M vs m, etc.)
+    const normalized = (_a = UNIT_ALIASES[unit]) !== null && _a !== void 0 ? _a : UNIT_ALIASES[unit.toLowerCase()];
     if (!normalized) {
         throw new Error(`Invalid time unit: ${unit}`);
     }
@@ -237,7 +238,8 @@ function getDaysInYear(year) {
  * Get the day of year (1-366)
  */
 function getDayOfYear(date) {
-    const start = new Date(Date.UTC(date.getFullYear(), 0, 0));
+    // Use local time consistently (not UTC) to avoid timezone issues
+    const start = new Date(date.getFullYear(), 0, 0);
     const diff = date.getTime() - start.getTime();
     return Math.floor(diff / types_1.MILLISECONDS_PER_DAY);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronos-ts",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "A comprehensive TypeScript library for date and time manipulation, inspired by Carbon PHP. Features immutable API, intervals, periods, timezones, and i18n support.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",