@fhss-web-team/fuzzy-dates 1.0.0

package/dist/fuzzyDate/parse/inputDateFormats.js

@@ -0,0 +1,225 @@
+import { calculateMaxDate, parseDateGroups } from '.';
+import { ok, isSeason } from '../types';
+const DAY = '(?<day>\\d{1,2})';
+const MONTH_DIGIT = '(?<month>\\d{1,2})';
+const MONTH_STRING = '(?<month>[a-z]+)';
+const YEAR = '(?<year>\\d{4})';
+const DECADE = '(?<decade>\\d{4}s)';
+// YYYY
+export const year = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// MMM(M) YYYY || SEASON YYYY
+export const monthStringYear = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${MONTH_STRING}\s${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const monthString = match.groups['month'].toLowerCase();
+    const format = isSeason(monthString) ? 'SEASON_YYYY' : 'MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYY MMM(M) || YYYY SEASON
+export const yearMonthString = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}\s${MONTH_STRING}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const monthString = match.groups['month'].toLowerCase();
+    const format = isSeason(monthString) ? 'SEASON_YYYY' : 'MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// D(D) MMM(M) YYYY
+export const dayMonthStringYear = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${DAY}\s${MONTH_STRING}\s${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// MMM(M) D(D) YYYY
+export const monthStringDayYear = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${MONTH_STRING}\s${DAY}\s${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYY MMM(M) D(D)
+export const yearMonthStringDay = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}\s${MONTH_STRING}\s${DAY}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYY D(D) MMM(M)
+export const yearDayMonthString = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}\s${DAY}\s${MONTH_STRING}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// M(M) YYYY
+export const monthDigitYear = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${MONTH_DIGIT}\s${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYY M(M)
+export const yearMonthDigit = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}\s${MONTH_DIGIT}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// D(D) M(M) YYYY
+export const dayMonthDigitYear = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${DAY}\s${MONTH_DIGIT}\s${YEAR}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYY M(M)  D(D)
+export const yearMonthDigitDay = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${YEAR}\s${MONTH_DIGIT}\s${DAY}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'D_MMMM_YYYY';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};
+// YYYYs
+export const decade = (rawDate) => {
+    const pattern = new RegExp(String.raw `^${DECADE}$`);
+    const match = pattern.exec(rawDate);
+    if (!match?.groups)
+        return null;
+    const result = parseDateGroups(match.groups);
+    if (!result.ok)
+        return result;
+    const format = 'YYYYs';
+    const minDate = result.value.date;
+    const maxDate = calculateMaxDate(minDate, format);
+    return ok({
+        format: format,
+        minDate: minDate,
+        maxDate: maxDate,
+    });
+};

package/dist/fuzzyDate/parse/modifiers.d.ts

@@ -0,0 +1,240 @@
+export declare const none: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "NONE";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const before: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "BEFORE";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const after: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "AFTER";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const about: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "ABOUT";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const between: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: false;
+    error: "Invalid \"BETWEEN\" modifier.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "BETWEEN";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const from: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: false;
+    error: "Invalid \"FROM\" modifier.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "FROM";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const early: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "EARLY";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const mid: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "MID";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};
+export declare const late: (cleanedInput: string, rawInput: string) => {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly original: string;
+        readonly modifier: "LATE";
+        readonly start: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+        readonly end: {
+            readonly format: "YYYYs" | "YYYY" | "SEASON_YYYY" | "MMMM_YYYY" | "D_MMMM_YYYY";
+            readonly minDate: Date;
+            readonly maxDate: Date;
+        };
+    };
+};

package/dist/fuzzyDate/parse/modifiers.js

@@ -0,0 +1,193 @@
+import { getTimes } from '.';
+import { ok, err, DATE_NEG_INFINITY, DATE_POS_INFINITY } from '../types';
+import { stringToDate } from './stringToDate';
+export const none = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput);
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    return ok({
+        original: rawInput,
+        modifier: 'NONE',
+        start: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+        end: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+    });
+};
+export const before = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('before '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    return ok({
+        original: rawInput,
+        modifier: 'BEFORE',
+        start: {
+            format: date.format,
+            minDate: DATE_NEG_INFINITY,
+            maxDate: date.minDate,
+        },
+        end: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+    });
+};
+export const after = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('after '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    return ok({
+        original: rawInput,
+        modifier: 'AFTER',
+        start: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+        end: {
+            format: date.format,
+            minDate: date.maxDate,
+            maxDate: DATE_POS_INFINITY,
+        },
+    });
+};
+export const about = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('about '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    return ok({
+        original: rawInput,
+        modifier: 'ABOUT',
+        start: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+        end: {
+            format: date.format,
+            minDate: date.minDate,
+            maxDate: date.maxDate,
+        },
+    });
+};
+export const between = (cleanedInput, rawInput) => {
+    const dates = cleanedInput.slice('between '.length).split(' and ');
+    if (dates.length !== 2)
+        return err('Invalid "BETWEEN" modifier.');
+    const startResult = stringToDate(dates[0]);
+    const endDateResult = stringToDate(dates[1]);
+    if (!startResult.ok)
+        return startResult;
+    if (!endDateResult.ok)
+        return endDateResult;
+    const start = startResult.value;
+    const end = endDateResult.value;
+    return ok({
+        original: rawInput,
+        modifier: 'BETWEEN',
+        start: {
+            format: start.format,
+            minDate: start.minDate,
+            maxDate: start.maxDate,
+        },
+        end: { format: end.format, minDate: end.minDate, maxDate: end.maxDate },
+    });
+};
+export const from = (cleanedInput, rawInput) => {
+    const dates = cleanedInput.slice('from '.length).split(' to ');
+    if (dates.length !== 2)
+        return err('Invalid "FROM" modifier.');
+    const startResult = stringToDate(dates[0]);
+    const endDateResult = stringToDate(dates[1]);
+    if (!startResult.ok)
+        return startResult;
+    if (!endDateResult.ok)
+        return endDateResult;
+    const start = startResult.value;
+    const end = endDateResult.value;
+    return ok({
+        original: rawInput,
+        modifier: 'FROM',
+        start: {
+            format: start.format,
+            minDate: start.minDate,
+            maxDate: start.maxDate,
+        },
+        end: { format: end.format, minDate: end.minDate, maxDate: end.maxDate },
+    });
+};
+export const early = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('early '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    const { start, half } = getTimes(date);
+    return ok({
+        original: rawInput,
+        modifier: 'EARLY',
+        start: {
+            format: date.format,
+            minDate: new Date(start),
+            maxDate: new Date(start + half),
+        },
+        end: {
+            format: date.format,
+            minDate: new Date(start),
+            maxDate: new Date(start + half),
+        },
+    });
+};
+export const mid = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('mid '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    console.log(date);
+    const { start, half } = getTimes(date);
+    return ok({
+        original: rawInput,
+        modifier: 'MID',
+        start: {
+            format: date.format,
+            minDate: new Date(start + half / 2),
+            maxDate: new Date(start + half),
+        },
+        end: {
+            format: date.format,
+            minDate: new Date(start + half / 2),
+            maxDate: new Date(start + half),
+        },
+    });
+};
+export const late = (cleanedInput, rawInput) => {
+    const result = stringToDate(cleanedInput.slice('late '.length));
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    const { start, half } = getTimes(date);
+    return ok({
+        original: rawInput,
+        modifier: 'LATE',
+        start: {
+            format: date.format,
+            minDate: new Date(start + half),
+            maxDate: date.maxDate,
+        },
+        end: {
+            format: date.format,
+            minDate: new Date(start + half),
+            maxDate: date.maxDate,
+        },
+    });
+};

package/dist/fuzzyDate/parse/stringToDate.d.ts

@@ -0,0 +1,38 @@
+export declare function stringToDate(dateInput: string): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly format: "YYYY";
+        readonly minDate: Date;
+        readonly maxDate: Date;
+    };
+} | {
+    ok: true;
+    value: {
+        readonly format: "SEASON_YYYY" | "MMMM_YYYY";
+        readonly minDate: Date;
+        readonly maxDate: Date;
+    };
+} | {
+    ok: true;
+    value: {
+        readonly format: "D_MMMM_YYYY";
+        readonly minDate: Date;
+        readonly maxDate: Date;
+    };
+} | {
+    ok: true;
+    value: {
+        readonly format: "YYYYs";
+        readonly minDate: Date;
+        readonly maxDate: Date;
+    };
+};