scschedule 2.1.1 → 3.0.0

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,6 +19,10 @@ 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
@@ -25,8 +38,12 @@ 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;

package/dist/types.d.ts

@@ -60,20 +60,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 +94,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 */
@@ -225,7 +219,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 +229,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, non-empty
+ *    times, 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

@@ -8,26 +8,26 @@ 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, non-empty
+ *    times, 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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scschedule",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"
@@ -20,7 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "scdate": "2.1.1"
+    "scdate": "3.0.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/validateTimezone.d.ts

@@ -1,5 +0,0 @@
-import type { Schedule, ValidationError } from '../types.js';
-/**
- * Validates that a schedule's timezone is a valid IANA timezone identifier.
- */
-export declare const validateTimezone: (schedule: Schedule) => ValidationError[];

package/dist/internal/validateTimezone.js

@@ -1,16 +0,0 @@
-import { ValidationIssue } from '../constants.js';
-import { isValidTimezone } from './isValidTimezone.js';
-/**
- * Validates that a schedule's timezone is a valid IANA timezone identifier.
- */
-export const validateTimezone = (schedule) => {
-    if (!isValidTimezone(schedule.timezone)) {
-        return [
-            {
-                issue: ValidationIssue.InvalidTimezone,
-                timezone: schedule.timezone,
-            },
-        ];
-    }
-    return [];
-};