scschedule 2.1.1 → 3.1.0

package/dist/internal/validateNoOverlappingRules.js

@@ -14,10 +14,11 @@ import { doRulesOverlap } from './doRulesOverlap.js';
 export const validateNoOverlappingRules = (schedule) => {
     const errors = [];
     // Check weekly rules for overlaps
-    for (let i = 0; i < schedule.weekly.length; i++) {
-        for (let j = i + 1; j < schedule.weekly.length; j++) {
-            const rule1 = schedule.weekly[i];
-            const rule2 = schedule.weekly[j];
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    for (let i = 0; i < weeklyRules.length; i++) {
+        for (let j = i + 1; j < weeklyRules.length; j++) {
+            const rule1 = weeklyRules[i];
+            const rule2 = weeklyRules[j];
             if (rule1 && rule2) {
                 const overlapWeekday = doRulesOverlap(rule1, rule2);
                 if (overlapWeekday !== undefined) {

package/dist/internal/validateNoSpilloverConflictsAtOverrideBoundaries.d.ts

@@ -3,9 +3,11 @@ import type { Schedule, ValidationError } from '../types.js';
  * Validates that cross-midnight spillover at override boundaries doesn't
  * create overlapping time ranges. Checks:
  * 1. Spillover into override first day (from weekly or previous override)
- * 2. Override last day spillover into next day (weekly or another override)
+ * 2. Override last day spillover into next day (weekly, weekly: true, or
+ *    another override)
  *
  * Note: Spillover into empty/closed days is allowed (adds availability).
- * Only spillover that OVERLAPS with explicit time ranges is flagged as error.
+ * Spillover that overlaps with explicit time ranges OR into weekly: true
+ * days (which are fully available) is flagged as an error.
  */
 export declare const validateNoSpilloverConflictsAtOverrideBoundaries: (schedule: Schedule) => ValidationError[];

package/dist/internal/validateNoSpilloverConflictsAtOverrideBoundaries.js

@@ -7,10 +7,12 @@ import { splitCrossMidnightTimeRange } from './splitCrossMidnightTimeRange.js';
  * Validates that cross-midnight spillover at override boundaries doesn't
  * create overlapping time ranges. Checks:
  * 1. Spillover into override first day (from weekly or previous override)
- * 2. Override last day spillover into next day (weekly or another override)
+ * 2. Override last day spillover into next day (weekly, weekly: true, or
+ *    another override)
  *
  * Note: Spillover into empty/closed days is allowed (adds availability).
- * Only spillover that OVERLAPS with explicit time ranges is flagged as error.
+ * Spillover that overlaps with explicit time ranges OR into weekly: true
+ * days (which are fully available) is flagged as an error.
  */
 export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
     const errors = [];
@@ -27,15 +29,17 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
         // including indefinite ones)
         // Get rules that apply to previous day (weekly or override)
         const previousDayResult = getApplicableRuleForDate(schedule, previousDate);
-        // Check each rule from previous day for cross-midnight spillover
-        previousDayResult.rules.forEach((previousDayRule, previousDayRuleIndex) => {
-            // Skip if previous day rule doesn't include previous weekday
-            if (!doesWeekdaysIncludeWeekday(previousDayRule.weekdays, previousWeekday)) {
-                return;
-            }
-            // Check each time range for cross-midnight
-            previousDayRule.times.forEach((timeRange) => {
-                const splitRanges = splitCrossMidnightTimeRange(timeRange);
+        // If previous day is always available (weekly: true), no cross-midnight
+        // rules to check
+        if (previousDayResult.rules !== true) {
+            // Check each rule from previous day for cross-midnight spillover
+            previousDayResult.rules.forEach((previousDayRule, previousDayRuleIndex) => {
+                // Skip if previous day rule doesn't include previous weekday
+                if (!doesWeekdaysIncludeWeekday(previousDayRule.weekdays, previousWeekday)) {
+                    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];
@@ -45,41 +49,38 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
                         if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, firstDateWeekday)) {
                             return;
                         }
-                        // 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.type === 'override') {
-                                    // Previous day is in an override
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                        overrideIndex,
-                                        date: firstDate.toJSON(),
-                                        overrideRuleIndex,
-                                        sourceOverrideIndex: previousDayResult.source.overrideIndex,
-                                        sourceOverrideRuleIndex: previousDayRuleIndex,
-                                    });
-                                }
-                                else {
-                                    // Previous day is weekly
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                        overrideIndex,
-                                        date: firstDate.toJSON(),
-                                        overrideRuleIndex,
-                                        sourceWeeklyRuleIndex: previousDayRuleIndex,
-                                    });
-                                }
+                        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,
+                                });
                             }
-                        });
+                            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
         // Skip for indefinite overrides (no last day)
         if (!override.to) {
@@ -95,54 +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);
-                    // 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 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.type === 'override') {
-                                    // Next day is in an override
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
-                                        overrideIndex,
-                                        date: lastDate.toJSON(),
-                                        overrideRuleIndex,
-                                        nextDayOverrideIndex: nextDayResult.source.overrideIndex,
-                                        nextDayOverrideRuleIndex: nextDayRuleIndex,
-                                    });
-                                }
-                                else {
-                                    // Next day is weekly
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
-                                        overrideIndex,
-                                        date: lastDate.toJSON(),
-                                        overrideRuleIndex,
-                                        nextDayWeeklyRuleIndex: nextDayRuleIndex,
-                                    });
-                                }
-                            }
-                        });
+            // 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;
+                    }
+                    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,
+                            });
+                        }
+                        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;
 };
 /**
@@ -86,7 +84,8 @@ const validateRule = (rule, fieldPrefix) => {
 export const validateScDateFormats = (schedule) => {
     const errors = [];
     // Validate weekly rules
-    schedule.weekly.forEach((rule, ruleIndex) => {
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    weeklyRules.forEach((rule, ruleIndex) => {
         errors.push(...validateRule(rule, `weekly[${String(ruleIndex)}]`));
     });
     // Validate overrides

package/dist/isScheduleAvailable.d.ts

@@ -2,5 +2,14 @@ import type { STimestamp } from 'scdate';
 import type { Schedule } from './types.js';
 /**
  * Checks if a schedule is available at the specified timestamp.
+ *
+ * When `weekly` is `true`, the schedule is always available (unless an
+ * override applies). Otherwise, checks whether the timestamp falls within any
+ * matching time range for the day, including cross-midnight spillover from the
+ * previous day.
+ *
+ * @param schedule The schedule to check availability against.
+ * @param timestamp The timestamp to check.
+ * @returns True if the schedule is available at the given timestamp.
  */
 export declare const isScheduleAvailable: (schedule: Schedule, timestamp: STimestamp | string) => boolean;

package/dist/isScheduleAvailable.js

@@ -3,6 +3,15 @@ import { getApplicableRuleForDate } from './internal/getApplicableRuleForDate.js
 import { isTimeInTimeRange } from './internal/isTimeInTimeRange.js';
 /**
  * Checks if a schedule is available at the specified timestamp.
+ *
+ * When `weekly` is `true`, the schedule is always available (unless an
+ * override applies). Otherwise, checks whether the timestamp falls within any
+ * matching time range for the day, including cross-midnight spillover from the
+ * previous day.
+ *
+ * @param schedule The schedule to check availability against.
+ * @param timestamp The timestamp to check.
+ * @returns True if the schedule is available at the given timestamp.
  */
 export const isScheduleAvailable = (schedule, timestamp) => {
     const date = getDateFromTimestamp(timestamp);
@@ -10,14 +19,18 @@ export const isScheduleAvailable = (schedule, timestamp) => {
     const weekday = getWeekdayFromDate(date);
     // Get the applicable rules for this date
     const { rules } = getApplicableRuleForDate(schedule, date.date);
+    // If weekly is true, always available (unless overridden)
+    if (rules === true) {
+        return true;
+    }
     // Check if any rule's time ranges include this timestamp (same-day check)
     const matchesSameDay = rules.some((rule) => {
         // Check if this weekday is in the rule
         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;
@@ -25,13 +38,17 @@ export const isScheduleAvailable = (schedule, timestamp) => {
     // Also check previous day's rules for cross-midnight spillover
     const previousDate = addDaysToDate(date, -1);
     const previousWeekday = getWeekdayFromDate(previousDate);
-    const { rules: previousRules } = getApplicableRuleForDate(schedule, previousDate.date);
-    return previousRules.some((rule) => {
+    const previousResult = getApplicableRuleForDate(schedule, previousDate.date);
+    // If previous day was always available, no cross-midnight rules to check
+    if (previousResult.rules === true) {
+        return false;
+    }
+    return previousResult.rules.some((rule) => {
         // Check if previous day's weekday is in the rule
         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
@@ -60,20 +49,19 @@ export interface OverrideScheduleRule {
     rules: WeeklyScheduleRule[];
 }
 /**
- * Represents a complete availability schedule. A schedule consists of a
- * timezone for all date/time operations, base weekly recurring patterns, and
- * optional date-specific overrides. Priority order for determining
- * availability: 1. Specific override (with both from and to dates) 2.
- * Indefinite override (with only from date) 3. Weekly schedule
+ * Represents a complete availability schedule. A schedule consists of base
+ * weekly recurring patterns and optional date-specific overrides. Priority
+ * order for determining availability: 1. Specific override (with both from and
+ * to dates) 2. Indefinite override (with only from date) 3. Weekly schedule
  */
 export interface Schedule {
     /**
-     * IANA timezone identifier (e.g., 'America/New_York', 'Europe/London'). Must
-     * be in `Intl.supportedValuesOf('timeZone')`.
+     * Base recurring weekly schedule patterns.
+     * - `true`: available 24/7 (overrides can close windows)
+     * - `WeeklyScheduleRule[]`: available during defined time ranges
+     * - `[]`: never available (overrides can open windows)
      */
-    timezone: string;
-    /** Base recurring weekly schedule patterns */
-    weekly: WeeklyScheduleRule[];
+    weekly: WeeklyScheduleRule[] | true;
     /**
      * Date-specific exceptions to the weekly schedule. Overrides take precedence
      * over weekly rules.
@@ -95,11 +83,6 @@ export interface AvailabilityRange {
  * property to narrow the type and access error-specific fields.
  */
 export type ValidationError = {
-    /** The timezone string is not a valid IANA timezone identifier */
-    issue: ValidationIssue.InvalidTimezone;
-    /** The invalid timezone string that was provided */
-    timezone: string;
-} | {
     /** Two or more specific overrides have identical date ranges */
     issue: ValidationIssue.DuplicateOverrides;
     /** Indexes of the two duplicate overrides */
@@ -109,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
@@ -225,7 +179,7 @@ export type ValidationError = {
 } | {
     /**
      * Cross-midnight spillover from override's last day conflicts with next
-     * day's time ranges
+     * day's time ranges or weekly: true availability
      */
     issue: ValidationIssue.SpilloverConflictOverrideIntoNext;
     /** Index of the override whose last day causes spillover */
@@ -235,8 +189,8 @@ export type ValidationError = {
     /** The override rule index causing the spillover */
     overrideRuleIndex: number;
     /**
-     * The next day's rule that conflicts (weekly or another override). If
-     * nextDayOverrideIndex is undefined, it's a weekly rule.
+     * The next day's rule that conflicts. When all three fields are
+     * undefined, the next day is weekly: true (fully available).
      */
     nextDayWeeklyRuleIndex?: number;
     nextDayOverrideIndex?: number;

package/dist/validateSchedule.d.ts

@@ -3,13 +3,15 @@ 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 (timezone, 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
  *
  * If structural errors are found, validation stops early and returns only
  * those errors. This provides better user experience and avoids crashes from
  * invalid data during normalization.
+ *
+ * @param schedule The schedule to validate.
  */
 export declare const validateSchedule: (schedule: Schedule) => ValidationResult;

package/dist/validateSchedule.js

@@ -2,36 +2,33 @@ 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';
-import { validateTimezone } from './internal/validateTimezone.js';
 /**
  * Validates a schedule configuration and returns all validation errors found.
  *
  * Validation is performed in two phases:
- * 1. Structural validation (timezone, 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
  *
  * If structural errors are found, validation stops early and returns only
  * those errors. This provides better user experience and avoids crashes from
  * invalid data during normalization.
+ *
+ * @param schedule The schedule to validate.
  */
 export const validateSchedule = (schedule) => {
     // Phase 1: Structural validation
     // Note: Order matters - date formats and order must be validated before
     // weekday matching (which calls filterWeekdaysForDates)
     const structuralErrors = [
-        ...validateTimezone(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": "2.1.1",
+  "version": "3.1.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"
@@ -20,7 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "scdate": "2.1.1"
+    "scdate": "3.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",

package/dist/internal/isValidTimezone.d.ts

@@ -1,4 +0,0 @@
-/**
- * Checks if a string is a valid IANA timezone identifier.
- */
-export declare const isValidTimezone: (timezone: string) => boolean;

package/dist/internal/isValidTimezone.js

@@ -1,12 +0,0 @@
-/**
- * Checks if a string is a valid IANA timezone identifier.
- */
-export const isValidTimezone = (timezone) => {
-    try {
-        const validTimezones = Intl.supportedValuesOf('timeZone');
-        return validTimezones.includes(timezone);
-    }
-    catch {
-        return false;
-    }
-};

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[];