chronolizer 0.1.0 → 0.2.0

package/dist/locales/shared.mjs

@@ -0,0 +1,289 @@
+import { InstantExpr, Unit, daysInMonth, isIsoDate } from "../ast/schemas.mjs";
+import { boundedRange, dateLiteral, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "../ast/constructors.mjs";
+import { formatInstantExpression } from "../filter/expression.mjs";
+import { formatFilter, rangeKey } from "../filter/codec.mjs";
+import { NaturalCandidate } from "../language/model.mjs";
+import { Option, Schema, String as String$1 } from "effect";
+//#region src/locales/shared.ts
+const textAt = (values, index) => values[index] ?? "";
+const Period = Schema.Struct({
+	start: InstantExpr,
+	end: InstantExpr,
+	canonical: Schema.String
+});
+const periodRange = (period) => boundedRange(greaterThanOrEqual(period.start), lessThan(period.end));
+const periodToDateRange = (unit) => boundedRange(greaterThanOrEqual(startOf(now(), unit)), lessThanOrEqual(now()));
+const fromNowRange = () => lowerOpenRange(greaterThanOrEqual(now()));
+const untilNowRange = () => upperOpenRange(lessThanOrEqual(now()));
+const remainingPeriodRange = (unit) => {
+	const start = startOf(now(), unit);
+	return boundedRange(greaterThanOrEqual(now()), lessThan(shift(start, 1, unit)));
+};
+const periodStartDay = (period, canonical) => Period.make({
+	start: period.start,
+	end: shift(period.start, 1, "day"),
+	canonical
+});
+const periodEndDay = (period, canonical) => Period.make({
+	start: shift(period.end, -1, "day"),
+	end: period.end,
+	canonical
+});
+const relativeWeekend = (direction, canonical) => {
+	const weekBase = direction === 0 ? now() : shift(now(), direction, "week");
+	const weekStart = startOf(weekBase, "week");
+	const start = shift(weekStart, 5, "day");
+	return Period.make({
+		start,
+		end: shift(start, 2, "day"),
+		canonical
+	});
+};
+const TrailingCount = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+const TrailingPeriod = Schema.Struct({
+	amount: TrailingCount,
+	unit: Unit
+});
+const FuturePeriod = Schema.Struct({
+	amount: TrailingCount,
+	unit: Unit
+});
+const CalendarPeriodOffset = Schema.Struct({
+	amount: Schema.Int,
+	unit: Unit
+});
+const validYear = (value) => {
+	const year = Number(value);
+	return Number.isInteger(year) && year >= 1 && year <= 9998 ? year : void 0;
+};
+const parseTrailingCount = (value) => {
+	const amount = Number(value);
+	return Schema.is(TrailingCount)(amount) ? Option.some(amount) : Option.none();
+};
+const trailingRange = (amount, unit) => boundedRange(greaterThanOrEqual(shift(now(), -amount, unit)), lessThanOrEqual(now()));
+const futureRange = (amount, unit) => boundedRange(greaterThanOrEqual(now()), lessThanOrEqual(shift(now(), amount, unit)));
+const trailingPeriod = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Shift" || range.lower.value.amount >= 0 || range.lower.value.base._tag !== "Now" || range.upper.value._tag !== "Now") return Option.none();
+	return Option.some(TrailingPeriod.make({
+		amount: -range.lower.value.amount,
+		unit: range.lower.value.unit
+	}));
+};
+const futurePeriod = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Now" || range.upper.value._tag !== "Shift" || range.upper.value.amount <= 0 || range.upper.value.base._tag !== "Now") return Option.none();
+	return Option.some(FuturePeriod.make({
+		amount: range.upper.value.amount,
+		unit: range.upper.value.unit
+	}));
+};
+const relativePeriod = (unit, direction, canonical) => {
+	const base = direction === 0 ? now() : shift(now(), direction, unit);
+	const start = startOf(base, unit);
+	return Period.make({
+		start,
+		end: shift(start, 1, unit),
+		canonical
+	});
+};
+const pad = (value) => String(value).padStart(2, "0");
+const isoDate = (year, month, day) => `${String(year).padStart(4, "0")}-${pad(month)}-${pad(day)}`;
+const nextDay = (year, month, day) => {
+	if (day < daysInMonth(year, month)) return isoDate(year, month, day + 1);
+	if (month < 12) return isoDate(year, month + 1, 1);
+	return isoDate(year + 1, 1, 1);
+};
+const previousDay = (year, month, day) => {
+	if (day > 1) return isoDate(year, month, day - 1);
+	if (month > 1) return isoDate(year, month - 1, daysInMonth(year, month - 1));
+	return isoDate(year - 1, 12, 31);
+};
+const fixedDatePeriod = (value, canonical) => {
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	return Period.make({
+		start: dateLiteral(value),
+		end: dateLiteral(nextDay(year, month, day)),
+		canonical
+	});
+};
+const namedDatePeriod = (yearText, monthText, dayText, monthNumber, canonical) => {
+	const year = validYear(yearText);
+	const month = monthNumber(monthText);
+	const day = Number(dayText);
+	if (year === void 0 || month === void 0) return Option.none();
+	const value = isoDate(year, month, day);
+	if (!isIsoDate(value) || value === "9999-12-31") return Option.none();
+	return Option.some(fixedDatePeriod(value, canonical(day, month, year)));
+};
+const fixedMonthPeriod = (year, month, canonical) => {
+	const nextYear = month === 12 ? year + 1 : year;
+	const nextMonth = month === 12 ? 1 : month + 1;
+	return Period.make({
+		start: dateLiteral(isoDate(year, month, 1)),
+		end: dateLiteral(isoDate(nextYear, nextMonth, 1)),
+		canonical
+	});
+};
+const fixedYearPeriod = (year, canonical) => Period.make({
+	start: dateLiteral(isoDate(year, 1, 1)),
+	end: dateLiteral(isoDate(year + 1, 1, 1)),
+	canonical
+});
+const fixedQuarterPeriod = (year, quarter, canonical) => {
+	const month = (quarter - 1) * 3 + 1;
+	const nextYear = quarter === 4 ? year + 1 : year;
+	const nextMonth = quarter === 4 ? 1 : month + 3;
+	return Period.make({
+		start: dateLiteral(isoDate(year, month, 1)),
+		end: dateLiteral(isoDate(nextYear, nextMonth, 1)),
+		canonical
+	});
+};
+const quarterOfRelativeYear = (quarter, direction, canonical) => {
+	const yearBase = direction === 0 ? now() : shift(now(), direction, "year");
+	const yearStart = startOf(yearBase, "year");
+	const start = quarter === 1 ? yearStart : shift(yearStart, (quarter - 1) * 3, "month");
+	return Period.make({
+		start,
+		end: shift(start, 1, "quarter"),
+		canonical
+	});
+};
+const monthOfRelativeYear = (month, direction, canonical) => {
+	const yearBase = direction === 0 ? now() : shift(now(), direction, "year");
+	const yearStart = startOf(yearBase, "year");
+	const start = month === 1 ? yearStart : shift(yearStart, month - 1, "month");
+	return Period.make({
+		start,
+		end: shift(start, 1, "month"),
+		canonical
+	});
+};
+const calendarPeriodOffset = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThan" || range.lower.value._tag !== "StartOf" || range.lower.value.base._tag !== "Shift" || range.lower.value.base.amount === 0 || range.lower.value.base.base._tag !== "Now" || range.lower.value.unit !== range.lower.value.base.unit || range.upper.value._tag !== "Shift" || range.upper.value.amount !== 1 || range.upper.value.unit !== range.lower.value.unit || formatInstantExpression(range.upper.value.base) !== formatInstantExpression(range.lower.value)) return Option.none();
+	return Option.some(CalendarPeriodOffset.make({
+		amount: range.lower.value.base.amount,
+		unit: range.lower.value.unit
+	}));
+};
+const candidate = (range, canonical) => NaturalCandidate.make({
+	range,
+	canonical
+});
+const joinedNowCandidate = (input, periodToNow, nowToPeriod, parsePeriod, canonicalToNow, canonicalFromNow) => {
+	for (const [prefix, suffix] of periodToNow) {
+		if (!input.startsWith(prefix) || !input.endsWith(suffix)) continue;
+		const period = parsePeriod(input.slice(prefix.length, -suffix.length));
+		if (Option.isNone(period)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(period.value.start), lessThanOrEqual(now())), canonicalToNow(period.value.canonical)));
+	}
+	for (const prefix of nowToPeriod) {
+		if (!input.startsWith(prefix)) continue;
+		const period = parsePeriod(input.slice(prefix.length));
+		if (Option.isNone(period)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(now()), lessThan(period.value.end)), canonicalFromNow(period.value.canonical)));
+	}
+	return Option.none();
+};
+const joinedPeriodCandidate = (input, joins, parsePeriod, canonical) => {
+	for (const [prefix, separator] of joins) {
+		if (!input.startsWith(prefix)) continue;
+		const separatorIndex = input.indexOf(separator, prefix.length);
+		if (separatorIndex === -1) continue;
+		const lower = parsePeriod(input.slice(prefix.length, separatorIndex));
+		const upper = parsePeriod(input.slice(separatorIndex + separator.length));
+		if (Option.isNone(lower) || Option.isNone(upper)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(lower.value.start), lessThan(upper.value.end)), canonical(lower.value.canonical, upper.value.canonical)));
+	}
+	return Option.none();
+};
+const periodBoundaryCandidate = (period, boundary, canonical) => {
+	switch (boundary) {
+		case "since": return candidate(lowerOpenRange(greaterThanOrEqual(period.start)), canonical);
+		case "before": return candidate(upperOpenRange(lessThan(period.start)), canonical);
+		case "through": return candidate(upperOpenRange(lessThan(period.end)), canonical);
+		case "after": return candidate(lowerOpenRange(greaterThanOrEqual(period.end)), canonical);
+	}
+};
+const openBoundaryCandidate = (input, boundaries, parsePeriod) => {
+	for (const boundary of boundaries) {
+		if (!input.startsWith(boundary[0])) continue;
+		const period = parsePeriod(input.slice(boundary[0].length));
+		if (Option.isNone(period)) continue;
+		const canonical = `${boundary[0]}${period.value.canonical}`;
+		return Option.some(periodBoundaryCandidate(period.value, boundary[1], canonical));
+	}
+	return Option.none();
+};
+const expressionDates = (range) => {
+	const filter = formatFilter(range);
+	const expressions = [
+		filter.gt,
+		filter.gte,
+		filter.lt,
+		filter.lte
+	];
+	const dates = /* @__PURE__ */ new Set();
+	for (const expression of expressions) {
+		if (expression === void 0) continue;
+		const match = String$1.match(/^(\d{4})-(\d{2})-(\d{2})/u)(expression);
+		if (Option.isSome(match)) dates.add(match.value[0]);
+	}
+	return [...dates];
+};
+const datedQuarterPeriods = (range) => {
+	return [...new Set(expressionDates(range).map((date) => date.slice(0, 4)))].flatMap((year) => [
+		1,
+		2,
+		3,
+		4
+	].map((quarter) => `q${quarter} ${year}`));
+};
+const datedPeriods = (range, months) => {
+	const dates = expressionDates(range);
+	return [...[...new Set(dates.map((date) => date.slice(0, 4)))].flatMap((year) => [...months.map((month) => `${month} ${year}`), year]), ...dates.flatMap((date) => date === "0000-01-01" ? [date] : [date, previousDay(Number(date.slice(0, 4)), Number(date.slice(5, 7)), Number(date.slice(8, 10)))])];
+};
+const periodsFromPhrases = (phrases, parsePeriod) => phrases.flatMap((phrase) => Option.toArray(parsePeriod(phrase)));
+const renderPeriodRange = (range, toDate, periods, since, before, through, after, between, toNow, fromNow, untilNow, afterNow) => {
+	const expected = rangeKey(range);
+	for (const entry of toDate) if (rangeKey(entry.range) === expected) return Option.some(entry.canonical);
+	const filter = formatFilter(range);
+	const startsAt = (expression) => periods.find((period) => formatInstantExpression(period.start) === expression);
+	const endsAt = (expression) => periods.find((period) => formatInstantExpression(period.end) === expression);
+	if (filter.lte === "now" && filter.gt === void 0 && filter.gte === void 0) return Option.some(untilNow());
+	if (filter.gte === "now" && filter.lt === void 0 && filter.lte === void 0) return Option.some(afterNow());
+	if (filter.gte !== void 0 && filter.lte === "now") {
+		const period = startsAt(filter.gte);
+		if (period !== void 0) return Option.some(toNow(period.canonical));
+	}
+	if (filter.gte === "now" && filter.lt !== void 0) {
+		const period = endsAt(filter.lt);
+		if (period !== void 0) return Option.some(fromNow(period.canonical));
+	}
+	if (filter.gte !== void 0 && filter.lt !== void 0) {
+		const exact = periods.find((period) => formatInstantExpression(period.start) === filter.gte && formatInstantExpression(period.end) === filter.lt);
+		if (exact !== void 0) return Option.some(exact.canonical);
+		const lower = startsAt(filter.gte)?.canonical;
+		const upper = endsAt(filter.lt)?.canonical;
+		return lower === void 0 || upper === void 0 ? Option.none() : Option.some(between(lower, upper));
+	}
+	if (filter.gte !== void 0 && filter.lt === void 0 && filter.lte === void 0) {
+		const start = startsAt(filter.gte);
+		if (start !== void 0) return Option.some(since(start.canonical));
+		const end = endsAt(filter.gte);
+		if (end !== void 0) return Option.some(after(end.canonical));
+	}
+	if (filter.lt !== void 0 && filter.gt === void 0 && filter.gte === void 0) {
+		const start = startsAt(filter.lt);
+		if (start !== void 0) return Option.some(before(start.canonical));
+		const end = endsAt(filter.lt);
+		if (end !== void 0) return Option.some(through(end.canonical));
+	}
+	return Option.none();
+};
+//#endregion
+export { Period, calendarPeriodOffset, candidate, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear };

package/dist/locales/tr.d.mts

@@ -0,0 +1,10 @@
+import { LanguageConflictError, LanguageRegistrationError } from "../language/errors.mjs";
+import { BaseLanguageContribution, LanguagePlugin } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+//#region src/locales/tr.d.ts
+declare const TurkishContribution: BaseLanguageContribution;
+declare const TurkishLanguage: LanguagePlugin;
+declare const TurkishLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+export { TurkishContribution, TurkishLanguage, TurkishLanguageLayer };