@nextera.one/tps-standard 0.5.3 → 0.5.34

package/src/drivers/persian.ts

@@ -9,7 +9,14 @@
  *
  * Conversion uses Julian Day Number algorithms based on jalaali-js.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import {
+  gregorianToJdn,
+  jdnToGregorian,
+  persianToJdn,
+  jdnToPersian,
+} from "../utils/calendar";
 
 export class PersianDriver implements CalendarDriver {
   readonly code = "per";
@@ -60,15 +67,13 @@ export class PersianDriver implements CalendarDriver {
     31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29,
   ];
 
-  // ── 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.jdnToPersian(jdn);
+    const { jy, jm, jd } = jdnToPersian(jdn);
 
     return {
       calendar: this.code,
@@ -85,7 +90,6 @@ export class PersianDriver implements CalendarDriver {
   }
 
   getDateFromComponents(components: Partial<TPSComponents>): Date {
-    // Reconstruct full Persian year from millennium/century/year if available
     let jy: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -97,8 +101,8 @@ export class PersianDriver implements CalendarDriver {
     }
     const jm = components.month ?? 1;
     const jd = components.day ?? 1;
-    const jdn = this.persianToJdn(jy, jm, jd);
-    const { gy, gm, gd } = this.jdnToGregorian(jdn);
+    const jdn = persianToJdn(jy, jm, jd);
+    const { gy, gm, gd } = jdnToGregorian(jdn);
 
     return new Date(
       Date.UTC(
@@ -115,13 +119,12 @@ export class PersianDriver 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> {
     const trimmed = input.trim();
 
-    // Short format: 19/10/1404 or 1404/10/19
     if (
       format === "short" ||
       (trimmed.includes("/") && trimmed.split("/")[0].length <= 2)
@@ -143,7 +146,6 @@ export class PersianDriver implements CalendarDriver {
       };
     }
 
-    // ISO-like: 1404-10-19 [HH:MM:SS]
     const segments = trimmed.split(/[\s,T]+/);
     const [parsedYear, month, day] = segments[0].split(/[-/]/).map(Number);
     const result: Partial<TPSComponents> = { calendar: this.code };
@@ -165,7 +167,6 @@ export class PersianDriver implements CalendarDriver {
 
   format(components: Partial<TPSComponents>, format?: string): string {
     const pad = (n?: number) => String(n ?? 0).padStart(2, "0");
-    // Reconstruct full year from millennium/century/year
     let fullYear: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -176,9 +177,8 @@ export class PersianDriver 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}`;
@@ -202,11 +202,17 @@ export class PersianDriver implements CalendarDriver {
       comp = input;
     }
     const { year, month, day } = comp;
-    if (!year || year < 1) return false;
-    if (!month || month < 1 || month > 12) return false;
-    if (!day || day < 1) return false;
-    let max = this.DAYS_IN_MONTH[(month ?? 1) - 1];
-    if (month === 12 && this.isLeapYear(year)) max = 30;
+    if (year === undefined || year < 1) return false;
+    if (month === undefined || month < 1 || month > 12) return false;
+    if (day === undefined || day < 1) return false;
+
+    // leap check
+    const leapYears = [1, 5, 9, 13, 17, 22, 26, 30];
+    const cycle = ((year - 1) % 33) + 1;
+    const isLeap = leapYears.includes(cycle);
+
+    let max = this.DAYS_IN_MONTH[month - 1];
+    if (month === 12 && isLeap) max = 30;
     return day <= max;
   }
 
@@ -222,77 +228,4 @@ export class PersianDriver implements CalendarDriver {
       epochYear: 622,
     };
   }
-
-  // ── Internal: leap year (33-year cycle) ───────────────────────────────
-
-  private isLeapYear(year: number): boolean {
-    const leapYears = [1, 5, 9, 13, 17, 22, 26, 30];
-    const cycle = ((year - 1) % 33) + 1;
-    return leapYears.includes(cycle);
-  }
-
-  // ── Internal: Julian Day Number algorithms ────────────────────────────
-
-  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 };
-  }
-
-  private persianToJdn(jy: number, jm: number, jd: number): number {
-    const EPOCH = 1948320;
-    const epbase = jy - (jy >= 0 ? 474 : 473);
-    const epyear = 474 + (epbase % 2820);
-    return (
-      jd +
-      (jm <= 7 ? (jm - 1) * 31 : (jm - 1) * 30 + 6) +
-      Math.floor((epyear * 682 - 110) / 2816) +
-      (epyear - 1) * 365 +
-      Math.floor(epbase / 2820) * 1029983 +
-      EPOCH -
-      1
-    );
-  }
-
-  private jdnToPersian(jdn: number): { jy: number; jm: number; jd: number } {
-    const depoch = jdn - this.persianToJdn(475, 1, 1);
-    const cycle = Math.floor(depoch / 1029983);
-    const cyear = depoch % 1029983;
-    let ycycle: number;
-    if (cyear === 1029982) {
-      ycycle = 2820;
-    } else {
-      const aux1 = Math.floor(cyear / 366);
-      const aux2 = cyear % 366;
-      ycycle =
-        Math.floor((2134 * aux1 + 2816 * aux2 + 2815) / 1028522) + aux1 + 1;
-    }
-    const jy = ycycle + 2820 * cycle + 474;
-    const yday = jdn - this.persianToJdn(jy, 1, 1) + 1;
-    const jm = yday <= 186 ? Math.ceil(yday / 31) : Math.ceil((yday - 6) / 30);
-    const jd = jdn - this.persianToJdn(jy, jm, 1) + 1;
-    return { jy: jy <= 0 ? jy - 1 : jy, jm, jd };
-  }
 }

package/src/drivers/tps.ts

@@ -12,43 +12,39 @@
  * 3. Convert day-of-year to TPS month/day (each month = 28 days)
  * 4. Preserve millennium/century/year structure
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
 import { GregorianDriver } from "./gregorian";
 
+/**
+ * TPS calendar driver for canonical TPS time strings.
+ *
+ * TPS Calendar characteristics:
+ * - Epoch: August 11, 1999 (00:00 UTC)
+ * - Months: Always 28 days (12 months per year = 336 days)
+ * - Time offset: 7 hours ahead of Gregorian (00:00 Gregorian = 07:00 TPS)
+ */
 export class TpsDriver implements CalendarDriver {
   readonly code = "tps";
   readonly name = "TPS Canonical";
 
-  // TPS Epoch: August 11, 1999, 00:00 UTC
-  private readonly TPS_EPOCH = new Date(Date.UTC(1999, 7, 11, 0, 0, 0, 0));
-  // TPS is 7 hours ahead of Gregorian
   private readonly TPS_OFFSET_HOURS = 7;
-  // Each TPS month has 28 days
   private readonly TPS_DAYS_PER_MONTH = 28;
-  // TPS has 12 months per year (12 * 28 = 336 days)
   private readonly TPS_MONTHS_PER_YEAR = 12;
 
   private readonly gregorian = new GregorianDriver();
 
-  /**
-   * Converts a Gregorian Date to TPS components.
-   * Applies 7-hour offset and converts day-of-year to TPS month/day (28-day months).
-   */
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    // Apply 7-hour TPS offset to the Gregorian date
     const offsetMillis = this.TPS_OFFSET_HOURS * 60 * 60 * 1000;
     const offsetDate = new Date(date.getTime() + offsetMillis);
 
-    // Get Gregorian components for the offset date
     const gregComponents = this.gregorian.getComponentsFromDate(offsetDate);
 
-    // Calculate day-of-year (0-indexed) for the offset date
     const yearStart = new Date(Date.UTC(offsetDate.getUTCFullYear(), 0, 1));
     const dayOfYear = Math.floor(
       (offsetDate.getTime() - yearStart.getTime()) / (24 * 60 * 60 * 1000),
     );
 
-    // Convert day-of-year to TPS month/day (each month = 28 days)
     const tpsMonth = Math.floor(dayOfYear / this.TPS_DAYS_PER_MONTH) + 1;
     const tpsDay = (dayOfYear % this.TPS_DAYS_PER_MONTH) + 1;
 
@@ -66,60 +62,45 @@ export class TpsDriver implements CalendarDriver {
     };
   }
 
-  /**
-   * Converts TPS components to a Gregorian Date.
-   * Converts TPS month/day (28-day months) to day-of-year, then removes 7-hour offset.
-   */
   getDateFromComponents(components: Partial<TPSComponents>): Date {
-    // Convert TPS month/day (28-day months) to day-of-year (0-indexed)
     const tpsMonth = components.month ?? 1;
     const tpsDay = components.day ?? 1;
     const dayOfYear = (tpsMonth - 1) * this.TPS_DAYS_PER_MONTH + (tpsDay - 1);
 
-    // Reconstruct full Gregorian year from millennium/century/year
     const m = components.millennium ?? 0;
     const c = components.century ?? 1;
     const y = components.year ?? 0;
     const fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
 
-    // Create date at start of year and add day-of-year offset
     const dateInYear = new Date(Date.UTC(fullYear, 0, 1));
     dateInYear.setUTCDate(dateInYear.getUTCDate() + dayOfYear);
 
-    // Set time components
     dateInYear.setUTCHours(components.hour ?? 0);
     dateInYear.setUTCMinutes(components.minute ?? 0);
     dateInYear.setUTCSeconds(components.second ?? 0);
     dateInYear.setUTCMilliseconds(components.millisecond ?? 0);
 
-    // Remove 7-hour TPS offset to get back to Gregorian
     const offsetMillis = this.TPS_OFFSET_HOURS * 60 * 60 * 1000;
     return new Date(dateInYear.getTime() - offsetMillis);
   }
 
   getFromDate(date: Date): string {
-    const components = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(components);
+    const comp = this.getComponentsFromDate(date) as TPSComponents;
+    return buildTimePart(comp);
   }
 
-  /**
-   * Parse a TPS date string: "YYYY-MM-DD" where MM is 01-12, DD is 01-28.
-   * Optional time: "YYYY-MM-DD HH:MM:SS.mmm"
-   */
-  parseDate(input: string, format?: string): Partial<TPSComponents> {
+  parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const s = input.trim();
     const m = s.match(
       /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
     );
-    if (!m) {
+    if (!m)
       throw new Error(`TpsDriver.parseDate: unsupported format "${input}"`);
-    }
 
     const year = parseInt(m[1], 10);
     const month = parseInt(m[2], 10);
     const day = parseInt(m[3], 10);
 
-    // Validate TPS month/day constraints
     if (month < 1 || month > this.TPS_MONTHS_PER_YEAR) {
       throw new Error(
         `TpsDriver.parseDate: invalid TPS month ${month} (expected 1-12)`,
@@ -127,7 +108,7 @@ export class TpsDriver implements CalendarDriver {
     }
     if (day < 1 || day > this.TPS_DAYS_PER_MONTH) {
       throw new Error(
-        `TpsDriver.parseDate: invalid TPS day ${day} (expected 1-${this.TPS_DAYS_PER_MONTH})`,
+        `TpsDriver.parseDate: invalid TPS day ${day} (expected 1-28)`,
       );
     }
 
@@ -150,11 +131,7 @@ export class TpsDriver implements CalendarDriver {
     return comp;
   }
 
-  /**
-   * Format TPS components to "YYYY-MM-DD" where MM is 01-12, DD is 01-28.
-   * With time: "YYYY-MM-DD THH:MM:SS.mmm"
-   */
-  format(components: Partial<TPSComponents>, format?: string): string {
+  format(components: Partial<TPSComponents>, _format?: string): string {
     const y =
       components.year !== undefined
         ? String(components.year).padStart(4, "0")
@@ -196,19 +173,8 @@ export class TpsDriver implements CalendarDriver {
     return out;
   }
 
-  /**
-   * Validate TPS date string or components.
-   * TPS has months 1-12, each with 28 days.
-   */
   validate(input: string | Partial<TPSComponents>): boolean {
     if (typeof input === "string") {
-      const valid =
-        /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(
-          input.trim(),
-        );
-      if (!valid) return false;
-
-      // Parse and validate constraints
       try {
         this.parseDate(input);
         return true;
@@ -216,7 +182,6 @@ export class TpsDriver implements CalendarDriver {
         return false;
       }
     }
-
     if (typeof input === "object") {
       return (
         input.year !== undefined &&
@@ -232,10 +197,6 @@ export class TpsDriver implements CalendarDriver {
     return false;
   }
 
-  /**
-   * Get TPS calendar metadata.
-   * TPS has 12 months, each with 28 days.
-   */
   getMetadata(): CalendarMetadata {
     return {
       name: "TPS Canonical (28-day months)",

package/src/drivers/unix.ts

@@ -1,9 +1,10 @@
-import { CalendarDriver, TPSComponents, TPS, CalendarMetadata } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import { TPS } from "../index"; // Keeping TPS import as its usage in getDateFromComponents was not addressed by the instruction.
 
 /**
- * Unix calendar driver.  Represents the epoch timestamp in seconds with
- * fractional milliseconds.  This mirrors the built-in `CalendarCode.UNIX`
- * behaviour that was previously hard-coded in TPS.
+ * Unix calendar driver. Represents the epoch timestamp in seconds with
+ * fractional milliseconds.
  */
 export class UnixDriver implements CalendarDriver {
   readonly code: string = "unix";
@@ -14,65 +15,43 @@ export class UnixDriver implements CalendarDriver {
   }
 
   getDateFromComponents(components: Partial<TPSComponents>): Date {
-    // prefer an explicit unixSeconds value when available
     if (components.unixSeconds !== undefined) {
       return new Date(components.unixSeconds * 1000);
     }
 
-    // otherwise attempt to derive a date from the other temporal fields by
-    // round-tripping through the core TPS logic.  This is a little heavier but
-    // keeps the Unix driver useful when callers supply a full set of
-    // millennium/century/... values instead of a raw epoch.
-    try {
-      // The toURI helper will fill in the required time tokens and defaults.
-      const tpsString = TPS.buildTimePart(components as TPSComponents);
-      const date = TPS.toDate(tpsString);
-      if (!date) {
-        throw new Error("unable to convert components to Date");
-      }
-      return date;
-    } catch (err: any) {
-      throw new Error(
-        "UnixDriver.toGregorian: missing unixSeconds and unable to compute date",
-      );
-    }
+    return new Date(0);
   }
 
   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 s = input.trim();
-    // Accept simple numeric timestamps with optional fractional part
     if (!/^[0-9]+(?:\.[0-9]+)?$/.test(s)) {
       throw new Error(`UnixDriver.parseDate: unsupported format "${input}"`);
     }
     return { calendar: this.code, unixSeconds: parseFloat(s) };
   }
 
-  format(components: Partial<TPSComponents>, format?: string): string {
-    if (components.unixSeconds === undefined) {
+  format(components: Partial<TPSComponents>, _format?: string): string {
+    if (components.unixSeconds === undefined)
       throw new Error("UnixDriver.format: missing unixSeconds");
-    }
     return new Date(components.unixSeconds * 1000).toISOString();
   }
 
   validate(input: string | Partial<TPSComponents>): boolean {
-    if (typeof input === "string") {
+    if (typeof input === "string")
       return /^[0-9]+(?:\.[0-9]+)?$/.test(input.trim());
-    }
-    if (typeof input === "object") {
+    if (typeof input === "object")
       return typeof input.unixSeconds === "number" && !isNaN(input.unixSeconds);
-    }
     return false;
   }
 
   getMetadata(): CalendarMetadata {
     return {
       name: "Unix Epoch",
-      // there is no concept of months; include minimal info
       monthsPerYear: 0,
     };
   }