@fhss-web-team/fuzzy-dates 1.2.2 → 2.0.0

package/dist/src/gedcomX/toGedcomX.js

@@ -0,0 +1,28 @@
+import { isRange } from '../helpers/types';
+export function toGedcomX(model) {
+    const startDate = toSimpleDate(model.start);
+    const endDate = toSimpleDate(model.end);
+    if (isRange(model)) {
+        return `${model.approximate ? 'A' : ''}${startDate ?? ''}/${endDate ?? ''}`;
+    }
+    else {
+        return `${model.approximate ? 'A' : ''}${startDate}`;
+    }
+}
+function toSimpleDate(dateValue) {
+    if (dateValue === null)
+        return null;
+    const year = dateValue.min.getUTCFullYear();
+    const month = dateValue.min.getUTCMonth() + 1;
+    const day = dateValue.min.getUTCDate();
+    const sign = year >= 0 ? '+' : '-';
+    const yearAbs = Math.abs(year);
+    const yyyy = String(yearAbs).padStart(4, '0');
+    if (dateValue.precision === 'Year')
+        return `${sign}${yyyy}`;
+    const mm = String(month).padStart(2, '0');
+    if (dateValue.precision === 'Month' || dateValue.precision === 'Season')
+        return `${sign}${yyyy}-${mm}`;
+    const dd = String(day).padStart(2, '0');
+    return `${sign}${yyyy}-${mm}-${dd}`;
+}

package/dist/src/helpers/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DATE_NEG_INFINITY: Date;
+export declare const DATE_POS_INFINITY: Date;

package/dist/src/helpers/constants.js

@@ -0,0 +1,2 @@
+export const DATE_NEG_INFINITY = new Date(-8640000000000000);
+export const DATE_POS_INFINITY = new Date(8640000000000000);

package/dist/src/helpers/types.d.ts

@@ -0,0 +1,12 @@
+export type SimpleDate = {
+    precision: Precision;
+    min: Date;
+    max: Date;
+};
+export type FuzzyDateModel = {
+    approximate: boolean;
+    start: SimpleDate | null;
+    end: SimpleDate | null;
+};
+export type Precision = 'Year' | 'Season' | 'Month' | 'Day' | 'Hour' | 'Minute' | 'Second';
+export declare function isRange(model: FuzzyDateModel): boolean;

package/dist/src/helpers/types.js

@@ -0,0 +1,3 @@
+export function isRange(model) {
+    return (model.start?.min !== model.end?.min || model.start?.max !== model.end?.max);
+}

package/dist/src/normalize/normalize.js

@@ -0,0 +1,51 @@
+import { isSeasonMonth, SEASON_MONTH_MAP } from '../parse/simpleDate/maps';
+import { isRange } from '../helpers/types';
+export function normalize(model) {
+    const startDate = normalizeSimple(model.start);
+    const endDate = normalizeSimple(model.end);
+    if (isRange(model)) {
+        if (startDate === null) {
+            return `${model.approximate ? 'approximately ' : ''}before ${endDate}`;
+        }
+        if (endDate === null) {
+            return `${model.approximate ? 'approximately ' : ''}after ${startDate}`;
+        }
+        if (model.approximate) {
+            return `between ${startDate} and ${endDate}`;
+        }
+        else {
+            return `from ${startDate} to ${endDate}`;
+        }
+    }
+    else {
+        return `${model.approximate ? 'about ' : ''}${startDate}`;
+    }
+}
+function normalizeSimple(input) {
+    if (input === null)
+        return null;
+    const precision = input.precision;
+    const date = input.min;
+    const options = { timeZone: 'UTC' };
+    switch (precision) {
+        case 'Year':
+            options.year = 'numeric';
+            break;
+        case 'Season': {
+            const month = date.getUTCMonth() + 1;
+            if (!isSeasonMonth(month))
+                return '';
+            return `${SEASON_MONTH_MAP[month]} ${date.getUTCFullYear()}`;
+        }
+        case 'Month':
+            options.month = 'long';
+            options.year = 'numeric';
+            break;
+        case 'Day':
+            options.day = 'numeric';
+            options.month = 'long';
+            options.year = 'numeric';
+            break;
+    }
+    return date.toLocaleDateString('en-GB', options);
+}

package/dist/src/parse/index.d.ts

@@ -0,0 +1,47 @@
+export declare function parse(input: 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: false;
+    error: "Invalid \"FROM\" modifier.";
+} | {
+    ok: true;
+    value: {
+        approximate: boolean;
+        start: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        } | null;
+        end: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        } | null;
+    };
+};

package/dist/src/parse/index.js

@@ -0,0 +1,41 @@
+import { ok } from '../helpers/result';
+import { after, before, between, from, none } from './modifiers';
+// Main Parse Function
+export function parse(input) {
+    const cleanedInput = input
+        .toLowerCase() // lowercases
+        .replace(/(\d+)\s*(st|nd|rd|th|of)\b(\s*of)?/gi, '$1') // removes ordinal suffixes and 'of'
+        .replace(/[.,/\-_]+/g, ' ') // replaces separators with spaces
+        .replace(/\s+/g, ' ') // collapses multiple spaces to a single space
+        .trim(); // Removes trailing and leading spaces
+    let approximate = cleanedInput.startsWith('about ') ||
+        cleanedInput.startsWith('approximately ') ||
+        cleanedInput.startsWith('around ');
+    const removeApproximate = approximate
+        ? cleanedInput.slice(cleanedInput.indexOf(' ') + 1)
+        : cleanedInput;
+    let range;
+    if (removeApproximate.startsWith('before ')) {
+        range = before(removeApproximate);
+    }
+    else if (removeApproximate.startsWith('after ')) {
+        range = after(removeApproximate);
+    }
+    else if (removeApproximate.startsWith('between ')) {
+        range = between(removeApproximate);
+        approximate = true;
+    }
+    else if (removeApproximate.startsWith('from ')) {
+        range = from(removeApproximate);
+    }
+    else {
+        range = none(removeApproximate);
+    }
+    if (!range.ok)
+        return range;
+    return ok({
+        approximate,
+        start: range.value.start,
+        end: range.value.end,
+    });
+}

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

@@ -0,0 +1,182 @@
+export declare function none(rawInput: string): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly start: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+        readonly end: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+    };
+};
+export declare function before(rawInput: string): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly start: null;
+        readonly end: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+    };
+};
+export declare function after(rawInput: string): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly start: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+        readonly end: null;
+    };
+};
+export declare function between(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 start: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+        readonly end: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+    };
+};
+export declare function from(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 start: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+        readonly end: {
+            readonly precision: "Year";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Season" | "Month";
+            readonly min: Date;
+            readonly max: Date;
+        } | {
+            readonly precision: "Day";
+            readonly min: Date;
+            readonly max: Date;
+        };
+    };
+};

package/dist/src/parse/modifiers.js

@@ -0,0 +1,62 @@
+import { err, ok } from '../helpers/result';
+import { parseSimpleDate } from './simpleDate/parse';
+export function none(rawInput) {
+    const result = parseSimpleDate(rawInput);
+    if (!result.ok)
+        return result;
+    const date = result.value;
+    return ok({
+        start: date,
+        end: date,
+    });
+}
+export function before(rawInput) {
+    const input = rawInput.slice('before '.length);
+    const result = parseSimpleDate(input);
+    if (!result.ok)
+        return result;
+    return ok({
+        start: null,
+        end: result.value,
+    });
+}
+export function after(rawInput) {
+    const input = rawInput.slice('after '.length);
+    const result = parseSimpleDate(input);
+    if (!result.ok)
+        return result;
+    return ok({
+        start: result.value,
+        end: null,
+    });
+}
+export function between(rawInput) {
+    const dates = rawInput.slice('between '.length).split(' and ');
+    if (dates.length !== 2)
+        return err('Invalid "BETWEEN" modifier.');
+    const startResult = parseSimpleDate(dates[0]);
+    if (!startResult.ok)
+        return startResult;
+    const endResult = parseSimpleDate(dates[1]);
+    if (!endResult.ok)
+        return endResult;
+    return ok({
+        start: startResult.value,
+        end: endResult.value,
+    });
+}
+export function from(rawInput) {
+    const dates = rawInput.slice('from '.length).split(' to ');
+    if (dates.length !== 2)
+        return err('Invalid "FROM" modifier.');
+    const startResult = parseSimpleDate(dates[0]);
+    if (!startResult.ok)
+        return startResult;
+    const endResult = parseSimpleDate(dates[1]);
+    if (!endResult.ok)
+        return endResult;
+    return ok({
+        start: startResult.value,
+        end: endResult.value,
+    });
+}

package/dist/{fuzzyDate/parse/inputDateFormats.d.ts → src/parse/simpleDate/formats.d.ts}

@@ -10,9 +10,9 @@ export declare const year: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Year";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const monthStringYear: (rawDate: string) => {
@@ -27,9 +27,9 @@ export declare const monthStringYear: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "SEASON_YYYY" | "MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Season" | "Month";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const yearMonthString: (rawDate: string) => {
@@ -44,9 +44,9 @@ export declare const yearMonthString: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "SEASON_YYYY" | "MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Season" | "Month";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const dayMonthStringYear: (rawDate: string) => {
@@ -61,9 +61,9 @@ export declare const dayMonthStringYear: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const monthStringDayYear: (rawDate: string) => {
@@ -78,9 +78,9 @@ export declare const monthStringDayYear: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const yearMonthStringDay: (rawDate: string) => {
@@ -95,9 +95,9 @@ export declare const yearMonthStringDay: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const yearDayMonthString: (rawDate: string) => {
@@ -112,9 +112,9 @@ export declare const yearDayMonthString: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const monthDigitYear: (rawDate: string) => {
@@ -129,9 +129,9 @@ export declare const monthDigitYear: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Month";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const yearMonthDigit: (rawDate: string) => {
@@ -146,9 +146,9 @@ export declare const yearMonthDigit: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Month";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const dayMonthDigitYear: (rawDate: string) => {
@@ -163,9 +163,9 @@ export declare const dayMonthDigitYear: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;
 export declare const yearMonthDigitDay: (rawDate: string) => {
@@ -180,25 +180,8 @@ export declare const yearMonthDigitDay: (rawDate: string) => {
 } | {
     ok: true;
     value: {
-        readonly format: "D_MMMM_YYYY";
-        readonly minDate: Date;
-        readonly maxDate: Date;
-    };
-} | null;
-export declare const decade: (rawDate: string) => {
-    ok: false;
-    error: "Year is required.";
-} | {
-    ok: false;
-    error: "Unknown month.";
-} | {
-    ok: false;
-    error: "Unknown date format.";
-} | {
-    ok: true;
-    value: {
-        readonly format: "YYYYs";
-        readonly minDate: Date;
-        readonly maxDate: Date;
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
     };
 } | null;