@nextera.one/tps-standard 0.5.3 → 0.5.34

package/src/drivers/gregorian.ts

@@ -1,17 +1,9 @@
-import {
-  CalendarDriver,
-  TPSComponents,
-  TimeOrder,
-  TPS,
-  CalendarMetadata,
-} from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
 
 /**
  * Gregorian calendar driver.
- * This mirrors the built-in logic that used to live in `TPS.fromDate`/`toDate`
- * and provides implementations for the full `CalendarDriver` interface.
- * The driver also implements the optional helpers, enabling unit tests to
- * exercise `parseDate`, `format`, `validate`, and `getMetadata`.
+ * Supports robust validation and canonical Date conversions.
  */
 export class GregorianDriver implements CalendarDriver {
   readonly code: string = "greg";
@@ -54,16 +46,13 @@ export class GregorianDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    // buildTimePart understands the `order` field if the caller has set it
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
   // --- optional helpers --------------------------------------------------
 
   parseDate(input: string, format?: string): Partial<TPSComponents> {
-    // Accept ISO-like formats: "YYYY-MM-DD" and optionally time portion
     const s = input.trim();
-    // simple regex - not exhaustive
     const m = s.match(
       /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
     );
@@ -95,7 +84,6 @@ export class GregorianDriver implements CalendarDriver {
   }
 
   format(components: Partial<TPSComponents>, format?: string): string {
-    // For simplicity we ignore `format` and always produce ISO-ish string
     const y =
       components.year !== undefined
         ? String(components.year).padStart(4, "0")
@@ -136,24 +124,38 @@ export class GregorianDriver implements CalendarDriver {
     return out;
   }
 
+  private isLeap(y: number): boolean {
+    return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+  }
+
   validate(input: string | Partial<TPSComponents>): boolean {
     if (typeof input === "string") {
-      // basic ISO date with optional time and fractional seconds
       return /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(
         input.trim(),
       );
     }
     if (typeof input === "object") {
-      return (
-        input.year !== undefined &&
-        input.month !== undefined &&
-        input.day !== undefined &&
-        input.year >= 0 &&
-        input.month >= 1 &&
-        input.month <= 12 &&
-        input.day >= 1 &&
-        input.day <= 31
-      );
+      const y = input.year ?? 0;
+      const m = input.month ?? 1;
+      const d = input.day ?? 1;
+
+      if (y < 0 || m < 1 || m > 12 || d < 1) return false;
+
+      const daysInMonth = [
+        31,
+        this.isLeap(y) ? 29 : 28,
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+      ];
+      return d <= daysInMonth[m - 1];
     }
     return false;
   }

package/src/drivers/hijri.ts

@@ -10,7 +10,9 @@
  * This uses the Tabular Islamic Calendar (civil/Type II-A) algorithm
  * based on the formulas from Meeus "Astronomical Algorithms".
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import { gregorianToHijri, hijriToGregorian } from "../utils/calendar";
 
 export class HijriDriver implements CalendarDriver {
   readonly code = "hij";
@@ -56,15 +58,8 @@ export class HijriDriver implements CalendarDriver {
     "as-Sabt",
   ];
 
-  /** Leap years in a 30-year cycle (civil / Type II-A pattern) */
-  private readonly LEAP_YEARS_IN_CYCLE = new Set([
-    2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29,
-  ]);
-
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const { hy, hm, hd } = this.gregorianToHijri(
+    const { hy, hm, hd } = gregorianToHijri(
       date.getUTCFullYear(),
       date.getUTCMonth() + 1,
       date.getUTCDate(),
@@ -96,7 +91,7 @@ export class HijriDriver implements CalendarDriver {
     }
     const hm = components.month ?? 1;
     const hd = components.day ?? 1;
-    const { gy, gm, gd } = this.hijriToGregorian(hy, hm, hd);
+    const { gy, gm, gd } = hijriToGregorian(hy, hm, hd);
 
     return new Date(
       Date.UTC(
@@ -113,7 +108,7 @@ export class HijriDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
   parseDate(input: string, format?: string): Partial<TPSComponents> {
@@ -166,9 +161,8 @@ export class HijriDriver implements CalendarDriver {
       fullYear = components.year ?? 0;
     }
 
-    if (format === "short") {
+    if (format === "short")
       return `${components.day}/${pad(components.month)}/${fullYear}`;
-    }
     if (format === "long") {
       const mn = this.MONTH_NAMES[(components.month ?? 1) - 1];
       return `${components.day} ${mn} ${fullYear}`;
@@ -192,7 +186,6 @@ export class HijriDriver implements CalendarDriver {
       comp = input;
     }
     const { year, month, day } = comp;
-    // Reconstruct full year for leap check
     let fullYear: number;
     if (comp.millennium !== undefined) {
       fullYear =
@@ -205,7 +198,12 @@ export class HijriDriver implements CalendarDriver {
     if (fullYear < 1) return false;
     if (!month || month < 1 || month > 12) return false;
     if (!day || day < 1) return false;
-    const maxDays = this.daysInMonth(fullYear, month);
+
+    // leap check (cycle of 30 years)
+    const isLeap = new Set([2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29]).has(
+      ((fullYear - 1) % 30) + 1,
+    );
+    const maxDays = month === 12 && isLeap ? 30 : month % 2 === 1 ? 30 : 29;
     return day <= maxDays;
   }
 
@@ -221,102 +219,4 @@ export class HijriDriver implements CalendarDriver {
       epochYear: 1,
     };
   }
-
-  // ── Internal helpers ──────────────────────────────────────────────────
-
-  private isLeapYear(year: number): boolean {
-    return this.LEAP_YEARS_IN_CYCLE.has(((year - 1) % 30) + 1);
-  }
-
-  private daysInMonth(year: number, month: number): number {
-    if (month === 12 && this.isLeapYear(year)) return 30;
-    return month % 2 === 1 ? 30 : 29;
-  }
-
-  // ── Gregorian ↔ Hijri (Tabular algorithm from Meeus) ──────────────────
-
-  /**
-   * Convert Gregorian to Hijri (Tabular Islamic Calendar).
-   * Algorithm from "Astronomical Algorithms" by Jean Meeus.
-   */
-  private gregorianToHijri(
-    gy: number,
-    gm: number,
-    gd: number,
-  ): { hy: number; hm: number; hd: number } {
-    // Step 1: Gregorian → JDN
-    const jdn = this.gregorianToJdn(gy, gm, gd);
-    // Step 2: JDN → Hijri
-    // L = JDN − 1948440 + 10632
-    const L = jdn - 1948440 + 10632;
-    // N = floor((L − 1) / 10631)
-    const N = Math.floor((L - 1) / 10631);
-    // L = L − 10631 × N + 354
-    const L2 = L - 10631 * N + 354;
-    // J = floor((10985 − L2) / 5316) × floor((50×L2) / 17719) + floor(L2 / 5670) × floor((43×L2) / 15238)
-    const J =
-      Math.floor((10985 - L2) / 5316) * Math.floor((50 * L2) / 17719) +
-      Math.floor(L2 / 5670) * Math.floor((43 * L2) / 15238);
-    // L3 = L2 − floor((30 − J) / 15) × floor((17719 × J) / 50) − floor(J / 16) × floor((15238 × J) / 43) + 29
-    const L3 =
-      L2 -
-      Math.floor((30 - J) / 15) * Math.floor((17719 * J) / 50) -
-      Math.floor(J / 16) * Math.floor((15238 * J) / 43) +
-      29;
-    const hm = Math.floor((24 * L3) / 709);
-    const hd = L3 - Math.floor((709 * hm) / 24);
-    const hy = 30 * N + J - 30;
-    return { hy, hm, hd };
-  }
-
-  /**
-   * Convert Hijri to Gregorian.
-   */
-  private hijriToGregorian(
-    hy: number,
-    hm: number,
-    hd: number,
-  ): { gy: number; gm: number; gd: number } {
-    // Hijri → JDN
-    const jdn =
-      Math.floor((11 * hy + 3) / 30) +
-      354 * hy +
-      30 * hm -
-      Math.floor((hm - 1) / 2) +
-      hd +
-      1948440 -
-      385;
-    // JDN → Gregorian
-    return this.jdnToGregorian(jdn);
-  }
-
-  // ── JDN helpers ───────────────────────────────────────────────────────
-
-  private gregorianToJdn(gy: number, gm: number, gd: number): number {
-    const a = Math.floor((14 - gm) / 12);
-    const y = gy + 4800 - a;
-    const m = gm + 12 * a - 3;
-    return (
-      gd +
-      Math.floor((153 * m + 2) / 5) +
-      365 * y +
-      Math.floor(y / 4) -
-      Math.floor(y / 100) +
-      Math.floor(y / 400) -
-      32045
-    );
-  }
-
-  private jdnToGregorian(jdn: number): { gy: number; gm: number; gd: number } {
-    const a = jdn + 32044;
-    const b = Math.floor((4 * a + 3) / 146097);
-    const c = a - Math.floor((146097 * b) / 4);
-    const d = Math.floor((4 * c + 3) / 1461);
-    const e = c - Math.floor((1461 * d) / 4);
-    const m = Math.floor((5 * e + 2) / 153);
-    const gd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const gm = m + 3 - 12 * Math.floor(m / 10);
-    const gy = 100 * b + d - 4800 + Math.floor(m / 10);
-    return { gy, gm, gd };
-  }
 }

package/src/drivers/holocene.ts

@@ -9,9 +9,13 @@
  *
  * This is a thin wrapper around GregorianDriver with a year offset.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
 import { GregorianDriver } from "./gregorian";
 
+/**
+ * Holocene (Human Era) Calendar Driver
+ */
 export class HoloceneDriver implements CalendarDriver {
   readonly code = "holo";
   readonly name = "Holocene (Human Era)";
@@ -19,8 +23,6 @@ export class HoloceneDriver implements CalendarDriver {
   private readonly gregorian = new GregorianDriver();
   private readonly YEAR_OFFSET = 10000;
 
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
     const greg = this.gregorian.getComponentsFromDate(date);
     const fullYear = date.getUTCFullYear() + this.YEAR_OFFSET;
@@ -57,21 +59,20 @@ export class HoloceneDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
-  parseDate(input: string, format?: string): Partial<TPSComponents> {
-    // Accept ISO-like: "12026-01-09" (Holocene year)
+  parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const m = input
       .trim()
       .match(
         /^(\d{4,5})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
       );
-    if (!m) {
+    if (!m)
       throw new Error(
         `HoloceneDriver.parseDate: unsupported format "${input}"`,
       );
-    }
+
     const result: Partial<TPSComponents> = {
       calendar: this.code,
       year: parseInt(m[1], 10),
@@ -86,9 +87,8 @@ export class HoloceneDriver implements CalendarDriver {
     return result;
   }
 
-  format(components: Partial<TPSComponents>, format?: string): string {
+  format(components: Partial<TPSComponents>, _format?: string): string {
     const pad = (n?: number, w = 2) => String(n ?? 0).padStart(w, "0");
-    // Reconstruct full Holocene year from components
     let holoYear: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -117,7 +117,6 @@ export class HoloceneDriver implements CalendarDriver {
       );
     }
     if (typeof input === "object") {
-      // Delegate day/month validation to Gregorian (same structure)
       return this.gregorian.validate({
         year: input.year,
         month: input.month,
@@ -146,7 +145,7 @@ export class HoloceneDriver implements CalendarDriver {
       ],
       isLunar: false,
       monthsPerYear: 12,
-      epochYear: -10000, // 10001 BCE
+      epochYear: -10000,
     };
   }
 }

package/src/drivers/julian.ts

@@ -9,7 +9,14 @@
  *
  * Conversion uses Julian Day Number algorithms.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import {
+  gregorianToJdn,
+  jdnToGregorian,
+  julianToJdn,
+  jdnToJulian,
+} from "../utils/calendar";
 
 export class JulianDriver implements CalendarDriver {
   readonly code = "jul";
@@ -49,15 +56,13 @@ export class JulianDriver implements CalendarDriver {
     31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
   ];
 
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const jdn = this.gregorianToJdn(
+    const jdn = gregorianToJdn(
       date.getUTCFullYear(),
       date.getUTCMonth() + 1,
       date.getUTCDate(),
     );
-    const { jy, jm, jd } = this.jdnToJulian(jdn);
+    const { jy, jm, jd } = jdnToJulian(jdn);
 
     return {
       calendar: this.code,
@@ -85,8 +90,8 @@ export class JulianDriver implements CalendarDriver {
     }
     const jm = components.month ?? 1;
     const jd = components.day ?? 1;
-    const jdn = this.julianToJdn(fullYear, jm, jd);
-    const { gy, gm, gd } = this.jdnToGregorian(jdn);
+    const jdn = julianToJdn(fullYear, jm, jd);
+    const { gy, gm, gd } = jdnToGregorian(jdn);
 
     return new Date(
       Date.UTC(
@@ -103,17 +108,17 @@ export class JulianDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
-  parseDate(input: string, format?: string): Partial<TPSComponents> {
+  parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const trimmed = input.trim();
     const m = trimmed.match(
       /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
     );
-    if (!m) {
+    if (!m)
       throw new Error(`JulianDriver.parseDate: unsupported format "${input}"`);
-    }
+
     const fullYear = parseInt(m[1], 10);
     const result: Partial<TPSComponents> = {
       calendar: this.code,
@@ -131,7 +136,7 @@ export class JulianDriver implements CalendarDriver {
     return result;
   }
 
-  format(components: Partial<TPSComponents>, format?: string): string {
+  format(components: Partial<TPSComponents>, _format?: string): string {
     const pad = (n?: number, w = 2) => String(n ?? 0).padStart(w, "0");
     let fullYear: number;
     if (components.millennium !== undefined) {
@@ -164,7 +169,6 @@ export class JulianDriver implements CalendarDriver {
       );
     }
     if (typeof input === "object") {
-      // Reconstruct full year for leap check
       let fullYear: number;
       if (input.millennium !== undefined) {
         fullYear =
@@ -178,7 +182,7 @@ export class JulianDriver implements CalendarDriver {
       if (month === undefined || day === undefined) return false;
       if (month < 1 || month > 12 || day < 1) return false;
       let maxDay = this.DAYS_IN_MONTH[month - 1];
-      if (month === 2 && this.isLeapYear(fullYear)) maxDay = 29;
+      if (month === 2 && fullYear % 4 === 0) maxDay = 29;
       return day <= maxDay;
     }
     return false;
@@ -194,62 +198,4 @@ export class JulianDriver implements CalendarDriver {
       epochYear: 1,
     };
   }
-
-  // ── Internal helpers ──────────────────────────────────────────────────
-
-  /** Julian leap year: every 4 years, no century exception */
-  private isLeapYear(year: number): boolean {
-    return year % 4 === 0;
-  }
-
-  // ── JDN algorithms ────────────────────────────────────────────────────
-
-  private julianToJdn(jy: number, jm: number, jd: number): number {
-    const a = Math.floor((14 - jm) / 12);
-    const y = jy + 4800 - a;
-    const m = jm + 12 * a - 3;
-    return (
-      jd + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - 32083
-    );
-  }
-
-  private jdnToJulian(jdn: number): { jy: number; jm: number; jd: number } {
-    const c = jdn + 32082;
-    const d = Math.floor((4 * c + 3) / 1461);
-    const e = c - Math.floor((1461 * d) / 4);
-    const m = Math.floor((5 * e + 2) / 153);
-    const jd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const jm = m + 3 - 12 * Math.floor(m / 10);
-    const jy = d - 4800 + Math.floor(m / 10);
-    return { jy, jm, jd };
-  }
-
-  /** Gregorian → JDN (for converting incoming Gregorian Date) */
-  private gregorianToJdn(gy: number, gm: number, gd: number): number {
-    const a = Math.floor((14 - gm) / 12);
-    const y = gy + 4800 - a;
-    const m = gm + 12 * a - 3;
-    return (
-      gd +
-      Math.floor((153 * m + 2) / 5) +
-      365 * y +
-      Math.floor(y / 4) -
-      Math.floor(y / 100) +
-      Math.floor(y / 400) -
-      32045
-    );
-  }
-
-  private jdnToGregorian(jdn: number): { gy: number; gm: number; gd: number } {
-    const a = jdn + 32044;
-    const b = Math.floor((4 * a + 3) / 146097);
-    const c = a - Math.floor((146097 * b) / 4);
-    const d = Math.floor((4 * c + 3) / 1461);
-    const e = c - Math.floor((1461 * d) / 4);
-    const m = Math.floor((5 * e + 2) / 153);
-    const gd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const gm = m + 3 - 12 * Math.floor(m / 10);
-    const gy = 100 * b + d - 4800 + Math.floor(m / 10);
-    return { gy, gm, gd };
-  }
 }