mdtg 2.1.1 → 3.0.1

package/README.md

@@ -1,6 +1,6 @@
 # MDTG
 
-This is a package that helps you to convert `Date` objects to [military date time](https://en.wikipedia.org/wiki/Date-time_group) and vice versa.
+This package converts `Date` objects to [military date time](https://en.wikipedia.org/wiki/Date-time_group) and vice versa.
 
 ### Install
 
@@ -11,16 +11,42 @@ npm install mdtg
 ### Usage
 
 ```js
-import { MDTG } from "mdtg";
+import { parse, toMDT } from "mdtg";
 
-const mdtg = new MDTG();
+const date = new Date();
 
-console.log(mdtg.toMDT({ form: "short" }));
-console.log(mdtg.toMDT({ form: "shortened" }));
-console.log(mdtg.toMDT({ form: "long" }));
+console.log(toMDT(date, { form: "short" }));
+console.log(toMDT(date, { form: "shortened" }));
+console.log(toMDT(date, { form: "long" }));
 
-console.log(MDTG.parse("12135530Zaug24"));
-console.log(MDTG.parse("12135530Asep24"));
-console.log(MDTG.parse("121355LOCT24"));
-console.log(MDTG.parse("121355M"));
+console.log(parse("12135530Zaug24"));
+console.log(parse("12135530Asep24"));
+console.log(parse("121355LOCT24"));
+console.log(parse("121355M"));
 ```
+
+### API
+
+#### `toMDT(date, options)`
+
+Converts a valid `Date` to a date-time group. `date` defaults to the current
+date. `options.form` is `"short"`, `"shortened"`, or `"long"` (the default).
+`options.timezone` accepts the NATO time-zone letters `A` through `Z`;
+lowercase letters are accepted and unknown values default to `Z`.
+
+```js
+toMDT(new Date(Date.UTC(2024, 7, 12, 11, 55, 30)), {
+  form: "long",
+  timezone: "A",
+});
+// "12125530Aaug24"
+```
+
+#### `parse(value)`
+
+Parses short (`121155Z`), shortened (`121155Zaug24`), and long
+(`12115530Zaug24`) formats into a `Date`. Short values use the current UTC
+month and year. Years are interpreted as `2000` through `2099`.
+
+Invalid calendar dates and times, such as `310224Zfeb24` or `126155Z`, throw a
+`RangeError`. Other invalid values throw an `Error`.

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "mdtg",
-  "version": "2.1.1",
-  "main": "index.js",
+  "version": "3.0.1",
+  "main": "src/index.js",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=22.0.0",
+    "npm": ">=10.0.0"
   },
   "scripts": {
     "bench": "vitest bench --run",
     "coverage": "vitest run --coverage",
-    "format": "biome format .",
+    "format": "biome check .",
     "prelint": "npm run format && npm run prettier",
     "lint": "biome lint .",
     "prettier": "prettier **/*.yml",

package/src/constants.js

@@ -0,0 +1,55 @@
+export const MONTHS = [
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "oct",
+  "nov",
+  "dec",
+];
+
+export const OFFSETS = Object.freeze({
+  Y: 12,
+  X: 11,
+  W: 10,
+  V: 9,
+  U: 8,
+  T: 7,
+  S: 6,
+  R: 5,
+  Q: 4,
+  P: 3,
+  O: 2,
+  N: 1,
+  Z: 0,
+  A: -1,
+  B: -2,
+  C: -3,
+  D: -4,
+  E: -5,
+  F: -6,
+  G: -7,
+  H: -8,
+  I: -9,
+  J: -10,
+  K: -11,
+  L: -12,
+  M: -13,
+});
+
+export const SHORT_FORMAT_REGEX = /^[0-9]{6}[A-Z]$/;
+export const SHORTENED_FORMAT_REGEX =
+  /^[0-9]{6}[A-Z](jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[0-9]{2}$/i;
+export const LONG_FORMAT_REGEX =
+  /^[0-9]{8}[A-Z](jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[0-9]{2}$/i;
+
+export const FORM = Object.freeze({
+  SHORT: "short",
+  SHORTENED: "shortened",
+  LONG: "long",
+});

package/src/format.js

@@ -0,0 +1,81 @@
+import { FORM, MONTHS, OFFSETS } from "./constants.js";
+import {
+  isLongFormat,
+  isShortenedFormat,
+  isShortFormat,
+  validateDate,
+  validateTimezone,
+} from "./validation.js";
+
+const normalizeNumber = (number) => String(number).padStart(2, "0");
+
+const createDateWithOffset = (date, offset) =>
+  new Date(date.getTime() - offset * 60 * 60 * 1000);
+
+const buildShort = (date, timezone) => {
+  const result = [date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes()]
+    .map(normalizeNumber)
+    .concat(timezone)
+    .join("");
+
+  if (!isShortFormat(result)) {
+    throw new Error("Failed to build short MDTG");
+  }
+
+  return result;
+};
+
+const buildLong = (date, timezone) => {
+  const result = [
+    date.getUTCDate(),
+    date.getUTCHours(),
+    date.getUTCMinutes(),
+    date.getUTCSeconds(),
+  ]
+    .map(normalizeNumber)
+    .concat(
+      timezone,
+      MONTHS[date.getUTCMonth()],
+      normalizeNumber(date.getUTCFullYear() % 100),
+    )
+    .join("");
+
+  if (!isLongFormat(result)) {
+    throw new Error("Failed to build long MDTG");
+  }
+
+  return result;
+};
+
+const buildShortened = (date, timezone) => {
+  const result = [
+    buildShort(date, timezone),
+    MONTHS[date.getUTCMonth()],
+    normalizeNumber(date.getUTCFullYear() % 100),
+  ].join("");
+
+  if (!isShortenedFormat(result)) {
+    throw new Error("Failed to build shortened MDTG");
+  }
+
+  return result;
+};
+
+export const toMDT = (
+  date = new Date(),
+  { form = FORM.LONG, timezone: timezoneInput = "Z" } = {},
+) => {
+  validateDate(date);
+
+  const timezone = validateTimezone(timezoneInput);
+  const adjustedDate = createDateWithOffset(date, OFFSETS[timezone]);
+
+  switch (form) {
+    case FORM.SHORT:
+      return buildShort(adjustedDate, timezone);
+    case FORM.SHORTENED:
+      return buildShortened(adjustedDate, timezone);
+    default:
+      return buildLong(adjustedDate, timezone);
+  }
+};

package/src/index.js

@@ -0,0 +1,8 @@
+export { FORM } from "./constants.js";
+export { toMDT } from "./format.js";
+export { parse } from "./parse.js";
+export {
+  isLongFormat,
+  isShortenedFormat,
+  isShortFormat,
+} from "./validation.js";

package/src/parse.js

@@ -0,0 +1,81 @@
+import { MONTHS, OFFSETS } from "./constants.js";
+import {
+  isLongFormat,
+  isShortenedFormat,
+  isShortFormat,
+  validateDateTime,
+} from "./validation.js";
+
+const parseInteger = (input) => Number.parseInt(input, 10);
+
+const parseShort = (value) => {
+  const day = parseInteger(value.slice(0, 2));
+  const hours = parseInteger(value.slice(2, 4));
+  const minutes = parseInteger(value.slice(4, 6));
+  const timezone = value.slice(6, 7).toUpperCase();
+  const now = new Date();
+
+  validateDateTime({
+    year: now.getUTCFullYear(),
+    month: now.getUTCMonth(),
+    day,
+    hours,
+    minutes,
+  });
+
+  return new Date(
+    Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      day,
+      hours + OFFSETS[timezone],
+      minutes,
+    ),
+  );
+};
+
+const parseWithMonth = (value, { hasSeconds, timezoneIndex, monthStart }) => {
+  const day = parseInteger(value.slice(0, 2));
+  const hours = parseInteger(value.slice(2, 4));
+  const minutes = parseInteger(value.slice(4, 6));
+  const seconds = hasSeconds ? parseInteger(value.slice(6, 8)) : undefined;
+  const timezone = value.slice(timezoneIndex, timezoneIndex + 1).toUpperCase();
+  const month = MONTHS.indexOf(
+    value.slice(monthStart, monthStart + 3).toLowerCase(),
+  );
+  const year = 2000 + parseInteger(value.slice(monthStart + 3, monthStart + 5));
+
+  validateDateTime({
+    year,
+    month,
+    day,
+    hours,
+    minutes,
+    seconds,
+  });
+
+  const dateParts = [year, month, day, hours + OFFSETS[timezone], minutes];
+  if (seconds !== undefined) dateParts.push(seconds);
+
+  return new Date(Date.UTC(...dateParts));
+};
+
+export const parse = (value) => {
+  if (isShortFormat(value)) return parseShort(value);
+  if (isShortenedFormat(value)) {
+    return parseWithMonth(value, {
+      hasSeconds: false,
+      timezoneIndex: 6,
+      monthStart: 7,
+    });
+  }
+  if (isLongFormat(value)) {
+    return parseWithMonth(value, {
+      hasSeconds: true,
+      timezoneIndex: 8,
+      monthStart: 9,
+    });
+  }
+
+  throw new Error(`Invalid MDTG string "${value}"`);
+};

package/src/validation.js

@@ -0,0 +1,50 @@
+import {
+  LONG_FORMAT_REGEX,
+  OFFSETS,
+  SHORT_FORMAT_REGEX,
+  SHORTENED_FORMAT_REGEX,
+} from "./constants.js";
+
+export const isShortFormat = (value) =>
+  typeof value === "string" && SHORT_FORMAT_REGEX.test(value);
+
+export const isShortenedFormat = (value) =>
+  typeof value === "string" && SHORTENED_FORMAT_REGEX.test(value);
+
+export const isLongFormat = (value) =>
+  typeof value === "string" && LONG_FORMAT_REGEX.test(value);
+
+export const validateDate = (date) => {
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+    throw new TypeError("Expected a valid Date object");
+  }
+};
+
+export const validateTimezone = (timezone) => {
+  const key = timezone?.toUpperCase();
+  return key in OFFSETS ? key : "Z";
+};
+
+export const validateDateTime = ({
+  year,
+  month,
+  day,
+  hours,
+  minutes,
+  seconds,
+}) => {
+  const candidate = new Date(
+    Date.UTC(year, month, day, hours, minutes, seconds ?? 0),
+  );
+
+  if (
+    candidate.getUTCFullYear() !== year ||
+    candidate.getUTCMonth() !== month ||
+    candidate.getUTCDate() !== day ||
+    candidate.getUTCHours() !== hours ||
+    candidate.getUTCMinutes() !== minutes ||
+    candidate.getUTCSeconds() !== (seconds ?? 0)
+  ) {
+    throw new RangeError("Invalid MDTG date or time");
+  }
+};

package/index.js

@@ -1,249 +0,0 @@
-const normalizeNumber = (number) => String(number).padStart(2, "0");
-const parseInteger = (input) => Number.parseInt(input, 10);
-
-export class MDTG {
-  #currentDate;
-
-  static FORM = {
-    SHORT: "short",
-    SHORTENED: "shortened",
-    LONG: "long",
-  };
-
-  static #months = [
-    "jan",
-    "feb",
-    "mar",
-    "apr",
-    "may",
-    "jun",
-    "jul",
-    "aug",
-    "sep",
-    "oct",
-    "nov",
-    "dec",
-  ];
-
-  static #shortFormatRegex = /^[0-9]{6}[A-Z]$/;
-  static #shortenedFormatRegex =
-    /^[0-9]{6}[A-Z](jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[0-9]{2}$/i;
-  static #longFormatRegex =
-    /^[0-9]{8}[A-Z](jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[0-9]{2}$/i;
-
-  static #offset = {
-    Y: 12,
-    X: 11,
-    W: 10,
-    V: 9,
-    U: 8,
-    T: 7,
-    S: 6,
-    R: 5,
-    Q: 4,
-    P: 3,
-    O: 2,
-    N: 1,
-    Z: 0,
-    A: -1,
-    B: -2,
-    C: -3,
-    D: -4,
-    E: -5,
-    F: -6,
-    G: -7,
-    H: -8,
-    I: -9,
-    J: -10,
-    K: -11,
-    L: -12,
-    M: -13,
-  };
-
-  constructor(date) {
-    if (date && !(date instanceof Date)) {
-      throw new TypeError("Expected Date object");
-    }
-
-    const now = new Date();
-
-    this.#currentDate =
-      date ??
-      new Date(
-        Date.UTC(
-          now.getUTCFullYear(),
-          now.getUTCMonth(),
-          now.getUTCDate(),
-          now.getUTCHours(),
-          now.getUTCMinutes(),
-          now.getUTCSeconds(),
-          now.getUTCMilliseconds(),
-        ),
-      );
-  }
-
-  static #validateTimezone(tz) {
-    const key = tz?.toUpperCase();
-    return key in MDTG.#offset ? key : "Z";
-  }
-
-  #createDateWithOffset(offset) {
-    const d = this.#currentDate;
-
-    return new Date(
-      Date.UTC(
-        d.getUTCFullYear(),
-        d.getUTCMonth(),
-        d.getUTCDate(),
-        d.getUTCHours() - offset,
-        d.getUTCMinutes(),
-        d.getUTCSeconds(),
-      ),
-    );
-  }
-
-  static isShortFormat(str) {
-    return MDTG.#shortFormatRegex.test(str);
-  }
-
-  static isShortenedFormat(str) {
-    return MDTG.#shortenedFormatRegex.test(str);
-  }
-
-  static isLongFormat(str) {
-    return MDTG.#longFormatRegex.test(str);
-  }
-
-  #toShortMDT(timezone = "Z") {
-    const tz = MDTG.#validateTimezone(timezone);
-    const date = this.#createDateWithOffset(MDTG.#offset[tz]);
-
-    const result = [date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes()]
-      .map(normalizeNumber)
-      .concat(tz)
-      .join("");
-
-    if (!MDTG.isShortFormat(result)) {
-      throw new Error("Failed to build short MDTG");
-    }
-
-    return result;
-  }
-
-  #toLongMDT(timezone = "Z") {
-    const tz = MDTG.#validateTimezone(timezone);
-    const date = this.#createDateWithOffset(MDTG.#offset[tz]);
-
-    const result = [
-      date.getUTCDate(),
-      date.getUTCHours(),
-      date.getUTCMinutes(),
-      date.getUTCSeconds(),
-    ]
-      .map(normalizeNumber)
-      .concat(
-        tz,
-        MDTG.#months[date.getUTCMonth()],
-        normalizeNumber(date.getUTCFullYear() % 100),
-      )
-      .join("");
-
-    if (!MDTG.isLongFormat(result)) {
-      throw new Error("Failed to build long MDTG");
-    }
-
-    return result;
-  }
-
-  #toShortenedMDT(timezone = "Z") {
-    const tz = MDTG.#validateTimezone(timezone);
-    const date = this.#createDateWithOffset(MDTG.#offset[tz]);
-
-    const result = [
-      this.#toShortMDT(tz),
-      MDTG.#months[date.getUTCMonth()],
-      normalizeNumber(date.getUTCFullYear() % 100),
-    ].join("");
-
-    if (!MDTG.isShortenedFormat(result)) {
-      throw new Error("Failed to build shortened MDTG");
-    }
-
-    return result;
-  }
-
-  toMDT({ form = MDTG.FORM.LONG, timezone = "Z" } = {}) {
-    switch (form) {
-      case MDTG.FORM.SHORT:
-        return this.#toShortMDT(timezone);
-      case MDTG.FORM.SHORTENED:
-        return this.#toShortenedMDT(timezone);
-      default:
-        return this.#toLongMDT(timezone);
-    }
-  }
-
-  static #parseShort(str) {
-    const day = parseInteger(str.slice(0, 2));
-    const hours = parseInteger(str.slice(2, 4));
-    const minutes = parseInteger(str.slice(4, 6));
-    const tz = str.slice(6, 7).toUpperCase();
-
-    const today = new Date();
-
-    return new Date(
-      Date.UTC(
-        today.getUTCFullYear(),
-        today.getUTCMonth(),
-        day,
-        hours + MDTG.#offset[tz],
-        minutes,
-      ),
-    );
-  }
-
-  static #parseShortened(str) {
-    const day = parseInteger(str.slice(0, 2));
-    const hours = parseInteger(str.slice(2, 4));
-    const minutes = parseInteger(str.slice(4, 6));
-    const tz = str.slice(6, 7).toUpperCase();
-
-    const month = MDTG.#months.indexOf(str.slice(7, 10).toLowerCase());
-    if (month === -1) throw new Error("Invalid month");
-
-    const year = 2000 + parseInteger(str.slice(10, 12));
-
-    return new Date(
-      Date.UTC(year, month, day, hours + MDTG.#offset[tz], minutes),
-    );
-  }
-
-  static #parseLong(str) {
-    const day = parseInteger(str.slice(0, 2));
-    const hours = parseInteger(str.slice(2, 4));
-    const minutes = parseInteger(str.slice(4, 6));
-    const seconds = parseInteger(str.slice(6, 8));
-    const tz = str.slice(8, 9).toUpperCase();
-
-    const month = MDTG.#months.indexOf(str.slice(9, 12).toLowerCase());
-    if (month === -1) throw new Error("Invalid month");
-
-    const year = 2000 + parseInteger(str.slice(12, 14));
-
-    return new Date(
-      Date.UTC(year, month, day, hours + MDTG.#offset[tz], minutes, seconds),
-    );
-  }
-
-  static parse(str) {
-    if (MDTG.isShortFormat(str)) return MDTG.#parseShort(str);
-    if (MDTG.isShortenedFormat(str)) return MDTG.#parseShortened(str);
-    if (MDTG.isLongFormat(str)) return MDTG.#parseLong(str);
-
-    throw new Error(`Invalid MDTG string "${str}"`);
-  }
-
-  toDate() {
-    return new Date(this.#currentDate);
-  }
-}