@fhss-web-team/fuzzy-dates 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FHSS Web Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# CFHG Fuzzy Dates
+
+Parse imprecise, human-entered date strings into a structured, consistent model that you can normalize, search, sort, and serialize.
+
+## Features
+- Handles modifiers like `before`, `after`, `about`, `between`, `from`, `early`, `mid`, `late`.
+- Normalizes many input shapes (`1st of February 1900`, `Feb 1 1900`, `winter 1890`, `1800s`).
+- Produces inclusive lower/upper bounds for range filtering and a collation key for stable chronological sorting.
+- Outputs a canonical JSON model plus GEDCOM X formal dates for genealogy interoperability.
+- ESM + TypeScript ready (`.d.ts` shipped with the package).
+
+## Installation
+```bash
+npm install cfhg-fuzzy-dates
+```
+
+## Quick start
+```ts
+import { FuzzyDate } from 'cfhg-fuzzy-dates';
+
+const parsed = FuzzyDate.parse('about Feb 1900');
+if (!parsed.ok) throw parsed.error;
+
+const date = parsed.value;
+console.log(date.normalized);   // "about 1 February 1900"
+console.log(date.lowerBound);   // 1899-02-01T00:00:00.000Z (Date)
+console.log(date.upperBound);   // 1901-01-31T23:59:59.999Z (Date)
+console.log(date.collationKey); // deterministic string for sorting
+
+// Serialize for storage and hydrate later
+const json = date.toJSON();
+const hydrated = FuzzyDate.fromJSON(json);
+```
+
+## API snapshot
+- `FuzzyDate.parse(input: string): Result<FuzzyDate, string>` — non-throwing parse; errors come back as `{ ok: false, error }`.
+- `FuzzyDate.fromJSON(model: FuzzyDateModel)` — rebuild from the canonical JSON model.
+- `FuzzyDate` instance properties:
+  - `original` — original input string.
+  - `normalized` — normalized human-readable string.
+  - `lowerBound` / `upperBound` — inclusive Date bounds (or `null` for unbounded).
+  - `collationKey` — sortable string aligned to chronological order.
+  - `formal` — GEDCOM X formal date representation.
+  - `toJSON()` — returns the canonical model.
+
+## Development
+- Tests: `npm test` (Vitest)
+- Build: `npm run build` (TypeScript -> `dist/`)
+- Pack locally (publish dry-run): `npm pack` then install the generated `.tgz` in a temp project to verify exports and typings.
+
+## License
+MIT © FHSS Web Team

package/dist/fuzzyDate/collate/collate.d.ts

@@ -0,0 +1,2 @@
+import { FuzzyDateModel } from '../types';
+export declare function collate(model: FuzzyDateModel): string;

package/dist/fuzzyDate/collate/collate.js

@@ -0,0 +1,15 @@
+import { FORMAT_ORDER, MODIFIER_ORDER } from '../types';
+export function collate(model) {
+    const date1 = model.start.minDate.toISOString();
+    const modifier = MODIFIER_ORDER.indexOf(model.modifier)
+        .toString()
+        .padStart(2, '0');
+    const format1 = FORMAT_ORDER.indexOf(model.start.format)
+        .toString()
+        .padStart(2, '0');
+    const date2 = model.end.minDate.toISOString();
+    const format2 = FORMAT_ORDER.indexOf(model.end.format)
+        .toString()
+        .padStart(2, '0');
+    return `${date1}|${modifier}|${format1}|${date2}|${format2}`;
+}

package/dist/fuzzyDate/fuzzyDate.d.ts

@@ -0,0 +1,206 @@
+import { FuzzyDateModel } from './types';
+/**
+ * Represents an immutable, parsed fuzzy date suitable for genealogy and
+ * historical data contexts.
+ *
+ * A `FuzzyDate` encapsulates a human-entered date expression
+ * (e.g. `"before 1900"`, `"between 1 Jan 1900 and 31 Dec 1901"`,
+ * `"March 1890"`) and exposes multiple *derived representations* optimized
+ * for different use cases:
+ *
+ * - A canonical JSON model for storage and transport
+ * - Query bounds for database filtering
+ * - A collation key for stable chronological ordering
+ * - A normalized, human-readable string form
+ * - A GEDCOM X formal date representation
+ *
+ * ---
+ *
+ * ### Design principles
+ *
+ * - **Immutable**: Instances cannot be mutated after construction.
+ * - **Explicit construction**: Instances must be created via `parse()` or
+ *   `fromJSON()`. Direct construction via `new` is intentionally disallowed.
+ * - **Derived projections**: Query bounds, collation keys, and serializations
+ *   are all derived from a single internal model to guarantee consistency.
+ * - **UTC semantics**: All date calculations and comparisons are performed
+ *   using UTC to avoid timezone-related ambiguity.
+ *
+ * ---
+ *
+ * ### Intended usage
+ *
+ * - Use `parse()` for untrusted, human-entered input.
+ * - Use `fromJSON()` when hydrating from a trusted serialized model
+ *   (e.g. database JSON).
+ * - Store the JSON model as the canonical representation.
+ * - Store `lowerBound`, `upperBound`, and `collationKey` separately for
+ *   efficient querying and ordering.
+ */
+export declare class FuzzyDate {
+    /**
+     * Canonical internal model representing the parsed fuzzy date.
+     *
+     * This model is considered the single source of truth; all other
+     * representations are derived from it.
+     */
+    private _model;
+    /**
+     * Private constructor to enforce factory-based creation.
+     *
+     * Consumers must use {@link FuzzyDate.parse} or {@link FuzzyDate.fromJSON}.
+     */
+    private constructor();
+    /**
+     * The original human-readable input string used to construct this fuzzy date.
+     *
+     * This value is preserved verbatim and is not normalized or modified.
+     */
+    get original(): string;
+    /**
+     * GEDCOM X formal date representation of this fuzzy date.
+     *
+     * This value is suitable for interoperability with genealogy systems
+     * that support the GEDCOM X date specification.
+     *
+     * @see https://github.com/FamilySearch/gedcomx/blob/master/specifications/date-format-specification.md
+     *
+     * @remarks
+     * This representation is derived and may evolve as GEDCOM X mapping
+     * rules are refined.
+     */
+    get formal(): string;
+    /**
+     * Normalized, human-readable representation of the fuzzy date.
+     *
+     * This format represents the interpreted meaning of the original input
+     * using a standardized vocabulary and ordering.
+     *
+     * Example outputs:
+     * - `"before 1900"`
+     * - `"March 1890"`
+     * - `"between 1 Jan 1900 and 31 Dec 1901"`
+     */
+    get normalized(): string;
+    /**
+     * The inclusive lower bound of this fuzzy date's possible interval (UTC).
+     *
+     * This bound is intended for **endpoint-in-window** searching:
+     * a fuzzy date matches an inclusive search range `[searchStart, searchEnd]`
+     * if **either** its `lowerBound` **or** its `upperBound` falls within the
+     * search range.
+     *
+     * Formally (inclusive):
+     *
+     * ```text
+     * (searchStart <= lowerBound <= searchEnd) OR (searchStart <= upperBound <= searchEnd)
+     * ```
+     *
+     * ## Unbounded intervals
+     *
+     * Open-ended intervals are represented with `null`:
+     * - `lowerBound === null` means unbounded in the past (−∞)
+     * - `upperBound === null` means unbounded in the future (+∞)
+     *
+     * When using the predicate above, treat a `null` bound as not satisfying
+     * the endpoint check (i.e., it is not “within” any finite window).
+     *
+     * @remarks
+     * - Derived from the canonical model.
+     * - Always interpreted as UTC.
+     */
+    get lowerBound(): Date | null;
+    /**
+     * The inclusive upper bound of this fuzzy date's possible interval (UTC).
+     *
+     * This bound is intended for **endpoint-in-window** searching:
+     * a fuzzy date matches an inclusive search range `[searchStart, searchEnd]`
+     * if **either** its `lowerBound` **or** its `upperBound` falls within the
+     * search range.
+     *
+     * Formally (inclusive):
+     *
+     * ```text
+     * (searchStart <= lowerBound <= searchEnd) OR (searchStart <= upperBound <= searchEnd)
+     * ```
+     *
+     * ## Unbounded intervals
+     *
+     * Open-ended intervals are represented with `null`:
+     * - `lowerBound === null` means unbounded in the past (−∞)
+     * - `upperBound === null` means unbounded in the future (+∞)
+     *
+     * When using the predicate above, treat a `null` bound as not satisfying
+     * the endpoint check (i.e., it is not “within” any finite window).
+     *
+     * @remarks
+     * - Derived from the canonical model.
+     * - Always interpreted as UTC.
+     */
+    get upperBound(): Date | null;
+    /**
+     * Collation key used for chronological ordering.
+     *
+     * The collation key is a derived string whose lexicographic ordering
+     * is guaranteed to match the semantic chronological ordering of fuzzy dates.
+     *
+     * ```text
+     * a occurs before b  ⇔  a.collationKey < b.collationKey
+     * ```
+     *
+     * This property is intended for:
+     * - database indexing
+     * - `ORDER BY` clauses
+     * - stable sorting without parsing
+     *
+     * @remarks
+     * - Not human-readable
+     * - Not intended for round-tripping
+     * - Derived entirely from the canonical model
+     */
+    get collationKey(): string;
+    /**
+     * Serializes this fuzzy date to its canonical JSON representation.
+     *
+     * The returned object is suitable for long-term storage,
+     * transport, and later reconstruction via {@link fromJSON}.
+     */
+    toJSON(): FuzzyDateModel;
+    /**
+     * Reconstructs a `FuzzyDate` from a previously serialized canonical model.
+     *
+     * @param json A trusted `FuzzyDateModel`, typically loaded from storage.
+     */
+    static fromJSON(json: FuzzyDateModel): FuzzyDate;
+    /**
+     * Parses a human-readable date string into a `FuzzyDate`.
+     *
+     * This method should be used for all untrusted or user-provided input.
+     *
+     * @param input Human-readable date expression.
+     * @returns A result object containing either a `FuzzyDate` or parse issues.
+     *
+     * @remarks
+     * - Parsing is non-throwing; errors are returned as structured issues.
+     * - Successful results are guaranteed to produce a valid canonical model.
+     */
+    static 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: FuzzyDate;
+    };
+}

package/dist/fuzzyDate/fuzzyDate.js

@@ -0,0 +1,220 @@
+import { parse } from './parse/index';
+import { normalize } from './normalize/normalize';
+import { collate } from './collate/collate';
+import { toGedcomX } from './gedcomX/toGedcomX';
+import { DATE_NEG_INFINITY, DATE_POS_INFINITY, ok, } from './types';
+/**
+ * Represents an immutable, parsed fuzzy date suitable for genealogy and
+ * historical data contexts.
+ *
+ * A `FuzzyDate` encapsulates a human-entered date expression
+ * (e.g. `"before 1900"`, `"between 1 Jan 1900 and 31 Dec 1901"`,
+ * `"March 1890"`) and exposes multiple *derived representations* optimized
+ * for different use cases:
+ *
+ * - A canonical JSON model for storage and transport
+ * - Query bounds for database filtering
+ * - A collation key for stable chronological ordering
+ * - A normalized, human-readable string form
+ * - A GEDCOM X formal date representation
+ *
+ * ---
+ *
+ * ### Design principles
+ *
+ * - **Immutable**: Instances cannot be mutated after construction.
+ * - **Explicit construction**: Instances must be created via `parse()` or
+ *   `fromJSON()`. Direct construction via `new` is intentionally disallowed.
+ * - **Derived projections**: Query bounds, collation keys, and serializations
+ *   are all derived from a single internal model to guarantee consistency.
+ * - **UTC semantics**: All date calculations and comparisons are performed
+ *   using UTC to avoid timezone-related ambiguity.
+ *
+ * ---
+ *
+ * ### Intended usage
+ *
+ * - Use `parse()` for untrusted, human-entered input.
+ * - Use `fromJSON()` when hydrating from a trusted serialized model
+ *   (e.g. database JSON).
+ * - Store the JSON model as the canonical representation.
+ * - Store `lowerBound`, `upperBound`, and `collationKey` separately for
+ *   efficient querying and ordering.
+ */
+export class FuzzyDate {
+    /**
+     * Canonical internal model representing the parsed fuzzy date.
+     *
+     * This model is considered the single source of truth; all other
+     * representations are derived from it.
+     */
+    _model;
+    /**
+     * Private constructor to enforce factory-based creation.
+     *
+     * Consumers must use {@link FuzzyDate.parse} or {@link FuzzyDate.fromJSON}.
+     */
+    constructor(model) {
+        this._model = model;
+    }
+    /**
+     * The original human-readable input string used to construct this fuzzy date.
+     *
+     * This value is preserved verbatim and is not normalized or modified.
+     */
+    get original() {
+        return this._model.original;
+    }
+    /**
+     * GEDCOM X formal date representation of this fuzzy date.
+     *
+     * This value is suitable for interoperability with genealogy systems
+     * that support the GEDCOM X date specification.
+     *
+     * @see https://github.com/FamilySearch/gedcomx/blob/master/specifications/date-format-specification.md
+     *
+     * @remarks
+     * This representation is derived and may evolve as GEDCOM X mapping
+     * rules are refined.
+     */
+    get formal() {
+        return toGedcomX(this._model);
+    }
+    /**
+     * Normalized, human-readable representation of the fuzzy date.
+     *
+     * This format represents the interpreted meaning of the original input
+     * using a standardized vocabulary and ordering.
+     *
+     * Example outputs:
+     * - `"before 1900"`
+     * - `"March 1890"`
+     * - `"between 1 Jan 1900 and 31 Dec 1901"`
+     */
+    get normalized() {
+        return normalize(this._model);
+    }
+    /**
+     * The inclusive lower bound of this fuzzy date's possible interval (UTC).
+     *
+     * This bound is intended for **endpoint-in-window** searching:
+     * a fuzzy date matches an inclusive search range `[searchStart, searchEnd]`
+     * if **either** its `lowerBound` **or** its `upperBound` falls within the
+     * search range.
+     *
+     * Formally (inclusive):
+     *
+     * ```text
+     * (searchStart <= lowerBound <= searchEnd) OR (searchStart <= upperBound <= searchEnd)
+     * ```
+     *
+     * ## Unbounded intervals
+     *
+     * Open-ended intervals are represented with `null`:
+     * - `lowerBound === null` means unbounded in the past (−∞)
+     * - `upperBound === null` means unbounded in the future (+∞)
+     *
+     * When using the predicate above, treat a `null` bound as not satisfying
+     * the endpoint check (i.e., it is not “within” any finite window).
+     *
+     * @remarks
+     * - Derived from the canonical model.
+     * - Always interpreted as UTC.
+     */
+    get lowerBound() {
+        return this._model.start.minDate === DATE_NEG_INFINITY
+            ? null
+            : this._model.start.minDate;
+    }
+    /**
+     * The inclusive upper bound of this fuzzy date's possible interval (UTC).
+     *
+     * This bound is intended for **endpoint-in-window** searching:
+     * a fuzzy date matches an inclusive search range `[searchStart, searchEnd]`
+     * if **either** its `lowerBound` **or** its `upperBound` falls within the
+     * search range.
+     *
+     * Formally (inclusive):
+     *
+     * ```text
+     * (searchStart <= lowerBound <= searchEnd) OR (searchStart <= upperBound <= searchEnd)
+     * ```
+     *
+     * ## Unbounded intervals
+     *
+     * Open-ended intervals are represented with `null`:
+     * - `lowerBound === null` means unbounded in the past (−∞)
+     * - `upperBound === null` means unbounded in the future (+∞)
+     *
+     * When using the predicate above, treat a `null` bound as not satisfying
+     * the endpoint check (i.e., it is not “within” any finite window).
+     *
+     * @remarks
+     * - Derived from the canonical model.
+     * - Always interpreted as UTC.
+     */
+    get upperBound() {
+        return this._model.start.maxDate === DATE_POS_INFINITY
+            ? null
+            : this._model.start.maxDate;
+    }
+    /**
+     * Collation key used for chronological ordering.
+     *
+     * The collation key is a derived string whose lexicographic ordering
+     * is guaranteed to match the semantic chronological ordering of fuzzy dates.
+     *
+     * ```text
+     * a occurs before b  ⇔  a.collationKey < b.collationKey
+     * ```
+     *
+     * This property is intended for:
+     * - database indexing
+     * - `ORDER BY` clauses
+     * - stable sorting without parsing
+     *
+     * @remarks
+     * - Not human-readable
+     * - Not intended for round-tripping
+     * - Derived entirely from the canonical model
+     */
+    get collationKey() {
+        return collate(this._model);
+    }
+    /**
+     * Serializes this fuzzy date to its canonical JSON representation.
+     *
+     * The returned object is suitable for long-term storage,
+     * transport, and later reconstruction via {@link fromJSON}.
+     */
+    toJSON() {
+        return this._model;
+    }
+    /**
+     * Reconstructs a `FuzzyDate` from a previously serialized canonical model.
+     *
+     * @param json A trusted `FuzzyDateModel`, typically loaded from storage.
+     */
+    static fromJSON(json) {
+        return new FuzzyDate(json);
+    }
+    /**
+     * Parses a human-readable date string into a `FuzzyDate`.
+     *
+     * This method should be used for all untrusted or user-provided input.
+     *
+     * @param input Human-readable date expression.
+     * @returns A result object containing either a `FuzzyDate` or parse issues.
+     *
+     * @remarks
+     * - Parsing is non-throwing; errors are returned as structured issues.
+     * - Successful results are guaranteed to produce a valid canonical model.
+     */
+    static parse(input) {
+        const result = parse(input);
+        if (!result.ok)
+            return result;
+        const date = new FuzzyDate(result.value);
+        return ok(date);
+    }
+}

package/dist/fuzzyDate/fuzzyDate.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fuzzyDate/fuzzyDate.spec.js

@@ -0,0 +1,158 @@
+import { assert, describe, expect, it } from 'vitest';
+import { FuzzyDate } from './fuzzyDate';
+describe('Fuzzy Date', () => {
+    it('errs if it parses an invalid date', () => {
+        const unknownDate = FuzzyDate.parse('a');
+        expect(unknownDate).toStrictEqual({
+            ok: false,
+            error: 'Unknown date format.',
+        });
+        const invalidBetween = FuzzyDate.parse('between 1900');
+        expect(invalidBetween).toStrictEqual({
+            ok: false,
+            error: 'Invalid "BETWEEN" modifier.',
+        });
+        const invalidFrom = FuzzyDate.parse('from 1900');
+        expect(invalidFrom).toStrictEqual({
+            ok: false,
+            error: 'Invalid "FROM" modifier.',
+        });
+        const invalidMonth = FuzzyDate.parse('jam 1900');
+        expect(invalidMonth).toStrictEqual({
+            ok: false,
+            error: 'Unknown month.',
+        });
+    });
+    it('parses date inputs', () => {
+        const formats = {
+            '1800s': '1800s',
+            '1800': '1800',
+            'Winter 1800': 'winter 1800',
+            '1800 Winter': 'winter 1800',
+            'Jan 1800': 'January 1800',
+            'January 1800': 'January 1800',
+            '1800 Jan': 'January 1800',
+            '1800 January': 'January 1800',
+            '1 Jan 1800': '1 January 1800',
+            '1 1800': 'January 1800',
+            '01 1800': 'January 1800',
+            '1800 1': 'January 1800',
+            '1800 01': 'January 1800',
+            '1 January 1800': '1 January 1800',
+            '01 Jan 1800': '1 January 1800',
+            '01 January 1800': '1 January 1800',
+            'Jan 1 1800': '1 January 1800',
+            'January 1 1800': '1 January 1800',
+            'Jan 01 1800': '1 January 1800',
+            'January 01 1800': '1 January 1800',
+            '1800 Jan 1': '1 January 1800',
+            '1800 January 1': '1 January 1800',
+            '1800 Jan 01': '1 January 1800',
+            '1800 January 01': '1 January 1800',
+            '1800 1 Jan': '1 January 1800',
+            '1800 1 January': '1 January 1800',
+            '1800 01 Jan': '1 January 1800',
+            '1800 01 January': '1 January 1800',
+            '1 1 1800': '1 January 1800',
+            '01 1 1800': '1 January 1800',
+            '1 01 1800': '1 January 1800',
+            '1800 1 1': '1 January 1800',
+            '1800 01 1': '1 January 1800',
+            '1800 1 01': '1 January 1800',
+            '    1st    of    February    1900    ': '1 February 1900',
+            'feb 1st, 1900': '1 February 1900',
+            'February 1st, 1900': '1 February 1900',
+            '  ---___////,,,,    sEpTeMbEr 30  th ,,,   ---// 1984': '30 September 1984',
+        };
+        for (const [key, value] of Object.entries(formats)) {
+            const result = FuzzyDate.parse(key);
+            let normal;
+            if (result.ok) {
+                normal = result.value.normalized;
+            }
+            else {
+                normal = result.error;
+            }
+            expect(normal).toStrictEqual(value);
+        }
+    });
+    it('test modifiers parsing', () => {
+        const modifiers = [
+            '',
+            'before',
+            'after',
+            'about',
+            'between',
+            'from',
+            'early',
+            'mid',
+            'late',
+            'or',
+        ];
+        const parse = {
+            'before 1st of February 1900': 'before 1 February 1900',
+            'after 1st of February 1900': 'after 1 February 1900',
+            'about 1st of February 1900': 'about 1 February 1900',
+            'between 1st of February 1900 and 18/03/1905': 'between 1 February 1900 and 18 March 1905',
+            'from 1st of February 1900 to 18/03/1905': 'from 1 February 1900 to 18 March 1905',
+        };
+        Object.entries(parse).forEach(([input, expected]) => {
+            const result = FuzzyDate.parse(input);
+            let normal;
+            if (result.ok) {
+                normal = result.value.normalized;
+            }
+            else {
+                normal = result.error;
+            }
+            expect(normal).toStrictEqual(expected);
+        });
+    });
+    it('orders serialized dates in chronological order', () => {
+        const order = [
+            'before 2000',
+            'before jan 2000',
+            'before jan 1 2000',
+            'about 2000',
+            'about jan 2000',
+            'about jan 1 2000',
+            '2000',
+            'jan 2000',
+            'jan 1 2000',
+            'from 2000 to 2001',
+            'from 2000 to jan 2001',
+            'from 2000 to 1 jan 2001',
+            'from jan 2000 to 2001',
+            'from jan 2000 to jan 2001',
+            'from jan 2000 to 1 jan 2001',
+            'from 1 jan 2000 to 2001',
+            'from 1 jan 2000 to jan 2001',
+            'from 1 jan 2000 to 1 jan 2001',
+            'between 2000 and 2001',
+            'between 2000 and jan 2001',
+            'between 2000 and 1 jan 2001',
+            'between jan 2000 and 2001',
+            'between jan 2000 and jan 2001',
+            'between jan 2000 and 1 jan 2001',
+            'between 1 jan 2000 and 2001',
+            'between 1 jan 2000 and jan 2001',
+            'between 1 jan 2000 and 1 jan 2001',
+            'after 2000',
+            'after jan 2000',
+            'after jan 1 2000',
+            'jan 2 2000',
+            'dec 31 2000',
+            '',
+        ];
+        for (let i = 1; i < order.length - 1; i++) {
+            const previous = FuzzyDate.parse(order[i - 1]);
+            const current = FuzzyDate.parse(order[i]);
+            if (previous.ok && current.ok) {
+                expect(previous.value.collationKey < current.value.collationKey).toBeTruthy();
+            }
+            else {
+                assert.fail('failed to parse input');
+            }
+        }
+    });
+});

package/dist/fuzzyDate/gedcomX/toGedcomX.d.ts

@@ -0,0 +1,2 @@
+import { FuzzyDateModel } from '../types';
+export declare function toGedcomX(model: FuzzyDateModel): string;