@fhss-web-team/fuzzy-dates 1.2.3 → 2.1.1

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

@@ -1,11 +1,9 @@
-import { calculateMaxDate, parseDateGroups } from '.';
-import { isSeason } from '../helpers/maps';
-import { ok } from '../helpers/result';
+import { ok } from '../../helpers/result';
+import { calculateMaxDate, parseDateGroups } from './helpers';
 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}$`);
@@ -15,16 +13,16 @@ export const year = (rawDate) => {
     const result = parseDateGroups(match.groups);
     if (!result.ok)
         return result;
-    const format = 'YYYY';
-    const minDate = result.value.date;
-    const maxDate = calculateMaxDate(minDate, format);
+    const precision = 'Year';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
-// MMM(M) YYYY || SEASON YYYY
+// MMM(M) YYYY
 export const monthStringYear = (rawDate) => {
     const pattern = new RegExp(String.raw `^${MONTH_STRING}\s${YEAR}$`);
     const match = pattern.exec(rawDate);
@@ -34,16 +32,16 @@ export const monthStringYear = (rawDate) => {
     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);
+    const precision = 'Month';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
-// YYYY MMM(M) || YYYY SEASON
+// YYYY MMM(M)
 export const yearMonthString = (rawDate) => {
     const pattern = new RegExp(String.raw `^${YEAR}\s${MONTH_STRING}$`);
     const match = pattern.exec(rawDate);
@@ -52,14 +50,13 @@ export const yearMonthString = (rawDate) => {
     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);
+    const precision = 'Month';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // D(D) MMM(M) YYYY
@@ -71,13 +68,13 @@ export const dayMonthStringYear = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // MMM(M) D(D) YYYY
@@ -89,13 +86,13 @@ export const monthStringDayYear = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // YYYY MMM(M) D(D)
@@ -107,13 +104,13 @@ export const yearMonthStringDay = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // YYYY D(D) MMM(M)
@@ -125,13 +122,13 @@ export const yearDayMonthString = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // M(M) YYYY
@@ -143,13 +140,13 @@ export const monthDigitYear = (rawDate) => {
     const result = parseDateGroups(match.groups);
     if (!result.ok)
         return result;
-    const format = 'MMMM_YYYY';
-    const minDate = result.value.date;
-    const maxDate = calculateMaxDate(minDate, format);
+    const precision = 'Month';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // YYYY M(M)
@@ -161,13 +158,13 @@ export const yearMonthDigit = (rawDate) => {
     const result = parseDateGroups(match.groups);
     if (!result.ok)
         return result;
-    const format = 'MMMM_YYYY';
-    const minDate = result.value.date;
-    const maxDate = calculateMaxDate(minDate, format);
+    const precision = 'Month';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // D(D) M(M) YYYY
@@ -179,13 +176,13 @@ export const dayMonthDigitYear = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };
 // YYYY M(M)  D(D)
@@ -197,30 +194,12 @@ export const yearMonthDigitDay = (rawDate) => {
     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);
+    const precision = 'Day';
+    const min = result.value.date;
+    const max = calculateMaxDate(min, precision);
     return ok({
-        format: format,
-        minDate: minDate,
-        maxDate: maxDate,
+        precision,
+        min,
+        max,
     });
 };

package/dist/src/parse/simpleDate/helpers.d.ts

@@ -0,0 +1,21 @@
+import { Precision } from '../../helpers/types';
+export declare function calculateMaxDate(start: Date, precision: Precision): Date;
+export declare function parseDateGroups(groups: {
+    day?: string;
+    month?: string;
+    year?: string;
+}): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        date: Date;
+    };
+};

package/dist/src/parse/simpleDate/helpers.js

@@ -0,0 +1,53 @@
+import { isMonth, MONTH_NAME_MAP } from './maps';
+import { err, ok } from '../../helpers/result';
+export function calculateMaxDate(start, precision) {
+    const endDate = new Date(start);
+    if (precision === 'Year') {
+        endDate.setUTCFullYear(endDate.getUTCFullYear() + 1);
+    }
+    else if (precision === 'Month') {
+        endDate.setUTCMonth(endDate.getUTCMonth() + 1);
+    }
+    else if (precision === 'Day') {
+        endDate.setUTCDate(endDate.getUTCDate() + 1);
+    }
+    else if (precision === 'Hour') {
+        endDate.setUTCHours(endDate.getUTCHours() + 1);
+    }
+    else if (precision === 'Minute') {
+        endDate.setUTCMinutes(endDate.getUTCMinutes() + 1);
+    }
+    else {
+        endDate.setUTCSeconds(endDate.getUTCSeconds() + 1);
+    }
+    endDate.setUTCMilliseconds(-1);
+    return endDate;
+}
+export function parseDateGroups(groups) {
+    if (!groups.year)
+        return err('Year is required.');
+    const year = parseInt(groups.year);
+    let month = 0; //default to January
+    if (groups.month) {
+        const result = resolveMonth(groups.month.toLowerCase());
+        if (!result.ok)
+            return result;
+        month = result.value.monthNumber;
+    }
+    let day = 1; //default to 1st day
+    if (groups.day) {
+        const dayToken = /^(?:0?[1-9]|[12][0-9]|3[01])$/.exec(groups.day)?.[0];
+        if (!dayToken)
+            return err('Unknown date format.');
+        day = Number(dayToken);
+    }
+    return ok({ date: new Date(Date.UTC(year, month, day)) });
+}
+function resolveMonth(rawMonth) {
+    const monthToken = /^(?:0?[1-9]|1[0-2])$/.exec(rawMonth)?.[0]; //Matches 01-09 or 1-9 or 10-12
+    if (monthToken)
+        return ok({ monthNumber: Number(monthToken) - 1 }); //months are zero-based
+    if (isMonth(rawMonth))
+        return ok({ monthNumber: MONTH_NAME_MAP[rawMonth] - 1 });
+    return err('Unknown month.');
+}

package/dist/{fuzzyDate/helpers → src/parse/simpleDate}/maps.d.ts

@@ -5,22 +5,6 @@ export declare const MONTH_SEASON_MAP: {
     readonly autumn: 9;
     readonly winter: 12;
 };
-export declare function isSeason(input: string): input is keyof typeof MONTH_SEASON_MAP;
-export declare const SEASON_MONTH_MAP: {
-    readonly 1: "winter";
-    readonly 2: "winter";
-    readonly 3: "spring";
-    readonly 4: "spring";
-    readonly 5: "spring";
-    readonly 6: "summer";
-    readonly 7: "summer";
-    readonly 8: "summer";
-    readonly 9: "fall";
-    readonly 10: "fall";
-    readonly 11: "fall";
-    readonly 12: "winter";
-};
-export declare function isSeasonMonth(input: number): input is keyof typeof SEASON_MONTH_MAP;
 export declare const MONTH_NAME_MAP: {
     readonly jan: 1;
     readonly january: 1;

package/dist/{fuzzyDate/helpers → src/parse/simpleDate}/maps.js

@@ -5,26 +5,6 @@ export const MONTH_SEASON_MAP = {
     autumn: 9,
     winter: 12,
 };
-export function isSeason(input) {
-    return Object.keys(MONTH_SEASON_MAP).includes(input);
-}
-export const SEASON_MONTH_MAP = {
-    1: 'winter',
-    2: 'winter',
-    3: 'spring',
-    4: 'spring',
-    5: 'spring',
-    6: 'summer',
-    7: 'summer',
-    8: 'summer',
-    9: 'fall',
-    10: 'fall',
-    11: 'fall',
-    12: 'winter',
-};
-export function isSeasonMonth(input) {
-    return input >= 1 && input <= 12;
-}
 export const MONTH_NAME_MAP = {
     jan: 1,
     january: 1,

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

@@ -0,0 +1,31 @@
+export declare function parseSimpleDate(input: string): {
+    ok: false;
+    error: "Year is required.";
+} | {
+    ok: false;
+    error: "Unknown month.";
+} | {
+    ok: false;
+    error: "Unknown date format.";
+} | {
+    ok: true;
+    value: {
+        readonly precision: "Year";
+        readonly min: Date;
+        readonly max: Date;
+    };
+} | {
+    ok: true;
+    value: {
+        readonly precision: "Month";
+        readonly min: Date;
+        readonly max: Date;
+    };
+} | {
+    ok: true;
+    value: {
+        readonly precision: "Day";
+        readonly min: Date;
+        readonly max: Date;
+    };
+};

package/dist/{fuzzyDate/parse/stringToDate.js → src/parse/simpleDate/parse.js}

@@ -1,6 +1,6 @@
-import { err } from '../helpers/result';
-import { dayMonthDigitYear, dayMonthStringYear, decade, monthDigitYear, monthStringDayYear, monthStringYear, year, yearMonthDigitDay, yearDayMonthString, yearMonthDigit, yearMonthString, yearMonthStringDay, } from './inputDateFormats';
-export function stringToDate(dateInput) {
+import { err } from '../../helpers/result';
+import { dayMonthDigitYear, dayMonthStringYear, monthDigitYear, monthStringDayYear, monthStringYear, year, yearMonthDigitDay, yearDayMonthString, yearMonthDigit, yearMonthString, yearMonthStringDay, } from './formats';
+export function parseSimpleDate(input) {
     const parsers = [
         year,
         monthStringYear,
@@ -13,10 +13,9 @@ export function stringToDate(dateInput) {
         yearMonthDigit,
         dayMonthDigitYear,
         yearMonthDigitDay,
-        decade,
     ];
     for (const parseFormat of parsers) {
-        const result = parseFormat(dateInput);
+        const result = parseFormat(input);
         if (result)
             return result;
     }

package/package.json

@@ -1,17 +1,13 @@
 {
   "name": "@fhss-web-team/fuzzy-dates",
-  "version": "1.2.3",
+  "version": "2.1.1",
   "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": {
-    "url": "https://github.com/FHSS-Web-Team/fuzzy-dates/issues"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/FHSS-Web-Team/fuzzy-dates.git"
   },
   "main": "./dist/index.js",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
@@ -25,25 +21,19 @@
     "LICENSE"
   ],
   "license": "MIT",
-  "author": "",
   "type": "module",
   "scripts": {
     "build": "npm run clean && tsc",
     "test": "vitest",
     "test:run": "vitest run",
     "clean": "rm -rf dist",
-    "prepublishOnly": "npm run clean && npm run build",
     "preversion": "npm run build",
     "postversion": "git push",
     "deploy": "npm run build && npm publish --access public"
   },
   "devDependencies": {
     "prettier": "^3.6.2",
-    "ts-node": "^10.9.2",
     "typescript": "^5.0.0",
     "vitest": "^4.0.0"
-  },
-  "dependencies": {
-    "zod": "^4.3.5"
   }
 }

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

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

package/dist/fuzzyDate/collate/collate.js

@@ -1,15 +0,0 @@
-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)
-        .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}`;
-}