Cron Reference

Coverage License NPM Version Open Issues

⏲️ Cron Quartz and Cron UNIX expression parser.

Usage

📦 Node

Install @lou.codes/cron as a dependency:

1
pnpm add @lou.codes/cron
2
# or
3
npm install @lou.codes/cron
4
# or
5
yarn add @lou.codes/cron

Import it and use it:

1
import { parseStringQuartz, parseCronQuartz } from "@lou.codes/cron";
2

3
const cron = parseStringQuartz("1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10");
4
/*
5
	{
6
		seconds: { every: 3, start: { from: 1, to: 2 } },
7
		minutes: [{ from: 1, to: 2 }, 3, 4],
8
		hours: "*",
9
		dayOfMonth: { nearest: 2 },
10
		month: ["SEP", "OCT"],
11
		dayOfWeek: { last: 1 },
12
		year: { every: 10, start: "*" }
13
	}
14
*/
15

16
parseCronQuartz(cron); // "1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10"

🦕 Deno

Import @lou.codes/cron using the npm: prefix, and use it directly:

1
import { parseStringQuartz, parseCronQuartz } from "npm:@lou.codes/cron";
2

3
const cron = parseStringQuartz("1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10");
4
/*
5
	{
6
		seconds: { every: 3, start: { from: 1, to: 2 } },
7
		minutes: [{ from: 1, to: 2 }, 3, 4],
8
		hours: "*",
9
		dayOfMonth: { nearest: 2 },
10
		month: ["SEP", "OCT"],
11
		dayOfWeek: { last: 1 },
12
		year: { every: 10, start: "*" }
13
	}
14
*/
15

16
parseCronQuartz(cron); // "1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10"

🌎 Browser

Import @lou.codes/cron using esm.sh, and use it directly:

1
<script type="module">
2
	import {
3
		parseStringQuartz,
4
		parseCronQuartz,
5
	} from "https://esm.sh/@lou.codes/cron";
6

7
	const cron = parseStringQuartz("1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10");
8
	/*
9
		{
10
			seconds: { every: 3, start: { from: 1, to: 2 } },
11
			minutes: [{ from: 1, to: 2 }, 3, 4],
12
			hours: "*",
13
			dayOfMonth: { nearest: 2 },
14
			month: ["SEP", "OCT"],
15
			dayOfWeek: { last: 1 },
16
			year: { every: 10, start: "*" }
17
		}
18
	*/
19

20
	parseCronQuartz(cron); // "1-2/3 1-2,3,4 * 2W SEP,OCT 1L */10"
21
</script>

Useful links

📝 Documentation: TypeDoc generated documentation.
⏳ Changelog: List of changes between versions.
✅ Tests Coverage: Coveralls page with tests coverage.

To do

A big change is coming with stricter types and a better DX. Stay tuned.

Common

splitExpression()

1
function splitExpression(source: string): string[];

Splits given string by spaces (even if multiple).

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

string[]

An array with all elements of the given expression.

Example

1
splitExpression("  1  2   3    4     5 "); // ["1", "2", "3", "4", "5"]
2
splitExpression("1 2 3 4 5"); // ["1", "2", "3", "4", "5"]
3
splitExpression("12345"); // ["12345"]

validateOr()

1
function validateOr(...validations: readonly (value: unknown) => boolean[]): (value: unknown) => boolean

Run several validations in the same string, true if any is true.

Parameters

Parameter	Type	Description
…`validations`	readonly (`value`: `unknown`) => `boolean`[]	List of validations.

Returns

Function

Curried function with validations in context.

Parameters

Parameter	Type
`value`	`unknown`

Returns

boolean

Example

1
validateOr([])("1"); // false
2

3
validateOr([item => item === "1", item => parseInt(item as string, 10) === 1])(
4
	"1",
5
); // true
6

7
validateOr([item => item === "1", item => parseInt(item as string, 10) === 2])(
8
	"1",
9
); // true
10

11
validateOr([item => item === "2", item => parseInt(item as string, 10) === 2])(
12
	"1",
13
); // false

Other

CronDayOfMonth

1
type CronDayOfMonth: CronNearestDayOfMonth | CronPartExtended<CronDayOfMonthValue>;

Cron day of month.

CronDayOfMonthValue

1
type CronDayOfMonthValue:
2
  | 1
3
  | 2
4
  | 3
5
  | 4
6
  | 5
7
  | 6
8
  | 7
9
  | 8
10
  | 9
11
  | 10
12
  | 11
13
  | 12
14
  | 13
15
  | 14
16
  | 15
17
  | 16
18
  | 17
19
  | 18
20
  | 19
21
  | 20
22
  | 21
23
  | 22
24
  | 23
25
  | 24
26
  | 25
27
  | 26
28
  | 27
29
  | 28
30
  | 29
31
  | 30
32
  | 31;

Cron day of the month value (1-31).

CronDayOfWeek

1
type CronDayOfWeek: CronLastValue | CronPartExtended<CronDayOfWeekValue> | CronSpecificDayOfWeek;

Cron day of week.

CronDayOfWeekValue

1
type CronDayOfWeekValue: CronDayOfWeekValueNumber | CronDayOfWeekValueString;

Cron day of week value (0-7 | SUN-SAT).

CronDayOfWeekValueNumber

1
type CronDayOfWeekValueNumber:
2
  | 0
3
  | 1
4
  | 2
5
  | 3
6
  | 4
7
  | 5
8
  | 6
9
  | 7;

Cron day of week number value (0-7).

CronDayOfWeekValueString

1
type CronDayOfWeekValueString:
2
  | "FRI"
3
  | "MON"
4
  | "SAT"
5
  | "SUN"
6
  | "THU"
7
  | "TUE"
8
  | "WED";

Cron day of week string value (SUN-SAT).

CronEvery

1
type CronEvery: typeof CRON_EVERY;

Cron every (*).

CronHours

1
type CronHours: CronPart<CronHoursValue>;

Cron hours.

CronHoursValue

1
type CronHoursValue:
2
  | 0
3
  | 1
4
  | 2
5
  | 3
6
  | 4
7
  | 5
8
  | 6
9
  | 7
10
  | 8
11
  | 9
12
  | 10
13
  | 11
14
  | 12
15
  | 13
16
  | 14
17
  | 15
18
  | 16
19
  | 17
20
  | 18
21
  | 19
22
  | 20
23
  | 21
24
  | 22
25
  | 23;

Cron hours value (0-23).

CronLast

1
type CronLast: typeof CRON_LAST;

Cron every (L).

CronLastValue

1
type CronLastValue: object;

Cron last object. It gets turned into the string ${last}L.

Type declaration

Member	Type
`last`	`CronDayOfWeekValueNumber`

CronList<Value>

1
type CronList<Value>: ReadonlyArray<CronListItem<Value>>;

Cron list (value1,value2,valueN).

Type parameters

Type parameter
`Value`

CronListItem<Value>

1
type CronListItem<Value>: CronRange<Value> | CronSteps<Value> | Value;

Cron list item.

Type parameters

Type parameter
`Value`

CronMinutes

1
type CronMinutes: CronPart<CronMinutesValue>;

Cron minutes.

CronMinutesValue

1
type CronMinutesValue:
2
  | 0
3
  | 1
4
  | 2
5
  | 3
6
  | 4
7
  | 5
8
  | 6
9
  | 7
10
  | 8
11
  | 9
12
  | 10
13
  | 11
14
  | 12
15
  | 13
16
  | 14
17
  | 15
18
  | 16
19
  | 17
20
  | 18
21
  | 19
22
  | 20
23
  | 21
24
  | 22
25
  | 23
26
  | 24
27
  | 25
28
  | 26
29
  | 27
30
  | 28
31
  | 29
32
  | 30
33
  | 31
34
  | 32
35
  | 33
36
  | 34
37
  | 35
38
  | 36
39
  | 37
40
  | 38
41
  | 39
42
  | 40
43
  | 41
44
  | 42
45
  | 43
46
  | 44
47
  | 45
48
  | 46
49
  | 47
50
  | 48
51
  | 49
52
  | 50
53
  | 51
54
  | 52
55
  | 53
56
  | 54
57
  | 55
58
  | 56
59
  | 57
60
  | 58
61
  | 59;

Cron minutes value (0-59).

CronMonth

1
type CronMonth: CronPart<CronMonthValue>;

Cron month.

CronMonthValue

1
type CronMonthValue: CronMonthValueNumber | CronMonthValueString;

Cron month value (1-12 and JAN-DEC).

CronMonthValueNumber

1
type CronMonthValueNumber:
2
  | 1
3
  | 2
4
  | 3
5
  | 4
6
  | 5
7
  | 6
8
  | 7
9
  | 8
10
  | 9
11
  | 10
12
  | 11
13
  | 12;

Cron month number value (1-12).

CronMonthValueString

1
type CronMonthValueString:
2
  | "APR"
3
  | "AUG"
4
  | "DEC"
5
  | "FEB"
6
  | "JAN"
7
  | "JUL"
8
  | "JUN"
9
  | "MAR"
10
  | "MAY"
11
  | "NOV"
12
  | "OCT"
13
  | "SEP";

Cron month string value (JAN-DEC).

CronNearest

1
type CronNearest: typeof CRON_NEAREST;

Cron every (W).

CronNearestDayOfMonth

1
type CronNearestDayOfMonth: object;

Nearest day of month object It gets turned into the string ${nearest}W.

Type declaration

Member	Type
`nearest`	`CronDayOfMonthValue`

CronPart<Value>

1
type CronPart<Value>:
2
  | CronEvery
3
  | CronList<Value>
4
  | CronRange<Value>
5
  | CronSteps<Value>
6
  | Value;

Cron part.

Type parameters

Type parameter
`Value`

CronPartExtended<Value>

1
type CronPartExtended<Value>: CronLast | CronPart<Value> | CronStartOrBlank;

Cron part extended (used by CronDayOfWeek and DayOfMonth).

Type parameters

Type parameter
`Value`

CronQuartz

1
type CronQuartz: CronQuartzExtension & CronUnix;

Cron object (Quartz).

CronQuartzExtension

1
type CronQuartzExtension: object;

Cron expression parts coming with Quartz.

Type declaration

Member	Type	Description
`seconds`	`CronSeconds`	Cron `CronSeconds` object.
`year`	`CronYear`	Cron `CronYear` object.

CronRange<Value>

1
type CronRange<Value>: object;

Cron range (from-to).

Type parameters

Type parameter
`Value`

Type declaration

Member	Type
`from`	`Value`
`to`	`Value`

CronSeconds

1
type CronSeconds: CronPart<CronSecondsValue>;

Cron seconds.

CronSecondsValue

1
type CronSecondsValue:
2
  | 0
3
  | 1
4
  | 2
5
  | 3
6
  | 4
7
  | 5
8
  | 6
9
  | 7
10
  | 8
11
  | 9
12
  | 10
13
  | 11
14
  | 12
15
  | 13
16
  | 14
17
  | 15
18
  | 16
19
  | 17
20
  | 18
21
  | 19
22
  | 20
23
  | 21
24
  | 22
25
  | 23
26
  | 24
27
  | 25
28
  | 26
29
  | 27
30
  | 28
31
  | 29
32
  | 30
33
  | 31
34
  | 32
35
  | 33
36
  | 34
37
  | 35
38
  | 36
39
  | 37
40
  | 38
41
  | 39
42
  | 40
43
  | 41
44
  | 42
45
  | 43
46
  | 44
47
  | 45
48
  | 46
49
  | 47
50
  | 48
51
  | 49
52
  | 50
53
  | 51
54
  | 52
55
  | 53
56
  | 54
57
  | 55
58
  | 56
59
  | 57
60
  | 58
61
  | 59;

Cron seconds value (0-59).

CronSpecificDayOfWeek

1
type CronSpecificDayOfWeek: object;

Cron specific day of week object. It gets turned into the string ${day}#${week}.

Type declaration

Member	Type
`day`	`CronDayOfWeekValueNumber`
`week`	`CronWeekValue`

CronStartOrBlank

1
type CronStartOrBlank: typeof CRON_START_OR_BLANK;

Cron start or blank value (?).

CronSteps<Value>

1
type CronSteps<Value>: object;

Cron steps (start/every).

Type parameters

Type parameter
`Value`

Type declaration

Member	Type
`every`	`number`
`start`	`CronEvery` \| `CronRange`<`Value`> \| `Value`

CronUnix

1
type CronUnix: object;

Cron expression (UNIX).

Type declaration

Member	Type	Description
`dayOfMonth`	`CronDayOfMonth`	Cron `CronDayOfMonth` object.
`dayOfWeek`	`CronDayOfWeek`	Cron `CronDayOfWeek` object.
`hours`	`CronHours`	Cron `CronHours` object.
`minutes`	`CronMinutes`	Cron `CronMinutes` object.
`month`	`CronMonth`	Cron `CronMonth` object.

CronValueParser<Value>

1
type CronValueParser<Value>: Unary<Value, Maybe<string>>;

Parses a value into a string or undefined if invalid.

Type parameters

Type parameter
`Value`

CronWeekValue

1
type CronWeekValue:
2
  | 1
3
  | 2
4
  | 3
5
  | 4
6
  | 5;

Cron week value (1-5).

CronYear

1
type CronYear: CronPart<CronYearValue>;

Cron year.

CronYearValue

1
type CronYearValue:
2
  | 1970
3
  | 1971
4
  | 1972
5
  | 1973
6
  | 1974
7
  | 1975
8
  | 1976
9
  | 1977
10
  | 1978
11
  | 1979
12
  | 1980
13
  | 1981
14
  | 1982
15
  | 1983
16
  | 1984
17
  | 1985
18
  | 1986
19
  | 1987
20
  | 1988
21
  | 1989
22
  | 1990
23
  | 1991
24
  | 1992
25
  | 1993
26
  | 1994
27
  | 1995
28
  | 1996
29
  | 1997
30
  | 1998
31
  | 1999
32
  | 2000
33
  | 2001
34
  | 2002
35
  | 2003
36
  | 2004
37
  | 2005
38
  | 2006
39
  | 2007
40
  | 2008
41
  | 2009
42
  | 2010
43
  | 2011
44
  | 2012
45
  | 2013
46
  | 2014
47
  | 2015
48
  | 2016
49
  | 2017
50
  | 2018
51
  | 2019
52
  | 2020
53
  | 2021
54
  | 2022
55
  | 2023
56
  | 2024
57
  | 2025
58
  | 2026
59
  | 2027
60
  | 2028
61
  | 2029
62
  | 2030
63
  | 2031
64
  | 2032
65
  | 2033
66
  | 2034
67
  | 2035
68
  | 2036
69
  | 2037
70
  | 2038
71
  | 2039
72
  | 2040
73
  | 2041
74
  | 2042
75
  | 2043
76
  | 2044
77
  | 2045
78
  | 2046
79
  | 2047
80
  | 2048
81
  | 2049
82
  | 2050
83
  | 2051
84
  | 2052
85
  | 2053
86
  | 2054
87
  | 2055
88
  | 2056
89
  | 2057
90
  | 2058
91
  | 2059
92
  | 2060
93
  | 2061
94
  | 2062
95
  | 2063
96
  | 2064
97
  | 2065
98
  | 2066
99
  | 2067
100
  | 2068
101
  | 2069
102
  | 2070
103
  | 2071
104
  | 2072
105
  | 2073
106
  | 2074
107
  | 2075
108
  | 2076
109
  | 2077
110
  | 2078
111
  | 2079
112
  | 2080
113
  | 2081
114
  | 2082
115
  | 2083
116
  | 2084
117
  | 2085
118
  | 2086
119
  | 2087
120
  | 2088
121
  | 2089
122
  | 2090
123
  | 2091
124
  | 2092
125
  | 2093
126
  | 2094
127
  | 2095
128
  | 2096
129
  | 2097
130
  | 2098
131
  | 2099;

Cron year value (1970-2099).

LimitTuple

1
type LimitTuple: readonly [number, number];

Lower and upper limit of a number value.

StringValueParser<Value>

1
type StringValueParser<Value>: Unary<string, Maybe<Value>>;

Parses a string into a value of given type or undefined if invalid

Type parameters

Type parameter
`Value`

CRON_EVERY

1
const CRON_EVERY: "*" = "*";

CRON_LAST

1
const CRON_LAST: "L" = "L";

CRON_LIST_SEPARATOR

1
const CRON_LIST_SEPARATOR: "," = ",";

CRON_NEAREST

1
const CRON_NEAREST: "W" = "W";

CRON_RANGE_SEPARATOR

1
const CRON_RANGE_SEPARATOR: "-" = "-";

CRON_SPECIFIC_SEPARATOR

1
const CRON_SPECIFIC_SEPARATOR: "#" = "#";

CRON_START_OR_BLANK

1
const CRON_START_OR_BLANK: "?" = "?";

CRON_STEPS_SEPARATOR

1
const CRON_STEPS_SEPARATOR: "/" = "/";

QUARTZ_DAY_OF_MONTH_POSITION

1
const QUARTZ_DAY_OF_MONTH_POSITION: 3 = 3;

QUARTZ_DAY_OF_WEEK_POSITION

1
const QUARTZ_DAY_OF_WEEK_POSITION: 5 = 5;

QUARTZ_HOURS_POSITION

1
const QUARTZ_HOURS_POSITION: 2 = 2;

QUARTZ_MINUTES_POSITION

1
const QUARTZ_MINUTES_POSITION: 1 = 1;

QUARTZ_MONTH_POSITION

1
const QUARTZ_MONTH_POSITION: 4 = 4;

QUARTZ_SECONDS_POSITION

1
const QUARTZ_SECONDS_POSITION: 0 = 0;

QUARTZ_YEAR_POSITION

1
const QUARTZ_YEAR_POSITION: 6 = 6;

UNIX_DAY_OF_MONTH_POSITION

1
const UNIX_DAY_OF_MONTH_POSITION: 2 = 2;

UNIX_DAY_OF_WEEK_POSITION

1
const UNIX_DAY_OF_WEEK_POSITION: 4 = 4;

UNIX_HOURS_POSITION

1
const UNIX_HOURS_POSITION: 1 = 1;

UNIX_MINUTES_POSITION

1
const UNIX_MINUTES_POSITION: 0 = 0;

UNIX_MONTH_POSITION

1
const UNIX_MONTH_POSITION: 3 = 3;

isCronSecondsValue()

1
function isCronSecondsValue(value: unknown): value is CronSecondsValue;

Check if given is CronSecondsValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronSecondsValue

Returns true if is CronSecondsValue, false otherwise.

Example

1
isCronSecondsValue(30); // true
2
isCronSecondsValue(80); // false

Parsers

parseCronDayOfMonth()

1
function parseCronDayOfMonth(source: CronDayOfMonth): Maybe<string>;

Parses CronDayOfMonth into a string.

Parameters

Parameter	Type	Description
`source`	`CronDayOfMonth`	`CronDayOfMonth` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronDayOfMonth(10); // "10"
2
parseCronDayOfMonth("*"); // "*"
3
parseCronDayOfMonth("?"); // "?"
4
parseCronDayOfMonth({ every: 10, start: 2 }); // "2/10"
5
parseCronDayOfMonth({ every: 10, start: "L" }); // "L/10"
6
parseCronDayOfMonth([1, 2, 3, 4]); // "1,2,3,4"
7
parseCronDayOfMonth({ from: 5, to: 10 }); // "5-10"
8
parseCronDayOfMonth([1, 2, 3, 4, { from: 5, to: 10 }]); // "1,2,3,4,5-10"
9
parseCronDayOfMonth("L"); // "L"
10
parseCronDayOfMonth({ nearest: 1 }); // "1W"
11
parseCronDayOfMonth({ every: 99, start: "*" }); // undefined

parseCronDayOfMonthValue()

1
function parseCronDayOfMonthValue(input: CronDayOfMonthValue): Maybe<string>;

Parses CronDayOfMonthValue into a string.

Parameters

Parameter	Type
`input`	`CronDayOfMonthValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronDayOfMonthValue(1); // "1"
2
parseCronDayOfMonthValue(31); // "31"
3
parseCronDayOfMonthValue(99); // undefined

parseCronDayOfWeek()

1
function parseCronDayOfWeek(source: CronDayOfWeek): Maybe<string>;

Parses CronDayOfWeek into a string.

Parameters

Parameter	Type	Description
`source`	`CronDayOfWeek`	`CronDayOfWeek` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronDayOfWeek(6); // "6"
2
parseCronDayOfWeek("*"); // "*"
3
parseCronDayOfWeek("?"); // "?"
4
parseCronDayOfWeek({ every: 6, start: 2 }); // "2/6"
5
parseCronDayOfWeek({ every: 6, start: "L" }); // "L/6"
6
parseCronDayOfWeek([1, 2, 3, 4]); // "1,2,3,4"
7
parseCronDayOfWeek({ from: 1, to: 5 }); // "1-5"
8
parseCronDayOfWeek({ from: "MON", to: "SAT" }); // "MON-SAT"
9
parseCronDayOfWeek([1, 2, 3, { from: 5, to: 7 }]); // "1,2,3,5-7"
10
parseCronDayOfWeek("L"); // "L"
11
parseCronDayOfWeek({ last: 2 }); // "2L"
12
parseCronDayOfWeek({ day: 1, week: 5 }); // "1#5"

parseCronDayOfWeekValue()

1
function parseCronDayOfWeekValue(input: CronDayOfWeekValue): Maybe<string>;

Parses CronDayOfWeekValue into a string.

Parameters

Parameter	Type
`input`	`CronDayOfWeekValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronDayOfWeekValue(1); // "1"
2
parseCronDayOfWeekValue(7); // "7"
3
parseCronDayOfWeekValue(99); // undefined

parseCronEvery()

1
function parseCronEvery(source: string): undefined | "*";

Parses a CronEvery into a string.

Parameters

Parameter	Type	Description
`source`	`string`	`CronEvery` to be parsed.

Returns

undefined | "*"

A string or undefined if invalid.

Example

1
parseCronEvery("*"); // "*"
2
parseCronEvery("💩"); // undefined

parseCronHours()

1
function parseCronHours(
2
	source:
3
		| "*"
4
		| CronHoursValue
5
		| CronList<CronHoursValue>
6
		| CronRange<CronHoursValue>
7
		| CronSteps<CronHoursValue>,
8
): Maybe<string>;

Parses CronHours into a string.

Parameters

Parameter	Type	Description
`source`	\| `"*"` \| `CronHoursValue` \| `CronList`<`CronHoursValue`> \| `CronRange`<`CronHoursValue`> \| `CronSteps`<`CronHoursValue`>	`CronHours` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronHours(10); // "10"
2
parseCronHours("*"); // "*"
3
parseCronHours({ every: 10, start: 2 }); // "2/10"
4
parseCronHours([1, 2, 3, 4]); // "1,2,3,4"
5
parseCronHours({ from: 5, to: 10 }); // "5-10"
6
parseCronHours([1, 2, 3, 4, { from: 5, to: 10 }]); // "1,2,3,4,5-10"

parseCronHoursValue()

1
function parseCronHoursValue(input: CronHoursValue): Maybe<string>;

Parses CronHoursValue into a string.

Parameters

Parameter	Type
`input`	`CronHoursValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronHoursValue(10); // "10"
2
parseCronHoursValue(23); // "23"
3
parseCronHoursValue(99); // undefined

parseCronLast()

1
function parseCronLast(source: string): undefined | "L";

Parses CronLast into a string.

Parameters

Parameter	Type	Description
`source`	`string`	`CronLast` to be parsed.

Returns

undefined | "L"

A string or undefined if invalid.

Example

1
parseCronLast("L"); // "L"
2
parseCronLast("💩"); // undefined

parseCronLastValue()

1
function parseCronLastValue(source: CronLastValue): undefined | string;

Parses CronLastValue into a string.

Parameters

Parameter	Type	Description
`source`	`CronLastValue`	`CronLastValue` to be parsed.

Returns

undefined | string

A string or undefined if invalid.

Example

1
parseCronLastValue({ last: 1 }); // "1L"
2
parseCronLastValue({ last: 99 }); // undefined

parseCronList()

1
function parseCronList(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: CronValueParser<Value>,
5
) => (source: CronList<Value>) => undefined | string;

Parses CronList into a string.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` to be used when parsing `CronSteps`.

Returns

Function

Curried function with limit on context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`CronValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	`CronList`<`Value`>

Returns

undefined | string

Example

1
const parseCronSecondsList = parseCronList([0, 59])(parseCronSecondsValue);
2

3
parseCronSecondsList([13, 10]); // "13,10",
4
parseCronSecondsList([{ from: 13, to: 10 }, 10]); // "13-10,10",
5
parseCronSecondsList([{ every: 10, start: 13 }, 10]); // "13/10,10",
6
parseCronSecondsList([{ every: 10, start: { from: 13, to: 10 } }, 10]); // "13-10/10,10"
7
parseCronSecondsList([{ every: 10, start: "L" }, 10]); // "L/10,10"
8
parseCronSecondsList([]); // undefined

parseCronMinutes()

1
function parseCronMinutes<Source>(
2
	source:
3
		| "*"
4
		| Source
5
		| CronList<Source>
6
		| CronRange<Source>
7
		| CronSteps<Source>,
8
): Maybe<string>;

Parses CronMinutes into a string.

Type parameters

Type parameter
`Source` extends `number`

Parameters

Parameter	Type	Description
`source`	\| `"*"` \| `Source` \| `CronList`<`Source`> \| `CronRange`<`Source`> \| `CronSteps`<`Source`>	`CronMinutes` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronMinutes(10); // "10"
2
parseCronMinutes("*"); // "*"
3
parseCronMinutes({ every: 10, start: 2 }); // "2/10"
4
parseCronMinutes([1, 2, 3, 4]); // "1,2,3,4"
5
parseCronMinutes({ from: 5, to: 10 }); // "5-10"
6
parseCronMinutes([1, 2, 3, 4, { from: 5, to: 10 }]); // "1,2,3,4,5-10"

parseCronMinutesValue()

1
function parseCronMinutesValue<Source>(
2
	source: Source,
3
): Source extends CronMinutesValue ? `${Source<Source>}`
4
:	Maybe<
5
		| "0"
6
		| "1"
7
		| "2"
8
		| "3"
9
		| "4"
10
		| "5"
11
		| "6"
12
		| "7"
13
		| "8"
14
		| "9"
15
		| "10"
16
		| "11"
17
		| "12"
18
		| "13"
19
		| "14"
20
		| "15"
21
		| "16"
22
		| "17"
23
		| "18"
24
		| "19"
25
		| "20"
26
		| "21"
27
		| "22"
28
		| "23"
29
		| "24"
30
		| "25"
31
		| "26"
32
		| "27"
33
		| "28"
34
		| "29"
35
		| "30"
36
		| "31"
37
		| "32"
38
		| "33"
39
		| "34"
40
		| "35"
41
		| "36"
42
		| "37"
43
		| "38"
44
		| "39"
45
		| "40"
46
		| "41"
47
		| "42"
48
		| "43"
49
		| "44"
50
		| "45"
51
		| "46"
52
		| "47"
53
		| "48"
54
		| "49"
55
		| "50"
56
		| "51"
57
		| "52"
58
		| "53"
59
		| "54"
60
		| "55"
61
		| "56"
62
		| "57"
63
		| "58"
64
		| "59"
65
	>;

Parses CronMinutesValue into a string.

Type parameters

Type parameter
`Source` extends `number`

Parameters

Parameter	Type	Description
`source`	`Source`	`CronMinutesValue` to be parsed.

Returns

Source extends CronMinutesValue ? `${Source<Source>}` : Maybe< | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31" | "32" | "33" | "34" | "35" | "36" | "37" | "38" | "39" | "40" | "41" | "42" | "43" | "44" | "45" | "46" | "47" | "48" | "49" | "50" | "51" | "52" | "53" | "54" | "55" | "56" | "57" | "58" | "59">

A string or undefined if invalid.

Example

1
parseCronMinutesValue(0); // "0"
2
parseCronMinutesValue(59); // "59"

parseCronMonth()

1
function parseCronMonth(
2
	source:
3
		| "*"
4
		| CronMonthValue
5
		| CronList<CronMonthValue>
6
		| CronRange<CronMonthValue>
7
		| CronSteps<CronMonthValue>,
8
): Maybe<string>;

Parses CronMonth into a string.

Parameters

Parameter	Type	Description
`source`	\| `"*"` \| `CronMonthValue` \| `CronList`<`CronMonthValue`> \| `CronRange`<`CronMonthValue`> \| `CronSteps`<`CronMonthValue`>	`CronMonth` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronMonth(10); // "10"
2
parseCronMonth("*"); // "*"
3
parseCronMonth({ every: 6, start: 2 }); // "2/6"
4
parseCronMonth([1, 2, 3, 4]); // "1,2,3,4"
5
parseCronMonth({ from: 1, to: 5 }); // "1-5"
6
parseCronMonth({ from: "JAN", to: "OCT" }); // "JAN-OCT"
7
parseCronMonth([1, 2, 3, { from: 5, to: 7 }]); // "1,2,3,5-7"

parseCronMonthValue()

1
function parseCronMonthValue(input: CronMonthValue): Maybe<string>;

Parses CronMonthValue into a string.

Parameters

Parameter	Type
`input`	`CronMonthValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronMonthValue(1); // "1"
2
parseCronMonthValue(12); // "12"
3
parseCronMonthValue(99); // undefined

parseCronNearestDayOfMonth()

1
function parseCronNearestDayOfMonth(
2
	source: CronNearestDayOfMonth,
3
): undefined | string;

Parses CronNearestDayOfMonth into a string.

Parameters

Parameter	Type	Description
`source`	`CronNearestDayOfMonth`	`CronNearestDayOfMonth` to be parsed.

Returns

undefined | string

A string or undefined if invalid.

Example

1
parseCronNearestDayOfMonth({ nearest: 2 }); // "2W"
2
parseCronNearestDayOfMonth({ nearest: 99 }); // undefined

parseCronPart()

1
function parseCronPart(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: CronValueParser<Value>,
5
) => (
6
	source: "*" | Value | CronList<Value> | CronRange<Value> | CronSteps<Value>,
7
) => Maybe<string>;

Parses CronPart into a string.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` to be used when parsing `CronSteps`.

Returns

Function

Curried function with limit on context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`CronValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	\| `"*"` \| `Value` \| `CronList`<`Value`> \| `CronRange`<`Value`> \| `CronSteps`<`Value`>

Returns

Maybe<string>

Example

1
const parseCronPartSeconds = parseCronPart([0, 59])(parseCronSecondsValue);
2

3
parseCronPartSeconds("*"); // "*"
4
parseCronPartSeconds([13, 10]); // "13,10"
5
parseCronPartSeconds([{ from: 13, to: 10 }, 10]); // "13-10,10"
6
parseCronPartSeconds([{ every: 10, start: 13 }, 10]); // "13/10,10"
7
parseCronPartSeconds([{ every: 99, start: 13 }, 10]); // undefined
8
parseCronPartSeconds([
9
	{
10
		every: 10,
11
		start: { from: 13, to: 10 },
12
	},
13
	10,
14
]); // "13-10/10,10"
15
parseCronPartSeconds([{ every: 10, start: "?" }, 10]); // "?/10,10"
16
parseCronPartSeconds({ every: 10, start: 13 }); // "13/10"
17
parseCronPartSeconds({
18
	every: 10,
19
	start: { from: 13, to: 10 },
20
}); // "13-10/10"
21
parseCronPartSeconds({ every: 10, start: "?" }); // "?/10"
22
parseCronPartSeconds({
23
	from: 13,
24
	to: 10,
25
}); // "13-10"

parseCronQuartz()

1
function parseCronQuartz(cronQuartz: CronQuartz): undefined | string;

Parses CronQuartz into a string.

Parameters

Parameter	Type
`cronQuartz`	`CronQuartz`

Returns

undefined | string

A string or undefined if invalid.

Example

1
parseCronQuartz({
2
	dayOfMonth: "*",
3
	dayOfWeek: "*",
4
	hours: "*",
5
	minutes: "*",
6
	month: "*",
7
	seconds: "*",
8
	year: "*",
9
}); // wanted: "* * * * * * *"
10
parseCronQuartz({
11
	dayOfMonth: [1, 2],
12
	dayOfWeek: [1, 2],
13
	hours: [1, 2],
14
	minutes: [1, 2],
15
	month: [1, 2],
16
	seconds: [1, 2],
17
	year: [1989, 2020],
18
}); // "1,2 1,2 1,2 1,2 1,2 1,2 1989,2020"
19
parseCronQuartz({
20
	dayOfMonth: { from: 1, to: 2 },
21
	dayOfWeek: { from: 1, to: 2 },
22
	hours: { from: 1, to: 2 },
23
	minutes: { from: 1, to: 2 },
24
	month: { from: 1, to: 2 },
25
	seconds: { from: 1, to: 2 },
26
	year: { from: 1989, to: 2020 },
27
}); // "1-2 1-2 1-2 1-2 1-2 1-2 1989-2020"
28
parseCronQuartz({
29
	dayOfMonth: { every: 2, start: 1 },
30
	dayOfWeek: { every: 2, start: 1 },
31
	hours: { every: 2, start: 1 },
32
	minutes: { every: 2, start: 1 },
33
	month: { every: 2, start: 1 },
34
	seconds: { every: 2, start: 1 },
35
	year: { every: 10, start: 1989 },
36
}); // "1/2 1/2 1/2 1/2 1/2 1/2 1989/10"
37
parseCronQuartz({
38
	dayOfMonth: { nearest: 2 },
39
	dayOfWeek: { last: 1 },
40
	hours: "*",
41
	minutes: [{ from: 1, to: 2 }, 3, 4],
42
	month: ["SEP", "OCT"],
43
	seconds: { every: 3, start: { from: 1, to: 2 } },
44
	year: { every: 10, start: "?" },
45
}); // "1-2/3 1-2,3,4 * 2W SEP,OCT 1L ?/10",
46
parseCronQuartz({
47
	dayOfMonth: undefined,
48
	dayOfWeek: "*",
49
	hours: "*",
50
	minutes: "*",
51
	month: "*",
52
	seconds: "*",
53
	year: "*",
54
}); // undefined,

parseCronRange()

1
function parseCronRange<Value>(
2
	parser: CronValueParser<Value>,
3
): (source: CronRange<Value>) => undefined | string;

Parses CronRange into a string.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type	Description
`parser`	`CronValueParser`<`Value`>	`CronValueParser` for `CronRange`.

Returns

Function

Curried function with parser in context.

Parameters

Parameter	Type
`source`	`CronRange`<`Value`>

Returns

undefined | string

Example

1
parseCronRangeSeconds({ from: 13, to: 10 }); // "13-10"
2
parseCronRangeSeconds({ from: 999, to: 999 }); // undefined

parseCronSeconds()

1
function parseCronSeconds(
2
	source:
3
		| "*"
4
		| CronSecondsValue
5
		| CronList<CronSecondsValue>
6
		| CronRange<CronSecondsValue>
7
		| CronSteps<CronSecondsValue>,
8
): Maybe<string>;

Parses CronSeconds into a string.

Parameters

Parameter	Type	Description
`source`	\| `"*"` \| `CronSecondsValue` \| `CronList`<`CronSecondsValue`> \| `CronRange`<`CronSecondsValue`> \| `CronSteps`<`CronSecondsValue`>	`CronSeconds` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronSeconds(10); // "10",
2
parseCronSeconds("*"); // "*",
3
parseCronSeconds({ every: 10, start: 2 }); // "2/10",
4
parseCronSeconds([1, 2, 3, 4]); // "1,2,3,4",
5
parseCronSeconds({ from: 5, to: 10 }); // "5-10",
6
parseCronSeconds([1, 2, 3, 4, { from: 5, to: 10 }]); // "1,2,3,4,5-10",

parseCronSecondsValue()

1
function parseCronSecondsValue(input: CronSecondsValue): Maybe<string>;

Parses CronSecondsValue into a string.

Parameters

Parameter	Type
`input`	`CronSecondsValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronSecondsValue(10); // "10"
2
parseCronSecondsValue(59); // "59"
3
parseCronSecondsValue(99); // undefined

parseCronSpecificDayOfWeek()

1
function parseCronSpecificDayOfWeek(
2
	source: string | CronSpecificDayOfWeek,
3
): undefined | string;

Parses CronSpecificDayOfWeek into a string.

Parameters

Parameter	Type	Description
`source`	`string` \| `CronSpecificDayOfWeek`	`CronSpecificDayOfWeek` to be parsed.

Returns

undefined | string

A string or undefined if invalid.

Example

1
parseCronSpecificDayOfWeek({ day: 1, week: 5 }); // "1#5"
2
parseCronSpecificDayOfWeek({ day: 99, week: 99 }); // undefined

parseCronStartOrBlank()

1
function parseCronStartOrBlank(source: string): undefined | "?";

Parses CronStartOrBlank into a string.

Parameters

Parameter	Type	Description
`source`	`string`	`CronStartOrBlank` to be parsed.

Returns

undefined | "?"

A string or undefined if invalid.

Example

1
parseCronStartOrBlank("?"); // "?"
2
parseCronStartOrBlank("💩"); // undefined

parseCronSteps()

1
function parseCronSteps(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: CronValueParser<Value>,
5
) => (source: CronSteps<Value>) => undefined | string;

Parses CronSteps into a string.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` to be used when parsing `CronSteps`.

Returns

Function

Curried function with limit on context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`CronValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	`CronSteps`<`Value`>

Returns

undefined | string

Example

1
const parseCronStepsSeconds = parseCronSteps([0, 59])(parseCronSecondsValue);
2

3
parseCronStepsSeconds({ every: 10, start: 13 }); // "13/10"
4
parseCronStepsSeconds({ every: 99, start: 13 }); // undefined
5
parseCronStepsSeconds({
6
	every: 10,
7
	start: { from: 13, to: 10 },
8
}); // "13-10/10"
9
parseCronStepsSeconds({ every: 10, start: "?" }); // "?/10"

parseCronUnix()

1
function parseCronUnix(cronUnix: CronUnix): undefined | string;

Parses Cron (UNIX) into a string.

Parameters

Parameter	Type
`cronUnix`	`CronUnix`

Returns

undefined | string

A string or undefined if invalid.

Example

1
parseCronUnix({
2
	dayOfMonth: "*",
3
	dayOfWeek: "*",
4
	hours: "*",
5
	minutes: "*",
6
	month: "*",
7
}); // "* * * * *"
8
parseCronUnix({
9
	dayOfMonth: [1, 2],
10
	dayOfWeek: [1, 2],
11
	hours: [1, 2],
12
	minutes: [1, 2],
13
	month: [1, 2],
14
}); // "1,2 1,2 1,2 1,2 1,2"
15
parseCronUnix({
16
	dayOfMonth: { from: 1, to: 2 },
17
	dayOfWeek: { from: 1, to: 2 },
18
	hours: { from: 1, to: 2 },
19
	minutes: { from: 1, to: 2 },
20
	month: { from: 1, to: 2 },
21
}); // "1-2 1-2 1-2 1-2 1-2"
22
parseCronUnix({
23
	dayOfMonth: { every: 2, start: 1 },
24
	dayOfWeek: { every: 2, start: 1 },
25
	hours: { every: 2, start: 1 },
26
	minutes: { every: 2, start: 1 },
27
	month: { every: 2, start: 1 },
28
}); // "1/2 1/2 1/2 1/2 1/2"
29
parseCronUnix({
30
	dayOfMonth: { nearest: 2 },
31
	dayOfWeek: { last: 1 },
32
	hours: "*",
33
	minutes: [{ from: 1, to: 2 }, 3, 4],
34
	month: ["SEP", "OCT"],
35
}); // "1-2,3,4 * 2W SEP,OCT 1L"
36
parseCronUnix({
37
	dayOfMonth: undefined,
38
	dayOfWeek: "*",
39
	hours: "*",
40
	minutes: "*",
41
	month: "*",
42
}); // undefined

parseCronYear()

1
function parseCronYear(
2
	source:
3
		| "*"
4
		| CronYearValue
5
		| CronList<CronYearValue>
6
		| CronRange<CronYearValue>
7
		| CronSteps<CronYearValue>,
8
): Maybe<string>;

Parses CronYear into a string.

Parameters

Parameter	Type	Description
`source`	\| `"*"` \| `CronYearValue` \| `CronList`<`CronYearValue`> \| `CronRange`<`CronYearValue`> \| `CronSteps`<`CronYearValue`>	`CronYear` to be parsed.

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronYear(1989); // "1989"
2
parseCronYear("*"); // "*"
3
parseCronYear({ every: 10, start: 1989 }); // "1989/10"
4
parseCronYear({ every: 10, start: "?" }); // "?/10"
5
parseCronYear([1989, 1991, 2015, 2020]); // "1989,1991,2015,2020"
6
parseCronYear({ from: 1989, to: 2020 }); // "1989-2020"
7
parseCronYear([1989, 1989, 1991, 2015, 2020, { from: 1989, to: 2020 }]); // "1989,1991,2015,2020,1989-2020"

parseCronYearValue()

1
function parseCronYearValue(input: CronYearValue): Maybe<string>;

Parses CronYearValue into a string.

Parameters

Parameter	Type
`input`	`CronYearValue`

Returns

Maybe<string>

A string or undefined if invalid.

Example

1
parseCronYearValue(1989); // "1989"
2
parseCronYearValue(2022); // "2022"
3
parseCronYearValue(1969); // undefined
4
parseCronYearValue(3000); // undefined

parseStringDayOfMonth()

1
function parseStringDayOfMonth(source: string): Maybe<CronDayOfMonth>;

Parses a string into a CronDayOfMonth.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronDayOfMonth>

A CronDayOfMonth or undefined if invalid.

Example

1
parseStringDayOfMonth("10"); // 10,
2
parseStringDayOfMonth("*"); // "*",
3
parseStringDayOfMonth("?"); // "?",
4
parseStringDayOfMonth("2/10"); // { every: 10, start: 2 },
5
parseStringDayOfMonth("?/10"); // { every: 10, start: "?" },
6
parseStringDayOfMonth("1,2,3,4"); // [1, 2, 3, 4],
7
parseStringDayOfMonth("5-10"); // { from: 5, to: 10 },
8
parseStringDayOfMonth("1,2,3,4,5-10"); // [1, 2, 3, 4, { from: 5, to: 10 }],
9
parseStringDayOfMonth("L"); // "L",
10
parseStringDayOfMonth("1W"); // { nearest: 1 },
11
parseStringDayOfMonth("INVALID"); // undefined,
12
parseStringDayOfMonth("1,2,3,4,INVALID"); // undefined,

parseStringDayOfMonthValue()

1
function parseStringDayOfMonthValue(input: string): Maybe<CronDayOfMonthValue>;

Parses a string into a CronDayOfMonthValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronDayOfMonthValue>

A CronDayOfMonthValue or undefined if invalid.

Example

1
parseStringDayOfMonthValue("13"); // 13
2
parseStringDayOfMonthValue("99"); // undefined

parseStringDayOfWeek()

1
function parseStringDayOfWeek(source: string): Maybe<CronDayOfWeek>;

Parses a string into a CronDayOfWeek.

Parameters

Parameter	Type	Description
`source`	`string`	String to be parsed.

Returns

Maybe<CronDayOfWeek>

A CronDayOfWeek or undefined if invalid.

Example

1
parseStringDayOfWeek("6"); // 6
2
parseStringDayOfWeek("*"); // "*"
3
parseStringDayOfWeek("?"); // "?"
4
parseStringDayOfWeek("2/6"); // { every: 6, start: 2 }
5
parseStringDayOfWeek("?/6"); // { every: 6, start: "?" }
6
parseStringDayOfWeek("1,2,3,4"); // [1, 2, 3, 4]
7
parseStringDayOfWeek("1-5"); // { from: 1, to: 5 }
8
parseStringDayOfWeek("MON-SAT"); // { from: "MON", to: "SAT" }
9
parseStringDayOfWeek("mon-sat"); // { from: "MON", to: "SAT" }
10
parseStringDayOfWeek("1,2,3,5-7"); // [1, 2, 3, { from: 5, to: 7 }]
11
parseStringDayOfWeek("L"); // "L"
12
parseStringDayOfWeek("2L"); // { last: 2 }
13
parseStringDayOfWeek("1#5"); // { day: 1, week: 5 }
14
parseStringDayOfWeek("INVALID"); // undefined
15
parseStringDayOfWeek("1,2,3,4,INVALID"); // undefined

parseStringDayOfWeekValue()

1
function parseStringDayOfWeekValue(input: string): Maybe<CronDayOfWeekValue>;

Parses a string into a CronDayOfWeekValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronDayOfWeekValue>

A CronDayOfWeekValue or undefined if invalid.

Example

1
parseStringDayOfWeekValue("5"); // 5
2
parseStringDayOfWeekValue("FRI"); // "FRI"
3
parseStringDayOfWeekValue("fri"); // "FRI"
4
parseStringDayOfWeekValue("8"); // undefined
5
parseStringDayOfWeekValue("IDK"); // undefined

parseStringHours()

1
function parseStringHours(source: string): Maybe<CronPart<CronHoursValue>>;

Parses a string into a CronHours.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronPart<CronHoursValue>>

A CronHours or undefined if invalid.

Example

1
parseStringHours("10"); // 10
2
parseStringHours("*"); // "*"
3
parseStringHours("2/10"); // { every: 10, start: 2 }
4
parseStringHours("?/10"); // { every: 10, start: "?" }
5
parseStringHours("1,2,3,4"); // [1, 2, 3, 4]
6
parseStringHours("5-10"); // { from: 5, to: 10 }
7
parseStringHours("1,2,3,4,5-10"); // [1, 2, 3, 4, { from: 5, to: 10 }]
8
parseStringHours("INVALID"); // undefined
9
parseStringHours("1,2,3,4,INVALID"); // undefined

parseStringHoursValue()

1
function parseStringHoursValue(input: string): Maybe<CronHoursValue>;

Parses a string into a CronHoursValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronHoursValue>

A CronHoursValue or undefined if invalid.

Example

1
parseStringHoursValue("10"); // 10
2
parseStringHoursValue("25"); // undefined

parseStringLastValue()

1
function parseStringLastValue(source: string): Maybe<CronLastValue>;

Parses a string into a CronLastValue.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronLastValue>

A CronLastValue or undefined if invalid.

Example

1
parseStringLastValue("5L"); // { last: 5 }
2
parseStringLastValue("INVALID"); // undefined

parseStringList()

1
function parseStringList(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: StringValueParser<Value>,
5
) => (source: string) => undefined | CronList<Value>;

Parses a string into a CronList.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` to be used when parsing `CronSteps`.

Returns

Function

Curried function with limit in context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`StringValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	`string`

Returns

undefined | CronList<Value>

Example

1
parseStringListSeconds("13,10"); // [13, 10]
2
parseStringListSeconds("13-10,10"); // [{ from: 13, to: 10 }, 10]
3
parseStringListSeconds("13/10,10"); // [{ every: 10, start: 13 }, 10]
4
parseStringListSeconds("13-10/10,10"); // [{ every: 10, start: { from: 13, to: 10 } }, 10]
5
parseStringListSeconds("?/10,10"); // [{ every: 10, start: "?" }, 10]
6
parseStringListSeconds("13,INVALID"); // undefined
7
parseStringListSeconds("INVALID"); // undefined

parseStringMinutes()

1
function parseStringMinutes(source: string): Maybe<CronPart<CronMinutesValue>>;

Parses a string into a CronMinutes.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronPart<CronMinutesValue>>

A CronMinutes or undefined if invalid.

Example

1
parseStringMinutes("10"); // 10
2
parseStringMinutes("*"); // "*"
3
parseStringMinutes("2/10"); // { every: 10, start: 2 }
4
parseStringMinutes("?/10"); // { every: 10, start: "?" }
5
parseStringMinutes("1,2,3,4"); // [1, 2, 3, 4]
6
parseStringMinutes("5-10"); // { from: 5, to: 10 }
7
parseStringMinutes("1,2,3,4,5-10"); // [1, 2, 3, 4, { from: 5, to: 10 }]
8
parseStringMinutes("INVALID"); // undefined
9
parseStringMinutes("1,2,3,4,INVALID"); // undefined

parseStringMinutesValue()

1
function parseStringMinutesValue(input: string): Maybe<CronMinutesValue>;

Parses a string into a CronMinutesValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronMinutesValue>

A CronMinutesValue or undefined if invalid.

Example

1
parseStringMinutesValue("10"); // 10
2
parseStringMinutesValue("61"); // undefined

parseStringMonth()

1
function parseStringMonth(source: string): Maybe<CronPart<CronMonthValue>>;

Parses a string into a CronMonth.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronPart<CronMonthValue>>

A CronMonth or undefined if invalid.

Example

1
parseStringMonth("10"); // 10
2
parseStringMonth("*"); // "*"
3
parseStringMonth("2/6"); // { every: 6, start: 2 }
4
parseStringMonth("?/6"); // { every: 6, start: "?" }
5
parseStringMonth("1,2,3,4"); // [1, 2, 3, 4]
6
parseStringMonth("1-5"); // { from: 1, to: 5 }
7
parseStringMonth("JAN-OCT"); // { from: "JAN", to: "OCT" }
8
parseStringMonth("jan-oct"); // { from: "JAN", to: "OCT" }
9
parseStringMonth("1,2,3,5-7"); // [1, 2, 3, { from: 5, to: 7 }]
10
parseStringMonth("INVALID"); // undefined
11
parseStringMonth("1,2,3,4,INVALID"); // undefined

parseStringMonthValue()

1
function parseStringMonthValue(input: string): Maybe<CronMonthValue>;

Parses a string into a CronMonthValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronMonthValue>

A CronMonthValue or undefined if invalid.

Example

1
parseStringMonthValue("10"); // 10
2
parseStringMonthValue("OCT"); // "OCT"
3
parseStringMonthValue("oct"); // "OCT"
4
parseStringMonthValue("24"); // undefined
5
parseStringMonthValue("IDK"); // undefined

parseStringNearestDayOfMonth()

1
function parseStringNearestDayOfMonth(
2
	source: string,
3
): undefined | CronNearestDayOfMonth;

Parses a string into a CronNearestDayOfMonth.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

undefined | CronNearestDayOfMonth

A CronNearestDayOfMonth or undefined if invalid.

Example

1
parseStringNearestDayOfMonth("2W"); // { nearest: 2 }
2
parseStringNearestDayOfMonth("INVALID"); // undefined

parseStringPart()

1
function parseStringPart(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: StringValueParser<Value>,
5
) => (source: string) => Maybe<CronPart<Value>>;

Parses a string into a CronPart.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` to be used when parsing `CronSteps`.

Returns

Function

Curried function with limit in context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`StringValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	`string`

Returns

Maybe<CronPart<Value>>

Example

1
const parseStringPartSeconds = parseStringPart([0, 59])(
2
	parseStringSecondsValue,
3
);
4

5
parseStringPartSeconds("*"); // "*"
6
parseStringPartSeconds("13,10"); // [13, 10]
7
parseStringPartSeconds("13-10,10"); // [{ from: 13, to: 10 }, 10]
8
parseStringPartSeconds("13/10,10"); // [{ every: 10, start: 13 }, 10]
9
parseStringPartSeconds("?/10,10"); // [{ every: 10, start: "?" }, 10]
10
parseStringPartSeconds("13/10"); // { every: 10, start: 13 }
11
parseStringPartSeconds("?/10"); // { every: 10, start: "?" }
12
parseStringPartSeconds("13-10"); // { from: 13, to: 10 }

parseStringQuartz()

1
function parseStringQuartz(source: string): Maybe<CronQuartz>;

Parses a string into a CronQuartz.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronQuartz>

A Cron or undefined if invalid.

Example

1
parseStringQuartz("* * * * * * *");
2
// {
3
// 	dayOfMonth: "*",
4
// 	dayOfWeek: "*",
5
// 	hours: "*",
6
// 	minutes: "*",
7
// 	month: "*",
8
// 	seconds: "*",
9
// 	year: "*",
10
// }
11

12
parseStringQuartz("* * * * *");
13
// {
14
// 	dayOfMonth: "*",
15
// 	dayOfWeek: "*",
16
// 	hours: "*",
17
// 	minutes: "*",
18
// 	month: "*",
19
// 	seconds: "*",
20
// 	year: "*",
21
// }
22

23
parseStringQuartz("1,2 1,2 1,2 1,2 1,2 1,2 1989,2020");
24
// {
25
// 	dayOfMonth: [1, 2],
26
// 	dayOfWeek: [1, 2],
27
// 	hours: [1, 2],
28
// 	minutes: [1, 2],
29
// 	month: [1, 2],
30
// 	seconds: [1, 2],
31
// 	year: [1989, 2020],
32
// }
33

34
parseStringQuartz("1-2 1-2 1-2 1-2 1-2 1-2 1989-2020");
35
// {
36
// 	dayOfMonth: { from: 1, to: 2 },
37
// 	dayOfWeek: { from: 1, to: 2 },
38
// 	hours: { from: 1, to: 2 },
39
// 	minutes: { from: 1, to: 2 },
40
// 	month: { from: 1, to: 2 },
41
// 	seconds: { from: 1, to: 2 },
42
// 	year: { from: 1989, to: 2020 },
43
// }
44

45
parseStringQuartz("1/2 1/2 1/2 1/2 1/2 1/2 1989/10");
46
// {
47
// 	dayOfMonth: { every: 2, start: 1 },
48
// 	dayOfWeek: { every: 2, start: 1 },
49
// 	hours: { every: 2, start: 1 },
50
// 	minutes: { every: 2, start: 1 },
51
// 	month: { every: 2, start: 1 },
52
// 	seconds: { every: 2, start: 1 },
53
// 	year: { every: 10, start: 1989 },
54
// }
55

56
parseStringQuartz("1-2/3 1-2,3,4 * 2W SEP,OCT 1L ?/10");
57
// {
58
// 	dayOfMonth: { nearest: 2 },
59
// 	dayOfWeek: { last: 1 },
60
// 	hours: "*",
61
// 	minutes: [{ from: 1, to: 2 }, 3, 4],
62
// 	month: ["SEP", "OCT"],
63
// 	seconds: { every: 3, start: { from: 1, to: 2 } },
64
// 	year: { every: 10, start: "?" },
65
// }
66

67
parseStringQuartz("INVALID"); // undefined

parseStringQuartzExpression()

1
function parseStringQuartzExpression(
2
	source: string,
3
):
4
	| undefined
5
	| readonly [string, string, string, string, string, string, string];

Parses given string expression.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

undefined | readonly [string, string, string, string, string, string, string]

An array of 7 elements or undefined if invalid.

Example

1
parseStringQuartzExpression("1 1 1 1 1"); // ["*", "1", "1", "1", "1", "1", "*"]
2
parseStringQuartzExpression("1 1 1 1 1 1989"); // ["*", "1", "1", "1", "1", "1", "1989"]
3
parseStringQuartzExpression("1 1 1 1 1 1"); // ["1", "1", "1", "1", "1", "1", "*"]
4
parseStringQuartzExpression("1 1 1 1 1 1 1"); // ["1", "1", "1", "1", "1", "1", "1"]
5
parseStringQuartzExpression(" 1  1   1    1    1   1  1 "); // ["1", "1", "1", "1", "1", "1", "1"]
6
parseStringQuartzExpression("1 1 1 1 1 1 1 1"); // undefined
7
parseStringQuartzExpression("1 1 1 1"); // undefined

parseStringRange()

1
function parseStringRange<Value>(
2
	parser: StringValueParser<Value>,
3
): (source: string) => Maybe<CronRange<Value>>;

Parses a string into a CronRange.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type	Description
`parser`	`StringValueParser`<`Value`>	`StringValueParser` for `CronRange`.

Returns

Function

Curried function with parser in context.

Parameters

Parameter	Type
`source`	`string`

Returns

Maybe<CronRange<Value>>

Example

1
const parseStringRangeSeconds = parseStringRange(parseStringSecondsValue);
2

3
parseStringRangeSeconds("13-10"); // { from: 13, to: 10 }
4
parseStringRangeSeconds("INVALID"); // undefined

parseStringSeconds()

1
function parseStringSeconds(source: string): Maybe<CronPart<CronSecondsValue>>;

Parses a string into a CronSeconds.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronPart<CronSecondsValue>>

A CronSeconds or undefined if invalid.

Example

1
parseStringSeconds("10"); // 10
2
parseStringSeconds("*"); // "*"
3
parseStringSeconds("2/10"); // { every: 10, start: 2 }
4
parseStringSeconds("?/10"); // { every: 10, start: "?" }
5
parseStringSeconds("1,2,3,4"); // [1, 2, 3, 4]
6
parseStringSeconds("5-10"); // { from: 5, to: 10 }
7
parseStringSeconds("1,2,3,4,5-10"); // [1, 2, 3, 4, { from: 5, to: 10 }]
8
parseStringSeconds("INVALID"); // undefined
9
parseStringSeconds("1,2,3,4,INVALID"); // undefined

parseStringSecondsValue()

1
function parseStringSecondsValue(input: string): Maybe<CronSecondsValue>;

Parses a string into a CronSecondsValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronSecondsValue>

A CronSecondsValue or undefined if invalid.

Example

1
parseStringSecondsValue("10"); // 10
2
parseStringSecondsValue("61"); // undefined

parseStringSpecificDayOfWeek()

1
function parseStringSpecificDayOfWeek(
2
	source: string,
3
): Maybe<CronSpecificDayOfWeek>;

Parses a string into a CronSpecificDayOfWeek.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronSpecificDayOfWeek>

A CronSpecificDayOfWeek or undefined if invalid.

Example

1
parseStringSpecificDayOfWeek("1#5"); // { day: 1, week: 5 }
2
parseStringSpecificDayOfWeek("INVALID"); // undefined

parseStringSteps()

1
function parseStringSteps(
2
	limit: LimitTuple,
3
): <Value>(
4
	parser: StringValueParser<Value>,
5
) => (source: string) => Maybe<CronSteps<Value>>;

Parses a string into a CronSteps.

Parameters

Parameter	Type	Description
`limit`	`LimitTuple`	`LimitTuple` for `CronSteps`.

Returns

Function

Curried function with limit in context.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type
`parser`	`StringValueParser`<`Value`>

Returns

Function

Parameters

Parameter	Type
`source`	`string`

Returns

Maybe<CronSteps<Value>>

Example

1
const parseSecondsSteps = parseStringSteps([0, 59])(parseStringSecondsValue);
2

3
parseSecondsSteps("13/10"); // { every: 10, start: 13 }
4
parseSecondsSteps("13-10/10"); // { every: 10, start: { from: 13, to: 10 } }
5
parseSecondsSteps("?/10"); // { every: 10, start: "?" }
6
parseSecondsSteps("13"); // undefined

parseStringUnix()

1
function parseStringUnix(source: string): Maybe<CronUnix>;

Parses a string into a CronUnix.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronUnix>

A CronUnix or undefined if invalid.

Example

1
parseStringUnix("* * * * *");
2
// {
3
// 	dayOfMonth: "*",
4
// 	dayOfWeek: "*",
5
// 	hours: "*",
6
// 	minutes: "*",
7
// 	month: "*",
8
// }
9

10
parseStringUnix("* * * * *");
11
// {
12
// 	dayOfMonth: "*",
13
// 	dayOfWeek: "*",
14
// 	hours: "*",
15
// 	minutes: "*",
16
// 	month: "*",
17
// }
18

19
parseStringUnix("1,2 1,2 1,2 1,2 1,2");
20
// {
21
// 	dayOfMonth: [1, 2],
22
// 	dayOfWeek: [1, 2],
23
// 	hours: [1, 2],
24
// 	minutes: [1, 2],
25
// 	month: [1, 2],
26
// }
27

28
parseStringUnix("1-2 1-2 1-2 1-2 1-2");
29
// {
30
// 	dayOfMonth: { from: 1, to: 2 },
31
// 	dayOfWeek: { from: 1, to: 2 },
32
// 	hours: { from: 1, to: 2 },
33
// 	minutes: { from: 1, to: 2 },
34
// 	month: { from: 1, to: 2 },
35
// }
36

37
parseStringUnix("1/2 1/2 1/2 1/2 1/2");
38
// {
39
// 	dayOfMonth: { every: 2, start: 1 },
40
// 	dayOfWeek: { every: 2, start: 1 },
41
// 	hours: { every: 2, start: 1 },
42
// 	minutes: { every: 2, start: 1 },
43
// 	month: { every: 2, start: 1 },
44
// }
45

46
parseStringUnix("1-2,3,4 * 2W SEP,OCT 1L");
47
// {
48
// 	dayOfMonth: { nearest: 2 },
49
// 	dayOfWeek: { last: 1 },
50
// 	hours: "*",
51
// 	minutes: [{ from: 1, to: 2 }, 3, 4],
52
// 	month: ["SEP", "OCT"],
53
// }
54

55
parseStringUnix("INVALID"); // undefined

parseStringUnixExpression()

1
function parseStringUnixExpression(
2
	source: string,
3
): undefined | readonly [string, string, string, string, string];

Parses given expression or undefined if invalid.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

undefined | readonly [string, string, string, string, string]

An array of 5 elements or undefined if invalid.

Example

1
parseStringUnixExpression("1 1 1 1 1"); // ["1", "1", "1", "1", "1"]
2
parseStringUnixExpression(" 1   1    1    1   1 "); // ["1", "1", "1", "1", "1"]
3
parseStringUnixExpression("1 1 1 1 1 1"); // undefined
4
parseStringUnixExpression("1 1 1 1"); // undefined

parseStringYear()

1
function parseStringYear(source: string): Maybe<CronPart<CronYearValue>>;

Parses a string into a CronYear.

Parameters

Parameter	Type	Description
`source`	`string`	string to be parsed.

Returns

Maybe<CronPart<CronYearValue>>

A CronYear or undefined if invalid.

Example

1
parseStringYear("1989"); // 1989,
2
parseStringYear("*"); // "*",
3
parseStringYear("1989/10"); // { every: 10, start: 1989 },
4
parseStringYear("?/10"); // { every: 10, start: "?" },
5
parseStringYear("1989,1991,2015,2020"); // [1989, 1991, 2015, 2020],
6
parseStringYear("1989-2020"); // { from: 1989, to: 2020 },
7
parseStringYear("1989,1991,2015,2020,1989-2020"); // [1989, 1991, 2015, 2020, { from: 1989, to: 2020 }],
8
parseStringYear("INVALID"); // undefined,
9
parseStringYear("1,2,3,4,INVALID"); // undefined,

parseStringYearValue()

1
function parseStringYearValue(input: string): Maybe<CronYearValue>;

Parses a string into a CronYearValue.

Parameters

Parameter	Type
`input`	`string`

Returns

Maybe<CronYearValue>

A CronYearValue or undefined if invalid.

Example

1
parseStringYearValue("1989"); // 1989
2
parseStringYearValue("3000"); // undefined

Predicates

isCronDayOfMonthValue()

1
function isCronDayOfMonthValue(value: unknown): value is CronDayOfMonthValue;

Check if given is CronDayOfMonthValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronDayOfMonthValue

Returns true if is CronDayOfMonthValue, false otherwise.

Example

1
isCronDayOfMonthValue(13); // true
2
isCronDayOfMonthValue(50); // false

isCronDayOfWeekValue()

1
function isCronDayOfWeekValue(value: unknown): value is CronDayOfWeekValue;

Check if given is CronDayOfWeekValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronDayOfWeekValue

Returns true if is CronDayOfWeekValue, false otherwise.

Example

1
isCronDayOfWeekValue(5); // true
2
isCronDayOfWeekValue("FRI"); // true
3
isCronDayOfWeekValue("fri"); // true
4
isCronDayOfWeekValue("FRIDAY"); // false
5
isCronDayOfWeekValue(10); // false
6
isCronDayOfWeekValue("INVALID"); // false

isCronDayOfWeekValueNumber()

1
function isCronDayOfWeekValueNumber(
2
	value: unknown,
3
): value is CronDayOfWeekValueNumber;

Check if given is CronDayOfWeekValueNumber.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronDayOfWeekValueNumber

Returns true if is CronDayOfWeekValueNumber, false otherwise.

Example

1
isCronDayOfWeekValueNumber(5); // true
2
isCronDayOfWeekValueNumber(10); // false
3
isCronDayOfWeekValueNumber("INVALID"); // false

isCronDayOfWeekValueString()

1
function isCronDayOfWeekValueString(
2
	value: unknown,
3
): value is CronDayOfWeekValueString;

Check if given is CronDayOfWeekValueString.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronDayOfWeekValueString

Returns true if is CronDayOfWeekValueString, false otherwise.

Example

1
isCronDayOfWeekValueString("FRI"); // true
2
isCronDayOfWeekValueString("fri"); // true
3
isCronDayOfWeekValueString("FRIDAY"); // false

isCronEvery()

1
function isCronEvery(value: unknown): value is "*";

Check if given is CronEvery.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is "*"

Returns true if is CronEvery, false otherwise.

Example

1
isCronEvery("*"); // true
2
isCronEvery("INVALID"); // false

isCronHoursValue()

1
function isCronHoursValue(value: unknown): value is CronHoursValue;

Check if given is CronHoursValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronHoursValue

Returns true if is CronHoursValue, false otherwise.

Example

1
isCronHoursValue(12); // true
2
isCronHoursValue(50); // false

isCronLast()

1
function isCronLast(value: unknown): value is "L";

Check if given is CronLast.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is "L"

Returns true if is CronLast, false otherwise.

Example

1
isCronLast("L"); // true
2
isCronLast("INVALID"); // false

isCronLastValue()

1
function isCronLastValue(value: unknown): value is CronLastValue;

Check if given is CronLastValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronLastValue

Returns true if is CronLastValue, false otherwise.

Example

1
isCronLastValue({ last: 7 }); // true
2
isCronLastValue({ last: 100 }); // false

isCronList()

1
function isCronList<Value>(value: unknown): value is CronList<Value>;

Check if given is CronList.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronList<Value>

Returns true if is CronList, false otherwise.

Example

1
isCronList(["value", "value", "value"]); // true

isCronMinutesValue()

1
function isCronMinutesValue(value: unknown): value is CronMinutesValue;

Check if given is CronMinutesValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronMinutesValue

Returns true if is CronMinutesValue, false otherwise.

Example

1
isCronMinutesValue(30); // true
2
isCronMinutesValue(80); // false

isCronMonthValue()

1
function isCronMonthValue(value: unknown): value is CronMonthValue;

Check if given is CronMonthValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronMonthValue

Returns true if is CronMonthValue, false otherwise.

Example

1
isCronMonthValue(10); // true
2
isCronMonthValue("OCT"); // true
3
isCronMonthValue("oct"); // true
4
isCronMonthValue("OCTOBER"); // false
5
isCronMonthValue(50); // false
6
isCronMonthValue("INVALID"); // false

isCronMonthValueNumber()

1
function isCronMonthValueNumber(value: unknown): value is CronMonthValueNumber;

Check if given is CronMonthValueNumber.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronMonthValueNumber

Returns true if is CronMonthValueNumber, false otherwise.

Example

1
isCronMonthValueNumber(10); // true
2
isCronMonthValueNumber(50); // false

isCronMonthValueString()

1
function isCronMonthValueString(value: unknown): value is CronMonthValueString;

Check if given is CronMonthValueString.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronMonthValueString

Returns true if is CronMonthValueString, false otherwise.

Example

1
isCronMonthValueString("OCT"); // true
2
isCronMonthValueString("oct"); // true
3
isCronMonthValueString("INVALID"); // false

isCronNearestDayOfMonth()

1
function isCronNearestDayOfMonth(
2
	value: unknown,
3
): value is CronNearestDayOfMonth;

Check if given is CronNearestDayOfMonth.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronNearestDayOfMonth

Returns true if is CronNearestDayOfMonth, false otherwise.

Example

1
isCronNearestDayOfMonth({ nearest: 10 }); // true
2
isCronNearestDayOfMonth({ nearest: 100 }); // false

isCronRange()

1
function isCronRange<Value>(value: unknown): value is CronRange<Value>;

Check if given is CronRange.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronRange<Value>

Returns true if is CronRange, false otherwise.

Example

1
isCronRange({ from: 10, to: 20 }); // true
2
isCronRange({}); // false

isCronSpecificDayOfWeek()

1
function isCronSpecificDayOfWeek(
2
	value: unknown,
3
): value is CronSpecificDayOfWeek;

Check if given is CronSpecificDayOfWeek.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronSpecificDayOfWeek

Returns true if is CronSpecificDayOfWeek, false otherwise.

Example

1
isCronSpecificDayOfWeek({ day: 1, week: 5 }); // true
2
isCronSpecificDayOfWeek({ day: 9, week: 9 }); // false

isCronStartOrBlank()

1
function isCronStartOrBlank(value: unknown): value is "?";

Check if given is CronStartOrBlank.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is "?"

Returns true if is CronStartOrBlank, false otherwise.

Example

1
isCronStartOrBlank("?"); // true
2
isCronStartOrBlank("INVALID"); // false

isCronSteps()

1
function isCronSteps<Value>(value: unknown): value is CronSteps<Value>;

Check if given is CronSteps.

Type parameters

Type parameter
`Value`

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronSteps<Value>

Returns true if is CronSteps, false otherwise.

Example

1
isCronSteps({ every: 10, start: "value" }); // true
2
isCronSteps({ every: "invalid" }); // false

isCronWeekValue()

1
function isCronWeekValue(value: unknown): value is CronWeekValue;

Check if given is CronWeekValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronWeekValue

Returns true if is CronWeekValue, false otherwise.

Example

1
isCronWeekValue(2); // true
2
isCronWeekValue(8); // false

isCronYearValue()

1
function isCronYearValue(value: unknown): value is CronYearValue;

Check if given is CronYearValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is CronYearValue

Returns true if is CronYearValue, false otherwise.

Example

1
isCronYearValue(1989); // true
2
isCronYearValue(3000); // false

isStringDayOfMonthValue()

1
function isStringDayOfMonthValue(value: unknown): value is string;

Check if given is a string representing a CronDayOfMonthValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronDayOfMonthValue, false otherwise.

Example

1
isStringDayOfMonthValue("13"); // true
2
isStringDayOfMonthValue("50"); // false

isStringDayOfWeekValue()

1
function isStringDayOfWeekValue(value: unknown): boolean;

Check if given is a string representing a CronDayOfWeekValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

boolean

Returns true if is a string representing a CronDayOfWeekValue, false otherwise.

Example

1
isStringDayOfWeekValue("5"); // true
2
isStringDayOfWeekValue("FRI"); // true
3
isStringDayOfWeekValue("fri"); // true
4
isStringDayOfWeekValue("FRIDAY"); // false
5
isStringDayOfWeekValue("10"); // false
6
isStringDayOfWeekValue("INVALID"); // false

isStringDayOfWeekValueNumber()

1
function isStringDayOfWeekValueNumber(value: unknown): value is string;

Check if given is a string representing a CronDayOfWeekValueNumber.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronDayOfWeekValueNumber, false otherwise.

Example

1
isStringDayOfWeekValueNumber("5"); // true
2
isStringDayOfWeekValueNumber("10"); // false

isStringHoursValue()

1
function isStringHoursValue(value: unknown): value is string;

Check if given is a string representing a CronHoursValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronHoursValue, false otherwise.

Example

1
isStringHoursValue("12"); // true
2
isStringHoursValue("50"); // false

isStringLastValue()

1
function isStringLastValue(value: unknown): value is string;

Check if given is a string representing a CronLastValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronLastValue, false otherwise.

Example

1
isStringLastValue("7L"); // true
2
isStringLastValue("7l"); // true
3
isStringLastValue("100L"); // false
4
isStringLastValue("INVALID"); // false

isStringList()

1
function isStringList(value: unknown): value is string;

Check if given is a string representing a CronList.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronList, false otherwise.

Example

1
isStringList("value,value,value"); // true
2
isStringList("value"); // false

isStringMinutesValue()

1
function isStringMinutesValue(value: unknown): value is string;

Check if given is a string representing a CronMinutesValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronMinutesValue, false otherwise.

Example

1
isStringMinutesValue("30"); // true
2
isStringMinutesValue("80"); // false

isStringMonthValue()

1
function isStringMonthValue(value: unknown): boolean;

Check if given is a string representing a CronMonthValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

boolean

Returns true if is a string representing a CronMonthValue, false otherwise.

Example

1
isStringMonthValue("10"); // true
2
isStringMonthValue("OCT"); // true
3
isStringMonthValue("oct"); // true
4
isStringMonthValue("OCTOBER"); // false
5
isStringMonthValue("50"); // false
6
isStringMonthValue("INVALID"); // false

isStringMonthValueNumber()

1
function isStringMonthValueNumber(value: unknown): value is string;

Check if given is a string representing a CronMonthValueNumber.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronMonthValueNumber, false otherwise.

Example

1
isStringMonthValueNumber("10"); // true
2
isStringMonthValueNumber("50"); // false

isStringNearestDayOfMonth()

1
function isStringNearestDayOfMonth(value: unknown): value is string;

Check if given is a string representing a CronNearestDayOfMonth.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronNearestDayOfMonth, false otherwise.

Example

1
isStringNearestDayOfMonth("10W"); // true
2
isStringNearestDayOfMonth("10w"); // true
3
isStringNearestDayOfMonth("100w"); // false
4
isStringNearestDayOfMonth("INVALID"); // false

isStringRange()

1
function isStringRange(value: unknown): value is string;

Check if given is a string representing a CronRange.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronRange, false otherwise.

Example

1
isStringRange("10-20"); // true
2
isStringRange("13-10-1989"); // false
3
isStringRange("value"); // false

isStringSecondsValue()

1
function isStringSecondsValue(value: unknown): value is string;

Check if given is a string representing a CronSecondsValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronSecondsValue, false otherwise.

Example

1
isStringSecondsValue("30"); // true
2
isStringSecondsValue("80"); // false

isStringSpecificDayOfWeek()

1
function isStringSpecificDayOfWeek(value: unknown): value is string;

Check if given is a string representing a CronSpecificDayOfWeek.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronSpecificDayOfWeek, false otherwise.

Example

1
isStringSpecificDayOfWeek("1#5"); // true
2
isStringSpecificDayOfWeek("9#9"); // false

isStringSteps()

1
function isStringSteps(value: unknown): value is string;

Check if given is a string representing a CronSteps.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronSteps, false otherwise.

Example

1
isStringSteps("value/value"); // true
2
isStringSteps("value/value/value"); // false
3
isStringSteps("value"); // false

isStringWeekValue()

1
function isStringWeekValue(value: unknown): value is string;

Check if given is a string representing a CronWeekValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronWeekValue, false otherwise.

Example

1
isStringWeekValue("2"); // true
2
isStringWeekValue("8"); // false

isStringYearValue()

1
function isStringYearValue(value: unknown): value is string;

Check if given is a string representing a CronYearValue.

Parameters

Parameter	Type	Description
`value`	`unknown`	Value to check.

Returns

value is string

Returns true if is a string representing a CronYearValue, false otherwise.

Example

1
isStringYearValue("1989"); // true
2
isStringYearValue("3000"); // false

stringIncludesOnlyOnce()

1
function stringIncludesOnlyOnce(
2
	search: string,
3
): (value: unknown) => value is string;

Checks if given search value appears just onces in given value.

Parameters

Parameter	Type	Description
`search`	`string`	Value to search.

Returns

Function

Curried function with search in context.

Parameters

Parameter	Type
`value`	`unknown`

Returns

value is string

Example

1
const includesCommaOnce = stringIncludesOnlyOnce(",");
2
includesCommaOnce("value,value"); // true
3
includesCommaOnce("value,value,value"); // false
4
includesCommaOnce("value"); // false