effect 3.21.4 → 3.21.5

package/src/Cron.ts

@@ -44,6 +44,8 @@ export interface Cron extends Pipeable, Equal.Equal, Inspectable {
   readonly months: ReadonlySet<number>
   readonly weekdays: ReadonlySet<number>
   /** @internal */
+  readonly and: boolean
+  /** @internal */
   readonly first: {
     readonly second: number
     readonly minute: number
@@ -89,6 +91,7 @@ const CronProto = {
   [Hash.symbol](this: Cron): number {
     return pipe(
       Hash.hash(this.tz),
+      Hash.combine(Hash.hash(this.and)),
       Hash.combine(Hash.array(Arr.fromIterable(this.seconds))),
       Hash.combine(Hash.array(Arr.fromIterable(this.minutes))),
       Hash.combine(Hash.array(Arr.fromIterable(this.hours))),
@@ -142,6 +145,7 @@ export const make = (values: {
   readonly days: Iterable<number>
   readonly months: Iterable<number>
   readonly weekdays: Iterable<number>
+  readonly and?: boolean | undefined
   readonly tz?: DateTime.TimeZone | undefined
 }): Cron => {
   const o: Mutable<Cron> = Object.create(CronProto)
@@ -151,6 +155,7 @@ export const make = (values: {
   o.days = new Set(Arr.sort(values.days, N.Order))
   o.months = new Set(Arr.sort(values.months, N.Order))
   o.weekdays = new Set(Arr.sort(values.weekdays, N.Order))
+  o.and = values.and === true
   o.tz = Option.fromNullable(values.tz)
 
   const seconds = Array.from(o.seconds)
@@ -291,7 +296,7 @@ export const isParseError = (u: unknown): u is ParseError => hasProperty(u, Pars
  * @category constructors
  */
 export const parse = (cron: string, tz?: DateTime.TimeZone | string): Either.Either<Cron, ParseError> => {
-  const segments = cron.split(" ").filter(String.isNonEmpty)
+  const segments = cron.trim().split(/\s+/).filter(String.isNonEmpty)
   if (segments.length !== 5 && segments.length !== 6) {
     return Either.left(
       new ParseError({
@@ -322,7 +327,18 @@ export const parse = (cron: string, tz?: DateTime.TimeZone | string): Either.Eit
     days: parseSegment(days, dayOptions),
     months: parseSegment(months, monthOptions),
     weekdays: parseSegment(weekdays, weekdayOptions)
-  }).pipe(Either.map(make))
+  }).pipe(Either.map(({ days, hours, minutes, months, seconds, tz, weekdays }) =>
+    make({
+      tz,
+      seconds: seconds.values,
+      minutes: minutes.values,
+      hours: hours.values,
+      days: days.values,
+      months: months.values,
+      weekdays: weekdays.values,
+      and: (days.wildcard || weekdays.wildcard) && days.values.size !== 0 && weekdays.values.size !== 0
+    })
+  ))
 }
 
 /**
@@ -410,6 +426,11 @@ export const match = (cron: Cron, date: DateTime.DateTime.Input): boolean => {
     return true
   }
 
+  if (cron.and) {
+    return (cron.days.size === 0 || cron.days.has(parts.day)) &&
+      (cron.weekdays.size === 0 || cron.weekdays.has(parts.weekDay))
+  }
+
   if (cron.weekdays.size === 0) {
     return cron.days.has(parts.day)
   }
@@ -553,48 +574,60 @@ const stepCron = (cron: Cron, startFrom: DateTime.DateTime.Input | undefined, di
       }
 
       if (cron.weekdays.size !== 0 || cron.days.size !== 0) {
-        let a: number = prev ? -Infinity : Infinity
-        let b: number = prev ? -Infinity : Infinity
-
-        if (cron.weekdays.size !== 0) {
-          const currentWeekday = current.getUTCDay()
-          const nextWeekday = table.weekday[currentWeekday]
-          if (nextWeekday === undefined) {
-            a = prev
-              ? currentWeekday - 7 + boundary.weekday
-              : 7 - currentWeekday + boundary.weekday
-          } else {
-            a = nextWeekday - currentWeekday
+        if (cron.and) {
+          const matchesDay = cron.days.size === 0 || cron.days.has(current.getUTCDate())
+          const matchesWeekday = cron.weekdays.size === 0 || cron.weekdays.has(current.getUTCDay())
+          if (!matchesDay || !matchesWeekday) {
+            current.setUTCDate(current.getUTCDate() + tick)
+            current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
+            adjustDst(current)
+            continue
           }
-        }
-
-        // Only check day-of-month if weekday constraint not already satisfied (they're OR'd)
-        if (cron.days.size !== 0 && a !== 0) {
-          const currentDay = current.getUTCDate()
-          const nextDay = table.day[currentDay]
-          if (nextDay === undefined) {
-            if (prev) {
-              // When wrapping to previous month, calculate days back:
-              // Current day offset + gap from end of prev month to target day
-              // Example: June 3 → May 20 with boundary.day=20: -(3 + (31 - 20)) = -14
-              const prevMonthDays = daysInMonth(
-                new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), 0))
-              )
-              b = -(currentDay + (prevMonthDays - boundary.day))
+        } else {
+          let a: number = prev ? -Infinity : Infinity
+          let b: number = prev ? -Infinity : Infinity
+
+          if (cron.weekdays.size !== 0) {
+            const currentWeekday = current.getUTCDay()
+            const nextWeekday = table.weekday[currentWeekday]
+            if (nextWeekday === undefined) {
+              a = prev
+                ? currentWeekday - 7 + boundary.weekday
+                : 7 - currentWeekday + boundary.weekday
             } else {
+              a = nextWeekday - currentWeekday
+            }
+          }
+
+          // Only check day-of-month if weekday constraint not already satisfied (they're OR'd)
+          if (cron.days.size !== 0 && a !== 0) {
+            const currentDay = current.getUTCDate()
+            const nextDay = table.day[currentDay]
+            if (nextDay === undefined) {
+              if (prev) {
+                const prevMonthDays = daysInMonth(
+                  new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), 0))
+                )
+                b = -(currentDay + (prevMonthDays - boundary.day))
+              } else {
+                b = daysInMonth(current) - currentDay + boundary.day
+              }
+            } else if (!prev && nextDay > daysInMonth(current)) {
+              // The next matching day does not exist in the current month. Setting it
+              // directly would overflow and skip earlier matching days next month.
               b = daysInMonth(current) - currentDay + boundary.day
+            } else {
+              b = nextDay - currentDay
             }
-          } else {
-            b = nextDay - currentDay
           }
-        }
 
-        const addDays = prev ? Math.max(a, b) : Math.min(a, b)
-        if (addDays !== 0) {
-          current.setUTCDate(current.getUTCDate() + addDays)
-          current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
-          adjustDst(current)
-          continue
+          const addDays = prev ? Math.max(a, b) : Math.min(a, b)
+          if (addDays !== 0) {
+            current.setUTCDate(current.getUTCDate() + addDays)
+            current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
+            adjustDst(current)
+            continue
+          }
         }
       }
 
@@ -602,11 +635,11 @@ const stepCron = (cron: Cron, startFrom: DateTime.DateTime.Input | undefined, di
         const currentMonth = current.getUTCMonth() + 1
         const nextMonth = table.month[currentMonth]
         const clampBoundaryDay = (targetMonthIndex: number): number => {
-          if (cron.days.size !== 0) {
+          if (cron.days.size !== 0 && cron.weekdays.size === 0) {
             return boundary.day
           }
           const maxDayInMonth = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), targetMonthIndex, 1)))
-          return Math.min(boundary.day, maxDayInMonth)
+          return prev ? maxDayInMonth : 1
         }
         if (nextMonth === undefined) {
           current.setUTCFullYear(current.getUTCFullYear() + tick)
@@ -661,6 +694,7 @@ export const sequenceReverse = function*(cron: Cron, startFrom?: DateTime.DateTi
  * @since 2.0.0
  */
 export const Equivalence: equivalence.Equivalence<Cron> = equivalence.make((self, that) =>
+  self.and === that.and &&
   restrictionsEquals(self.seconds, that.seconds) &&
   restrictionsEquals(self.minutes, that.minutes) &&
   restrictionsEquals(self.hours, that.hours) &&
@@ -700,6 +734,12 @@ interface SegmentOptions {
   min: number
   max: number
   aliases?: Record<string, number> | undefined
+  normalize?: ((value: number) => number) | undefined
+}
+
+interface ParsedSegment {
+  readonly values: Set<number>
+  readonly wildcard: boolean
 }
 
 const secondOptions: SegmentOptions = {
@@ -743,7 +783,8 @@ const monthOptions: SegmentOptions = {
 
 const weekdayOptions: SegmentOptions = {
   min: 0,
-  max: 6,
+  max: 7,
+  normalize: (value) => value === 7 ? 0 : value,
   aliases: {
     sun: 0,
     mon: 1,
@@ -758,17 +799,21 @@ const weekdayOptions: SegmentOptions = {
 const parseSegment = (
   input: string,
   options: SegmentOptions
-): Either.Either<ReadonlySet<number>, ParseError> => {
-  const capacity = options.max - options.min + 1
+): Either.Either<ParsedSegment, ParseError> => {
   const values = new Set<number>()
   const fields = input.split(",")
-
-  for (const field of fields) {
-    const [raw, step] = splitStep(field)
-    if (raw === "*" && step === undefined) {
-      return Either.right(new Set())
+  const first = splitStep(fields[0]!)
+  const wildcard = first[0] === "*"
+  const normalize = options.normalize ?? ((value: number) => value)
+  const add = wildcard && (first[1] === undefined || first[1] === 1)
+    ? constVoid
+    : (value: number) => {
+      values.add(normalize(value))
     }
 
+  for (let index = 0; index < fields.length; index++) {
+    const field = fields[index]!
+    const [raw, step] = index === 0 ? first : splitStep(field)
     if (step !== undefined) {
       if (!Number.isInteger(step)) {
         return Either.left(new ParseError({ message: `Expected step value to be a positive integer`, input }))
@@ -782,8 +827,11 @@ const parseSegment = (
     }
 
     if (raw === "*") {
+      if (index === 0 && (step === undefined || step === 1)) {
+        continue
+      }
       for (let i = options.min; i <= options.max; i += step ?? 1) {
-        values.add(i)
+        add(i)
       }
     } else {
       const [left, right] = splitRange(raw, options.aliases)
@@ -797,7 +845,9 @@ const parseSegment = (
       }
 
       if (right === undefined) {
-        values.add(left)
+        for (let i = left; i <= (step === undefined ? left : options.max); i += step ?? 1) {
+          add(i)
+        }
       } else {
         if (!Number.isInteger(right)) {
           return Either.left(new ParseError({ message: `Expected a positive integer`, input }))
@@ -812,23 +862,20 @@ const parseSegment = (
         }
 
         for (let i = left; i <= right; i += step ?? 1) {
-          values.add(i)
+          add(i)
         }
       }
     }
-
-    if (values.size >= capacity) {
-      return Either.right(new Set())
-    }
   }
 
-  return Either.right(values)
+  return Either.right({ values, wildcard })
 }
 
 const splitStep = (input: string): [string, number | undefined] => {
   const seperator = input.indexOf("/")
   if (seperator !== -1) {
-    return [input.slice(0, seperator), Number(input.slice(seperator + 1))]
+    const step = input.slice(seperator + 1)
+    return [input.slice(0, seperator), decimalRegex.test(step) ? Number(step) : NaN]
   }
 
   return [input, undefined]
@@ -844,5 +891,7 @@ const splitRange = (input: string, aliases?: Record<string, number>): [number, n
 }
 
 function aliasOrValue(field: string, aliases?: Record<string, number>): number {
-  return aliases?.[field.toLocaleLowerCase()] ?? Number(field)
+  return aliases?.[field.toLocaleLowerCase()] ?? (decimalRegex.test(field) ? Number(field) : NaN)
 }
+
+const decimalRegex = /^\d+$/

package/src/internal/schedule.ts

@@ -482,6 +482,14 @@ export const cron: {
   return makeWithState<[boolean, [number, number, number]], unknown, [number, number]>(
     [true, [Number.MIN_SAFE_INTEGER, 0, 0]],
     (now, _, [initial, previous]) => {
+      if (now === Number.POSITIVE_INFINITY) {
+        return core.succeed([
+          [false, previous],
+          [previous[1], previous[2]],
+          ScheduleDecision.done
+        ])
+      }
+
       if (now < previous[0]) {
         return core.succeed([
           [false, previous],

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.21.4"
+let moduleVersion = "3.21.5"
 
 export const getCurrentVersion = () => moduleVersion