@reventlessdev/reventless-core 3.0.0-alpha.294 → 3.0.0-alpha.296

package/src/util/ScheduleTime.res

@@ -0,0 +1,266 @@
+// When a `Schedule.time` fires, read the same way by the local timers and the AWS
+// expression, so the two platforms agree. A calendar time in the hour skipped by
+// daylight saving does not fire that day, as EventBridge Scheduler does.
+open Reventless.Schedule
+
+exception InvalidTime(string)
+
+let utc = "UTC"
+let zoneName = (zone: option<zone>) => zone->Option.getOr(utc)
+
+let zoneOrThrow = name =>
+  switch DateTime.zoneMakeNamed(name) {
+  | Some(zone) => zone
+  | None => throw(InvalidTime(`unknown time zone "${name}"`))
+  }
+
+let minuteMs = 60_000.
+
+let intervalMs = (interval: interval) =>
+  switch interval {
+  | Minutes(n) => n->Int.toFloat *. minuteMs
+  | Hours(n) => n->Int.toFloat *. 60. *. minuteMs
+  | Days(n) => n->Int.toFloat *. 24. *. 60. *. minuteMs
+  | Weeks(n) => n->Int.toFloat *. 7. *. 24. *. 60. *. minuteMs
+  }
+
+let weekdayIndex = (day: weekday) =>
+  switch day {
+  | Sun => 0
+  | Mon => 1
+  | Tue => 2
+  | Wed => 3
+  | Thu => 4
+  | Fri => 5
+  | Sat => 6
+  }
+
+let weekdayName = (day: weekday) =>
+  switch day {
+  | Mon => "MON"
+  | Tue => "TUE"
+  | Wed => "WED"
+  | Thu => "THU"
+  | Fri => "FRI"
+  | Sat => "SAT"
+  | Sun => "SUN"
+  }
+
+let errors = (time: time) => {
+  let errs = []
+  let check = (ok, message) => ok ? () : errs->Array.push(message)
+  let positive = (n, what) => check(n >= 1, `${what} must be at least 1, got ${n->Int.toString}`)
+  let clock = (hour, minute) => {
+    check(hour >= 0 && hour <= 23, `hour must be 0 to 23, got ${hour->Int.toString}`)
+    check(minute >= 0 && minute <= 59, `minute must be 0 to 59, got ${minute->Int.toString}`)
+  }
+  let dayOfMonth = day =>
+    check(day >= 1 && day <= 31, `day must be 1 to 31, got ${day->Int.toString}`)
+  let monthOfYear = month =>
+    check(month >= 1 && month <= 12, `month must be 1 to 12, got ${month->Int.toString}`)
+  let zoneKnown = zone =>
+    zone->Option.forEach(name =>
+      check(DateTime.zoneMakeNamed(name)->Option.isSome, `unknown time zone "${name}"`)
+    )
+  switch time {
+  | Every(Minutes(n) | Hours(n) | Days(n) | Weeks(n)) => positive(n, "an interval")
+  | Calendar({calendar, ?zone}) =>
+    zoneKnown(zone)
+    switch calendar {
+    | Daily({hour, minute}) => clock(hour, minute)
+    | Weekly({days, hour, minute}) =>
+      check(days->Array.length > 0, "a weekly time needs at least one day")
+      clock(hour, minute)
+    | Monthly({day, hour, minute, ?every}) =>
+      dayOfMonth(day)
+      clock(hour, minute)
+      every->Option.forEach(every =>
+        check(every >= 1 && every <= 12, `every must be 1 to 12, got ${every->Int.toString}`)
+      )
+    | Yearly({month, day, hour, minute}) =>
+      monthOfYear(month)
+      dayOfMonth(day)
+      clock(hour, minute)
+    }
+  | Once({moment, ?zone}) =>
+    zoneKnown(zone)
+    switch moment {
+    | At({month, day, hour, minute}) =>
+      monthOfYear(month)
+      dayOfMonth(day)
+      clock(hour, minute)
+    | After(Minutes(n) | Hours(n) | Days(n) | Weeks(n) | Months(n) | Years(n)) =>
+      positive(n, "a period")
+    }
+  }
+  errs
+}
+
+/** Throws `InvalidTime` naming every problem of `time`, for a schedule about to be set. */
+let validate = time =>
+  switch time->errors {
+  | [] => ()
+  | errs => throw(InvalidTime(errs->Array.join("; ")))
+  }
+
+let localTimeOf = (millis, ~zone): localTime => {
+  let parts = DateTime.makeZonedFromMillis(millis, ~zone)->DateTime.toParts
+  {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hours,
+    minute: parts.minutes,
+  }
+}
+
+/**
+The moment a period after `from` falls on, in `zone`. Minutes and hours are elapsed time;
+days and longer keep the wall-clock time, and a month from 31 January is the last day
+of February.
+*/
+let afterPeriod = (period: period, ~from, ~zone) => {
+  let start = DateTime.makeZonedFromMillis(from, ~zone)
+  switch period {
+  | Minutes(n) => from +. n->Int.toFloat *. minuteMs
+  | Hours(n) => from +. n->Int.toFloat *. 60. *. minuteMs
+  | Days(n) => start->DateTime.add({days: n})->DateTime.toEpochMillis
+  | Weeks(n) => start->DateTime.add({weeks: n})->DateTime.toEpochMillis
+  | Months(n) => start->DateTime.add({months: n})->DateTime.toEpochMillis
+  | Years(n) => start->DateTime.add({years: n})->DateTime.toEpochMillis
+  }
+}
+
+/** `time` with an `After` turned into the `At` it falls on when counted from `from`. */
+let resolveOnce = (time, ~from) =>
+  switch time {
+  | Once({moment: After(period), ?zone}) =>
+    let tz = zoneOrThrow(zone->zoneName)
+    Once({moment: At(afterPeriod(period, ~from, ~zone=tz)->localTimeOf(~zone=tz)), ?zone})
+  | time => time
+  }
+
+/** The instant an `At` falls on; a time in the skipped hour moves forward by the gap. */
+let instantOf = ({year, month, day, hour, minute}: localTime, ~zone) =>
+  switch DateTime.makeZonedFromParts({year, month, day, hours: hour, minutes: minute}, ~zone) {
+  | Some(dateTime) => dateTime->DateTime.toEpochMillis
+  | None =>
+    throw(
+      InvalidTime(
+        `no such time: ${year->Int.toString}-${month->Int.toString}-${day->Int.toString}`,
+      ),
+    )
+  }
+
+let wallClockOf = (calendar: calendar) =>
+  switch calendar {
+  | Daily({hour, minute})
+  | Weekly({hour, minute})
+  | Monthly({hour, minute})
+  | Yearly({hour, minute}) => (hour, minute)
+  }
+
+let monthsEvery = every =>
+  every <= 1 ? [] : Array.fromInitializer(~length=11 / every + 1, i => 1 + i * every)
+
+let cronOf = (calendar: calendar, ~zone): Cron.t => {
+  let (hour, minute) = calendar->wallClockOf
+  let at = (~days=[], ~months=[], ~weekdays=[]) =>
+    Cron.make({minutes: [minute], hours: [hour], days, months, weekdays, tz: zone})
+  switch calendar {
+  | Daily(_) => at()
+  | Weekly({days}) => at(~weekdays=days->Array.map(weekdayIndex))
+  | Monthly({day, ?every}) => at(~days=[day], ~months=every->Option.getOr(1)->monthsEvery)
+  | Yearly({month, day}) => at(~days=[day], ~months=[month])
+  }
+}
+
+/**
+The first firing of `cron` strictly after `after` whose wall-clock time is
+`hour:minute`: a time the skipped hour moved is passed over.
+*/
+let nextOnWallClock = (cron, ~after, ~hour, ~minute, ~zone) => {
+  let rec loop = (from, tries) => {
+    let next = cron->Cron.next(Date.fromTime(from))->Date.getTime
+    let parts = DateTime.makeZonedFromMillis(next, ~zone)->DateTime.toParts
+    (parts.hours == hour && parts.minutes == minute) || tries >= 8 ? next : loop(next, tries + 1)
+  }
+  loop(after, 0)
+}
+
+/**
+The first firing of `time` strictly after `after`, or `None` when a once-only time is
+already past. For `Every`, `after` is the previous firing, or the moment it was set.
+*/
+let nextFiring = (time, ~after) =>
+  switch time->resolveOnce(~from=after) {
+  | Every(interval) => Some(after +. interval->intervalMs)
+  | Calendar({calendar, ?zone}) =>
+    let tz = zoneOrThrow(zone->zoneName)
+    let (hour, minute) = calendar->wallClockOf
+    Some(calendar->cronOf(~zone=tz)->nextOnWallClock(~after, ~hour, ~minute, ~zone=tz))
+  | Once({moment: At(localTime), ?zone}) =>
+    let at = localTime->instantOf(~zone=zoneOrThrow(zone->zoneName))
+    at > after ? Some(at) : None
+  | Once({moment: After(_)}) => None
+  }
+
+/** What EventBridge Scheduler is given for a time. */
+type awsSchedule = {
+  expression: string,
+  timezone: option<string>,
+  startDate: option<float>,
+  deleteAfterCompletion: bool,
+}
+
+let pad2 = n => n < 10 ? `0${n->Int.toString}` : n->Int.toString
+
+let rateOf = (n, unit) => `rate(${n->Int.toString} ${unit}${n == 1 ? "" : "s"})`
+
+let cronExpressionOf = (calendar: calendar) => {
+  let (hour, minute) = calendar->wallClockOf
+  let fields = switch calendar {
+  | Daily(_) => "* * ? *"
+  | Weekly({days}) => `? * ${days->Array.map(weekdayName)->Array.join(",")} *`
+  | Monthly({day, ?every}) =>
+    let month = switch every {
+    | Some(every) if every > 1 => `1/${every->Int.toString}`
+    | _ => "*"
+    }
+    `${day->Int.toString} ${month} ? *`
+  | Yearly({month, day}) => `${day->Int.toString} ${month->Int.toString} ? *`
+  }
+  `cron(${minute->Int.toString} ${hour->Int.toString} ${fields})`
+}
+
+/**
+The EventBridge Scheduler form of `time`, set at `setAt`. An `Every` starts one interval
+later, as the local timer does; without a start date AWS fires at once.
+*/
+let toAws = (time, ~setAt) =>
+  switch time->resolveOnce(~from=setAt) {
+  | Every(interval) => {
+      expression: switch interval {
+      | Minutes(n) => rateOf(n, "minute")
+      | Hours(n) => rateOf(n, "hour")
+      | Days(n) => rateOf(n, "day")
+      | Weeks(n) => rateOf(n * 7, "day")
+      },
+      timezone: None,
+      startDate: Some(setAt +. interval->intervalMs),
+      deleteAfterCompletion: false,
+    }
+  | Calendar({calendar, ?zone}) => {
+      expression: calendar->cronExpressionOf,
+      timezone: Some(zone->zoneName),
+      startDate: None,
+      deleteAfterCompletion: false,
+    }
+  | Once({moment: At({year, month, day, hour, minute}), ?zone}) => {
+      expression: `at(${year->Int.toString}-${month->pad2}-${day->pad2}T${hour->pad2}:${minute->pad2}:00)`,
+      timezone: Some(zone->zoneName),
+      startDate: None,
+      deleteAfterCompletion: true,
+    }
+  | Once({moment: After(_)}) => throw(InvalidTime("unresolved once-only time"))
+  }

package/src/util/ScheduleTime.res.mjs

@@ -0,0 +1,451 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DateTime from "@reventlessdev/rescript-effect/src/DateTime.res.mjs";
+import * as Cron from "effect/Cron";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DateTime$1 from "effect/DateTime";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let InvalidTime = /* @__PURE__ */Primitive_exceptions.create("ScheduleTime-ReventlessCore.InvalidTime");
+
+let utc = "UTC";
+
+function zoneName(zone) {
+  return Stdlib_Option.getOr(zone, utc);
+}
+
+function zoneOrThrow(name) {
+  let zone = DateTime.zoneMakeNamed(name);
+  if (zone !== undefined) {
+    return Primitive_option.valFromOption(zone);
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: `unknown time zone "` + name + `"`,
+    Error: new Error()
+  };
+}
+
+function intervalMs(interval) {
+  switch (interval.TAG) {
+    case "Minutes" :
+      return interval._0 * 60000;
+    case "Hours" :
+      return interval._0 * 60 * 60000;
+    case "Days" :
+      return interval._0 * 24 * 60 * 60000;
+    case "Weeks" :
+      return interval._0 * 7 * 24 * 60 * 60000;
+  }
+}
+
+function weekdayIndex(day) {
+  switch (day) {
+    case "Mon" :
+      return 1;
+    case "Tue" :
+      return 2;
+    case "Wed" :
+      return 3;
+    case "Thu" :
+      return 4;
+    case "Fri" :
+      return 5;
+    case "Sat" :
+      return 6;
+    case "Sun" :
+      return 0;
+  }
+}
+
+function weekdayName(day) {
+  switch (day) {
+    case "Mon" :
+      return "MON";
+    case "Tue" :
+      return "TUE";
+    case "Wed" :
+      return "WED";
+    case "Thu" :
+      return "THU";
+    case "Fri" :
+      return "FRI";
+    case "Sat" :
+      return "SAT";
+    case "Sun" :
+      return "SUN";
+  }
+}
+
+function errors(time) {
+  let errs = [];
+  let check = (ok, message) => {
+    if (ok) {
+      return;
+    } else {
+      errs.push(message);
+      return;
+    }
+  };
+  let positive = (n, what) => check(n >= 1, what + ` must be at least 1, got ` + n.toString());
+  let clock = (hour, minute) => {
+    check(hour >= 0 && hour <= 23, `hour must be 0 to 23, got ` + hour.toString());
+    check(minute >= 0 && minute <= 59, `minute must be 0 to 59, got ` + minute.toString());
+  };
+  let dayOfMonth = day => check(day >= 1 && day <= 31, `day must be 1 to 31, got ` + day.toString());
+  let monthOfYear = month => check(month >= 1 && month <= 12, `month must be 1 to 12, got ` + month.toString());
+  let zoneKnown = zone => Stdlib_Option.forEach(zone, name => check(Stdlib_Option.isSome(DateTime.zoneMakeNamed(name)), `unknown time zone "` + name + `"`));
+  switch (time.TAG) {
+    case "Every" :
+      positive(time._0._0, "an interval");
+      break;
+    case "Calendar" :
+      let calendar = time.calendar;
+      zoneKnown(time.zone);
+      switch (calendar.TAG) {
+        case "Daily" :
+          clock(calendar.hour, calendar.minute);
+          break;
+        case "Weekly" :
+          check(calendar.days.length !== 0, "a weekly time needs at least one day");
+          clock(calendar.hour, calendar.minute);
+          break;
+        case "Monthly" :
+          dayOfMonth(calendar.day);
+          clock(calendar.hour, calendar.minute);
+          Stdlib_Option.forEach(calendar.every, every => check(every >= 1 && every <= 12, `every must be 1 to 12, got ` + every.toString()));
+          break;
+        case "Yearly" :
+          monthOfYear(calendar.month);
+          dayOfMonth(calendar.day);
+          clock(calendar.hour, calendar.minute);
+          break;
+      }
+      break;
+    case "Once" :
+      let moment = time.moment;
+      zoneKnown(time.zone);
+      if (moment.TAG === "At") {
+        let match = moment._0;
+        monthOfYear(match.month);
+        dayOfMonth(match.day);
+        clock(match.hour, match.minute);
+      } else {
+        positive(moment._0._0, "a period");
+      }
+      break;
+  }
+  return errs;
+}
+
+function validate(time) {
+  let errs = errors(time);
+  if (errs.length === 0) {
+    return;
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: errs.join("; "),
+    Error: new Error()
+  };
+}
+
+function localTimeOf(millis, zone) {
+  let parts = DateTime$1.toParts(DateTime.makeZonedFromMillis(millis, zone));
+  return {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hours,
+    minute: parts.minutes
+  };
+}
+
+function afterPeriod(period, from, zone) {
+  let start = DateTime.makeZonedFromMillis(from, zone);
+  switch (period.TAG) {
+    case "Minutes" :
+      return from + period._0 * 60000;
+    case "Hours" :
+      return from + period._0 * 60 * 60000;
+    case "Days" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        days: period._0
+      }));
+    case "Weeks" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        weeks: period._0
+      }));
+    case "Months" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        months: period._0
+      }));
+    case "Years" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        years: period._0
+      }));
+  }
+}
+
+function resolveOnce(time, from) {
+  switch (time.TAG) {
+    case "Every" :
+    case "Calendar" :
+      return time;
+    case "Once" :
+      let period = time.moment;
+      if (period.TAG === "At") {
+        return time;
+      }
+      let zone = time.zone;
+      let tz = zoneOrThrow(Stdlib_Option.getOr(zone, utc));
+      return {
+        TAG: "Once",
+        moment: {
+          TAG: "At",
+          _0: localTimeOf(afterPeriod(period._0, from, tz), tz)
+        },
+        zone: zone
+      };
+  }
+}
+
+function instantOf(param, zone) {
+  let day = param.day;
+  let month = param.month;
+  let year = param.year;
+  let dateTime = DateTime.makeZonedFromParts({
+    year: year,
+    month: month,
+    day: day,
+    hours: param.hour,
+    minutes: param.minute
+  }, zone);
+  if (dateTime !== undefined) {
+    return DateTime$1.toEpochMillis(Primitive_option.valFromOption(dateTime));
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: `no such time: ` + year.toString() + `-` + month.toString() + `-` + day.toString(),
+    Error: new Error()
+  };
+}
+
+function wallClockOf(calendar) {
+  switch (calendar.TAG) {
+    case "Daily" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+    case "Weekly" :
+    case "Monthly" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+    case "Yearly" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+  }
+}
+
+function monthsEvery(every) {
+  if (every <= 1) {
+    return [];
+  } else {
+    return Stdlib_Array.fromInitializer(Primitive_int.div(11, every) + 1 | 0, i => 1 + (i * every | 0) | 0);
+  }
+}
+
+function cronOf(calendar, zone) {
+  let match = wallClockOf(calendar);
+  let minute = match[1];
+  let hour = match[0];
+  let at = (daysOpt, monthsOpt, weekdaysOpt) => {
+    let days = daysOpt !== undefined ? daysOpt : [];
+    let months = monthsOpt !== undefined ? monthsOpt : [];
+    let weekdays = weekdaysOpt !== undefined ? weekdaysOpt : [];
+    return Cron.make({
+      minutes: [minute],
+      hours: [hour],
+      days: days,
+      months: months,
+      weekdays: weekdays,
+      tz: zone
+    });
+  };
+  switch (calendar.TAG) {
+    case "Daily" :
+      return at(undefined, undefined, undefined);
+    case "Weekly" :
+      return at(undefined, undefined, calendar.days.map(weekdayIndex));
+    case "Monthly" :
+      return at([calendar.day], monthsEvery(Stdlib_Option.getOr(calendar.every, 1)), undefined);
+    case "Yearly" :
+      return at([calendar.day], [calendar.month], undefined);
+  }
+}
+
+function nextOnWallClock(cron, after, hour, minute, zone) {
+  let _from = after;
+  let _tries = 0;
+  while (true) {
+    let tries = _tries;
+    let from = _from;
+    let next = Cron.next(cron, new Date(from)).getTime();
+    let parts = DateTime$1.toParts(DateTime.makeZonedFromMillis(next, zone));
+    if (parts.hours === hour && parts.minutes === minute || tries >= 8) {
+      return next;
+    }
+    _tries = tries + 1 | 0;
+    _from = next;
+    continue;
+  };
+}
+
+function nextFiring(time, after) {
+  let interval = resolveOnce(time, after);
+  switch (interval.TAG) {
+    case "Every" :
+      return after + intervalMs(interval._0);
+    case "Calendar" :
+      let calendar = interval.calendar;
+      let tz = zoneOrThrow(Stdlib_Option.getOr(interval.zone, utc));
+      let match = wallClockOf(calendar);
+      return nextOnWallClock(cronOf(calendar, tz), after, match[0], match[1], tz);
+    case "Once" :
+      let localTime = interval.moment;
+      if (localTime.TAG !== "At") {
+        return;
+      }
+      let at = instantOf(localTime._0, zoneOrThrow(Stdlib_Option.getOr(interval.zone, utc)));
+      if (at > after) {
+        return at;
+      } else {
+        return;
+      }
+  }
+}
+
+function pad2(n) {
+  if (n < 10) {
+    return `0` + n.toString();
+  } else {
+    return n.toString();
+  }
+}
+
+function rateOf(n, unit) {
+  return `rate(` + n.toString() + ` ` + unit + (
+    n === 1 ? "" : "s"
+  ) + `)`;
+}
+
+function cronExpressionOf(calendar) {
+  let match = wallClockOf(calendar);
+  let fields;
+  switch (calendar.TAG) {
+    case "Daily" :
+      fields = "* * ? *";
+      break;
+    case "Weekly" :
+      fields = `? * ` + calendar.days.map(weekdayName).join(",") + ` *`;
+      break;
+    case "Monthly" :
+      let every = calendar.every;
+      let month = every !== undefined && every > 1 ? `1/` + every.toString() : "*";
+      fields = calendar.day.toString() + ` ` + month + ` ? *`;
+      break;
+    case "Yearly" :
+      fields = calendar.day.toString() + ` ` + calendar.month.toString() + ` ? *`;
+      break;
+  }
+  return `cron(` + match[1].toString() + ` ` + match[0].toString() + ` ` + fields + `)`;
+}
+
+function toAws(time, setAt) {
+  let interval = resolveOnce(time, setAt);
+  switch (interval.TAG) {
+    case "Every" :
+      let interval$1 = interval._0;
+      let tmp;
+      switch (interval$1.TAG) {
+        case "Minutes" :
+          tmp = rateOf(interval$1._0, "minute");
+          break;
+        case "Hours" :
+          tmp = rateOf(interval$1._0, "hour");
+          break;
+        case "Days" :
+          tmp = rateOf(interval$1._0, "day");
+          break;
+        case "Weeks" :
+          tmp = rateOf(interval$1._0 * 7 | 0, "day");
+          break;
+      }
+      return {
+        expression: tmp,
+        timezone: undefined,
+        startDate: setAt + intervalMs(interval$1),
+        deleteAfterCompletion: false
+      };
+    case "Calendar" :
+      return {
+        expression: cronExpressionOf(interval.calendar),
+        timezone: Stdlib_Option.getOr(interval.zone, utc),
+        startDate: undefined,
+        deleteAfterCompletion: false
+      };
+    case "Once" :
+      let match = interval.moment;
+      if (match.TAG === "At") {
+        let match$1 = match._0;
+        return {
+          expression: `at(` + match$1.year.toString() + `-` + pad2(match$1.month) + `-` + pad2(match$1.day) + `T` + pad2(match$1.hour) + `:` + pad2(match$1.minute) + `:00)`,
+          timezone: Stdlib_Option.getOr(interval.zone, utc),
+          startDate: undefined,
+          deleteAfterCompletion: true
+        };
+      }
+      throw {
+        RE_EXN_ID: InvalidTime,
+        _1: "unresolved once-only time",
+        Error: new Error()
+      };
+  }
+}
+
+let minuteMs = 60000;
+
+export {
+  InvalidTime,
+  utc,
+  zoneName,
+  zoneOrThrow,
+  minuteMs,
+  intervalMs,
+  weekdayIndex,
+  weekdayName,
+  errors,
+  validate,
+  localTimeOf,
+  afterPeriod,
+  resolveOnce,
+  instantOf,
+  wallClockOf,
+  monthsEvery,
+  cronOf,
+  nextOnWallClock,
+  nextFiring,
+  pad2,
+  rateOf,
+  cronExpressionOf,
+  toAws,
+}
+/* DateTime Not a pure module */