scschedule 3.0.0 → 3.2.0

package/README.md

@@ -51,7 +51,8 @@ const restaurant: Schedule = {
   weekly: [
     {
       weekdays: sWeekdays('-MTWTFS'), // Mon-Sat
-      times: [{ from: sTime('11:00'), to: sTime('22:00') }],
+      from: sTime('11:00'),
+      to: sTime('22:00'),
     },
   ],
 }
@@ -97,10 +98,6 @@ Define recurring availability patterns for specific days of the week:
 ```typescript
 interface WeeklyScheduleRule {
   weekdays: SWeekdays // e.g., 'SMTWTFS' or '-MTWTF-'
-  times: TimeRange[] // Array of time ranges
-}
-
-interface TimeRange {
   from: STime // e.g., '09:00'
   to: STime // e.g., '17:00'
 }
@@ -278,7 +275,8 @@ const restaurant: Schedule = {
   weekly: [
     {
       weekdays: sWeekdays('-MTWTFS'), // Mon-Sat
-      times: [{ from: sTime('11:00'), to: sTime('22:00') }],
+      from: sTime('11:00'),
+      to: sTime('22:00'),
     },
   ],
 }
@@ -291,10 +289,13 @@ const restaurant: Schedule = {
   weekly: [
     {
       weekdays: sWeekdays('-MTWTFS'), // Mon-Sat
-      times: [
-        { from: sTime('11:00'), to: sTime('14:00') }, // Lunch
-        { from: sTime('17:00'), to: sTime('22:00') }, // Dinner
-      ],
+      from: sTime('11:00'),
+      to: sTime('14:00'), // Lunch
+    },
+    {
+      weekdays: sWeekdays('-MTWTFS'), // Mon-Sat
+      from: sTime('17:00'),
+      to: sTime('22:00'), // Dinner
     },
   ],
 }
@@ -308,12 +309,14 @@ const restaurant: Schedule = {
     {
       // Weekdays: longer hours
       weekdays: sWeekdays('-MTWTF-'), // Mon-Fri
-      times: [{ from: sTime('10:00'), to: sTime('23:00') }],
+      from: sTime('10:00'),
+      to: sTime('23:00'),
     },
     {
       // Weekends: shorter hours
       weekdays: sWeekdays('S-----S'), // Sat-Sun
-      times: [{ from: sTime('12:00'), to: sTime('20:00') }],
+      from: sTime('12:00'),
+      to: sTime('20:00'),
     },
   ],
 }
@@ -348,7 +351,8 @@ const withExtendedHours: Schedule = {
         {
           // Extended hours for December, weekends only
           weekdays: sWeekdays('S-----S'),
-          times: [{ from: sTime('08:00'), to: sTime('23:00') }],
+          from: sTime('08:00'),
+          to: sTime('23:00'),
         },
       ],
     },
@@ -369,7 +373,8 @@ const newSchedule: Schedule = {
       rules: [
         {
           weekdays: sWeekdays('SMTWTFS'), // All days
-          times: [{ from: sTime('09:00'), to: sTime('21:00') }],
+          from: sTime('09:00'),
+          to: sTime('21:00'),
         },
       ],
     },
@@ -384,7 +389,8 @@ const lateNightBar: Schedule = {
   weekly: [
     {
       weekdays: sWeekdays('----TFS'), // Thu-Sat
-      times: [{ from: sTime('20:00'), to: sTime('03:00') }], // 8PM-3AM
+      from: sTime('20:00'),
+      to: sTime('03:00'), // 8PM-3AM
     },
   ],
 }
@@ -429,7 +435,8 @@ const popUpShop: Schedule = {
       rules: [
         {
           weekdays: sWeekdays('SMTWTFS'),
-          times: [{ from: sTime('10:00'), to: sTime('18:00') }],
+          from: sTime('10:00'),
+          to: sTime('18:00'),
         },
       ],
     },
@@ -446,7 +453,8 @@ const businessHours: Schedule = {
   weekly: [
     {
       weekdays: sWeekdays('-MTWTFS'),
-      times: [{ from: sTime('11:00'), to: sTime('22:00') }],
+      from: sTime('11:00'),
+      to: sTime('22:00'),
     },
   ],
 }
@@ -488,17 +496,6 @@ type ValidationError =
       issue: ValidationIssue.OverlappingSpecificOverrides
       overrideIndexes: [number, number]
     }
-  | {
-      issue: ValidationIssue.OverlappingTimesInRule
-      location:
-        | { type: RuleLocationType.Weekly; ruleIndex: number }
-        | {
-            type: RuleLocationType.Override
-            overrideIndex: number
-            ruleIndex: number
-          }
-      timeRangeIndexes: [number, number]
-    }
   | {
       issue: ValidationIssue.OverlappingRulesInWeekly
       ruleIndexes: [number, number]
@@ -510,16 +507,6 @@ type ValidationError =
       ruleIndexes: [number, number]
       weekday: Weekday
     }
-  | {
-      issue: ValidationIssue.EmptyTimes
-      location:
-        | { type: RuleLocationType.Weekly; ruleIndex: number }
-        | {
-            type: RuleLocationType.Override
-            overrideIndex: number
-            ruleIndex: number
-          }
-    }
   | {
       issue: ValidationIssue.EmptyWeekdays
       location:
@@ -590,7 +577,6 @@ import type {
   Schedule,
   WeeklyScheduleRule,
   OverrideScheduleRule,
-  TimeRange,
   AvailabilityRange,
   ValidationError,
   ValidationResult,

package/dist/constants.d.ts

@@ -8,13 +8,6 @@ export declare enum ValidationIssue {
     DuplicateOverrides = "duplicate-overrides",
     /** Two or more specific overrides have overlapping date ranges */
     OverlappingSpecificOverrides = "overlapping-specific-overrides",
-    /** Time ranges within a single rule overlap with each other */
-    OverlappingTimesInRule = "overlapping-times-in-rule",
-    /**
-     * A rule has an empty times array (should have at least one time range or be
-     * removed)
-     */
-    EmptyTimes = "empty-times",
     /**
      * A field contains an invalid scdate format (SDate, STime, SWeekdays, or
      * STimestamp)

package/dist/constants.js

@@ -9,13 +9,6 @@ export var ValidationIssue;
     ValidationIssue["DuplicateOverrides"] = "duplicate-overrides";
     /** Two or more specific overrides have overlapping date ranges */
     ValidationIssue["OverlappingSpecificOverrides"] = "overlapping-specific-overrides";
-    /** Time ranges within a single rule overlap with each other */
-    ValidationIssue["OverlappingTimesInRule"] = "overlapping-times-in-rule";
-    /**
-     * A rule has an empty times array (should have at least one time range or be
-     * removed)
-     */
-    ValidationIssue["EmptyTimes"] = "empty-times";
     /**
      * A field contains an invalid scdate format (SDate, STime, SWeekdays, or
      * STimestamp)

package/dist/getAvailableRangesFromSchedule.js

@@ -36,19 +36,16 @@ export const getAvailableRangesFromSchedule = (schedule, startDate, endDate) =>
             if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
                 continue;
             }
-            // Process each time range
-            for (const timeRange of rule.times) {
-                // Handle cross-midnight ranges (from > to means it crosses midnight)
-                const isCrossMidnight = isAfterTime(timeRange.from, timeRange.to);
-                const rangeStart = getTimestampFromDateAndTime(currentDate, timeRange.from);
-                const rangeEnd = isCrossMidnight
-                    ? getTimestampFromDateAndTime(addDaysToDate(currentDate, 1), timeRange.to)
-                    : getTimestampFromDateAndTime(currentDate, timeRange.to);
-                ranges.push({
-                    from: rangeStart,
-                    to: rangeEnd,
-                });
-            }
+            // Handle cross-midnight ranges (from > to means it crosses midnight)
+            const isCrossMidnight = isAfterTime(rule.from, rule.to);
+            const rangeStart = getTimestampFromDateAndTime(currentDate, rule.from);
+            const rangeEnd = isCrossMidnight
+                ? getTimestampFromDateAndTime(addDaysToDate(currentDate, 1), rule.to)
+                : getTimestampFromDateAndTime(currentDate, rule.to);
+            ranges.push({
+                from: rangeStart,
+                to: rangeEnd,
+            });
         }
         // Move to the next day
         currentDate = addDaysToDate(currentDate, 1);

package/dist/getNextAvailableFromSchedule.js

@@ -77,15 +77,13 @@ export const getNextAvailableFromSchedule = (schedule, fromTimestamp, maxDaysToS
             if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
                 continue;
             }
-            for (const timeRange of rule.times) {
-                // Day 0: only consider ranges starting after fromTimestamp's time
-                // Day 1+: consider all ranges (any start time qualifies)
-                if (day === 0 && !isAfterTime(timeRange.from, fromTime)) {
-                    continue;
-                }
-                if (!earliestTime || isBeforeTime(timeRange.from, earliestTime)) {
-                    earliestTime = timeRange.from;
-                }
+            // Day 0: only consider ranges starting after fromTimestamp's time
+            // Day 1+: consider all ranges (any start time qualifies)
+            if (day === 0 && !isAfterTime(rule.from, fromTime)) {
+                continue;
+            }
+            if (!earliestTime || isBeforeTime(rule.from, earliestTime)) {
+                earliestTime = rule.from;
             }
         }
         if (earliestTime) {

package/dist/getNextUnavailableFromSchedule.js

@@ -14,20 +14,18 @@ const collectRangeEndCandidates = (rules, date, timeZone, afterTime) => {
         if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
             continue;
         }
-        for (const timeRange of rule.times) {
-            if (isAfterTime(timeRange.from, timeRange.to)) {
-                // Cross-midnight range ends tomorrow
-                const tomorrow = addDaysToDate(date, 1);
-                const rangeEnd = getTimestampFromDateAndTime(tomorrow, timeRange.to);
-                candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
-            }
-            else {
-                if (afterTime && !isSameTimeOrAfter(timeRange.to, afterTime)) {
-                    continue;
-                }
-                const rangeEnd = getTimestampFromDateAndTime(date, timeRange.to);
-                candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+        if (isAfterTime(rule.from, rule.to)) {
+            // Cross-midnight range ends tomorrow
+            const tomorrow = addDaysToDate(date, 1);
+            const rangeEnd = getTimestampFromDateAndTime(tomorrow, rule.to);
+            candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+        }
+        else {
+            if (afterTime && !isSameTimeOrAfter(rule.to, afterTime)) {
+                continue;
             }
+            const rangeEnd = getTimestampFromDateAndTime(date, rule.to);
+            candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
         }
     }
     return candidates;
@@ -49,17 +47,15 @@ const collectSpilloverCandidates = (schedule, currentDate, timeZone, afterTime)
         if (!doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
             continue;
         }
-        for (const timeRange of rule.times) {
-            // Only cross-midnight ranges (from > to) spill into today
-            if (!isAfterTime(timeRange.from, timeRange.to)) {
-                continue;
-            }
-            if (!isSameTimeOrAfter(timeRange.to, afterTime)) {
-                continue;
-            }
-            const rangeEnd = getTimestampFromDateAndTime(currentDate, timeRange.to);
-            candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+        // Only cross-midnight ranges (from > to) spill into today
+        if (!isAfterTime(rule.from, rule.to)) {
+            continue;
+        }
+        if (!isSameTimeOrAfter(rule.to, afterTime)) {
+            continue;
         }
+        const rangeEnd = getTimestampFromDateAndTime(currentDate, rule.to);
+        candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
     }
     return candidates;
 };

package/dist/internal/doTimeRangesOverlap.d.ts

@@ -1,4 +1,4 @@
-import type { TimeRange } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Checks if two time ranges overlap when both start on the same day.
  *

package/dist/internal/getEffectiveTimesForWeekday.d.ts

@@ -1,5 +1,6 @@
 import { Weekday } from 'scdate';
-import type { TimeRange, WeeklyScheduleRule } from '../types.js';
+import type { WeeklyScheduleRule } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Gets the effective time ranges that apply to a specific weekday for a given
  * rule, accounting for both direct ranges and cross-midnight spillover from

package/dist/internal/getEffectiveTimesForWeekday.js

@@ -14,13 +14,10 @@ export const getEffectiveTimesForWeekday = (rule, weekday) => {
     const previousWeekday = getPreviousWeekday(weekday);
     // Check if this weekday is directly included in the rule's weekdays
     if (doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
-        // Add all time ranges for this weekday
-        rule.times.forEach((timeRange) => {
-            const splitRanges = splitCrossMidnightTimeRange(timeRange);
-            if (splitRanges.length > 0 && splitRanges[0]) {
-                effectiveTimes.push(splitRanges[0]);
-            }
-        });
+        const splitRanges = splitCrossMidnightTimeRange(rule);
+        if (splitRanges.length > 0 && splitRanges[0]) {
+            effectiveTimes.push(splitRanges[0]);
+        }
     }
     // Check if previous weekday has cross-midnight ranges that spill into this
     // weekday.
@@ -30,13 +27,11 @@ export const getEffectiveTimesForWeekday = (rule, weekday) => {
     // only those that occur in the date range. This ensures spillover is only
     // included from days that actually exist in the override period.
     if (doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
-        rule.times.forEach((timeRange) => {
-            const splitRanges = splitCrossMidnightTimeRange(timeRange);
-            // If there are 2 ranges, the second one is the spillover to next day
-            if (splitRanges.length === 2 && splitRanges[1]) {
-                effectiveTimes.push(splitRanges[1]);
-            }
-        });
+        const splitRanges = splitCrossMidnightTimeRange(rule);
+        // If there are 2 ranges, the second one is the spillover to next day
+        if (splitRanges.length === 2 && splitRanges[1]) {
+            effectiveTimes.push(splitRanges[1]);
+        }
     }
     return effectiveTimes;
 };

package/dist/internal/index.d.ts

@@ -1,3 +1,4 @@
+export type * from './types.js';
 export * from './doOverridesOverlap.js';
 export * from './doRulesOverlap.js';
 export * from './doTimeRangesOverlap.js';
@@ -7,10 +8,8 @@ export * from './isTimeInTimeRange.js';
 export * from './normalizeScheduleForValidation.js';
 export * from './splitCrossMidnightTimeRange.js';
 export * from './validateNoEmptyWeekdays.js';
-export * from './validateNonEmptyTimes.js';
 export * from './validateNoOverlappingOverrides.js';
 export * from './validateNoOverlappingRules.js';
-export * from './validateNoOverlappingTimesInRule.js';
 export * from './validateNoSpilloverConflictsAtOverrideBoundaries.js';
 export * from './validateOverrideDateOrder.js';
 export * from './validateOverrideWeekdaysMatchDates.js';

package/dist/internal/index.js

@@ -9,10 +9,8 @@ export * from './normalizeScheduleForValidation.js';
 export * from './splitCrossMidnightTimeRange.js';
 // Internal validation helpers
 export * from './validateNoEmptyWeekdays.js';
-export * from './validateNonEmptyTimes.js';
 export * from './validateNoOverlappingOverrides.js';
 export * from './validateNoOverlappingRules.js';
-export * from './validateNoOverlappingTimesInRule.js';
 export * from './validateNoSpilloverConflictsAtOverrideBoundaries.js';
 export * from './validateOverrideDateOrder.js';
 export * from './validateOverrideWeekdaysMatchDates.js';

package/dist/internal/isTimeInTimeRange.d.ts

@@ -1,5 +1,6 @@
 import { type STime } from 'scdate';
-import type { STimeString, TimeRange } from '../types.js';
+import type { STimeString } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Checks if a time falls within a time range, with support for
  * cross-midnight ranges (next-day portion).

package/dist/internal/splitCrossMidnightTimeRange.d.ts

@@ -1,4 +1,4 @@
-import type { TimeRange } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Splits a time range that crosses midnight into two same-day ranges.
  */

package/dist/internal/splitCrossMidnightTimeRange.js

@@ -5,8 +5,9 @@ import { isAfterTime, sTime } from 'scdate';
 export const splitCrossMidnightTimeRange = (timeRange) => {
     // Check if range crosses midnight
     if (isAfterTime(timeRange.to, timeRange.from)) {
-        // Same day range
-        return [timeRange];
+        // Same day range — construct a new object to strip extra fields (e.g.,
+        // weekdays) when callers pass a WeeklyScheduleRule as a TimeRange.
+        return [{ from: timeRange.from, to: timeRange.to }];
     }
     // Cross-midnight range: split into two periods
     return [

package/dist/internal/types.d.ts

@@ -0,0 +1,13 @@
+import type { STime } from 'scdate';
+import type { STimeString } from '../types.js';
+/**
+ * Represents a time range within a day. Time ranges can cross midnight. For
+ * example, a range from 20:00 to 02:00 represents 8:00 PM to 2:00 AM the next
+ * day.
+ */
+export interface TimeRange {
+    /** Start time of the range (inclusive) */
+    from: STime | STimeString;
+    /** End time of the range (inclusive) */
+    to: STime | STimeString;
+}

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/validateNoSpilloverConflictsAtOverrideBoundaries.js

@@ -38,52 +38,47 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
                 if (!doesWeekdaysIncludeWeekday(previousDayRule.weekdays, previousWeekday)) {
                     return;
                 }
-                // Check each time range for cross-midnight
-                previousDayRule.times.forEach((timeRange) => {
-                    const splitRanges = splitCrossMidnightTimeRange(timeRange);
-                    // If cross-midnight, splitRanges[1] is the spillover portion
-                    if (splitRanges.length === 2 && splitRanges[1]) {
-                        const spilloverRange = splitRanges[1];
-                        // Check if spillover conflicts with override first day's times
-                        override.rules.forEach((overrideRule, overrideRuleIndex) => {
-                            // Does first day match override rule's weekdays?
-                            if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, firstDateWeekday)) {
-                                return;
+                // Check for cross-midnight
+                const splitRanges = splitCrossMidnightTimeRange(previousDayRule);
+                // If cross-midnight, splitRanges[1] is the spillover portion
+                if (splitRanges.length === 2 && splitRanges[1]) {
+                    const spilloverRange = splitRanges[1];
+                    // Check if spillover conflicts with override first day's times
+                    override.rules.forEach((overrideRule, overrideRuleIndex) => {
+                        // Does first day match override rule's weekdays?
+                        if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, firstDateWeekday)) {
+                            return;
+                        }
+                        const overrideSplitRanges = splitCrossMidnightTimeRange(overrideRule);
+                        // Check same-day portion of override time range
+                        const overrideSameDayRange = overrideSplitRanges[0];
+                        if (overrideSameDayRange &&
+                            doTimeRangesOverlap(spilloverRange, overrideSameDayRange)) {
+                            // Use source information from getApplicableRuleForDate
+                            if (previousDayResult.source === 'override') {
+                                // Previous day is in an override
+                                errors.push({
+                                    issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
+                                    overrideIndex,
+                                    date: firstDate.toJSON(),
+                                    overrideRuleIndex,
+                                    sourceOverrideIndex: previousDayResult.overrideIndex,
+                                    sourceOverrideRuleIndex: previousDayRuleIndex,
+                                });
                             }
-                            // Check each time range in override rule
-                            overrideRule.times.forEach((overrideTimeRange) => {
-                                const overrideSplitRanges = splitCrossMidnightTimeRange(overrideTimeRange);
-                                // Check same-day portion of override time range
-                                const overrideSameDayRange = overrideSplitRanges[0];
-                                if (overrideSameDayRange &&
-                                    doTimeRangesOverlap(spilloverRange, overrideSameDayRange)) {
-                                    // Use source information from getApplicableRuleForDate
-                                    if (previousDayResult.source === 'override') {
-                                        // Previous day is in an override
-                                        errors.push({
-                                            issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                            overrideIndex,
-                                            date: firstDate.toJSON(),
-                                            overrideRuleIndex,
-                                            sourceOverrideIndex: previousDayResult.overrideIndex,
-                                            sourceOverrideRuleIndex: previousDayRuleIndex,
-                                        });
-                                    }
-                                    else {
-                                        // Previous day is weekly
-                                        errors.push({
-                                            issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                            overrideIndex,
-                                            date: firstDate.toJSON(),
-                                            overrideRuleIndex,
-                                            sourceWeeklyRuleIndex: previousDayRuleIndex,
-                                        });
-                                    }
-                                }
-                            });
-                        });
-                    }
-                });
+                            else {
+                                // Previous day is weekly
+                                errors.push({
+                                    issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
+                                    overrideIndex,
+                                    date: firstDate.toJSON(),
+                                    overrideRuleIndex,
+                                    sourceWeeklyRuleIndex: previousDayRuleIndex,
+                                });
+                            }
+                        }
+                    });
+                }
             });
         }
         // PART 2: Check spillover FROM override last day into next day
@@ -101,65 +96,60 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
             if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, lastDateWeekday)) {
                 return;
             }
-            // Check each time range for cross-midnight
-            overrideRule.times.forEach((timeRange) => {
-                const splitRanges = splitCrossMidnightTimeRange(timeRange);
-                // If cross-midnight, splitRanges[1] is the spillover portion
-                if (splitRanges.length === 2 && splitRanges[1]) {
-                    const spilloverRange = splitRanges[1];
-                    // Get what rule applies to next day
-                    const nextDayResult = getApplicableRuleForDate(schedule, nextDate);
-                    // If next day is always available (weekly: true), spillover
-                    // creates overlapping ranges with the full-day availability.
-                    if (nextDayResult.rules === true) {
-                        errors.push({
-                            issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
-                            overrideIndex,
-                            date: lastDate.toJSON(),
-                            overrideRuleIndex,
-                        });
+            // Check for cross-midnight
+            const splitRanges = splitCrossMidnightTimeRange(overrideRule);
+            // If cross-midnight, splitRanges[1] is the spillover portion
+            if (splitRanges.length === 2 && splitRanges[1]) {
+                const spilloverRange = splitRanges[1];
+                // Get what rule applies to next day
+                const nextDayResult = getApplicableRuleForDate(schedule, nextDate);
+                // If next day is always available (weekly: true), spillover
+                // creates overlapping ranges with the full-day availability.
+                if (nextDayResult.rules === true) {
+                    errors.push({
+                        issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
+                        overrideIndex,
+                        date: lastDate.toJSON(),
+                        overrideRuleIndex,
+                    });
+                    return;
+                }
+                // Check if spillover conflicts with next day's times
+                nextDayResult.rules.forEach((nextDayRule, nextDayRuleIndex) => {
+                    // Does next day match the rule's weekdays?
+                    if (!doesWeekdaysIncludeWeekday(nextDayRule.weekdays, nextDateWeekday)) {
                         return;
                     }
-                    // Check if spillover conflicts with next day's times
-                    nextDayResult.rules.forEach((nextDayRule, nextDayRuleIndex) => {
-                        // Does next day match the rule's weekdays?
-                        if (!doesWeekdaysIncludeWeekday(nextDayRule.weekdays, nextDateWeekday)) {
-                            return;
+                    const nextDaySplitRanges = splitCrossMidnightTimeRange(nextDayRule);
+                    // Check same-day portion of next day's time range
+                    const nextDaySameDayRange = nextDaySplitRanges[0];
+                    if (nextDaySameDayRange &&
+                        doTimeRangesOverlap(spilloverRange, nextDaySameDayRange)) {
+                        // Use source information from getApplicableRuleForDate
+                        if (nextDayResult.source === 'override') {
+                            // Next day is in an override
+                            errors.push({
+                                issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
+                                overrideIndex,
+                                date: lastDate.toJSON(),
+                                overrideRuleIndex,
+                                nextDayOverrideIndex: nextDayResult.overrideIndex,
+                                nextDayOverrideRuleIndex: nextDayRuleIndex,
+                            });
                         }
-                        // Check each time range in next day's rule
-                        nextDayRule.times.forEach((nextDayTimeRange) => {
-                            const nextDaySplitRanges = splitCrossMidnightTimeRange(nextDayTimeRange);
-                            // Check same-day portion of next day's time range
-                            const nextDaySameDayRange = nextDaySplitRanges[0];
-                            if (nextDaySameDayRange &&
-                                doTimeRangesOverlap(spilloverRange, nextDaySameDayRange)) {
-                                // Use source information from getApplicableRuleForDate
-                                if (nextDayResult.source === 'override') {
-                                    // Next day is in an override
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
-                                        overrideIndex,
-                                        date: lastDate.toJSON(),
-                                        overrideRuleIndex,
-                                        nextDayOverrideIndex: nextDayResult.overrideIndex,
-                                        nextDayOverrideRuleIndex: nextDayRuleIndex,
-                                    });
-                                }
-                                else {
-                                    // Next day is weekly
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
-                                        overrideIndex,
-                                        date: lastDate.toJSON(),
-                                        overrideRuleIndex,
-                                        nextDayWeeklyRuleIndex: nextDayRuleIndex,
-                                    });
-                                }
-                            }
-                        });
-                    });
-                }
-            });
+                        else {
+                            // Next day is weekly
+                            errors.push({
+                                issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
+                                overrideIndex,
+                                date: lastDate.toJSON(),
+                                overrideRuleIndex,
+                                nextDayWeeklyRuleIndex: nextDayRuleIndex,
+                            });
+                        }
+                    }
+                });
+            }
         });
     });
     return errors;

package/dist/internal/validateScDateFormats.js

@@ -67,7 +67,7 @@ const validateTimeRange = (timeRange, fieldPrefix) => {
     return errors;
 };
 /**
- * Validates a rule (weekdays and all time ranges).
+ * Validates a rule (weekdays and time range).
  */
 const validateRule = (rule, fieldPrefix) => {
     const errors = [];
@@ -75,9 +75,7 @@ const validateRule = (rule, fieldPrefix) => {
     if (weekdaysError) {
         errors.push(weekdaysError);
     }
-    rule.times.forEach((timeRange, timeIndex) => {
-        errors.push(...validateTimeRange(timeRange, `${fieldPrefix}.times[${String(timeIndex)}]`));
-    });
+    errors.push(...validateTimeRange(rule, fieldPrefix));
     return errors;
 };
 /**

package/dist/isScheduleAvailable.js

@@ -29,8 +29,8 @@ export const isScheduleAvailable = (schedule, timestamp) => {
         if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
             return false;
         }
-        // Check if any time range matches
-        return rule.times.some((timeRange) => isTimeInTimeRange(time, timeRange, true));
+        // Check if time range matches
+        return isTimeInTimeRange(time, rule, true);
     });
     if (matchesSameDay) {
         return true;
@@ -48,7 +48,7 @@ export const isScheduleAvailable = (schedule, timestamp) => {
         if (!doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
             return false;
         }
-        // Check if any time range matches (next-day portion)
-        return rule.times.some((timeRange) => isTimeInTimeRange(time, timeRange, false));
+        // Check if time range matches (next-day portion)
+        return isTimeInTimeRange(time, rule, false);
     });
 };

package/dist/types.d.ts

@@ -16,29 +16,18 @@ export type STimestampString = string;
  * String in SMTWTFS format representing weekdays.
  */
 export type SWeekdaysString = string;
-/**
- * Represents a time range within a day. Time ranges can cross midnight. For
- * example, a range from 20:00 to 02:00 represents 8:00 PM to 2:00 AM the next
- * day.
- */
-export interface TimeRange {
-    /** Start time of the range (inclusive) */
-    from: STime | STimeString;
-    /** End time of the range (inclusive) */
-    to: STime | STimeString;
-}
 /**
  * Defines a recurring weekly availability pattern. Specifies which days of the
- * week are available and what time ranges apply on those days.
+ * week are available and what time range applies on those days. For split
+ * shifts, use multiple rules with the same weekdays.
  */
 export interface WeeklyScheduleRule {
     /** Days of the week this rule applies to */
     weekdays: SWeekdays | SWeekdaysString;
-    /**
-     * Time ranges when available on the specified weekdays. Empty array means
-     * unavailable on these days.
-     */
-    times: TimeRange[];
+    /** Start time of the range (inclusive). Ranges can cross midnight. */
+    from: STime | STimeString;
+    /** End time of the range (inclusive). Ranges can cross midnight. */
+    to: STime | STimeString;
 }
 /**
  * Defines a date-specific override to the weekly schedule. Overrides apply to
@@ -103,35 +92,6 @@ export type ValidationError = {
     issue: ValidationIssue.OverlappingSpecificOverrides;
     /** Indexes of the two overlapping overrides */
     overrideIndexes: [number, number];
-} | {
-    /** Time ranges within a single rule overlap with each other */
-    issue: ValidationIssue.OverlappingTimesInRule;
-    /** Location of the rule containing overlapping times */
-    location: {
-        type: RuleLocationType.Weekly;
-        ruleIndex: number;
-    } | {
-        type: RuleLocationType.Override;
-        overrideIndex: number;
-        ruleIndex: number;
-    };
-    /** Indexes of the two overlapping time ranges within the rule */
-    timeRangeIndexes: [number, number];
-} | {
-    /**
-     * A rule has an empty times array
-     * (should have at least one time range or be removed)
-     */
-    issue: ValidationIssue.EmptyTimes;
-    /** Location of the rule with empty times */
-    location: {
-        type: RuleLocationType.Weekly;
-        ruleIndex: number;
-    } | {
-        type: RuleLocationType.Override;
-        overrideIndex: number;
-        ruleIndex: number;
-    };
 } | {
     /**
      * A field contains an invalid scdate format

package/dist/validateSchedule.d.ts

@@ -3,8 +3,8 @@ import type { Schedule, ValidationResult } from './types.js';
  * Validates a schedule configuration and returns all validation errors found.
  *
  * Validation is performed in two phases:
- * 1. Structural validation (formats, date order, empty weekdays, non-empty
- *    times, weekday-date mismatch) - runs on original schedule
+ * 1. Structural validation (formats, date order, empty weekdays,
+ *    weekday-date mismatch) - runs on original schedule
  * 2. Semantic validation (overlaps, conflicts) - runs on normalized schedule
  *    after filtering weekdays to actual dates
  *

package/dist/validateSchedule.js

@@ -2,9 +2,7 @@ import { normalizeScheduleForValidation } from './internal/normalizeScheduleForV
 import { validateNoEmptyWeekdays } from './internal/validateNoEmptyWeekdays.js';
 import { validateNoOverlappingOverrides } from './internal/validateNoOverlappingOverrides.js';
 import { validateNoOverlappingRules } from './internal/validateNoOverlappingRules.js';
-import { validateNoOverlappingTimesInRule } from './internal/validateNoOverlappingTimesInRule.js';
 import { validateNoSpilloverConflictsAtOverrideBoundaries } from './internal/validateNoSpilloverConflictsAtOverrideBoundaries.js';
-import { validateNonEmptyTimes } from './internal/validateNonEmptyTimes.js';
 import { validateOverrideDateOrder } from './internal/validateOverrideDateOrder.js';
 import { validateOverrideWeekdaysMatchDates } from './internal/validateOverrideWeekdaysMatchDates.js';
 import { validateScDateFormats } from './internal/validateScDateFormats.js';
@@ -12,8 +10,8 @@ import { validateScDateFormats } from './internal/validateScDateFormats.js';
  * Validates a schedule configuration and returns all validation errors found.
  *
  * Validation is performed in two phases:
- * 1. Structural validation (formats, date order, empty weekdays, non-empty
- *    times, weekday-date mismatch) - runs on original schedule
+ * 1. Structural validation (formats, date order, empty weekdays,
+ *    weekday-date mismatch) - runs on original schedule
  * 2. Semantic validation (overlaps, conflicts) - runs on normalized schedule
  *    after filtering weekdays to actual dates
  *
@@ -31,7 +29,6 @@ export const validateSchedule = (schedule) => {
         ...validateScDateFormats(schedule),
         ...validateOverrideDateOrder(schedule),
         ...validateNoEmptyWeekdays(schedule),
-        ...validateNonEmptyTimes(schedule),
         ...validateOverrideWeekdaysMatchDates(schedule),
     ];
     // Return immediately if structural errors exist
@@ -46,7 +43,6 @@ export const validateSchedule = (schedule) => {
     // Phase 3: Semantic validation on normalized schedule
     const semanticErrors = [
         ...validateNoOverlappingOverrides(normalizedSchedule),
-        ...validateNoOverlappingTimesInRule(normalizedSchedule),
         ...validateNoOverlappingRules(normalizedSchedule),
         ...validateNoSpilloverConflictsAtOverrideBoundaries(normalizedSchedule),
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scschedule",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"
@@ -20,7 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "scdate": "3.0.0"
+    "scdate": "3.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",

package/dist/internal/validateNoOverlappingTimesInRule.d.ts

@@ -1,5 +0,0 @@
-import type { Schedule, ValidationError } from '../types.js';
-/**
- * Validates that time ranges within rules do not overlap with each other.
- */
-export declare const validateNoOverlappingTimesInRule: (schedule: Schedule) => ValidationError[];

package/dist/internal/validateNoOverlappingTimesInRule.js

@@ -1,55 +0,0 @@
-import { RuleLocationType, ValidationIssue } from '../constants.js';
-import { doTimeRangesOverlap } from './doTimeRangesOverlap.js';
-/**
- * Validates that time ranges within a single rule do not overlap.
- */
-const validateRuleTimes = (rule, location) => {
-    const errors = [];
-    if (rule.times.length < 2) {
-        return errors;
-    }
-    // Check all pairs of time ranges for overlap on the same weekday
-    for (let i = 0; i < rule.times.length; i++) {
-        for (let j = i + 1; j < rule.times.length; j++) {
-            const timeRange1 = rule.times[i];
-            const timeRange2 = rule.times[j];
-            if (timeRange1 &&
-                timeRange2 &&
-                doTimeRangesOverlap(timeRange1, timeRange2)) {
-                errors.push({
-                    issue: ValidationIssue.OverlappingTimesInRule,
-                    location,
-                    timeRangeIndexes: [i, j],
-                });
-            }
-        }
-    }
-    return errors;
-};
-/**
- * Validates that time ranges within rules do not overlap with each other.
- */
-export const validateNoOverlappingTimesInRule = (schedule) => {
-    const errors = [];
-    // Validate weekly rules
-    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
-    weeklyRules.forEach((rule, ruleIndex) => {
-        const ruleErrors = validateRuleTimes(rule, {
-            type: RuleLocationType.Weekly,
-            ruleIndex,
-        });
-        errors.push(...ruleErrors);
-    });
-    // Validate override rules
-    schedule.overrides?.forEach((override, overrideIndex) => {
-        override.rules.forEach((rule, ruleIndex) => {
-            const ruleErrors = validateRuleTimes(rule, {
-                type: RuleLocationType.Override,
-                overrideIndex,
-                ruleIndex,
-            });
-            errors.push(...ruleErrors);
-        });
-    });
-    return errors;
-};

package/dist/internal/validateNonEmptyTimes.d.ts

@@ -1,5 +0,0 @@
-import type { Schedule, ValidationError } from '../types.js';
-/**
- * Validates that all rules have at least one time range defined.
- */
-export declare const validateNonEmptyTimes: (schedule: Schedule) => ValidationError[];

package/dist/internal/validateNonEmptyTimes.js

@@ -1,36 +0,0 @@
-import { RuleLocationType, ValidationIssue } from '../constants.js';
-/**
- * Validates that all rules have at least one time range defined.
- */
-export const validateNonEmptyTimes = (schedule) => {
-    const errors = [];
-    // Validate weekly rules
-    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
-    weeklyRules.forEach((rule, ruleIndex) => {
-        if (rule.times.length === 0) {
-            errors.push({
-                issue: ValidationIssue.EmptyTimes,
-                location: {
-                    type: RuleLocationType.Weekly,
-                    ruleIndex,
-                },
-            });
-        }
-    });
-    // Validate override rules
-    schedule.overrides?.forEach((override, overrideIndex) => {
-        override.rules.forEach((rule, ruleIndex) => {
-            if (rule.times.length === 0) {
-                errors.push({
-                    issue: ValidationIssue.EmptyTimes,
-                    location: {
-                        type: RuleLocationType.Override,
-                        overrideIndex,
-                        ruleIndex,
-                    },
-                });
-            }
-        });
-    });
-    return errors;
-};