chronolizer 0.1.0 → 0.2.0

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,93 @@
+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 } from "effect";
+//#region src/filter/expression.ts
+const unitFromSymbol = (symbol) => {
+	switch (symbol) {
+		case "d": return "day";
+		case "w": return "week";
+		case "M": return "month";
+		case "q": return "quarter";
+		case "y": return "year";
+		default: return;
+	}
+};
+const symbolFromUnit = (unit) => {
+	switch (unit) {
+		case "day": return "d";
+		case "week": return "w";
+		case "month": return "M";
+		case "quarter": return "q";
+		case "year": return "y";
+	}
+};
+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 };