🔧 remove no-undef rule, using TS for that.

🎨 improve @coven/cron code and tests.
🎨 improve @coven/expression code and tests.

Author: loucyx

@coven/cron/CronString.ts

@@ -1,4 +1,4 @@
 /**
- * String cron expression.
+ * String cron expression (5 fields separated by spaces).
  */
 export type CronString = `${string} ${string} ${string} ${string} ${string}`;

@coven/cron/README.md

@@ -5,6 +5,23 @@
 
 ⏳ A fantastic cron parser and constructor.
 
+This library is the fastest, smallest and safest cron expression parser out
+there. This is because it uses a regular expression (built with
+[`@coven/expression`](https://jsr.io/@coven/expression)) to parse strings into a
+consumable object, and the parse back is done by really quick curried functions
+and generators.
+
+It also includes a `nextDate` util that given a `Date` and a valid cron
+expression, will return the next matching date. It does validations beforehand
+so no "Invalid Date" errors are returned.
+
+As all [Coven Engineering](https://coven.engineering) libraries, it has 100%
+test coverage and it's built in top of modern tech compatible with all
+JavaScript runtimes.
+
+Only known limitation is it only accepts valid standard unix cron expressions,
+so cron quartz is not supported.
+
 ## Example
 
 ```typescript
@@ -27,7 +44,7 @@ stringify(cron); // "1-2,3,4 * 2 8,9 1"
 stringify({ hours: 13 }); // "* 13 * * *"
 
 // Only parses with valid dates:
-parse("* * 31 2 *"); // undefined because 2/31 is invalid
+parse("* * 31 2 *"); // undefined because 31 of February is invalid
 ```
 
 ## Other links

@coven/cron/deno.json

@@ -1,5 +1,5 @@
 {
 	"name": "@coven/cron",
-	"version": "0.0.5",
+	"version": "0.1.0",
 	"exports": "./mod.ts"
 }

@coven/cron/isListField.ts

@@ -1,7 +1,16 @@
+import { every } from "@coven/iterables";
 import { isArray, isNumber } from "@coven/predicates";
 import type { Field } from "./Field.ts";
-import type { ListField } from "./ListField.ts";
 import { isRangeField } from "./isRangeField.ts";
+import type { ListField } from "./ListField.ts";
+import type { ValueOrRangeField } from "./ValueOrRangeField.ts";
+
+const everyIsNumberOrRangeField = every<
+	ValueOrRangeField<number>,
+	ValueOrRangeField<number>
+>((
+	item,
+) => isNumber(item) || isRangeField(item));
 
 /**
  * Predicate checking if given value is a {@link ListField}.
@@ -11,4 +20,4 @@ import { isRangeField } from "./isRangeField.ts";
  */
 export const isListField = (value: Field<number>): value is ListField<number> =>
 	isArray(value) &&
-	value.every((item) => isNumber(item) || isRangeField(item));
+	everyIsNumberOrRangeField(value);

@coven/cron/isListString.ts

@@ -1,3 +1,4 @@
+import { includes } from "@coven/iterables";
 import type { ListString } from "./ListString.ts";
 import { LIST_EXPRESSION_SEPARATOR_TOKEN } from "./tokens.ts";
 
@@ -7,5 +8,6 @@ import { LIST_EXPRESSION_SEPARATOR_TOKEN } from "./tokens.ts";
  * @see {@link ListString}
  * @see {@link LIST_EXPRESSION_SEPARATOR_TOKEN}
  */
-export const isListString = (value: string): value is ListString =>
-	value.includes(LIST_EXPRESSION_SEPARATOR_TOKEN);
+export const isListString = includes(
+	LIST_EXPRESSION_SEPARATOR_TOKEN,
+) as (value: Iterable<unknown>) => value is ListString;

@coven/cron/isRangeField.ts

@@ -2,15 +2,18 @@ import { has, isNumber, isObject } from "@coven/predicates";
 import type { RangeField } from "./RangeField.ts";
 import { FROM_NAME, TO_NAME } from "./rangeFieldNames.ts";
 
+const hasFrom = has(FROM_NAME);
+const hasTo = has(TO_NAME);
+
 /**
  * Predicate checking if given value is a cron object range ({@link RangeField}).
  *
  * @see {@link RangeField}
  */
 export const isRangeField = (value: unknown): value is RangeField<number> =>
 	isObject(value) &&
-	has(FROM_NAME)(value) &&
-	has(TO_NAME)(value) &&
+	hasFrom(value) &&
+	hasTo(value) &&
 	isNumber(value[FROM_NAME]) &&
 	isNumber(value[TO_NAME]) &&
 	value[FROM_NAME] < value[TO_NAME];

@coven/cron/nextDates.ts

@@ -1,5 +1,5 @@
 import { EMPTY_STRING } from "@coven/constants";
-import { build, DIGIT, escape, quantity } from "@coven/expression";
+import { buildUnicode, DIGIT, escape, join, quantity } from "@coven/expression";
 import { iteratorFunctionToIterableIterator } from "@coven/iterables";
 import { isString, isUndefined } from "@coven/predicates";
 import type { CronObject } from "./CronObject.ts";
@@ -8,6 +8,8 @@ import { dateInCron } from "./dateInCron.ts";
 import { parse } from "./parse.ts";
 import { stringify } from "./stringify.ts";
 
+const dateReplace = join(quantity(2)(DIGIT), escape("."), quantity(3)(DIGIT));
+
 /**
  * Get next ISO date iterator for the given date and the given cron expression.
  *
@@ -36,11 +38,7 @@ export const nextDates = (
 				date
 					.toISOString()
 					.replace(
-						build()(
-							quantity(2)(DIGIT),
-							escape("."),
-							quantity(3)(DIGIT),
-						),
+						buildUnicode(dateReplace),
 						"00.000",
 					),
 			);

@coven/cron/normalizeAliases.ts

@@ -3,6 +3,8 @@ import type { KeyOf, ReadonlyArray } from "@coven/types";
 import type { FieldString } from "./FieldString.ts";
 import { normalizeMap } from "./normalizeMap.ts";
 
+const buildGIU = build("giu");
+
 /**
  * Normalizes day and month 3 letter aliases into their number counterparts.
  *
@@ -15,7 +17,7 @@ import { normalizeMap } from "./normalizeMap.ts";
  */
 export const normalizeAliases = (expression: string): FieldString =>
 	expression.replaceAll(
-		build("giu")(
+		buildGIU(
 			or(
 				...(Object.keys(normalizeMap) as ReadonlyArray<
 					KeyOf<typeof normalizeMap>

@coven/cron/parse.ts

@@ -8,6 +8,8 @@ import { cronRegExp } from "./cronRegExp.ts";
 import { normalizeAliases } from "./normalizeAliases.ts";
 import { parseFieldTuplesMap } from "./parseFieldTuplesMap.ts";
 
+const buildIU = build("iu");
+
 /**
  * Parses a cron expression into an object representation.
  *
@@ -29,7 +31,7 @@ import { parseFieldTuplesMap } from "./parseFieldTuplesMap.ts";
 export const parse = (expression: CronString): Maybe<CronObject> => {
 	const entries = parseFieldTuplesMap(
 		objectToEntries(
-			(build("iu")(cronRegExp).exec(normalizeAliases(expression))
+			(buildIU(cronRegExp).exec(normalizeAliases(expression))
 				?.groups ?? EMPTY_OBJECT) as ReadonlyRecord<
 					KeyOf<CronObject>,
 					string

@coven/cron/parseNumberTest.ts

@@ -1,5 +1,5 @@
 import {
-	build,
+	buildUnicode,
 	DIGIT,
 	END,
 	group,
@@ -27,7 +27,7 @@ import { paddedRegExp } from "./paddedRegExp.ts";
  * @see {@link paddedRegExp}
  */
 export const parseNumberTest: (text: string) => boolean = test(
-	build("u")(
+	buildUnicode(
 		START,
 		group(or(paddedRegExp(DIGIT), join(set(range(1)(5)), DIGIT))),
 		END,

@coven/cron/rangeStringTest.ts

@@ -1,12 +1,12 @@
-import { build, DIGIT, END, quantity, START } from "@coven/expression";
+import { buildUnicode, DIGIT, END, quantity, START } from "@coven/expression";
 import { test } from "@coven/predicates";
 import { RANGE_EXPRESSION_SEPARATOR_TOKEN } from "./tokens.ts";
 
 /**
  * Regular expression to test if given string is a range.
  */
 export const rangeStringTest: (text: string) => boolean = test(
-	build("u")(
+	buildUnicode(
 		START,
 		quantity("1,2")(DIGIT),
 		RANGE_EXPRESSION_SEPARATOR_TOKEN,

@coven/expression/build.ts

@@ -11,6 +11,15 @@ import { join } from "./join.ts";
 /**
  * Builds a `RegExp` with required `u` flag and strongly typed source (using
  * {@link join}).
+ *
+ * @example
+ * ```typescript
+ * build("ui")(group(or(13, "coven"))); // /(?:13|coven)/ui
+ * build()(group(or(13, "coven"))); // /(?:13|coven)/u -> use the buildUnicode alias
+ * ```
+ * @template Flags Regular expression flags ("u" must be included always).
+ * @param flags Regular expression flags ("u" by default).
+ * @returns Curried function with `flags` set in context.
  */
 export const build = <Flags extends RegularExpressionFlags = "u">(
 	flags: Flags | "u" = "u",

@coven/expression/buildUnicode.ts

@@ -0,0 +1,28 @@
+import type {
+	EmptyString,
+	ReadonlyArray,
+	Replace,
+	Stringable,
+	StringJoin,
+} from "@coven/types";
+import { build } from "./build.ts";
+
+/**
+ * Builds an unicode `RegExp` (alias for `build()`).
+ *
+ * @example
+ * ```typescript
+ * buildUnicode(group(or(13, "coven"))); // /(?:13|coven)/u
+ * ```
+ * @param tokens String tokens to be used as the RegExp source.
+ * @returns Regular Expression with the given tokens and the unicode flag.
+ */
+export const buildUnicode: <const Tokens extends ReadonlyArray<Stringable>>(
+	...tokens: Tokens
+) => Replace<
+	RegExp,
+	{
+		readonly flags: "u";
+		readonly source: StringJoin<Tokens, EmptyString>;
+	}
+> = build();

@coven/expression/deno.json

@@ -1,5 +1,5 @@
 {
 	"name": "@coven/expression",
-	"version": "0.0.6",
+	"version": "0.1.0",
 	"exports": "./mod.ts"
 }

@coven/expression/mod.ts

@@ -1,5 +1,6 @@
 export { allow } from "./allow.ts";
 export { build } from "./build.ts";
+export { buildUnicode } from "./buildUnicode.ts";
 export { capture } from "./capture.ts";
 export { capturedNumber } from "./capturedNumber.ts";
 export { captureNamed } from "./captureNamed.ts";

@coven/iterables/getIterator.ts

@@ -14,5 +14,4 @@
  */
 export const getIterator = <Item = unknown>(
 	iterable: Iterable<Item, unknown, undefined>,
-	// deno-lint-ignore no-undef
 ): IteratorObject<Item, undefined, unknown> => Iterator.from(iterable);

@coven/iterables/objectToEntries.ts

@@ -20,7 +20,6 @@ export const objectToEntries = <Key extends PropertyKey, Value>(
 	iteratorFunctionToIterableIterator(function* (): Generator<
 		Entry<Key extends number ? `${Key}` : Key, Value>
 	> {
-		// deno-lint-ignore no-undef
 		yield* Iterator.from(Reflect.ownKeys(input)).map((key) => [
 			key as Key extends number ? `${Key}` : Key,
 			input[key as keyof ReadonlyRecord<Key, Value>],

deno.json

@@ -113,7 +113,6 @@
 				"no-this-before-super",
 				"no-throw-literal",
 				"no-top-level-await",
-				"no-undef",
 				"no-unreachable",
 				"no-unsafe-finally",
 				"no-unsafe-negation",

tests/@coven/cron/compareField.test.ts

@@ -1,34 +1,25 @@
 import { compareField } from "@coven/cron";
-import { assertStrictEquals } from "@std/assert";
+import { assert, assertFalse } from "@std/assert";
 
-Deno.test("Two equal values return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, 13), true));
+Deno.test("Two equal values returns true", () => assert(compareField(13, 13)));
 
-Deno.test("Two different values return false", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, 99), false));
+Deno.test("Two different values returns false", () =>
+	assertFalse(compareField(13, 99)));
 
-Deno.test("Value and a range that contains it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, { from: 0, to: 99 }), true));
+Deno.test("Value and a range that contains it returns true", () =>
+	assert(compareField(13, { from: 0, to: 99 })));
 
-Deno.test("Value and a range that doesn't contain it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, { from: 0, to: 10 }), false));
+Deno.test("Value and a range that doesn't contain it returns true", () =>
+	assertFalse(compareField(13, { from: 0, to: 10 })));
 
-Deno.test("Value and a list that contains it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, [10, 13]), true));
+Deno.test("Value and a list that contains it returns true", () =>
+	assert(compareField(13, [10, 13])));
 
-Deno.test("Value and a list that doesn't contain it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, [10, 12]), false));
+Deno.test("Value and a list that doesn't contain it returns true", () =>
+	assertFalse(compareField(13, [10, 12])));
 
-Deno.test("Value and a list with a range that contains it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, [10, { from: 11, to: 99 }]), true));
+Deno.test("Value and a list with a range that contains it returns true", () =>
+	assert(compareField(13, [10, { from: 11, to: 99 }])));
 
-Deno.test("Value and a list with a range that doesn't contain it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareField(13, [5, { from: 10, to: 12 }]), false));
+Deno.test("Value and a list with a range that doesn't contain it returns true", () =>
+	assertFalse(compareField(13, [5, { from: 10, to: 12 }])));

tests/@coven/cron/compareRangeOrValue.test.ts

@@ -1,18 +1,14 @@
 import { compareRangeOrValue } from "@coven/cron";
-import { assertStrictEquals } from "@std/assert";
+import { assert, assertFalse } from "@std/assert";
 
-Deno.test("Two equal values return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareRangeOrValue(13)(13), true));
+Deno.test("Two equal values returns true", () =>
+	assert(compareRangeOrValue(13)(13)));
 
-Deno.test("Two different values return false", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareRangeOrValue(13)(99), false));
+Deno.test("Two different values returns false", () =>
+	assertFalse(compareRangeOrValue(13)(99)));
 
-Deno.test("Value and a range that contains it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareRangeOrValue(13)({ from: 0, to: 99 }), true));
+Deno.test("Value and a range that contains it returns true", () =>
+	assert(compareRangeOrValue(13)({ from: 0, to: 99 })));
 
-Deno.test("Value and a range that doesn't contain it return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(compareRangeOrValue(13)({ from: 0, to: 10 }), false));
+Deno.test("Value and a range that doesn't contain it returns false", () =>
+	assertFalse(compareRangeOrValue(13)({ from: 0, to: 10 })));

tests/@coven/cron/dateInCron.test.ts

@@ -1,5 +1,5 @@
 import { dateInCron } from "@coven/cron";
-import { assertStrictEquals } from "@std/assert";
+import { assert, assertFalse } from "@std/assert";
 
 const dateInCronTest = dateInCron({
 	dayOfMonth: 5,
@@ -9,16 +9,8 @@ const dateInCronTest = dateInCron({
 	month: 5,
 });
 
-Deno.test("a date inside the cron expression return true", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(
-		dateInCronTest(new Date("1989-05-05T05:05:00.000")),
-		true,
-	));
+Deno.test("Date inside the cron expression returns true", () =>
+	assert(dateInCronTest(new Date("1989-05-05T05:05:00.000"))));
 
-Deno.test("a date outside the cron expression return false", () =>
-	// deno-lint-ignore no-boolean-literal-for-arguments
-	assertStrictEquals(
-		dateInCronTest(new Date("2024-05-05T05:05:00.000")),
-		false,
-	));
+Deno.test("Date outside the cron expression returns false", () =>
+	assertFalse(dateInCronTest(new Date("2024-05-05T05:05:00.000"))));