From f765ba6530fd866764017b245e820ba2f0f6108e Mon Sep 17 00:00:00 2001 From: tigerswithguitars Date: Mon, 27 Oct 2014 22:31:02 +0000 Subject: [PATCH] Add the test and definition file and initial skeleton add ALL THE DOCUMENTATION and a whole load more tests Add the extensibility comments and dictionary to the recurrence interface --- later/later-test.ts | 631 +++++++++++++++++++++++++++++++++++++++++ later/later.d.ts | 673 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1304 insertions(+) create mode 100644 later/later-test.ts create mode 100644 later/later.d.ts diff --git a/later/later-test.ts b/later/later-test.ts new file mode 100644 index 000000000..2d336d1b3 --- /dev/null +++ b/later/later-test.ts @@ -0,0 +1,631 @@ +/// + + +module LaterTest_DefineSchedule { + + // define a new schedule + var textSched = later.parse.text('at 10:15am every weekday'); + var cronSched = later.parse.cron('0 0/5 14,18 * * ?'); + var recurSched = later.parse.recur().last().dayOfMonth(); + var manualSched = { schedules: [ { M: [ 3 ], D: [ 21 ] } ] }; + + // this schedule will fire on the closest weekday to the 15th + // every month at 2:00 am except in March + var complexSched = later.parse.recur() + .on(15).dayOfMonth().onWeekday().on(2).hour() + .and() + .on(14).dayOfMonth().on(6).dayOfWeek().on(2).hour() + .and() + .on(16).dayOfMonth().on(2).dayOfWeek().on(2).hour() + .except() + .on(3).month(); +} + +module LaterTest_ConfigureTimezone { + + // set later to use UTC (the default) + later.date.UTC(); + + // set later to use local time + later.date.localTime(); +} + +module LaterTest_TimePeriods { + export function second() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.second.name; + // 'second' + + later.second.range; + // 1 + + later.second.val(d); + // 5 + + later.second.isValid(d, 10); + // false + + later.second.extent(); + // [0, 59] + + later.second.start(d); + // 'Fri, 22 Mar 2013 10:02:05 GMT' + + later.second.end(d); + // 'Fri, 22 Mar 2013 10:02:05 GMT' + + later.second.next(d, 27); + // 'Fri, 22 Mar 2013 10:02:27 GMT' + + later.second.prev(d, 27); + // 'Fri, 22 Mar 2013 10:01:27 GMT' + } + + export function minute() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.minute.name; + // 'minute' + + later.minute.range; + // 60 + + later.minute.val(d); + // 2 + + later.minute.isValid(d, 2); + // true + + later.minute.extent(); + // [0, 59] + + later.minute.start(d); + // 'Fri, 22 Mar 2013 10:02:00 GMT' + + later.minute.end(d); + // 'Fri, 22 Mar 2013 10:02:59 GMT' + + later.minute.next(d, 27); + // 'Fri, 22 Mar 2013 10:27:00 GMT' + + later.minute.prev(d, 27); + // 'Fri, 22 Mar 2013 09:27:59 GMT' + } + + export function hour() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.hour.name; + // 'hour' + + later.hour.range; + // 3600 + + later.hour.val(d); + // 10 + + later.hour.isValid(d, 2); + // false + + later.hour.extent(); + // [0, 23] + + later.hour.start(d); + // 'Fri, 22 Mar 2013 10:00:00 GMT' + + later.hour.end(d); + // 'Fri, 22 Mar 2013 10:59:59 GMT' + + later.hour.next(d, 5); + // 'Sat, 23 Mar 2013 05:00:00 GMT' + + later.hour.prev(d, 21); + // 'Thu, 21 Mar 2013 21:59:59 GMT' + } + + export function time() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.time.name; + // 'time' + + later.time.range; + // 1 + + later.time.val(d); + // 36125 + + later.time.isValid(d, 36125); + // true + + later.time.extent(); + // [0, 86399] + + later.time.start(d); + // 'Fri, 22 Mar 2013 00:00:00 GMT' + + later.time.end(d); + // 'Fri, 22 Mar 2013 23:59:59 GMT' + + later.time.next(d, 60); + // 'Sat, 23 Mar 2013 00:01:00 GMT' + + later.time.prev(d, 60); + // 'Fri, 22 Mar 2013 00:01:00 GMT' + } + + export function day() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.day.name; + // 'day' + + later.day.range; + // 86400 + + later.day.val(d); + // 22 + + later.day.isValid(d, 3); + // false + + later.day.extent(d); + // [1, 31] + + later.day.start(d); + // 'Fri, 22 Mar 2013 00:00:00 GMT' + + later.day.end(d); + // 'Fri, 22 Mar 2013 23:59:59 GMT' + + later.day.next(d, 11); + // 'Thu, 11 Apr 2013 00:00:00 GMT' + + later.day.prev(d, 2); + // 'Sat, 02 Mar 2013 23:59:59 GMT' + } + + export function day_of_week() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.dayOfWeek.name; + // 'day of week' + + later.dayOfWeek.range; + // 86400 + + later.dayOfWeek.val(d); + // 6 + + later.dayOfWeek.isValid(d, 3); + // false + + later.dayOfWeek.extent(); + // [1, 7] + + later.dayOfWeek.start(d); + // 'Fri, 22 Mar 2013 00:00:00 GMT' + + later.dayOfWeek.end(d); + // 'Fri, 22 Mar 2013 23:59:59 GMT' + + later.dayOfWeek.next(d, 1); + // 'Sun, 24 Mar 2013 00:00:00 GMT' + + later.dayOfWeek.prev(d, 5); + // 'Thu, 21 Mar 2013 23:59:59 GMT' + } + + export function day_of_week_count() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.dayOfWeekCount.name; + // 'day of week count' + + later.dayOfWeekCount.range; + // 604800 + + later.dayOfWeekCount.val(d); + // 4 + + later.dayOfWeekCount.isValid(d, 4); + // true + + later.dayOfWeekCount.extent(d); + // [1, 5] + + later.dayOfWeekCount.start(d); + // 'Fri, 22 Mar 2013 00:00:00 GMT' + + later.dayOfWeekCount.end(d); + // 'Thu, 28 Mar 2013 23:59:59 GMT' + + // zero is special cased and means the last instance of + // a day of the week in the month, instead of meaning the + // first day of the week with the highest instance count + // which would have been Mar 29 with value 5. + later.dayOfWeekCount.next(d, 0); + // 'Mon, 25 Mar 2013 00:00:00 GMT' + + later.dayOfWeekCount.prev(d, 2); + // 'Thu, 14 Mar 2013 23:59:59 GMT' + } + + export function day_of_year() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.dayOfYear.name; + // 'day of year' + + later.dayOfYear.range; + // 86400 + + later.dayOfYear.val(d); + // 81 + + later.dayOfYear.isValid(d, 4); + // false + + later.dayOfYear.extent(d); + // [1, 365] + + later.dayOfYear.start(d); + // 'Fri, 22 Mar 2013 00:00:00 GMT' + + later.dayOfYear.end(d); + // 'Fri, 22 Mar 2013 23:59:59 GMT' + + later.dayOfYear.next(d, 256); + // 'Fri, 13 Sep 2013 00:00:00 GMT' + + later.dayOfYear.prev(d, 44); + // 'Wed, 13 Feb 2013 23:59:59 GMT' + } + + export function week_of_month() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.weekOfMonth.name; + // 'week of month' + + later.weekOfMonth.range; + // 604800 + + later.weekOfMonth.val(d); + // 4 + + later.weekOfMonth.isValid(d, 4); + // true + + later.weekOfMonth.extent(d); + // [1, 6] + + later.weekOfMonth.start(d); + // 'Sun, 17 Mar 2013 00:00:00 GMT' + + later.weekOfMonth.end(d); + // 'Sat, 23 Mar 2013 23:59:59 GMT' + + later.weekOfMonth.next(d, 1); + // 'Mon, 01 Apr 2013 00:00:00 GMT' + + later.weekOfMonth.prev(d, 2); + // 'Sat, 09 Mar 2013 23:59:59 GMT' + } + + export function week_of_year() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.weekOfYear.name; + // 'week of year' + + later.weekOfYear.range; + // 604800 + + later.weekOfYear.val(d); + // 12 + + later.weekOfYear.isValid(d, 21); + // false + + later.weekOfYear.extent(d); + // [1, 52] + + later.weekOfYear.start(d); + // 'Mon, 18 Mar 2013 00:00:00 GMT' + + later.weekOfYear.end(d); + // 'Sun, 24 Mar 2013 23:59:59 GMT' + + later.weekOfYear.next(d, 47); + // 'Mon, 18 Nov 2013 00:00:00 GMT' + + later.weekOfYear.prev(d, 52); + // 'Sun, 30 Dec 2012 23:59:59 GMT' + } + + export function month() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.month.name; + // 'month' + + later.month.range; + // 2629740 + + later.month.val(d); + // 3 + + later.month.isValid(d, 3); + // true + + later.month.extent(); + // [1, 12] + + later.month.start(d); + // 'Fri, 01 Mar 2013 00:00:00 GMT' + + later.month.end(d); + // 'Sun, 31 Mar 2013 23:59:59 GMT' + + later.month.next(d, 11); + // 'Fri, 01 Nov 2013 00:00:00 GMT' + + later.month.prev(d, 2); + // 'Thu, 28 Feb 2013 23:59:59 GMT' + } + + export function year() { + var d = new Date('2013-03-22T10:02:05Z'); + + later.year.name; + // 'year' + + later.year.range; + // 31556900 + + later.year.val(d); + // 2013 + + later.year.isValid(d, 2013); + // true + + later.year.extent(); + // [1970, 2099] + + later.year.start(d); + // 'Tue, 01 Jan 2013 00:00:00 GMT' + + later.year.end(d); + // 'Tue, 31 Dec 2013 23:59:59 GMT' + + later.year.next(d, 2014); + // 'Wed, 01 Jan 2014 00:00:00 GMT' + + later.year.prev(d, 2012); + // 'Mon, 31 Dec 2012 23:59:59 GMT' + } + + export interface IPartOfDayLater extends Later.IStatic { + partOfDay: Later.ITimePeriod; + } + + export function custom() { + + var customLater = later; + + customLater.partOfDay = { + + name: 'part of day', + + range: later.hour.range * 6, + + val: function(d: Date): number { + return later.hour.val(d) < 12 + ? 0 + : later.hour.val(d) < 18 + ? 1 + : 2; + }, + + isValid: function(d: Date, val: any) { + return customLater.partOfDay.val(d) === val; + }, + + extent: function(date?: Date) { + return [0, 2]; + }, + + start: function(date: Date) { + var hour = customLater.partOfDay.val(date) === 0 + ? 0 + : customLater.partOfDay.val(date) === 1 + ? 12 + : 18; + + return later.date.next( + later.year.val(date), + later.month.val(date), + later.day.val(date), + hour + ); + }, + + end: function(date: Date) { + var hour = customLater.partOfDay.val(date) === 0 + ? 11 + : customLater.partOfDay.val(date) === 1 + ? 5 + : 23; + + return later.date.prev( + later.year.val(date), + later.month.val(date), + later.day.val(date), + hour + ); + }, + + next: function(date: Date, val: any) { + var hour = val === 0 + ? 0 + : val === 1 + ? 12 + : 18; + + return later.date.next( + later.year.val(date), + later.month.val(date), + // increment the day if we already passed the desired time period + later.day.val(date) + (hour < later.hour.val(date) ? 1 : 0), + hour + ); + }, + + prev: function(date: Date, val: any) { + var hour = val === 0 + ? 11 + : val === 1 + ? 5 + : 23; + + return later.date.prev( + later.year.val(date), + later.month.val(date), + // decrement the day if we already passed the desired time period + later.day.val(date) + (hour > later.hour.val(date) ? -1 : 0), + hour + ); + } + }; + } +} + +module LaterTest_GenerateRecurences { + + export function on_method() { + // fires on the 2nd minute every hour + later.parse.recur().on(2).minute(); + + // fires every day at 8am and 8pm + later.parse.recur().on(8, 20).hour(); + + // fires every day at 8am + later.parse.recur().on('08:00:00').time(); + } + + export function first_method() { + // fires on the 0th minute of every hour + later.parse.recur().first().minute(); + } + + export function last_method() { + // fires on the last day of every month at 5am + later.parse.recur().on(5).hour().last().dayOfMonth(); + } + + export function onWeekend_method() { + // fires on the 5th minute of every hour during Sat and Sun + later.parse.recur().on(5).minute().onWeekend(); + } + + export function onWeekday_method() { + // fires on the 5th minute of every hour during Mon,Tues,Wed,Thur,Fri + later.parse.recur().on(5).minute().onWeekday(); + } + + export function every_method() { + // fires on the 0th, 10th, 20th, 30th, 40th, and 50th min of every hour + later.parse.recur().every(10).minute(); + + // fires on first second of Jan, Apr, July, Oct + later.parse.recur().every(3).month(); + } + + export function after_method() { + // fires on the 55th, 56th, 57th, 58th, and 59th minute + later.parse.recur().after(55).minute(); + + // fires at 12 noon and 6pm + later.parse.recur().every(6).hour().after('09:00').time(); + } + + export function before_method() { + // fires on the first second of January and February + later.parse.recur().before(3).month(); + + // fires at 6am every day + later.parse.recur().every(6).hour().before('09:00').time(); + + // fires between 9am and 6pm every day + later.parse.recur().after('09:00').time().before('18:00').time(); + later.parse.recur().after(9).hour().before(18).hour(); + } + + export function startingOn_method() { + // fires on the 10th, 25th, 40th, and 55th minute of every hour + later.parse.recur().every(15).minute().startingOn(10); + } + + export function between_method() { + // fires on the 10th, 25th, 40th minute of every hour + later.parse.recur().every(15).minute().between(10, 40); + } + + export function and_method() { + // fires every 2 hours on the first day of every month + // and 8:00am and 8:00pm on the last day of every month + var sched = later.parse.recur() + .every(2).hour().first().dayOfMonth() + .and() + .on(8, 20).hour().last().dayOfMonth() + } + + export function except_method() { + // fires every minute of every hour except on multiples of 2 and 3 + var sched = later.parse.recur() + .every().minute() + .except() + .every(2).minute().between(2, 59) + .and() + .every(3).minute().between(3, 59); + } + +} + +module LaterTest_CalculateOccurences { + + // Initialise next variable. + var next: Date[] = []; + + // calculate the next 10 occurrences of a recur schedule + var recurSched = later.parse.recur().last().dayOfMonth(); + + next = later.schedule(recurSched).next(10); + + // calculate the previous occurrence starting from March 21, 2013 + var cronSched = later.parse.cron('0 0/5 14,18 * * ?'); + + next = later.schedule(cronSched).prev(1, new Date(2013, 2, 21)); +} + +module LaterTest_ExecuteCodeUsingSchedule { + + // will fire every 5 minutes + var textSched = later.parse.text('every 5 min'); + + // execute logTime one time on the next occurrence of the text schedule + var timer = later.setTimeout(logTime, textSched); + + // execute logTime for each successive occurrence of the text schedule + var timer2 = later.setInterval(logTime, textSched); + + // function to execute + function logTime() { + console.log(new Date()); + } + + // clear the interval timer when you are done + timer2.clear(); +} \ No newline at end of file diff --git a/later/later.d.ts b/later/later.d.ts new file mode 100644 index 000000000..780de6398 --- /dev/null +++ b/later/later.d.ts @@ -0,0 +1,673 @@ +// Type definitions for LaterJS +// Project: http://bunkat.github.io/later/ +// Definitions by: Jason D Dryhurst-Smith +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Later { + + export interface IScheduleData { + + /** + * A list of recurrence information as a composite schedule. + */ + schedules: IRecurrence[]; + + /** + * A list of exceptions to the composite recurrence information. + */ + exceptions: IRecurrence[]; + + /** + * A code to identify any errors in the composite schedule and exceptions. + * The number tells you the position of the error within the schedule. + */ + error: number; + } + + export interface IRecurrence { + + /** Time in seconds from midnight. + */ + t?: number[]; + /** Seconds in minute. + */ + s?: number[]; + /** Minutes in hour. + */ + m?: number[]; + /** Hour in day. + */ + h?: number[]; + /** Day of the month. + */ + D?: number[]; + /** Day in week. + */ + dw?: number[]; + /** Nth day of the week in month. + */ + dc?: number[]; + /** Day in year. + */ + dy?: number[]; + /** Week in month. + */ + wm?: number[]; + /** ISO week in year. + */ + wy?: number[]; + /** Month in year. + */ + M?: number[]; + /** Year. + */ + Y?: number[]; + + /** After modifiers. + */ + t_a?: number[]; + /** After modifiers. + */ + s_a?: number[]; + /** After modifiers. + */ + m_a?: number[]; + /** After modifiers. + */ + h_a?: number[]; + /** After modifiers. + */ + D_a?: number[]; + /** After modifiers. + */ + dw_a?: number[]; + /** After modifiers. + */ + dc_a?: number[]; + /** After modifiers. + */ + dy_a?: number[]; + /** After modifiers. + */ + wm_a?: number[]; + /** After modifiers. + */ + wy_a?: number[]; + /** After modifiers. + */ + M_a?: number[]; + /** After modifiers. + */ + Y_a?: number[]; + + /** Before modifiers. + */ + t_b?: number[]; + /** Before modifiers. + */ + s_b?: number[]; + /** Before modifiers. + */ + m_b?: number[]; + /** Before modifiers. + */ + h_b?: number[]; + /** Before modifiers. + */ + D_b?: number[]; + /** Before modifiers. + */ + dw_b?: number[]; + /** Before modifiers. + */ + dc_b?: number[]; + /** Before modifiers. + */ + dy_b?: number[]; + /** Before modifiers. + */ + wm_b?: number[]; + /** Before modifiers. + */ + wy_b?: number[]; + /** Before modifiers. + */ + M_b?: number[]; + /** Before modifiers. + */ + Y_b?: number[]; + + /* + * Custom Time Periods and Modifiers + * For acces to custom time periods created as extension to the later static type + * and modifiers created on the later modifier static type. + */ + [ timeperiodAndModifierName: string ]: number[]; + } + + export interface IParseStatic { + + /** + * Create a recurrence builder for building schedule data. + */ + recur(): IRecurrenceBuilder; + + /** + * Create schedule data by parsing a cron string + * + * @param {string} [input] - A string value to parse. + */ + cron(input?: string): IScheduleData; + + /** + * Create schedule data by paring a human readable string. + * + * @param {string} [input] - A string value to parse. + */ + text(input?: string): IScheduleData; + } + + export interface ITimer { + + /** + * Clear the timer and end execution. + */ + clear(): void; + } + + export interface ISchedule { + + /** + * Finds the next valid instance or instances of the current schedule, + * optionally between a specified start and end date. Start date is + * Date.now() by default, end date is unspecified. Start date must be + * smaller than end date. + * + * @param {number} numberOfInst: The number of instances to return + * @param {Date} dateFrom: The earliest a valid instance can occur + * @param {Date} dateTo: The latest a valid instance can occur + */ + next(numberOfInst: number, dateFrom?: Date, dateTo?: Date): Date[]; + + /** + * Finds the next valid range or ranges of the current schedule, + * optionally between a specified start and end date. Start date is + * Date.now() by default, end date is unspecified. Start date must be + * greater than end date. + * + * @param {number} numberOfInst: The number of ranges to return + * @param {Date} dateFrom: The earliest a valid range can occur + * @param {Date} dateTo: The latest a valid range can occur + */ + nextRange(numberOfInst: number, dateFrom?: Date, dateTo?: Date): Date[]; + + /** + * Finds the previous valid instance or instances of the current schedule, + * optionally between a specified start and end date. Start date is + * Date.now() by default, end date is unspecified. Start date must be + * greater than end date. + * + * @param {number} numberOfInst: The number of instances to return + * @param {Date} dateFrom: The earliest a valid instance can occur + * @param {Date} dateTo: The latest a valid instance can occur + */ + prev(numberOfInst: number, dateFrom?: Date, dateTo?: Date): Date[]; + + /** + * Finds the previous valid range or ranges of the current schedule, + * optionally between a specified start and end date. Start date is + * Date.now() by default, end date is unspecified. Start date must be + * greater than end date. + * + * @param {number} numberOfInst: The number of ranges to return + * @param {Date} dateFrom: The earliest a valid range can occur + * @param {Date} dateTo: The latest a valid range can occur + */ + prevRange(numberOfInst: number, dateFrom?: Date, dateTo?: Date): Date[]; + } + + export interface IRecurrenceBuilder extends IScheduleData { + + /** a time period + */ + second(): IRecurrenceBuilder; + /** a time period + */ + minute(): IRecurrenceBuilder; + /** a time period + */ + hour(): IRecurrenceBuilder; + /** a time period + */ + time(): IRecurrenceBuilder; + /** a time period + */ + dayOfWeek(): IRecurrenceBuilder; + /** a time period + */ + dayOfWeekCount(): IRecurrenceBuilder; + /** a time period + */ + dayOfMonth(): IRecurrenceBuilder; + /** a time period + */ + dayOfYear(): IRecurrenceBuilder; + /** a time period + */ + weekOfMonth(): IRecurrenceBuilder; + /** a time period + */ + weekOfYear(): IRecurrenceBuilder; + /** a time period + */ + month(): IRecurrenceBuilder; + /** a time period + */ + year(): IRecurrenceBuilder; + + /** a time period + */ + fullDate(): IRecurrenceBuilder; + + /** + * Specifies one or more specific vals of a time period information provider. + * When used to specify a time, a string indicating the 24-hour time may be used. + * + * @param {number[]} values - A list of values. + */ + on(...values: number[]): IRecurrenceBuilder; + /** + * Specifies one or more specific vals of a time period information provider. + * When used to specify a time, a string indicating the 24-hour time may be used. + * + * @param {string} value - A string representing your value. + */ + on(value: string): IRecurrenceBuilder; + /** + * Specifies one or more specific vals of a time period information provider. + * When used to specify a time, a string indicating the 24-hour time may be used. + * + * @param {Date} date - A Date representing your value. + */ + on(date: Date): IRecurrenceBuilder; + + /** + * Preceed a time period. + * + * @param {number} [value] - A number representing your value. + */ + every(value?: number): IRecurrenceBuilder; + /** + * Preceed a time period. + * + * @param {string} [value] - A string representing your value. + */ + every(value?: string): IRecurrenceBuilder; + + /** + * Preceed a time period. + * + * @param {number} start - A number representing your start value. + * @param {number} end - A number representing your end value. + */ + between(start: number, end: number): IRecurrenceBuilder; + /** + * Preceed a time period. + * + * @param {string} start - A string representing your start value. + * @param {string} end - A string representing your end value. + */ + between(start: string, end: string): IRecurrenceBuilder; + + /** + * After a time period. + * + * @param {number} value - A number representing your value. + */ + after(value: number): IRecurrenceBuilder; + /** + * After a time period. + * + * @param {string} value - A string representing your value. + */ + after(value: string): IRecurrenceBuilder; + + /** + * After a time period. + * + * @param {number} value - A number representing your value. + */ + before(value: number): IRecurrenceBuilder; + /** + * After a time period. + * + * @param {string} value - A string representing your value. + */ + before(value: string): IRecurrenceBuilder; + + /** + * After a time period. + * + * @param {number} value - A number representing your value. + */ + startingOn(value: number): IRecurrenceBuilder; + /** + * After a time period. + * + * @param {string} value - A string representing your value. + */ + startingOn(value: string): IRecurrenceBuilder; + + /** + * Equivalent to .on(min) + */ + first(): IRecurrenceBuilder; + + /** + * Equivalent to .on(max) + */ + last(): IRecurrenceBuilder; + + /** + * Equivalent to .on(1,7).dayOfWeek() + */ + onWeekend(): IRecurrenceBuilder; + + /** + * Equivalent to .on(2,3,4,5,6).dayOfWeek() + */ + onWeekday(): IRecurrenceBuilder; + + /** + * Add a new schedule value to schedules, composite schedule. + */ + and(): IRecurrenceBuilder; + + /** + * Add exceptions. + */ + except(): IRecurrenceBuilder; + + /** + * Custom Timeperiod Recurrences. + * Using a key as defined by the custom period in any extension to Later.IStatic. + */ + customPeriod(key: string): IRecurrenceBuilder; + + /** + * Customise Recurrences. + * Using a key as defined by the custom modifier in any extension to Later.IModifierStatic. + */ + customModifier(key: string, values: number): IRecurrenceBuilder; + } + + export interface IDateProvider { + + /** + * Set later to use UTC time. + */ + UTC(): void; + + /** + * Set later to use local time. + */ + localTime(): void; + + /** + * Builds and returns a new Date using the specified values. Date + * returned is either using Local time or UTC based on isLocal. + * + * @param {number} [Y]: Four digit year + * @param {number} [M]: Month between 1 and 12, defaults to 1 + * @param {number} [D]: Date between 1 and 31, defaults to 1 + * @param {number} [h]: Hour between 0 and 23, defaults to 0 + * @param {number} [m]: Minute between 0 and 59, defaults to 0 + * @param {number} [s]: Second between 0 and 59, defaults to 0 + */ + next(Y?: number, M?: number, D?: number, h?: number, m?: number, s?: number): Date; + + /** + * Builds and returns a new Date using the specified values. Date + * returned is either using Local time or UTC based on isLocal. + * + * @param {number} [Y]: Four digit year + * @param {number} [M]: Month between 0 and 11, defaults to 11 + * @param {number} [D]: Date between 1 and 31, defaults to last day of month + * @param {number} [h]: Hour between 0 and 23, defaults to 23 + * @param {number} [m]: Minute between 0 and 59, defaults to 59 + * @param {number} [s]: Second between 0 and 59, defaults to 59 + */ + prev(Y?: number, M?: number, D?: number, h?: number, m?: number, s?: number): Date; + + /** + * Determines if a value will cause a particular constraint to rollover to the + * next largest time period. Used primarily when a constraint has a + * variable extent. + * + * @param {Date} d: Date + * @param {number} val: Value + * @param {IModifier} constraint: A modifier + * @param {ITimePeriod} period: A time period + */ + nextRollover(d: Date, val: number, constraint: IModifier, period: ITimePeriod): Date; + + /** + * Determines if a value will cause a particular constraint to rollover to the + * previous largest time period. Used primarily when a constraint has a + * variable extent. + * + * @param {Date} d: Date + * @param {number} val: Value + * @param {IModifier} constraint: A modifier + * @param {ITimePeriod} period: A time period + */ + prevRollover(d: Date, val: number, constraint: IModifier, period: ITimePeriod): Date; + } + + export interface ITimePeriod { + + /** + * The name of the time period information provider. + */ + name: string; + + /** + * The rough number of seconds that are covered when moving from one instance of this time period to the next instance. + */ + range: number; + + /** + * The value of this time period for the date specified. + * + * @param {Date} date - The given date. + */ + val(date: Date): number; + + /** + * True if the specified value is valid for the specified date, false otherwise. + * + * @param {Date} date - The given date. + * @param {any} value - The value to test for the date. + */ + isValid(date: Date, value: any): boolean; + + /** + * The minimum and maximum valid values for the time period for the specified date. + * If the minimum value is not 0, 0 can be specified in schedules to indicate the maximum value. + * This makes working with non - constant extents(like days in a month) easier. + * + * @param {Date} [date] - The given date. + */ + extent(date?: Date): number[]; + + /** + * The first second in which the value is the same as the value of the specified date. + * For example, the start of an hour would be the hour with 0 minutes and 0 seconds. + * + * @param {Date} date - The given date. + */ + start(date: Date): Date; + + /** + * The last second in which the value is the same as the value of the specified date. + * For example, the end of an hour would be the hour with 59 minutes and 59 seconds. + * + * @param {Date} date - The given date. + */ + end(date: Date): Date; + + /** + * Returns the next date where the value is the value specified. + * Sets the value to 1 if value specified is greater than the max allowed value. + * + * @param {Date} date - The given date. + * @param {any} value - The value to test for the date. + */ + next(date: Date, value: any): Date; + + /** + * Returns the previous date where the value is the value specified. + * Sets the value to the max allowed value if the value specified is greater than the max allowed value. + * + * @param {Date} date - The given date. + * @param {any} value - The value to test for the date. + */ + prev(date: Date, value: any): Date; + } + + export interface IModifier extends ITimePeriod { + /** + * Creates a new modified constraint. + * + * @param {ITimePeriod} constraint: The constraint to be modified + * @param {number} value: The starting value of the after constraint + */ + (constraint: ITimePeriod, value: number): ITimePeriod; + } + + export interface IModifierStatic { + + /** + * After Modifier + */ + after: IModifier; + + /** + * Before Modifier + */ + before: IModifier; + } + + export interface IStatic { + + /** + * Schedule + * Generates instances from schedule data. + */ + schedule(input: any): ISchedule; + + /** + * Parse + * For generating schedule data. + */ + parse: IParseStatic; + + /** Date Provider + */ + date: IDateProvider; + + /** + * Set timeout on window using given recurrence next. + * + * @param {function} callback - A callback called after first instance of recurrence pattern. + * @param {Later.IReccurence} - A recurrence instance. + */ + setTimeout(callback: () => void, time: IScheduleData): ITimer; + /** + * Set interval on window using given recurrence + * + * @param {function} callback - A callback called after each instance of recurrence pattern. + * @param {Later.IReccurence} - A recurrence instance. + */ + setInterval(callback: () => void, time: IScheduleData): ITimer; + + /** + * time period information provider. + */ + time: ITimePeriod; + /** + * Second time period information provider. + */ + second: ITimePeriod; + /** + * Minute time period information provider. + */ + minute: ITimePeriod; + /** + * Hour time period information provider. + */ + hour: ITimePeriod; + /** + * Day time period information provider. + */ + day: ITimePeriod; + /** + * Day of week time period information provider. + */ + dayOfWeek: ITimePeriod; + /** + * Day of week in month time period information provider. + */ + dayOfWeekCount: ITimePeriod; + /** + * Day in year time period information provider. + */ + dayOfYear: ITimePeriod; + /** + * Week of mobth time period information provider. + */ + weekOfMonth: ITimePeriod; + /** + * Week of yearfrom ISO 8601 time period information provider. + */ + weekOfYear: ITimePeriod; + /** + * Month time period information provider. + */ + month: ITimePeriod; + /** + * Year time period information provider. + */ + year: ITimePeriod; + + /** + * Later Modifiers: + * + * This type can be easily extended to include any custom IModifiers that you desire. + * These can then be used to create schedules of your own custom type. + * + * interface IGandalfsLaterModifier extends Later.IModifierStatic { + * duringTheThirdAge: IModifier + * } + * + * Be sure to use this interface when dealing with Later.modifier + */ + modifier: IModifierStatic + } +} + +/** + * Later Module: + * + * Easily define complex schedules then quickly calculate future or previous schedule occurrences. + * + * This type can be easily extended to include any custom ITimePeriods that you desire. + * These can then be used to create schedules of your own custom type. + * + * interface IGandalfsLater extends Later.IStatic { + * agesOfMiddleEarth: ITimePeriod + * } + * + * Be sure to use this interface when dealing with Later. + */ +declare var later: Later.IStatic; \ No newline at end of file