scschedule 3.1.0 → 4.0.0

package/README.md

@@ -472,13 +472,52 @@ const canOrderBreakfast =
 
 ## Validation Error Types
 
-The library uses discriminated unions for type-safe error handling:
+The library uses discriminated unions for type-safe error handling. Location types (`RuleLocation`, `FieldLocation`) provide structured data for finding and highlighting errors in the UI—no path parsing required.
+
+```typescript
+// RuleLocation - where a rule lives (used by EmptyWeekdays)
+type RuleLocation =
+  | { type: RuleLocationType.Weekly; ruleIndex: number }
+  | {
+      type: RuleLocationType.Override
+      overrideIndex: number
+      ruleIndex: number
+    }
+
+// FieldLocation - where a field lives (used by InvalidScDateFormat)
+type FieldLocation =
+  | { type: RuleLocationType.Weekly; ruleIndex: number; field: RuleField }
+  | {
+      type: RuleLocationType.Override
+      overrideIndex: number
+      field: OverrideField
+    }
+  | {
+      type: RuleLocationType.Override
+      overrideIndex: number
+      ruleIndex: number
+      field: RuleField
+    }
+
+// RuleField - rule-level fields (weekdays, from, to)
+enum RuleField {
+  Weekdays = 'weekdays',
+  From = 'from',
+  To = 'to',
+}
+
+// OverrideField - override date range fields (from, to)
+enum OverrideField {
+  From = 'from',
+  To = 'to',
+}
+```
 
 ```typescript
 type ValidationError =
   | {
       issue: ValidationIssue.InvalidScDateFormat
-      field: string
+      location: FieldLocation
       value: string
       expectedFormat: string
     }
@@ -509,13 +548,7 @@ type ValidationError =
     }
   | {
       issue: ValidationIssue.EmptyWeekdays
-      location:
-        | { type: RuleLocationType.Weekly; ruleIndex: number }
-        | {
-            type: RuleLocationType.Override
-            overrideIndex: number
-            ruleIndex: number
-          }
+      location: RuleLocation
     }
   | {
       issue: ValidationIssue.OverrideWeekdaysMismatch
@@ -580,13 +613,20 @@ import type {
   AvailabilityRange,
   ValidationError,
   ValidationResult,
+  RuleLocation,
+  FieldLocation,
   SDateString,
   STimeString,
   STimestampString,
   SWeekdaysString,
 } from 'scschedule'
 
-import { ValidationIssue, RuleLocationType } from 'scschedule'
+import {
+  ValidationIssue,
+  RuleLocationType,
+  RuleField,
+  OverrideField,
+} from 'scschedule'
 ```
 
 Note: The `Weekday` enum (used in some `ValidationError` variants) is exported from `scdate`, not `scschedule`:

package/dist/constants.d.ts

@@ -58,3 +58,25 @@ export declare enum RuleLocationType {
     /** The rule is in an override section */
     Override = "override"
 }
+/**
+ * Fields within a rule (weekly or override rule) that can contain scdate
+ * format values. Used in validation errors for rule-level format failures.
+ */
+export declare enum RuleField {
+    /** Days of the week (SMTWTFS format) */
+    Weekdays = "weekdays",
+    /** Start time */
+    From = "from",
+    /** End time */
+    To = "to"
+}
+/**
+ * Fields on an override's date range that can contain scdate format values.
+ * Used in validation errors for override-level format failures.
+ */
+export declare enum OverrideField {
+    /** Start date */
+    From = "from",
+    /** End date */
+    To = "to"
+}

package/dist/constants.js

@@ -60,3 +60,27 @@ export var RuleLocationType;
     /** The rule is in an override section */
     RuleLocationType["Override"] = "override";
 })(RuleLocationType || (RuleLocationType = {}));
+/**
+ * Fields within a rule (weekly or override rule) that can contain scdate
+ * format values. Used in validation errors for rule-level format failures.
+ */
+export var RuleField;
+(function (RuleField) {
+    /** Days of the week (SMTWTFS format) */
+    RuleField["Weekdays"] = "weekdays";
+    /** Start time */
+    RuleField["From"] = "from";
+    /** End time */
+    RuleField["To"] = "to";
+})(RuleField || (RuleField = {}));
+/**
+ * Fields on an override's date range that can contain scdate format values.
+ * Used in validation errors for override-level format failures.
+ */
+export var OverrideField;
+(function (OverrideField) {
+    /** Start date */
+    OverrideField["From"] = "from";
+    /** End date */
+    OverrideField["To"] = "to";
+})(OverrideField || (OverrideField = {}));

package/dist/internal/validateScDateFormats.js

@@ -1,16 +1,16 @@
 import { sDate, sTime, sWeekdays } from 'scdate';
-import { ValidationIssue } from '../constants.js';
+import { OverrideField, RuleField, RuleLocationType, ValidationIssue, } from '../constants.js';
 /**
  * Validates that a value is a valid SDate format (YYYY-MM-DD).
  */
-const validateSDateValue = (value, field) => {
+const validateSDateValue = (value, location) => {
     try {
         sDate(value);
     }
     catch {
         return {
             issue: ValidationIssue.InvalidScDateFormat,
-            field,
+            location,
             value: String(value),
             expectedFormat: 'YYYY-MM-DD',
         };
@@ -20,14 +20,14 @@ const validateSDateValue = (value, field) => {
 /**
  * Validates that a value is a valid STime format (HH:MM).
  */
-const validateSTimeValue = (value, field) => {
+const validateSTimeValue = (value, location) => {
     try {
         sTime(value);
     }
     catch {
         return {
             issue: ValidationIssue.InvalidScDateFormat,
-            field,
+            location,
             value: String(value),
             expectedFormat: 'HH:MM',
         };
@@ -37,14 +37,14 @@ const validateSTimeValue = (value, field) => {
 /**
  * Validates that a value is a valid SWeekdays format (SMTWTFS).
  */
-const validateSWeekdaysValue = (value, field) => {
+const validateSWeekdaysValue = (value, location) => {
     try {
         sWeekdays(value);
     }
     catch {
         return {
             issue: ValidationIssue.InvalidScDateFormat,
-            field,
+            location,
             value: String(value),
             expectedFormat: 'SMTWTFS',
         };
@@ -54,13 +54,19 @@ const validateSWeekdaysValue = (value, field) => {
 /**
  * Validates both from and to times in a time range.
  */
-const validateTimeRange = (timeRange, fieldPrefix) => {
+const validateTimeRange = (timeRange, locationBase) => {
     const errors = [];
-    const fromError = validateSTimeValue(timeRange.from, `${fieldPrefix}.from`);
+    const fromError = validateSTimeValue(timeRange.from, {
+        ...locationBase,
+        field: RuleField.From,
+    });
     if (fromError) {
         errors.push(fromError);
     }
-    const toError = validateSTimeValue(timeRange.to, `${fieldPrefix}.to`);
+    const toError = validateSTimeValue(timeRange.to, {
+        ...locationBase,
+        field: RuleField.To,
+    });
     if (toError) {
         errors.push(toError);
     }
@@ -69,13 +75,16 @@ const validateTimeRange = (timeRange, fieldPrefix) => {
 /**
  * Validates a rule (weekdays and time range).
  */
-const validateRule = (rule, fieldPrefix) => {
+const validateRule = (rule, locationBase) => {
     const errors = [];
-    const weekdaysError = validateSWeekdaysValue(rule.weekdays, `${fieldPrefix}.weekdays`);
+    const weekdaysError = validateSWeekdaysValue(rule.weekdays, {
+        ...locationBase,
+        field: RuleField.Weekdays,
+    });
     if (weekdaysError) {
         errors.push(weekdaysError);
     }
-    errors.push(...validateTimeRange(rule, fieldPrefix));
+    errors.push(...validateTimeRange(rule, locationBase));
     return errors;
 };
 /**
@@ -86,22 +95,37 @@ export const validateScDateFormats = (schedule) => {
     // Validate weekly rules
     const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
     weeklyRules.forEach((rule, ruleIndex) => {
-        errors.push(...validateRule(rule, `weekly[${String(ruleIndex)}]`));
+        errors.push(...validateRule(rule, {
+            type: RuleLocationType.Weekly,
+            ruleIndex,
+        }));
     });
     // Validate overrides
     schedule.overrides?.forEach((override, overrideIndex) => {
-        const fromError = validateSDateValue(override.from, `overrides[${String(overrideIndex)}].from`);
+        const fromError = validateSDateValue(override.from, {
+            type: RuleLocationType.Override,
+            overrideIndex,
+            field: OverrideField.From,
+        });
         if (fromError) {
             errors.push(fromError);
         }
         if (override.to) {
-            const toError = validateSDateValue(override.to, `overrides[${String(overrideIndex)}].to`);
+            const toError = validateSDateValue(override.to, {
+                type: RuleLocationType.Override,
+                overrideIndex,
+                field: OverrideField.To,
+            });
             if (toError) {
                 errors.push(toError);
             }
         }
         override.rules.forEach((rule, ruleIndex) => {
-            errors.push(...validateRule(rule, `overrides[${String(overrideIndex)}].rules[${String(ruleIndex)}]`));
+            errors.push(...validateRule(rule, {
+                type: RuleLocationType.Override,
+                overrideIndex,
+                ruleIndex,
+            }));
         });
     });
     return errors;

package/dist/types.d.ts

@@ -1,5 +1,35 @@
 import type { SDate, STime, STimestamp, SWeekdays, Weekday } from 'scdate';
-import { RuleLocationType, ValidationIssue } from './constants.js';
+import { OverrideField, RuleField, RuleLocationType, ValidationIssue } from './constants.js';
+/**
+ * Location of a rule within the schedule structure. Used by validation errors
+ * that point to a specific rule (e.g. EmptyWeekdays).
+ */
+export type RuleLocation = {
+    type: RuleLocationType.Weekly;
+    ruleIndex: number;
+} | {
+    type: RuleLocationType.Override;
+    overrideIndex: number;
+    ruleIndex: number;
+};
+/**
+ * Location of a field within the schedule structure. Used by validation errors
+ * that point to a specific field (e.g. InvalidScDateFormat).
+ */
+export type FieldLocation = {
+    type: RuleLocationType.Weekly;
+    ruleIndex: number;
+    field: RuleField;
+} | {
+    type: RuleLocationType.Override;
+    overrideIndex: number;
+    field: OverrideField;
+} | {
+    type: RuleLocationType.Override;
+    overrideIndex: number;
+    ruleIndex: number;
+    field: RuleField;
+};
 /**
  * String in YYYY-MM-DD format representing a date.
  */
@@ -98,8 +128,8 @@ export type ValidationError = {
      * (SDate, STime, SWeekdays, or STimestamp)
      */
     issue: ValidationIssue.InvalidScDateFormat;
-    /** Path to the field with invalid format (e.g., 'weekly[0].weekdays') */
-    field: string;
+    /** Location of the field with invalid format */
+    location: FieldLocation;
     /** The invalid value that was provided */
     value: string;
     /** The expected format (e.g., 'SMTWTFS', 'HH:MM', 'YYYY-MM-DD') */
@@ -110,14 +140,7 @@ export type ValidationError = {
      */
     issue: ValidationIssue.EmptyWeekdays;
     /** Location of the rule with empty weekdays */
-    location: {
-        type: RuleLocationType.Weekly;
-        ruleIndex: number;
-    } | {
-        type: RuleLocationType.Override;
-        overrideIndex: number;
-        ruleIndex: number;
-    };
+    location: RuleLocation;
 } | {
     /**
      * An override has weekdays that don't match any actual dates in the

package/package.json

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