chronolizer 0.1.0 → 0.3.0

package/dist/ast/normalize.mjs

@@ -0,0 +1,34 @@
+import { Shift } from "./schemas.mjs";
+import { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "./constructors.mjs";
+import { Match, Schema } from "effect";
+//#region src/ast/normalize.ts
+const isShift = Schema.is(Shift);
+const normalizeInstant = (expression) => Match.valueTags(expression, {
+	Now: () => now(),
+	DateLiteral: (literal) => dateLiteral(literal.value),
+	StartOf: (operation) => startOf(normalizeInstant(operation.base), operation.unit),
+	Shift: (operation) => {
+		const base = normalizeInstant(operation.base);
+		if (operation.amount === 0) return base;
+		if (isShift(base) && base.unit === operation.unit) {
+			const amount = base.amount + operation.amount;
+			if (Number.isSafeInteger(amount)) return normalizeInstant(shift(base.base, amount, operation.unit));
+		}
+		return shift(base, operation.amount, operation.unit);
+	}
+});
+const normalizeLower = (bound) => Match.valueTags(bound, {
+	GreaterThan: (value) => greaterThan(normalizeInstant(value.value)),
+	GreaterThanOrEqual: (value) => greaterThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeUpper = (bound) => Match.valueTags(bound, {
+	LessThan: (value) => lessThan(normalizeInstant(value.value)),
+	LessThanOrEqual: (value) => lessThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeRange = (range) => {
+	if (range.lower !== void 0 && range.upper !== void 0) return boundedRange(normalizeLower(range.lower), normalizeUpper(range.upper));
+	if (range.lower !== void 0) return lowerOpenRange(normalizeLower(range.lower));
+	return upperOpenRange(normalizeUpper(range.upper));
+};
+//#endregion
+export { normalizeInstant, normalizeRange };

package/dist/ast/schemas.d.mts

@@ -0,0 +1,80 @@
+import { Schema } from "effect";
+//#region src/ast/schemas.d.ts
+declare const Unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+type Unit = typeof Unit.Type;
+declare const daysInMonth: (year: number, month: number) => number;
+declare const isIsoDate: (value: string) => boolean;
+declare const IsoDate: Schema.String;
+type IsoDate = typeof IsoDate.Type;
+declare const Now_base: Schema.Class<Now, Schema.TaggedStruct<"Now", {}>, {}>;
+declare class Now extends Now_base {}
+declare const DateLiteral_base: Schema.Class<DateLiteral, Schema.TaggedStruct<"DateLiteral", {
+  readonly value: Schema.String;
+}>, {}>;
+declare class DateLiteral extends DateLiteral_base {}
+declare const Shift_base: Schema.Class<Shift, Schema.TaggedStruct<"Shift", {
+  readonly base: Schema.suspend<Schema.Codec<InstantExpr, InstantExpr, never, never>>;
+  readonly amount: Schema.Int;
+  readonly unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+}>, {}>;
+declare class Shift extends Shift_base {}
+declare const StartOf_base: Schema.Class<StartOf, Schema.TaggedStruct<"StartOf", {
+  readonly base: Schema.suspend<Schema.Codec<InstantExpr, InstantExpr, never, never>>;
+  readonly unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+}>, {}>;
+declare class StartOf extends StartOf_base {}
+type InstantExpr = Now | DateLiteral | Shift | StartOf;
+declare const InstantExpr: Schema.Codec<InstantExpr>;
+declare const GreaterThan: Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const GreaterThanOrEqual: Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LessThan: Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LessThanOrEqual: Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LowerBound: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>]>;
+type LowerBound = typeof LowerBound.Type;
+declare const UpperBound: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>, Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>]>;
+type UpperBound = typeof UpperBound.Type;
+declare const DateRangeExpr: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.optionalKey<Schema.Never>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.optionalKey<Schema.Never>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>]>;
+type DateRangeExpr = typeof DateRangeExpr.Type;
+//#endregion
+export { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate };

package/dist/ast/schemas.mjs

@@ -0,0 +1,65 @@
+import { Match, Option, Schema, String } from "effect";
+//#region src/ast/schemas.ts
+const Unit = Schema.Literals([
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year"
+]);
+const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+const daysInMonth = (year, month) => Match.value(month).pipe(Match.when(2, () => isLeapYear(year) ? 29 : 28), Match.when(Match.is(4, 6, 9, 11), () => 30), Match.orElse(() => 31));
+const isIsoDate = (value) => {
+	if (Option.isNone(String.match(/^\d{4}-\d{2}-\d{2}$/)(value))) return false;
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
+};
+const IsoDate = Schema.String.check(Schema.makeFilter(isIsoDate, { expected: "an ISO calendar date (YYYY-MM-DD)" })).annotate({ identifier: "IsoDate" });
+var Now = class extends Schema.TaggedClass()("Now", {}) {};
+var DateLiteral = class extends Schema.TaggedClass()("DateLiteral", { value: IsoDate }) {};
+const ShiftAmount = Schema.Int.check(Schema.isBetween({
+	minimum: Number.MIN_SAFE_INTEGER,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+var Shift = class extends Schema.TaggedClass()("Shift", {
+	base: Schema.suspend(() => InstantExpr),
+	amount: ShiftAmount,
+	unit: Unit
+}) {};
+var StartOf = class extends Schema.TaggedClass()("StartOf", {
+	base: Schema.suspend(() => InstantExpr),
+	unit: Unit
+}) {};
+const InstantExpr = Schema.suspend(() => Schema.Union([
+	Now,
+	DateLiteral,
+	Shift,
+	StartOf
+])).annotate({ identifier: "InstantExpr" });
+const GreaterThan = Schema.TaggedStruct("GreaterThan", { value: InstantExpr });
+const GreaterThanOrEqual = Schema.TaggedStruct("GreaterThanOrEqual", { value: InstantExpr });
+const LessThan = Schema.TaggedStruct("LessThan", { value: InstantExpr });
+const LessThanOrEqual = Schema.TaggedStruct("LessThanOrEqual", { value: InstantExpr });
+const LowerBound = Schema.Union([GreaterThan, GreaterThanOrEqual]);
+const UpperBound = Schema.Union([LessThan, LessThanOrEqual]);
+const BoundedDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: UpperBound
+});
+const LowerOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: Schema.optionalKey(Schema.Never)
+});
+const UpperOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: Schema.optionalKey(Schema.Never),
+	upper: UpperBound
+});
+const DateRangeExpr = Schema.Union([
+	BoundedDateRange,
+	LowerOpenDateRange,
+	UpperOpenDateRange
+]).annotate({ identifier: "DateRangeExpr" });
+//#endregion
+export { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate };

package/dist/filter/codec.d.mts

@@ -0,0 +1,92 @@
+import { DateRangeExpr, InstantExpr } from "../ast/schemas.mjs";
+import { FilterExpressionParseError, InvalidDateFilterError } from "./errors.mjs";
+import { Effect } from "effect";
+//#region src/filter/codec.d.ts
+declare const parseFilter: (filter: {
+  readonly gt?: string;
+  readonly gte?: string;
+  readonly lt?: string;
+  readonly lte?: string;
+}) => Effect.Effect<{
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}, FilterExpressionParseError | InvalidDateFilterError, never>;
+declare const formatFilter: (range: DateRangeExpr) => {
+  readonly gt?: string;
+  readonly gte?: string;
+  readonly lt?: string;
+  readonly lte?: string;
+};
+declare const rangeKey: (range: DateRangeExpr) => string;
+declare const completePeriod: (start: InstantExpr, end: InstantExpr) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+export { completePeriod, formatFilter, parseFilter, rangeKey };

package/dist/filter/codec.mjs

@@ -0,0 +1,48 @@
+import { boundedRange, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, upperOpenRange } from "../ast/constructors.mjs";
+import { normalizeRange } from "../ast/normalize.mjs";
+import { InvalidDateFilterError } from "./errors.mjs";
+import { formatInstantExpression, parseInstantExpression } from "./expression.mjs";
+import { DateFilter } from "./schema.mjs";
+import { Effect, Match } from "effect";
+//#region src/filter/codec.ts
+const parseLower = (filter) => {
+	if (filter.gt !== void 0) return Effect.map(parseInstantExpression(filter.gt), greaterThan);
+	if (filter.gte !== void 0) return Effect.map(parseInstantExpression(filter.gte), greaterThanOrEqual);
+	return Effect.void;
+};
+const parseUpper = (filter) => {
+	if (filter.lt !== void 0) return Effect.map(parseInstantExpression(filter.lt), lessThan);
+	if (filter.lte !== void 0) return Effect.map(parseInstantExpression(filter.lte), lessThanOrEqual);
+	return Effect.void;
+};
+const parseFilter = Effect.fn("chronolizer.parseFilter")(function* (filter) {
+	const [lower, upper] = yield* Effect.all([parseLower(filter), parseUpper(filter)]);
+	if (lower !== void 0 && upper !== void 0) return normalizeRange(boundedRange(lower, upper));
+	if (lower !== void 0) return normalizeRange(lowerOpenRange(lower));
+	if (upper !== void 0) return normalizeRange(upperOpenRange(upper));
+	return yield* new InvalidDateFilterError({ message: "A date filter must contain at least one bound" });
+});
+const formatLower = Match.typeTags()({
+	GreaterThan: (bound) => DateFilter.make({ gt: formatInstantExpression(bound.value) }),
+	GreaterThanOrEqual: (bound) => DateFilter.make({ gte: formatInstantExpression(bound.value) })
+});
+const formatUpper = Match.typeTags()({
+	LessThan: (bound) => DateFilter.make({ lt: formatInstantExpression(bound.value) }),
+	LessThanOrEqual: (bound) => DateFilter.make({ lte: formatInstantExpression(bound.value) })
+});
+const formatFilter = (range) => {
+	const normalized = normalizeRange(range);
+	if (normalized.lower !== void 0 && normalized.upper !== void 0) return DateFilter.make({
+		...formatLower(normalized.lower),
+		...formatUpper(normalized.upper)
+	});
+	if (normalized.lower !== void 0) return formatLower(normalized.lower);
+	return formatUpper(normalized.upper);
+};
+const rangeKey = (range) => {
+	const filter = formatFilter(range);
+	return `${filter.gt ?? ""}|${filter.gte ?? ""}|${filter.lt ?? ""}|${filter.lte ?? ""}`;
+};
+const completePeriod = (start, end) => boundedRange(greaterThanOrEqual(start), lessThan(end));
+//#endregion
+export { completePeriod, formatFilter, parseFilter, rangeKey };

package/dist/filter/errors.d.mts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+//#region src/filter/errors.d.ts
+declare const FilterExpressionParseError_base: Schema.Class<FilterExpressionParseError, Schema.TaggedStruct<"FilterExpressionParseError", {
+  readonly input: Schema.String;
+  readonly offset: Schema.Int;
+  readonly expected: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class FilterExpressionParseError extends FilterExpressionParseError_base {}
+declare const InvalidDateFilterError_base: Schema.Class<InvalidDateFilterError, Schema.TaggedStruct<"InvalidDateFilterError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidDateFilterError extends InvalidDateFilterError_base {}
+//#endregion
+export { FilterExpressionParseError, InvalidDateFilterError };

package/dist/filter/errors.mjs

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+//#region src/filter/errors.ts
+var FilterExpressionParseError = class extends Schema.TaggedError()("FilterExpressionParseError", {
+	input: Schema.String,
+	offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	expected: Schema.String
+}) {};
+var InvalidDateFilterError = class extends Schema.TaggedError()("InvalidDateFilterError", { message: Schema.String }) {};
+//#endregion
+export { FilterExpressionParseError, InvalidDateFilterError };

package/dist/filter/expression.d.mts

@@ -0,0 +1,8 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { FilterExpressionParseError } from "./errors.mjs";
+import { Effect } from "effect";
+//#region src/filter/expression.d.ts
+declare const parseInstantExpression: (input: string) => Effect.Effect<InstantExpr, FilterExpressionParseError, never>;
+declare const formatInstantExpression: (expression: InstantExpr) => string;
+//#endregion
+export { formatInstantExpression, parseInstantExpression };

package/dist/filter/expression.mjs

@@ -0,0 +1,76 @@
+import { isIsoDate } from "../ast/schemas.mjs";
+import { dateLiteral, now, shift, startOf } from "../ast/constructors.mjs";
+import { foldInstant } from "../ast/fold.mjs";
+import { normalizeInstant } from "../ast/normalize.mjs";
+import { FilterExpressionParseError } from "./errors.mjs";
+import { Effect, Match } from "effect";
+//#region src/filter/expression.ts
+const unitFromSymbol = (symbol) => Match.value(symbol).pipe(Match.when("d", () => "day"), Match.when("w", () => "week"), Match.when("M", () => "month"), Match.when("q", () => "quarter"), Match.when("y", () => "year"), Match.orElse(() => void 0));
+const symbolFromUnit = (unit) => Match.value(unit).pipe(Match.when("day", () => "d"), Match.when("week", () => "w"), Match.when("month", () => "M"), Match.when("quarter", () => "q"), Match.when("year", () => "y"), Match.exhaustive);
+const failAt = (input, offset, expected) => Effect.fail(new FilterExpressionParseError({
+	input,
+	offset,
+	expected
+}));
+const isDigit = (value) => value >= "0" && value <= "9";
+const isFirstPositiveDigit = (value) => value >= "1" && value <= "9";
+const parseInstantExpression = Effect.fn(function* (input) {
+	let cursor = 0;
+	let expression;
+	let fixedAnchor = false;
+	if (input.startsWith("now")) {
+		expression = now();
+		cursor = 3;
+	} else {
+		const candidate = input.slice(0, 10);
+		if (!isIsoDate(candidate)) return yield* failAt(input, 0, "\"now\" or an ISO date (YYYY-MM-DD)");
+		expression = dateLiteral(candidate);
+		cursor = 10;
+		fixedAnchor = true;
+	}
+	if (fixedAnchor && cursor < input.length) {
+		if (input.slice(cursor, cursor + 2) !== "||") return yield* failAt(input, cursor, "\"||\" before date operations");
+		cursor += 2;
+		if (cursor === input.length) return yield* failAt(input, cursor, "an operation beginning with \"+\", \"-\", or \"/\"");
+	}
+	while (cursor < input.length) {
+		const operator = input[cursor];
+		if (operator === "/") {
+			const unit = unitFromSymbol(input[cursor + 1] ?? "");
+			if (unit === void 0) return yield* failAt(input, cursor + 1, "a date unit: d, w, M, q, or y");
+			expression = startOf(expression, unit);
+			cursor += 2;
+			continue;
+		}
+		if (operator !== "+" && operator !== "-") return yield* failAt(input, cursor, "an operation beginning with \"+\", \"-\", or \"/\"");
+		const amountStart = cursor + 1;
+		if (!isFirstPositiveDigit(input[amountStart] ?? "")) return yield* failAt(input, amountStart, "a positive integer without a leading zero");
+		cursor = amountStart + 1;
+		while (cursor < input.length && isDigit(input[cursor] ?? "")) cursor += 1;
+		const amount = Number(input.slice(amountStart, cursor));
+		if (!Number.isSafeInteger(amount)) return yield* failAt(input, amountStart, "a safe positive integer");
+		const unit = unitFromSymbol(input[cursor] ?? "");
+		if (unit === void 0) return yield* failAt(input, cursor, "a date unit: d, w, M, q, or y");
+		expression = shift(expression, operator === "+" ? amount : -amount, unit);
+		cursor += 1;
+	}
+	return expression;
+});
+const appendOperation = (base, operation) => ({
+	text: `${base.text}${base.fixedAnchor ? "||" : ""}${operation}`,
+	fixedAnchor: false
+});
+const formatInstantExpression = (expression) => foldInstant(normalizeInstant(expression), {
+	now: () => ({
+		text: "now",
+		fixedAnchor: false
+	}),
+	dateLiteral: (value) => ({
+		text: value,
+		fixedAnchor: true
+	}),
+	shift: (base, amount, unit) => appendOperation(base, `${amount < 0 ? "-" : "+"}${Math.abs(amount)}${symbolFromUnit(unit)}`),
+	startOf: (base, unit) => appendOperation(base, `/${symbolFromUnit(unit)}`)
+}).text;
+//#endregion
+export { formatInstantExpression, parseInstantExpression };

package/dist/filter/schema.d.mts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+//#region src/filter/schema.d.ts
+declare const DateExpressionString: Schema.String;
+type DateExpressionString = typeof DateExpressionString.Type;
+declare const DateFilter: Schema.Struct<{
+  readonly gt: Schema.optionalKey<Schema.String>;
+  readonly gte: Schema.optionalKey<Schema.String>;
+  readonly lt: Schema.optionalKey<Schema.String>;
+  readonly lte: Schema.optionalKey<Schema.String>;
+}>;
+type DateFilter = typeof DateFilter.Type;
+//#endregion
+export { DateExpressionString, DateFilter };

package/dist/filter/schema.mjs

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+//#region src/filter/schema.ts
+const DateExpressionString = Schema.String.check(Schema.isMinLength(1)).annotate({ identifier: "DateExpressionString" });
+const DateFilter = Schema.Struct({
+	gt: Schema.optionalKey(DateExpressionString),
+	gte: Schema.optionalKey(DateExpressionString),
+	lt: Schema.optionalKey(DateExpressionString),
+	lte: Schema.optionalKey(DateExpressionString)
+}).check(Schema.makeFilter((filter) => !(filter.gt !== void 0 && filter.gte !== void 0), { expected: "at most one lower date bound" }), Schema.makeFilter((filter) => !(filter.lt !== void 0 && filter.lte !== void 0), { expected: "at most one upper date bound" }), Schema.makeFilter((filter) => filter.gt !== void 0 || filter.gte !== void 0 || filter.lt !== void 0 || filter.lte !== void 0, { expected: "at least one date bound" })).annotate({ identifier: "DateFilter" });
+//#endregion
+export { DateExpressionString, DateFilter };

package/dist/filter/transformation.d.mts

@@ -0,0 +1,37 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { Schema } from "effect";
+//#region src/filter/transformation.d.ts
+declare const InstantExpressionFromString: Schema.decodeTo<Schema.Codec<InstantExpr, InstantExpr, never, never>, Schema.String, never, never>;
+declare const DateRangeFromFilter: Schema.decodeTo<Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.optionalKey<Schema.Never>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.optionalKey<Schema.Never>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>]>, Schema.Struct<{
+  readonly gt: Schema.optionalKey<Schema.String>;
+  readonly gte: Schema.optionalKey<Schema.String>;
+  readonly lt: Schema.optionalKey<Schema.String>;
+  readonly lte: Schema.optionalKey<Schema.String>;
+}>, never, never>;
+//#endregion
+export { DateRangeFromFilter, InstantExpressionFromString };

package/dist/filter/transformation.mjs

@@ -0,0 +1,20 @@
+import { DateRangeExpr, InstantExpr } from "../ast/schemas.mjs";
+import { formatInstantExpression, parseInstantExpression } from "./expression.mjs";
+import { DateFilter } from "./schema.mjs";
+import { formatFilter, parseFilter } from "./codec.mjs";
+import { Effect, Match, Schema, SchemaIssue, SchemaTransformation } from "effect";
+//#region src/filter/transformation.ts
+const expressionIssue = (input, offset, expected) => new SchemaIssue.Forbidden({ message: `Invalid date expression at offset ${offset}: expected ${expected}; input: ${input}` });
+const InstantExpressionFromString = Schema.String.pipe(Schema.decodeTo(InstantExpr, SchemaTransformation.transformOrFail({
+	decode: (input) => Effect.mapError(parseInstantExpression(input), (error) => expressionIssue(error.input, error.offset, error.expected)),
+	encode: (expression) => Effect.succeed(formatInstantExpression(expression))
+})));
+const DateRangeFromFilter = DateFilter.pipe(Schema.decodeTo(DateRangeExpr, SchemaTransformation.transformOrFail({
+	decode: (filter) => Effect.mapError(parseFilter(filter), (error) => new SchemaIssue.Forbidden({ message: Match.valueTags(error, {
+		FilterExpressionParseError: (parseError) => `Invalid filter expression at offset ${parseError.offset}: expected ${parseError.expected}`,
+		InvalidDateFilterError: (filterError) => filterError.message
+	}) })),
+	encode: (range) => Effect.succeed(formatFilter(range))
+})));
+//#endregion
+export { DateRangeFromFilter, InstantExpressionFromString };