effect 3.17.2 → 3.17.3

package/src/internal/dateTime.ts

@@ -245,13 +245,14 @@ const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)
 export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
   readonly timeZone?: number | string | DateTime.TimeZone | undefined
   readonly adjustForTimeZone?: boolean | undefined
+  readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned => {
   if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
     return input
   }
   const self = unsafeMake(input)
   if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
-    throw new IllegalArgumentException(`Epoch millis out of range: ${self.epochMillis}`)
+    throw new RangeError(`Epoch millis out of range: ${self.epochMillis}`)
   }
   let zone: DateTime.TimeZone
   if (options?.timeZone === undefined) {
@@ -271,7 +272,7 @@ export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
   if (options?.adjustForTimeZone !== true) {
     return makeZonedProto(self.epochMillis, zone, self.partsUtc)
   }
-  return makeZonedFromAdjusted(self.epochMillis, zone)
+  return makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
 }
 
 /** @internal */
@@ -280,6 +281,7 @@ export const makeZoned: (
   options?: {
     readonly timeZone?: number | string | DateTime.TimeZone | undefined
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }
 ) => Option.Option<DateTime.Zoned> = Option.liftThrowable(unsafeMakeZoned)
 
@@ -320,27 +322,33 @@ export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epo
 export const setZone: {
   (zone: DateTime.TimeZone, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): (self: DateTime.DateTime) => DateTime.Zoned
   (self: DateTime.DateTime, zone: DateTime.TimeZone, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): DateTime.Zoned
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, zone: DateTime.TimeZone, options?: {
   readonly adjustForTimeZone?: boolean | undefined
+  readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned =>
   options?.adjustForTimeZone === true
-    ? makeZonedFromAdjusted(self.epochMillis, zone)
+    ? makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
     : makeZonedProto(self.epochMillis, zone, self.partsUtc))
 
 /** @internal */
 export const setZoneOffset: {
   (offset: number, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): (self: DateTime.DateTime) => DateTime.Zoned
   (self: DateTime.DateTime, offset: number, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): DateTime.Zoned
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, offset: number, options?: {
   readonly adjustForTimeZone?: boolean | undefined
+  readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned => setZone(self, zoneMakeOffset(offset), options))
 
 const validZoneCache = globalValue("effect/DateTime/validZoneCache", () => new Map<string, DateTime.TimeZone.Named>())
@@ -432,14 +440,17 @@ export const zoneToString = (self: DateTime.TimeZone): string => {
 export const setZoneNamed: {
   (zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): (self: DateTime.DateTime) => Option.Option<DateTime.Zoned>
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): Option.Option<DateTime.Zoned>
 } = dual(
   isDateTimeArgs,
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): Option.Option<DateTime.Zoned> => Option.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
 )
 
@@ -447,12 +458,15 @@ export const setZoneNamed: {
 export const unsafeSetZoneNamed: {
   (zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): (self: DateTime.DateTime) => DateTime.Zoned
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
+    readonly disambiguation?: DateTime.Disambiguation | undefined
   }): DateTime.Zoned
 } = dual(isDateTimeArgs, (self: DateTime.DateTime, zoneId: string, options?: {
   readonly adjustForTimeZone?: boolean | undefined
+  readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned => setZone(self, zoneUnsafeMakeNamed(zoneId), options))
 
 // =============================================================================
@@ -715,9 +729,92 @@ export const setPartsUtc: {
 // mapping
 // =============================================================================
 
-const makeZonedFromAdjusted = (adjustedMillis: number, zone: DateTime.TimeZone): DateTime.Zoned => {
-  const offset = zone._tag === "Offset" ? zone.offset : calculateNamedOffset(adjustedMillis, zone)
-  return makeZonedProto(adjustedMillis - offset, zone)
+const constDayMillis = 24 * 60 * 60 * 1000
+
+const makeZonedFromAdjusted = (
+  adjustedMillis: number,
+  zone: DateTime.TimeZone,
+  disambiguation: DateTime.Disambiguation
+): DateTime.Zoned => {
+  if (zone._tag === "Offset") {
+    return makeZonedProto(adjustedMillis - zone.offset, zone)
+  }
+  const beforeOffset = calculateNamedOffset(
+    adjustedMillis - constDayMillis,
+    adjustedMillis,
+    zone
+  )
+  const afterOffset = calculateNamedOffset(
+    adjustedMillis + constDayMillis,
+    adjustedMillis,
+    zone
+  )
+  // If there is no transition, we can return early
+  if (beforeOffset === afterOffset) {
+    return makeZonedProto(adjustedMillis - beforeOffset, zone)
+  }
+  const isForwards = beforeOffset < afterOffset
+  const transitionMillis = beforeOffset - afterOffset
+  // If the transition is forwards, we only need to check if we should move the
+  // local wall clock time forward if it is inside the gap
+  if (isForwards) {
+    const currentAfterOffset = calculateNamedOffset(
+      adjustedMillis - afterOffset,
+      adjustedMillis,
+      zone
+    )
+    if (currentAfterOffset === afterOffset) {
+      return makeZonedProto(adjustedMillis - afterOffset, zone)
+    }
+    const before = makeZonedProto(adjustedMillis - beforeOffset, zone)
+    const beforeAdjustedMillis = toDate(before).getTime()
+    // If the wall clock time has changed, we are inside the gap
+    if (adjustedMillis !== beforeAdjustedMillis) {
+      switch (disambiguation) {
+        case "reject": {
+          const formatted = new Date(adjustedMillis).toISOString()
+          throw new RangeError(`Gap time: ${formatted} does not exist in time zone ${zone.id}`)
+        }
+        case "earlier":
+          return makeZonedProto(adjustedMillis - afterOffset, zone)
+
+        case "compatible":
+        case "later":
+          return before
+      }
+    }
+    // The wall clock time is in the earlier offset, so we use that
+    return before
+  }
+
+  const currentBeforeOffset = calculateNamedOffset(
+    adjustedMillis - beforeOffset,
+    adjustedMillis,
+    zone
+  )
+  // The wall clock time is in the earlier offset, so we use that
+  if (currentBeforeOffset === beforeOffset) {
+    if (disambiguation === "earlier" || disambiguation === "compatible") {
+      return makeZonedProto(adjustedMillis - beforeOffset, zone)
+    }
+    const laterOffset = calculateNamedOffset(
+      adjustedMillis - beforeOffset + transitionMillis,
+      adjustedMillis + transitionMillis,
+      zone
+    )
+    if (laterOffset === beforeOffset) {
+      return makeZonedProto(adjustedMillis - beforeOffset, zone)
+    }
+    // If the offset changed in this period, then we are inside the period where
+    // the wall clock time occurs twice, once in the earlier offset and once in
+    // the later offset.
+    if (disambiguation === "reject") {
+      const formatted = new Date(adjustedMillis).toISOString()
+      throw new RangeError(`Ambiguous time: ${formatted} occurs twice in time zone ${zone.id}`)
+    }
+    // If the disambiguation is "later", we return the later offset below
+  }
+  return makeZonedProto(adjustedMillis - afterOffset, zone)
 }
 
 const offsetRegex = /([+-])(\d{2}):(\d{2})$/
@@ -730,8 +827,12 @@ const parseOffset = (offset: string): number | null => {
   return (sign === "+" ? 1 : -1) * (Number(hours) * 60 + Number(minutes)) * 60 * 1000
 }
 
-const calculateNamedOffset = (adjustedMillis: number, zone: DateTime.TimeZone.Named): number => {
-  const offset = zone.format.formatToParts(adjustedMillis).find((_) => _.type === "timeZoneName")?.value ?? ""
+const calculateNamedOffset = (
+  utcMillis: number,
+  adjustedMillis: number,
+  zone: DateTime.TimeZone.Named
+): number => {
+  const offset = zone.format.formatToParts(utcMillis).find((_) => _.type === "timeZoneName")?.value ?? ""
   if (offset === "GMT") {
     return 0
   }
@@ -745,9 +846,15 @@ const calculateNamedOffset = (adjustedMillis: number, zone: DateTime.TimeZone.Na
 
 /** @internal */
 export const mutate: {
-  (f: (date: Date) => void): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void): A
-} = dual(2, (self: DateTime.DateTime, f: (date: Date) => void): DateTime.DateTime => {
+  (f: (date: Date) => void, options?: {
+    readonly disambiguation?: DateTime.Disambiguation | undefined
+  }): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, f: (date: Date) => void, options?: {
+    readonly disambiguation?: DateTime.Disambiguation | undefined
+  }): A
+} = dual(isDateTimeArgs, (self: DateTime.DateTime, f: (date: Date) => void, options?: {
+  readonly disambiguation?: DateTime.Disambiguation | undefined
+}): DateTime.DateTime => {
   if (self._tag === "Utc") {
     const date = toDateUtc(self)
     f(date)
@@ -756,7 +863,7 @@ export const mutate: {
   const adjustedDate = toDate(self)
   const newAdjustedDate = new Date(adjustedDate.getTime())
   f(newAdjustedDate)
-  return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone)
+  return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone, options?.disambiguation ?? "compatible")
 })
 
 /** @internal */

package/src/internal/version.ts

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