651 lines
26 KiB
Swift
651 lines
26 KiB
Swift
//
|
|
// SwiftDate
|
|
// Parse, validate, manipulate, and display dates, time and timezones in Swift
|
|
//
|
|
// Created by Daniele Margutti
|
|
// - Web: https://www.danielemargutti.com
|
|
// - Twitter: https://twitter.com/danielemargutti
|
|
// - Mail: hello@danielemargutti.com
|
|
//
|
|
// Copyright © 2019 Daniele Margutti. Licensed under MIT License.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
public extension DateInRegion {
|
|
|
|
// MARK: - Random Date Generator
|
|
|
|
/// Generate a sequence of dates between a range.
|
|
///
|
|
/// - Parameters:
|
|
/// - count: number of dates to generate.
|
|
/// - initial: lower date bound.
|
|
/// - final: upper date bound.
|
|
/// - region: region of the dates.
|
|
/// - Returns: array of dates
|
|
static func randomDates(count: Int, between initial: DateInRegion, and final: DateInRegion,
|
|
region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {
|
|
var list: [DateInRegion] = []
|
|
for _ in 0..<count {
|
|
list.append(DateInRegion.randomDate(between: initial, and: final, region: region))
|
|
}
|
|
return list
|
|
}
|
|
|
|
/// Return a date between now and a specified amount days ealier.
|
|
///
|
|
/// - Parameters:
|
|
/// - days: days range
|
|
/// - region: destination region, `nil` to use the default region
|
|
/// - Returns: random date
|
|
static func randomDate(withinDaysBeforeToday days: Int,
|
|
region: Region = SwiftDate.defaultRegion) -> DateInRegion {
|
|
let today = DateInRegion(region: region)
|
|
let earliest = DateInRegion(today.date.addingTimeInterval(TimeInterval(-days * 24 * 60 * 60)), region: region)
|
|
return DateInRegion.randomDate(between: earliest, and: today)
|
|
}
|
|
|
|
/// Generate a random date in given region.
|
|
///
|
|
/// - Parameter region: destination region, `nil` to use the default region
|
|
/// - Returns: random date
|
|
static func randomDate(region: Region = SwiftDate.defaultRegion) -> DateInRegion {
|
|
let randomTime = TimeInterval(UInt32.random(in: UInt32.min..<UInt32.max))
|
|
let absoluteDate = Date(timeIntervalSince1970: randomTime)
|
|
return DateInRegion(absoluteDate, region: region)
|
|
}
|
|
|
|
/// Generate a random date between two intervals.
|
|
///
|
|
/// - Parameters:
|
|
/// - initial: lower bound date
|
|
/// - final: upper bound date
|
|
/// - region: destination region, `nil` to use the default region
|
|
/// - Returns: random Date
|
|
static func randomDate(between initial: DateInRegion, and final: DateInRegion,
|
|
region: Region = SwiftDate.defaultRegion) -> DateInRegion {
|
|
let interval = final.timeIntervalSince(initial)
|
|
let randomInterval = TimeInterval(UInt32.random(in: UInt32.min..<UInt32(interval)))
|
|
return initial.addingTimeInterval(randomInterval)
|
|
}
|
|
|
|
/// Return the oldest date in given list (timezone is ignored, comparison uses absolute date).
|
|
///
|
|
/// - Parameter list: list of dates
|
|
/// - Returns: a tuple with the index of the oldest date and its instance.
|
|
static func oldestIn(list: [DateInRegion]) -> DateInRegion? {
|
|
guard list.count > 0 else { return nil }
|
|
guard list.count > 1 else { return list.first! }
|
|
return list.min(by: {
|
|
return $0 < $1
|
|
})
|
|
}
|
|
|
|
/// Sort date by oldest, with the oldest date on top.
|
|
///
|
|
/// - Parameter list: list to sort
|
|
/// - Returns: sorted array
|
|
static func sortedByOldest(list: [DateInRegion]) -> [DateInRegion] {
|
|
return list.sorted(by: { $0.date.compare($1.date) == .orderedAscending })
|
|
}
|
|
|
|
/// Sort date by newest, with the newest date on top.
|
|
///
|
|
/// - Parameter list: list to sort
|
|
/// - Returns: sorted array
|
|
static func sortedByNewest(list: [DateInRegion]) -> [DateInRegion] {
|
|
return list.sorted(by: { $0.date.compare($1.date) == .orderedDescending })
|
|
}
|
|
|
|
/// Return the newest date in given list (timezone is ignored, comparison uses absolute date).
|
|
///
|
|
/// - Parameter list: list of dates
|
|
/// - Returns: a tuple with the index of the newest date and its instance.
|
|
static func newestIn(list: [DateInRegion]) -> DateInRegion? {
|
|
guard list.count > 0 else { return nil }
|
|
guard list.count > 1 else { return list.first! }
|
|
return list.max(by: {
|
|
return $0 < $1
|
|
})
|
|
}
|
|
|
|
/// Enumerate dates between two intervals by adding specified time components and return an array of dates.
|
|
/// `startDate` interval will be the first item of the resulting array.
|
|
/// The last item of the array is evaluated automatically and maybe not equal to `endDate`.
|
|
///
|
|
/// - Parameters:
|
|
/// - start: starting date
|
|
/// - endDate: ending date
|
|
/// - increment: components to add
|
|
/// - Returns: array of dates
|
|
static func enumerateDates(from startDate: DateInRegion, to endDate: DateInRegion, increment: DateComponents) -> [DateInRegion] {
|
|
return DateInRegion.enumerateDates(from: startDate, to: endDate, increment: { _ in
|
|
return increment
|
|
})
|
|
}
|
|
|
|
/// Enumerate dates between two intervals by adding specified time components defined in a closure and return an array of dates.
|
|
/// `startDate` interval will be the first item of the resulting array.
|
|
/// The last item of the array is evaluated automatically and maybe not equal to `endDate`.
|
|
///
|
|
/// - Parameters:
|
|
/// - start: starting date
|
|
/// - endDate: ending date
|
|
/// - increment: increment function. It get the last generated date and require a valida `DateComponents` instance which define the increment
|
|
/// - Returns: array of dates
|
|
static func enumerateDates(from startDate: DateInRegion, to endDate: DateInRegion, increment: ((DateInRegion) -> (DateComponents))) -> [DateInRegion] {
|
|
guard startDate.calendar == endDate.calendar else {
|
|
debugPrint("Cannot enumerate dates between two different region's calendars. Return empty array.")
|
|
return []
|
|
}
|
|
|
|
var dates: [DateInRegion] = []
|
|
var currentDate = startDate
|
|
while currentDate <= endDate {
|
|
dates.append(currentDate)
|
|
currentDate = (currentDate + increment(currentDate))
|
|
}
|
|
return dates
|
|
}
|
|
|
|
/// Returns a new DateInRegion that is initialized at the start of a specified unit of time.
|
|
///
|
|
/// - Parameter unit: time unit value.
|
|
/// - Returns: instance at the beginning of the time unit; `self` if fails.
|
|
func dateAtStartOf(_ unit: Calendar.Component) -> DateInRegion {
|
|
#if os(Linux)
|
|
guard let result = (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, for: date) else {
|
|
return self
|
|
}
|
|
return DateInRegion(result.start, region: region)
|
|
#else
|
|
var start: NSDate?
|
|
var interval: TimeInterval = 0
|
|
guard (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, start: &start, interval: &interval, for: date),
|
|
let startDate = start else {
|
|
return self
|
|
}
|
|
return DateInRegion(startDate as Date, region: region)
|
|
#endif
|
|
}
|
|
|
|
/// Return a new DateInRegion that is initialized at the start of the specified components
|
|
/// executed in order.
|
|
///
|
|
/// - Parameter units: sequence of transformations as time unit components
|
|
/// - Returns: new date at the beginning of the passed components, intermediate results if fails.
|
|
func dateAtStartOf(_ units: [Calendar.Component]) -> DateInRegion {
|
|
return units.reduce(self) { (currentDate, currentUnit) -> DateInRegion in
|
|
return currentDate.dateAtStartOf(currentUnit)
|
|
}
|
|
}
|
|
|
|
/// Returns a new Moment that is initialized at the end of a specified unit of time.
|
|
///
|
|
/// - parameter unit: time unit value.
|
|
///
|
|
/// - returns: A new Moment instance.
|
|
func dateAtEndOf(_ unit: Calendar.Component) -> DateInRegion {
|
|
// RangeOfUnit returns the start of the next unit; we will subtract one thousandth of a second
|
|
#if os(Linux)
|
|
guard let result = (region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, for: date) else {
|
|
return self
|
|
}
|
|
let startOfNextUnit = result.start.addingTimeInterval(result.duration)
|
|
let endOfThisUnit = Date(timeInterval: -0.001, since: startOfNextUnit)
|
|
return DateInRegion(endOfThisUnit, region: region)
|
|
#else
|
|
var start: NSDate?
|
|
var interval: TimeInterval = 0
|
|
guard (self.region.calendar as NSCalendar).range(of: unit.nsCalendarUnit, start: &start, interval: &interval, for: date),
|
|
let startDate = start else {
|
|
return self
|
|
}
|
|
let startOfNextUnit = startDate.addingTimeInterval(interval)
|
|
let endOfThisUnit = Date(timeInterval: -0.001, since: startOfNextUnit as Date)
|
|
return DateInRegion(endOfThisUnit, region: region)
|
|
#endif
|
|
}
|
|
|
|
/// Return a new DateInRegion that is initialized at the end of the specified components
|
|
/// executed in order.
|
|
///
|
|
/// - Parameter units: sequence of transformations as time unit components
|
|
/// - Returns: new date at the end of the passed components, intermediate results if fails.
|
|
func dateAtEndOf(_ units: [Calendar.Component]) -> DateInRegion {
|
|
return units.reduce(self) { (currentDate, currentUnit) -> DateInRegion in
|
|
return currentDate.dateAtEndOf(currentUnit)
|
|
}
|
|
}
|
|
|
|
/// Create a new date by altering specified components of the receiver.
|
|
/// Note: `calendar` and `timezone` are ignored.
|
|
/// Note: some components may alter the date cyclically (like setting both `.year` and `.yearForWeekOfYear`) and
|
|
/// may results in a wrong evaluated date.
|
|
///
|
|
/// - Parameter components: components to alter with their new values.
|
|
/// - Returns: new altered `DateInRegion` instance
|
|
func dateBySet(_ components: [Calendar.Component: Int?]) -> DateInRegion? {
|
|
var dateComponents = DateComponents()
|
|
dateComponents.year = (components[.year] ?? year)
|
|
dateComponents.month = (components[.month] ?? month)
|
|
dateComponents.day = (components[.day] ?? day)
|
|
dateComponents.hour = (components[.hour] ?? hour)
|
|
dateComponents.minute = (components[.minute] ?? minute)
|
|
dateComponents.second = (components[.second] ?? second)
|
|
dateComponents.nanosecond = (components[.nanosecond] ?? nanosecond)
|
|
|
|
// Some components may interfer with others, so we'll set it them only if explicitly set.
|
|
if let weekday = components[.weekday] {
|
|
dateComponents.weekday = weekday
|
|
}
|
|
if let weekOfYear = components[.weekOfYear] {
|
|
dateComponents.weekOfYear = weekOfYear
|
|
}
|
|
if let weekdayOrdinal = components[.weekdayOrdinal] {
|
|
dateComponents.weekdayOrdinal = weekdayOrdinal
|
|
}
|
|
if let yearForWeekOfYear = components[.yearForWeekOfYear] {
|
|
dateComponents.yearForWeekOfYear = yearForWeekOfYear
|
|
}
|
|
|
|
guard let newDate = calendar.date(from: dateComponents) else { return nil }
|
|
return DateInRegion(newDate, region: region)
|
|
}
|
|
|
|
/// Create a new date by altering specified time components.
|
|
///
|
|
/// - Parameters:
|
|
/// - hour: hour to set (`nil` to leave it unaltered)
|
|
/// - min: min to set (`nil` to leave it unaltered)
|
|
/// - secs: sec to set (`nil` to leave it unaltered)
|
|
/// - ms: milliseconds to set (`nil` to leave it unaltered)
|
|
/// - options: options for calculation
|
|
/// - Returns: new altered `DateInRegion` instance
|
|
func dateBySet(hour: Int?, min: Int?, secs: Int?, ms: Int? = nil, options: TimeCalculationOptions = TimeCalculationOptions()) -> DateInRegion? {
|
|
guard let date = calendar.date(bySettingHour: (hour ?? self.hour),
|
|
minute: (min ?? self.minute),
|
|
second: (secs ?? self.second),
|
|
of: self.date,
|
|
matchingPolicy: options.matchingPolicy,
|
|
repeatedTimePolicy: options.repeatedTimePolicy,
|
|
direction: options.direction) else { return nil }
|
|
guard let ms = ms else {
|
|
return DateInRegion(date, region: region)
|
|
}
|
|
var timestamp = date.timeIntervalSince1970.rounded(.down)
|
|
timestamp += Double(ms) / 1000.0
|
|
return DateInRegion(Date(timeIntervalSince1970: timestamp), region: region)
|
|
}
|
|
|
|
/// Creates a new instance by truncating the components
|
|
///
|
|
/// - Parameter components: components to truncate.
|
|
/// - Returns: new date with truncated components.
|
|
func dateTruncated(at components: [Calendar.Component]) -> DateInRegion? {
|
|
var dateComponents = self.dateComponents
|
|
|
|
for component in components {
|
|
switch component {
|
|
case .month: dateComponents.month = 1
|
|
case .day: dateComponents.day = 1
|
|
case .hour: dateComponents.hour = 0
|
|
case .minute: dateComponents.minute = 0
|
|
case .second: dateComponents.second = 0
|
|
case .nanosecond: dateComponents.nanosecond = 0
|
|
default: continue
|
|
}
|
|
}
|
|
|
|
guard let newDate = calendar.date(from: dateComponents) else { return nil }
|
|
return DateInRegion(newDate, region: region)
|
|
}
|
|
|
|
/// Creates a new instance by truncating the components starting from given components down the granurality.
|
|
///
|
|
/// - Parameter component: The component to be truncated from.
|
|
/// - Returns: new date with truncated components.
|
|
func dateTruncated(from component: Calendar.Component) -> DateInRegion? {
|
|
switch component {
|
|
case .month: return dateTruncated(at: [.month, .day, .hour, .minute, .second, .nanosecond])
|
|
case .day: return dateTruncated(at: [.day, .hour, .minute, .second, .nanosecond])
|
|
case .hour: return dateTruncated(at: [.hour, .minute, .second, .nanosecond])
|
|
case .minute: return dateTruncated(at: [.minute, .second, .nanosecond])
|
|
case .second: return dateTruncated(at: [.second, .nanosecond])
|
|
case .nanosecond: return dateTruncated(at: [.nanosecond])
|
|
default: return self
|
|
}
|
|
}
|
|
|
|
/// Round a given date time to the passed style (off|up|down).
|
|
///
|
|
/// - Parameter style: rounding mode.
|
|
/// - Returns: rounded date
|
|
func dateRoundedAt(_ style: RoundDateMode) -> DateInRegion {
|
|
switch style {
|
|
case .to5Mins: return dateRoundedAt(.toMins(5))
|
|
case .to10Mins: return dateRoundedAt(.toMins(10))
|
|
case .to30Mins: return dateRoundedAt(.toMins(30))
|
|
case .toCeil5Mins: return dateRoundedAt(.toCeilMins(5))
|
|
case .toCeil10Mins: return dateRoundedAt(.toCeilMins(10))
|
|
case .toCeil30Mins: return dateRoundedAt(.toCeilMins(30))
|
|
case .toFloor5Mins: return dateRoundedAt(.toFloorMins(5))
|
|
case .toFloor10Mins: return dateRoundedAt(.toFloorMins(10))
|
|
case .toFloor30Mins: return dateRoundedAt(.toFloorMins(30))
|
|
|
|
case .toMins(let minuteInterval):
|
|
let onesDigit: Int = (minute % 10)
|
|
if onesDigit < 5 {
|
|
return dateRoundedAt(.toFloorMins(minuteInterval))
|
|
} else {
|
|
return dateRoundedAt(.toCeilMins(minuteInterval))
|
|
}
|
|
|
|
case .toCeilMins(let minuteInterval):
|
|
let remain: Int = (minute % minuteInterval)
|
|
let value = (( Int(1.minutes.timeInterval) * (minuteInterval - remain)) - second)
|
|
return dateByAdding(value, .second)
|
|
|
|
case .toFloorMins(let minuteInterval):
|
|
let remain: Int = (minute % minuteInterval)
|
|
let value = -((Int(1.minutes.timeInterval) * remain) + second)
|
|
return dateByAdding(value, .second)
|
|
|
|
}
|
|
}
|
|
|
|
/// Offset a date by n calendar components.
|
|
/// Note: This operation can be functionally chained.
|
|
///
|
|
/// - Parameters:
|
|
/// - count: value of the offset (maybe negative).
|
|
/// - component: component to offset.
|
|
/// - Returns: new altered date.
|
|
func dateByAdding(_ count: Int, _ component: Calendar.Component) -> DateInRegion {
|
|
var newComponent = DateComponents(second: 0)
|
|
switch component {
|
|
case .era: newComponent = DateComponents(era: count)
|
|
case .year: newComponent = DateComponents(year: count)
|
|
case .month: newComponent = DateComponents(month: count)
|
|
case .day: newComponent = DateComponents(day: count)
|
|
case .hour: newComponent = DateComponents(hour: count)
|
|
case .minute: newComponent = DateComponents(minute: count)
|
|
case .second: newComponent = DateComponents(second: count)
|
|
case .weekday: newComponent = DateComponents(weekday: count)
|
|
case .weekdayOrdinal: newComponent = DateComponents(weekdayOrdinal: count)
|
|
case .quarter: newComponent = DateComponents(quarter: count)
|
|
case .weekOfMonth: newComponent = DateComponents(weekOfMonth: count)
|
|
case .weekOfYear: newComponent = DateComponents(weekOfYear: count)
|
|
case .yearForWeekOfYear: newComponent = DateComponents(yearForWeekOfYear: count)
|
|
case .nanosecond: newComponent = DateComponents(nanosecond: count)
|
|
default: break // .calendar and .timezone does nothing in this context
|
|
}
|
|
|
|
guard let newDate = region.calendar.date(byAdding: newComponent, to: date) else {
|
|
return self // failed to add component, return unmodified date
|
|
}
|
|
return DateInRegion(newDate, region: region)
|
|
}
|
|
|
|
/// Return related date starting from the receiver attributes.
|
|
///
|
|
/// - Parameter type: related date to obtain.
|
|
/// - Returns: instance of the related date; if fails the same unmodified date is returned
|
|
func dateAt(_ type: DateRelatedType) -> DateInRegion {
|
|
switch type {
|
|
case .startOfDay:
|
|
return calendar.startOfDay(for: date).in(region: region)
|
|
case .endOfDay:
|
|
return dateByAdding(1, .day).dateAt(.startOfDay).dateByAdding(-1, .second)
|
|
case .startOfWeek:
|
|
let components = calendar.dateComponents([.yearForWeekOfYear, .weekOfYear], from: date)
|
|
return calendar.date(from: components)!.in(region: region)
|
|
case .endOfWeek:
|
|
return dateAt(.startOfWeek).dateByAdding(7, .day).dateByAdding(-1, .second)
|
|
case .startOfMonth:
|
|
return dateBySet([.day: 1, .hour: 1, .minute: 1, .second: 1, .nanosecond: 1])!
|
|
case .endOfMonth:
|
|
return dateByAdding((monthDays - day), .day).dateAtEndOf(.day)
|
|
case .tomorrow:
|
|
return dateByAdding(1, .day)
|
|
case .tomorrowAtStart:
|
|
return dateByAdding(1, .day).dateAtStartOf(.day)
|
|
case .yesterday:
|
|
return dateByAdding(-1, .day)
|
|
case .yesterdayAtStart:
|
|
return dateByAdding(-1, .day).dateAtStartOf(.day)
|
|
case .nearestMinute(let nearest):
|
|
let minutes = (minute + nearest / 2) / nearest * nearest
|
|
return dateBySet([.minute: minutes])!
|
|
case .nearestHour(let nearest):
|
|
let hours = (hour + nearest / 2) / nearest * nearest
|
|
return dateBySet([.hour: hours, .minute: 0])!
|
|
case .nextWeekday(let weekday):
|
|
var cal = Calendar(identifier: calendar.identifier)
|
|
cal.firstWeekday = 2 // Sunday = 1, Saturday = 7
|
|
var components = DateComponents()
|
|
components.weekday = weekday.rawValue
|
|
guard let next = cal.nextDate(after: date, matching: components, matchingPolicy: .nextTimePreservingSmallerComponents) else {
|
|
return self
|
|
}
|
|
return DateInRegion(next, region: region)
|
|
case .nextDSTDate:
|
|
guard let nextDate = region.timeZone.nextDaylightSavingTimeTransition(after: date) else {
|
|
return self
|
|
}
|
|
return DateInRegion(nextDate, region: region)
|
|
case .prevMonth:
|
|
return dateByAdding(-1, .month).dateAtStartOf(.month).dateAtStartOf(.day)
|
|
case .nextMonth:
|
|
return dateByAdding(1, .month).dateAtStartOf(.month).dateAtStartOf(.day)
|
|
case .prevWeek:
|
|
return dateByAdding(-1, .weekOfYear).dateAtStartOf(.weekOfYear).dateAtStartOf(.day)
|
|
case .nextWeek:
|
|
return dateByAdding(1, .weekOfYear).dateAtStartOf(.weekOfYear).dateAtStartOf(.day)
|
|
case .nextYear:
|
|
return dateByAdding(1, .year).dateAtStartOf(.year)
|
|
case .prevYear:
|
|
return dateByAdding(-1, .year).dateAtStartOf(.year)
|
|
case .nextDSTTransition:
|
|
guard let transitionDate = region.timeZone.nextDaylightSavingTimeTransition(after: date) else {
|
|
return self
|
|
}
|
|
return DateInRegion(transitionDate, region: region)
|
|
}
|
|
}
|
|
|
|
/// Create a new instance of the date in the same region with time shifted by given time interval.
|
|
///
|
|
/// - Parameter interval: time interval to shift; maybe negative.
|
|
/// - Returns: new instance of the `DateInRegion`
|
|
func addingTimeInterval(_ interval: TimeInterval) -> DateInRegion {
|
|
return DateInRegion(date.addingTimeInterval(interval), region: region)
|
|
}
|
|
|
|
// MARK: - Conversion
|
|
|
|
/// Convert a date to a new calendar/timezone/locale.
|
|
/// Only non `nil` values are used, other values are inherithed by the receiver's region.
|
|
///
|
|
/// - Parameters:
|
|
/// - calendar: non `nil` value to change the calendar
|
|
/// - timezone: non `nil` value to change the timezone
|
|
/// - locale: non `nil` value to change the locale
|
|
/// - Returns: converted date
|
|
func convertTo(calendar: CalendarConvertible? = nil, timezone: ZoneConvertible? = nil, locale: LocaleConvertible? = nil) -> DateInRegion {
|
|
let newRegion = Region(calendar: (calendar ?? region.calendar),
|
|
zone: (timezone ?? region.timeZone),
|
|
locale: (locale ?? region.locale))
|
|
return convertTo(region: newRegion)
|
|
}
|
|
|
|
/// Return the dates for a specific weekday inside given month of specified year.
|
|
/// Ie. get me all the saturdays of Feb 2018.
|
|
/// NOTE: Values are returned in order.
|
|
///
|
|
/// - Parameters:
|
|
/// - weekday: weekday target.
|
|
/// - month: month target.
|
|
/// - year: year target.
|
|
/// - region: region target, omit to use `SwiftDate.defaultRegion`
|
|
/// - Returns: Ordered list of the dates for given weekday into given month.
|
|
static func datesForWeekday(_ weekday: WeekDay, inMonth month: Int, ofYear year: Int,
|
|
region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {
|
|
let fromDate = DateInRegion(year: year, month: month, day: 1, hour: 0, minute: 0, second: 0, nanosecond: 0, region: region)
|
|
let toDate = fromDate.dateAt(.endOfMonth)
|
|
return DateInRegion.datesForWeekday(weekday, from: fromDate, to: toDate, region: region)
|
|
}
|
|
|
|
/// Return the dates for a specific weekday inside a specified date range.
|
|
/// NOTE: Values are returned in order.
|
|
///
|
|
/// - Parameters:
|
|
/// - weekday: weekday target.
|
|
/// - startDate: from date of the range.
|
|
/// - endDate: to date of the range.
|
|
/// - region: region target, omit to use `SwiftDate.defaultRegion`
|
|
/// - Returns: Ordered list of the dates for given weekday in passed range.
|
|
static func datesForWeekday(_ weekday: WeekDay, from startDate: DateInRegion, to endDate: DateInRegion,
|
|
region: Region = SwiftDate.defaultRegion) -> [DateInRegion] {
|
|
|
|
let calendarObj = region.calendar
|
|
let startDateWeekDay = Int(calendarObj.component(.weekday, from: startDate.date))
|
|
let desiredDay = weekday.rawValue
|
|
|
|
let offset = (desiredDay - startDateWeekDay + 7) % 7
|
|
let firstOccurrence = calendarObj.startOfDay(for: calendarObj.date(byAdding: DateComponents(day: offset), to: startDate.date)!)
|
|
guard firstOccurrence.timeIntervalSince1970 < endDate.timeIntervalSince1970 else {
|
|
return []
|
|
}
|
|
var dateOccurrences = [DateInRegion(firstOccurrence, region: region)]
|
|
while true {
|
|
let nextDate = DateInRegion(calendarObj.date(byAdding: DateComponents(day: 7), to: dateOccurrences.last!.date)!,
|
|
region: region)
|
|
guard nextDate < endDate else {
|
|
break
|
|
}
|
|
dateOccurrences.append(nextDate)
|
|
}
|
|
return dateOccurrences
|
|
}
|
|
|
|
}
|
|
|
|
public extension DateInRegion {
|
|
|
|
/// Returns the date at the given week number and week day preserving smaller components (hour, minute, seconds)
|
|
///
|
|
/// For example: to get the third friday of next month
|
|
/// let today = DateInRegion()
|
|
/// let result = today.dateAt(weekdayOrdinal: 3, weekday: .friday, monthNumber: today.month + 1)
|
|
///
|
|
/// - Parameters:
|
|
/// - weekdayOrdinal: the week number (by set position in a recurrence rule)
|
|
/// - weekday: WeekDay
|
|
/// - monthNumber: a number from 1 to 12 representing the month, optional parameter
|
|
/// - yearNumber: a number representing the year, optional parameter
|
|
/// - Returns: new date created with the given parameters
|
|
func dateAt(weekdayOrdinal: Int, weekday: WeekDay, monthNumber: Int? = nil,
|
|
yearNumber: Int? = nil) -> DateInRegion {
|
|
let monthNum = monthNumber ?? month
|
|
let yearNum = yearNumber ?? year
|
|
|
|
var requiredWeekNum = weekdayOrdinal
|
|
var result = DateInRegion(year: yearNum, month: monthNum, day: 1, hour: hour,
|
|
minute: minute, second: second, nanosecond: nanosecond, region: region)
|
|
|
|
if result.weekday == weekday.rawValue {
|
|
requiredWeekNum -= 1
|
|
}
|
|
|
|
while requiredWeekNum > 0 {
|
|
result = result.nextWeekday(weekday)
|
|
requiredWeekNum -= 1
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
/// Returns the date on the given day of month preserving smaller components
|
|
func dateAt(dayOfMonth: Int, monthNumber: Int? = nil,
|
|
yearNumber: Int? = nil) -> DateInRegion {
|
|
let monthNum = monthNumber ?? month
|
|
let yearNum = yearNumber ?? year
|
|
|
|
let result = DateInRegion(year: yearNum, month: monthNum, day: dayOfMonth,
|
|
hour: hour, minute: minute, second: second,
|
|
nanosecond: nanosecond, region: region)
|
|
|
|
return result
|
|
}
|
|
|
|
/// Returns the date after given number of weeks on the given day of week
|
|
func dateAfter(weeks count: Int, on weekday: WeekDay) -> DateInRegion {
|
|
var result = self.dateByAdding(count, .weekOfMonth)
|
|
if result.weekday == weekday.rawValue {
|
|
return result
|
|
} else if result.weekday > weekday.rawValue {
|
|
result = result.dateByAdding(-1, .weekOfMonth)
|
|
}
|
|
return result.nextWeekday(weekday)
|
|
}
|
|
|
|
/// Returns the next weekday preserving smaller components
|
|
///
|
|
/// - Parameters:
|
|
/// - weekday: weekday to get.
|
|
/// - region: region target, omit to use `SwiftDate.defaultRegion`
|
|
/// - Returns: `DateInRegion`
|
|
func nextWeekday(_ weekday: WeekDay) -> DateInRegion {
|
|
var components = DateComponents()
|
|
components.weekday = weekday.rawValue
|
|
components.hour = hour
|
|
components.second = second
|
|
components.minute = minute
|
|
|
|
guard let next = region.calendar.nextDate(after: date, matching: components,
|
|
matchingPolicy: .nextTimePreservingSmallerComponents) else {
|
|
return self
|
|
}
|
|
|
|
return DateInRegion(next, region: region)
|
|
}
|
|
|
|
/// Returns next date with the given weekday and the given week number
|
|
func next(_ weekday: WeekDay, withWeekOfMonth weekNumber: Int,
|
|
andMonthNumber monthNumber: Int? = nil) -> DateInRegion {
|
|
var result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday, monthNumber: monthNumber)
|
|
|
|
if result <= self {
|
|
|
|
if let monthNum = monthNumber {
|
|
result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday,
|
|
monthNumber: monthNum, yearNumber: self.year + 1)
|
|
} else {
|
|
result = self.dateAt(weekdayOrdinal: weekNumber, weekday: weekday, monthNumber: self.month + 1)
|
|
}
|
|
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
/// Returns the next day of month preserving smaller components (hour, minute, seconds)
|
|
func next(dayOfMonth: Int, monthOfYear: Int? = nil) -> DateInRegion {
|
|
var components = DateComponents()
|
|
components.day = dayOfMonth
|
|
components.month = monthOfYear
|
|
components.hour = hour
|
|
components.second = second
|
|
components.minute = minute
|
|
|
|
guard let next = region.calendar.nextDate(after: date, matching: components,
|
|
matchingPolicy: .nextTimePreservingSmallerComponents) else {
|
|
return self
|
|
}
|
|
|
|
return DateInRegion(next, region: region)
|
|
}
|
|
}
|