chronolizer 0.1.0 → 0.3.0

package/dist/locales/shared.mjs

@@ -0,0 +1,395 @@
+import { GreaterThanOrEqual, InstantExpr, LessThan, LessThanOrEqual, Now, Shift, StartOf, 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 { Match, Option, RegExp as RegExp$1, 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 isGreaterThanOrEqual = Schema.is(GreaterThanOrEqual);
+const isLessThan = Schema.is(LessThan);
+const isLessThanOrEqual = Schema.is(LessThanOrEqual);
+const isNow = Schema.is(Now);
+const isShift = Schema.is(Shift);
+const isStartOf = Schema.is(StartOf);
+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 periodDay = (period, day, canonical) => {
+	if (!Number.isInteger(day) || day < 1 || day > 28) return Option.none();
+	const start = day === 1 ? period.start : shift(period.start, day - 1, "day");
+	return Option.some(Period.make({
+		start,
+		end: shift(start, 1, "day"),
+		canonical
+	}));
+};
+const periodPreviousDay = (period, canonical) => Period.make({
+	start: shift(period.start, -1, "day"),
+	end: period.start,
+	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 CountedPeriod = 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 (!isGreaterThanOrEqual(range.lower) || !isLessThanOrEqual(range.upper)) return Option.none();
+	if (!isShift(range.lower.value) || range.lower.value.amount >= 0 || !isNow(range.lower.value.base) || !isNow(range.upper.value)) return Option.none();
+	return Option.some(CountedPeriod.make({
+		amount: -range.lower.value.amount,
+		unit: range.lower.value.unit
+	}));
+};
+const futurePeriod = (range) => {
+	if (!isGreaterThanOrEqual(range.lower) || !isLessThanOrEqual(range.upper)) return Option.none();
+	if (!isNow(range.lower.value) || !isShift(range.upper.value) || range.upper.value.amount <= 0 || !isNow(range.upper.value.base)) return Option.none();
+	return Option.some(CountedPeriod.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 absoluteDateProfiles = /* @__PURE__ */ new Map();
+const absoluteDateProfile = (locale) => {
+	const cached = absoluteDateProfiles.get(locale);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat(locale, {
+		day: "numeric",
+		month: "numeric",
+		year: "numeric",
+		numberingSystem: "latn",
+		timeZone: "UTC"
+	});
+	const parts = [];
+	const pattern = formatter.formatToParts(/* @__PURE__ */ new Date("2006-11-22T00:00:00.000Z")).map((part) => {
+		if (part.type === "day" || part.type === "month" || part.type === "year") {
+			parts.push(part.type);
+			return part.type === "year" ? "([0-9]{4})" : "([0-9]{1,2})";
+		}
+		return RegExp$1.escape(part.value);
+	}).join("");
+	const profile = {
+		formatter,
+		pattern: new RegExp(`^${pattern}$`, "u"),
+		parts
+	};
+	absoluteDateProfiles.set(locale, profile);
+	return profile;
+};
+const formatAbsoluteDate = (value, locale) => absoluteDateProfile(locale).formatter.format(/* @__PURE__ */ new Date(`${value}T00:00:00.000Z`));
+const parseLocalizedAbsoluteDate = (input, locale) => {
+	const profile = absoluteDateProfile(locale);
+	const match = String$1.match(profile.pattern)(input);
+	if (Option.isNone(match)) return Option.none();
+	let day = "";
+	let month = "";
+	let year = "";
+	for (const [index, part] of profile.parts.entries()) {
+		const value = textAt(match.value, index + 1);
+		if (part === "day") day = value;
+		if (part === "month") month = value;
+		if (part === "year") year = value;
+	}
+	const value = isoDate(Number(year), Number(month), Number(day));
+	return isIsoDate(value) ? Option.some(value) : Option.none();
+};
+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 absoluteDatePeriod = (input, locale) => {
+	return (isIsoDate(input) ? Option.some(input) : parseLocalizedAbsoluteDate(input, locale)).pipe(Option.filter((date) => date !== "9999-12-31"), Option.map((date) => fixedDatePeriod(date, formatAbsoluteDate(date, locale))));
+};
+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 minimumDaysInMonth = (month) => daysInMonth(1, month);
+const currentYearDatePeriod = (month, day, canonical) => {
+	const yearStart = startOf(now(), "year");
+	const monthStart = month === 1 ? yearStart : shift(yearStart, month - 1, "month");
+	const start = day === 1 ? monthStart : shift(monthStart, day - 1, "day");
+	return Period.make({
+		start,
+		end: shift(start, 1, "day"),
+		canonical
+	});
+};
+const namedCurrentYearDatePeriod = (monthText, dayText, monthNumber, canonical) => {
+	const month = monthNumber(monthText);
+	const day = Number(dayText);
+	if (month === void 0 || !Number.isInteger(day) || day < 1 || day > minimumDaysInMonth(month)) return Option.none();
+	return Option.some(currentYearDatePeriod(month, day, canonical(day, month)));
+};
+const currentYearDate = (expression) => {
+	const match = String$1.match(/^now\/y(?:\+([1-9]\d*)M)?(?:\+([1-9]\d*)d)?$/u)(expression);
+	if (Option.isNone(match)) return Option.none();
+	const month = Number(textAt(match.value, 1) || "0") + 1;
+	const offset = Number(textAt(match.value, 2) || "0");
+	return month >= 1 && month <= 12 ? Option.some([month, offset]) : Option.none();
+};
+const currentYearDatePeriods = (range, canonical) => {
+	const filter = formatFilter(range);
+	const expressions = [
+		filter.gt,
+		filter.gte,
+		filter.lt,
+		filter.lte
+	];
+	const dates = /* @__PURE__ */ new Map();
+	for (const expression of expressions) {
+		if (expression === void 0) continue;
+		const date = currentYearDate(expression);
+		if (Option.isNone(date)) continue;
+		const [month, offset] = date.value;
+		for (const day of [offset, offset + 1]) {
+			if (day < 1 || day > minimumDaysInMonth(month)) continue;
+			dates.set(`${month}-${day}`, [month, day]);
+		}
+	}
+	return [...dates.values()].map(([month, day]) => currentYearDatePeriod(month, day, canonical(day, month)));
+};
+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 (!isGreaterThanOrEqual(range.lower) || !isLessThan(range.upper)) return Option.none();
+	const start = range.lower.value;
+	const end = range.upper.value;
+	if (!isStartOf(start) || !isShift(start.base) || start.base.amount === 0 || !isNow(start.base.base) || start.unit !== start.base.unit || !isShift(end) || end.amount !== 1 || end.unit !== start.unit || formatInstantExpression(end.base) !== formatInstantExpression(start)) return Option.none();
+	return Option.some(CalendarPeriodOffset.make({
+		amount: start.base.amount,
+		unit: start.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) => Match.value(boundary).pipe(Match.when("since", () => candidate(lowerOpenRange(greaterThanOrEqual(period.start)), canonical)), Match.when("before", () => candidate(upperOpenRange(lessThan(period.start)), canonical)), Match.when("through", () => candidate(upperOpenRange(lessThan(period.end)), canonical)), Match.when("after", () => candidate(lowerOpenRange(greaterThanOrEqual(period.end)), canonical)), Match.exhaustive);
+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, absoluteDatePeriod, calendarPeriodOffset, candidate, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, formatAbsoluteDate, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodDay, periodEndDay, periodPreviousDay, 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 };