@fhss-web-team/fuzzy-dates 1.1.1 → 1.2.0

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

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

package/dist/fuzzyDate/collate/collate.js

@@ -1,4 +1,4 @@
-import { FORMAT_ORDER, MODIFIER_ORDER } from '../types';
+import { FORMAT_ORDER, MODIFIER_ORDER } from '../helpers/constants';
 export function collate(model) {
     const date1 = model.start.minDate.toISOString();
     const modifier = MODIFIER_ORDER.indexOf(model.modifier)

package/dist/fuzzyDate/fuzzyDate.d.ts

@@ -1,4 +1,4 @@
-import { FuzzyDateModel } from './types';
+import { FuzzyDateJson } from './helpers/types';
 /**
  * Represents an immutable, parsed fuzzy date suitable for genealogy and
  * historical data contexts.
@@ -159,13 +159,19 @@ export declare class FuzzyDate {
      * The returned object is suitable for long-term storage,
      * transport, and later reconstruction via {@link fromJSON}.
      */
-    toJSON(): FuzzyDateModel;
+    toJSON(): FuzzyDateJson;
     /**
      * Reconstructs a `FuzzyDate` from a previously serialized canonical model.
      *
-     * @param json A trusted `FuzzyDateModel`, typically loaded from storage.
+     * @param data A trusted `FuzzyDateModel`, typically loaded from storage.
      */
-    static fromJSON(json: FuzzyDateModel): FuzzyDate;
+    static fromJSON(data: unknown): {
+        ok: true;
+        value: FuzzyDate;
+    } | {
+        ok: false;
+        error: "Invalid JSON data.";
+    };
     /**
      * Parses a human-readable date string into a `FuzzyDate`.
      *

package/dist/fuzzyDate/fuzzyDate.js

@@ -2,7 +2,9 @@ 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';
+import { DATE_NEG_INFINITY, DATE_POS_INFINITY } from './helpers/constants';
+import { ok, err } from './helpers/result';
+import { fuzzyDateJsonSchema } from './helpers/schemas';
 /**
  * Represents an immutable, parsed fuzzy date suitable for genealogy and
  * historical data contexts.
@@ -180,15 +182,47 @@ export class FuzzyDate {
      * transport, and later reconstruction via {@link fromJSON}.
      */
     toJSON() {
-        return this._model;
+        return {
+            modifier: this._model.modifier,
+            start: {
+                format: this._model.start.format,
+                minDate: this._model.start.minDate.toISOString(),
+                maxDate: this._model.start.maxDate.toISOString(),
+            },
+            end: {
+                format: this._model.end.format,
+                minDate: this._model.end.minDate.toISOString(),
+                maxDate: this._model.end.maxDate.toISOString(),
+            },
+        };
     }
     /**
      * Reconstructs a `FuzzyDate` from a previously serialized canonical model.
      *
-     * @param json A trusted `FuzzyDateModel`, typically loaded from storage.
+     * @param data A trusted `FuzzyDateModel`, typically loaded from storage.
      */
-    static fromJSON(json) {
-        return new FuzzyDate(json);
+    static fromJSON(data) {
+        try {
+            const json = typeof data === 'string' ? JSON.parse(data) : data;
+            const safeJson = fuzzyDateJsonSchema.parse(json);
+            const model = {
+                modifier: safeJson.modifier,
+                start: {
+                    format: safeJson.start.format,
+                    minDate: new Date(safeJson.start.minDate),
+                    maxDate: new Date(safeJson.start.maxDate),
+                },
+                end: {
+                    format: safeJson.end.format,
+                    minDate: new Date(safeJson.end.minDate),
+                    maxDate: new Date(safeJson.end.maxDate),
+                },
+            };
+            return ok(new FuzzyDate(model));
+        }
+        catch {
+            return err('Invalid JSON data.');
+        }
     }
     /**
      * Parses a human-readable date string into a `FuzzyDate`.

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

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

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

@@ -0,0 +1,4 @@
+export declare const DATE_NEG_INFINITY: Date;
+export declare const DATE_POS_INFINITY: Date;
+export declare const FORMAT_ORDER: readonly ["YYYYs", "YYYY", "SEASON_YYYY", "MMMM_YYYY", "D_MMMM_YYYY"];
+export declare const MODIFIER_ORDER: readonly ["BEFORE", "ABOUT", "NONE", "EARLY", "MID", "LATE", "FROM", "BETWEEN", "AFTER"];

package/dist/fuzzyDate/helpers/constants.js

@@ -0,0 +1,20 @@
+export const DATE_NEG_INFINITY = new Date(-8640000000000000);
+export const DATE_POS_INFINITY = new Date(8640000000000000);
+export const FORMAT_ORDER = [
+    'YYYYs',
+    'YYYY',
+    'SEASON_YYYY',
+    'MMMM_YYYY',
+    'D_MMMM_YYYY',
+];
+export const MODIFIER_ORDER = [
+    'BEFORE',
+    'ABOUT',
+    'NONE',
+    'EARLY',
+    'MID',
+    'LATE',
+    'FROM',
+    'BETWEEN',
+    'AFTER',
+];

package/dist/fuzzyDate/{types.d.ts → helpers/maps.d.ts}

@@ -1,30 +1,3 @@
-type Ok<T> = {
-    ok: true;
-    value: T;
-};
-type Err<E = unknown> = {
-    ok: false;
-    error: E;
-};
-export type Result<T, E> = Ok<T> | Err<E>;
-export declare function ok<T = undefined>(value?: T): Ok<T>;
-export declare function err<E>(error: E): Err<E>;
-export declare const DATE_NEG_INFINITY: Date;
-export declare const DATE_POS_INFINITY: Date;
-export declare const FORMAT_ORDER: readonly ["YYYYs", "YYYY", "SEASON_YYYY", "MMMM_YYYY", "D_MMMM_YYYY"];
-export type NormalFormat = (typeof FORMAT_ORDER)[number];
-export declare const MODIFIER_ORDER: readonly ["BEFORE", "ABOUT", "NONE", "EARLY", "MID", "LATE", "FROM", "BETWEEN", "AFTER"];
-export type FuzzyDateModifier = (typeof MODIFIER_ORDER)[number];
-export type FuzzyDateValue = {
-    format: NormalFormat;
-    minDate: Date;
-    maxDate: Date;
-};
-export type FuzzyDateModel = {
-    modifier: FuzzyDateModifier;
-    start: FuzzyDateValue;
-    end: FuzzyDateValue;
-};
 export declare const MONTH_SEASON_MAP: {
     readonly spring: 3;
     readonly summer: 6;
@@ -75,4 +48,3 @@ export declare const MONTH_NAME_MAP: {
     readonly december: 12;
 };
 export declare function isMonth(input: string): input is keyof typeof MONTH_NAME_MAP;
-export {};

package/dist/fuzzyDate/{types.js → helpers/maps.js}

@@ -1,35 +1,3 @@
-export function ok(value) {
-    return {
-        ok: true,
-        value,
-    };
-}
-export function err(error) {
-    return {
-        ok: false,
-        error,
-    };
-}
-export const DATE_NEG_INFINITY = new Date(-8640000000000000);
-export const DATE_POS_INFINITY = new Date(8640000000000000);
-export const FORMAT_ORDER = [
-    'YYYYs',
-    'YYYY',
-    'SEASON_YYYY',
-    'MMMM_YYYY',
-    'D_MMMM_YYYY',
-];
-export const MODIFIER_ORDER = [
-    'BEFORE',
-    'ABOUT',
-    'NONE',
-    'EARLY',
-    'MID',
-    'LATE',
-    'FROM',
-    'BETWEEN',
-    'AFTER',
-];
 export const MONTH_SEASON_MAP = {
     spring: 3,
     summer: 6,

package/dist/fuzzyDate/helpers/result.d.ts

@@ -0,0 +1,12 @@
+type Ok<T> = {
+    ok: true;
+    value: T;
+};
+type Err<E = unknown> = {
+    ok: false;
+    error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare function ok<T = undefined>(value?: T): Ok<T>;
+export declare function err<E>(error: E): Err<E>;
+export {};

package/dist/fuzzyDate/helpers/result.js

@@ -0,0 +1,12 @@
+export function ok(value) {
+    return {
+        ok: true,
+        value,
+    };
+}
+export function err(error) {
+    return {
+        ok: false,
+        error,
+    };
+}

package/dist/fuzzyDate/helpers/schemas.d.ts

@@ -0,0 +1,36 @@
+import z from 'zod';
+export declare const fuzzyDateJsonSchema: z.ZodObject<{
+    modifier: z.ZodEnum<{
+        BEFORE: "BEFORE";
+        ABOUT: "ABOUT";
+        NONE: "NONE";
+        EARLY: "EARLY";
+        MID: "MID";
+        LATE: "LATE";
+        FROM: "FROM";
+        BETWEEN: "BETWEEN";
+        AFTER: "AFTER";
+    }>;
+    start: z.ZodObject<{
+        format: z.ZodEnum<{
+            YYYYs: "YYYYs";
+            YYYY: "YYYY";
+            SEASON_YYYY: "SEASON_YYYY";
+            MMMM_YYYY: "MMMM_YYYY";
+            D_MMMM_YYYY: "D_MMMM_YYYY";
+        }>;
+        minDate: z.ZodISODateTime;
+        maxDate: z.ZodISODateTime;
+    }, z.core.$strip>;
+    end: z.ZodObject<{
+        format: z.ZodEnum<{
+            YYYYs: "YYYYs";
+            YYYY: "YYYY";
+            SEASON_YYYY: "SEASON_YYYY";
+            MMMM_YYYY: "MMMM_YYYY";
+            D_MMMM_YYYY: "D_MMMM_YYYY";
+        }>;
+        minDate: z.ZodISODateTime;
+        maxDate: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/fuzzyDate/helpers/schemas.js

@@ -0,0 +1,12 @@
+import z from 'zod';
+import { FORMAT_ORDER, MODIFIER_ORDER } from './constants';
+const fuzzyDateValueSchema = z.object({
+    format: z.enum(FORMAT_ORDER),
+    minDate: z.iso.datetime(),
+    maxDate: z.iso.datetime(),
+});
+export const fuzzyDateJsonSchema = z.object({
+    modifier: z.enum(MODIFIER_ORDER),
+    start: fuzzyDateValueSchema,
+    end: fuzzyDateValueSchema,
+});

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

@@ -0,0 +1,16 @@
+import z from 'zod';
+import { FORMAT_ORDER, MODIFIER_ORDER } from './constants';
+import { fuzzyDateJsonSchema } from './schemas';
+export type FuzzyDateFormat = (typeof FORMAT_ORDER)[number];
+export type FuzzyDate = (typeof MODIFIER_ORDER)[number];
+export type FuzzyDateValue = {
+    format: FuzzyDateFormat;
+    minDate: Date;
+    maxDate: Date;
+};
+export type FuzzyDateModel = {
+    modifier: FuzzyDate;
+    start: FuzzyDateValue;
+    end: FuzzyDateValue;
+};
+export type FuzzyDateJson = z.infer<typeof fuzzyDateJsonSchema>;

package/dist/fuzzyDate/helpers/types.js

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

package/dist/fuzzyDate/normalize/normalize.d.ts

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

package/dist/fuzzyDate/normalize/normalize.js

@@ -1,4 +1,4 @@
-import { SEASON_MONTH_MAP, isSeasonMonth, } from '../types';
+import { isSeasonMonth, SEASON_MONTH_MAP } from '../helpers/maps';
 // Main function
 export function normalize(model) {
     const startDate = normalizeDate(model.start.minDate, model.start.format);

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

@@ -1,4 +1,4 @@
-import { NormalFormat, FuzzyDateValue } from '../types';
+import { FuzzyDateFormat, FuzzyDateValue } from '../helpers/types';
 export declare function parse(input: string): {
     ok: false;
     error: "Year is required.";
@@ -155,7 +155,7 @@ export declare function getTimes(date: FuzzyDateValue): {
     end: number;
     half: number;
 };
-export declare function calculateMaxDate(start: Date, format: NormalFormat): Date;
+export declare function calculateMaxDate(start: Date, format: FuzzyDateFormat): Date;
 export declare function parseDateGroups(groups: {
     day?: string;
     month?: string;

package/dist/fuzzyDate/parse/index.js

@@ -1,5 +1,6 @@
 import { about, after, before, between, early, from, late, mid, none, } from './modifiers';
-import { ok, err, MONTH_NAME_MAP, MONTH_SEASON_MAP, isMonth, isSeason, } from '../types';
+import { err, ok } from '../helpers/result';
+import { isMonth, isSeason, MONTH_NAME_MAP, MONTH_SEASON_MAP, } from '../helpers/maps';
 // Main Parse Function
 export function parse(input) {
     const cleanedInput = input

package/dist/fuzzyDate/parse/inputDateFormats.js

@@ -1,5 +1,6 @@
 import { calculateMaxDate, parseDateGroups } from '.';
-import { ok, isSeason } from '../types';
+import { isSeason } from '../helpers/maps';
+import { ok } from '../helpers/result';
 const DAY = '(?<day>\\d{1,2})';
 const MONTH_DIGIT = '(?<month>\\d{1,2})';
 const MONTH_STRING = '(?<month>[a-z]+)';

package/dist/fuzzyDate/parse/modifiers.js

@@ -1,5 +1,6 @@
 import { getTimes } from '.';
-import { ok, err, DATE_NEG_INFINITY, DATE_POS_INFINITY } from '../types';
+import { DATE_NEG_INFINITY, DATE_POS_INFINITY } from '../helpers/constants';
+import { err, ok } from '../helpers/result';
 import { stringToDate } from './stringToDate';
 export const none = (cleanedInput) => {
     const result = stringToDate(cleanedInput);

package/dist/fuzzyDate/parse/stringToDate.js

@@ -1,4 +1,4 @@
-import { err } from '../types';
+import { err } from '../helpers/result';
 import { dayMonthDigitYear, dayMonthStringYear, decade, monthDigitYear, monthStringDayYear, monthStringYear, year, yearMonthDigitDay, yearDayMonthString, yearMonthDigit, yearMonthString, yearMonthStringDay, } from './inputDateFormats';
 export function stringToDate(dateInput) {
     const parsers = [

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { FuzzyDate } from './fuzzyDate/fuzzyDate';
-export { FuzzyDateModel } from './fuzzyDate/types';
+export { FuzzyDateJson } from './fuzzyDate/helpers/types';
+export { fuzzyDateJsonSchema } from './fuzzyDate/helpers/schemas';

package/dist/index.js

@@ -1 +1,2 @@
 export { FuzzyDate } from './fuzzyDate/fuzzyDate';
+export { fuzzyDateJsonSchema } from './fuzzyDate/helpers/schemas';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fhss-web-team/fuzzy-dates",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Parses imprecise date strings into a structured form that can be normalized, indexed, searched, and ordered while preserving the original input.",
   "homepage": "https://github.com/FHSS-Web-Team/fuzzy-dates#readme",
   "bugs": {
@@ -42,5 +42,8 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.0.0",
     "vitest": "^4.0.0"
+  },
+  "dependencies": {
+    "zod": "^4.3.5"
   }
 }