@nextera.one/tps-standard 0.5.2 → 0.5.33

package/src/drivers/tps.ts

@@ -12,12 +12,12 @@
  * 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 { GregorianDriver } from './gregorian';
+import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { GregorianDriver } from "./gregorian";
 
 export class TpsDriver implements CalendarDriver {
-  readonly code = 'tps';
-  readonly name = 'TPS Canonical';
+  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));
@@ -45,7 +45,7 @@ export class TpsDriver implements CalendarDriver {
     // 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)
+      (offsetDate.getTime() - yearStart.getTime()) / (24 * 60 * 60 * 1000),
     );
 
     // Convert day-of-year to TPS month/day (each month = 28 days)
@@ -72,14 +72,14 @@ export class TpsDriver implements CalendarDriver {
    */
   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 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 || 1;
-    const c = components.century || 1;
-    const y = components.year || 0;
+    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
@@ -87,10 +87,10 @@ export class TpsDriver implements CalendarDriver {
     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);
+    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;
@@ -103,12 +103,14 @@ export class TpsDriver implements CalendarDriver {
   }
 
   /**
-   * Parse a TPS date string: "YYYY-MM-DD" where MM is 01-13, DD is 01-28.
+   * 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> {
     const s = input.trim();
-    const m = s.match(/^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/);
+    const m = s.match(
+      /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
+    );
     if (!m) {
       throw new Error(`TpsDriver.parseDate: unsupported format "${input}"`);
     }
@@ -119,16 +121,21 @@ export class TpsDriver implements CalendarDriver {
 
     // 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)`);
+      throw new Error(
+        `TpsDriver.parseDate: invalid TPS month ${month} (expected 1-12)`,
+      );
     }
     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})`);
+      throw new Error(
+        `TpsDriver.parseDate: invalid TPS day ${day} (expected 1-${this.TPS_DAYS_PER_MONTH})`,
+      );
     }
 
     const hour = m[4] !== undefined ? parseInt(m[4], 10) : undefined;
     const minute = m[5] !== undefined ? parseInt(m[5], 10) : undefined;
     const second = m[6] !== undefined ? parseInt(m[6], 10) : undefined;
-    const millisecond = m[7] !== undefined ? parseInt((m[7] + '000').slice(0, 3), 10) : undefined;
+    const millisecond =
+      m[7] !== undefined ? parseInt((m[7] + "000").slice(0, 3), 10) : undefined;
 
     const comp: Partial<TPSComponents> = {
       calendar: this.code,
@@ -144,13 +151,22 @@ export class TpsDriver implements CalendarDriver {
   }
 
   /**
-   * Format TPS components to "YYYY-MM-DD" where MM is 01-13, DD is 01-28.
+   * 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 {
-    const y = components.year !== undefined ? String(components.year).padStart(4, '0') : '0000';
-    const mo = components.month !== undefined ? String(components.month).padStart(2, '0') : '01';
-    const d = components.day !== undefined ? String(components.day).padStart(2, '0') : '01';
+    const y =
+      components.year !== undefined
+        ? String(components.year).padStart(4, "0")
+        : "0000";
+    const mo =
+      components.month !== undefined
+        ? String(components.month).padStart(2, "0")
+        : "01";
+    const d =
+      components.day !== undefined
+        ? String(components.day).padStart(2, "0")
+        : "01";
     let out = `${y}-${mo}-${d}`;
 
     if (
@@ -159,10 +175,22 @@ export class TpsDriver implements CalendarDriver {
       components.second !== undefined ||
       components.millisecond !== undefined
     ) {
-      const h = components.hour !== undefined ? String(components.hour).padStart(2, '0') : '00';
-      const mi = components.minute !== undefined ? String(components.minute).padStart(2, '0') : '00';
-      const s = components.second !== undefined ? String(Math.floor(components.second)).padStart(2, '0') : '00';
-      const ms = components.millisecond !== undefined ? String(components.millisecond).padStart(3, '0') : '000';
+      const h =
+        components.hour !== undefined
+          ? String(components.hour).padStart(2, "0")
+          : "00";
+      const mi =
+        components.minute !== undefined
+          ? String(components.minute).padStart(2, "0")
+          : "00";
+      const s =
+        components.second !== undefined
+          ? String(Math.floor(components.second)).padStart(2, "0")
+          : "00";
+      const ms =
+        components.millisecond !== undefined
+          ? String(components.millisecond).padStart(3, "0")
+          : "000";
       out += `T${h}:${mi}:${s}.${ms}`;
     }
     return out;
@@ -170,11 +198,14 @@ export class TpsDriver implements CalendarDriver {
 
   /**
    * Validate TPS date string or components.
-   * TPS has months 1-13, each with 28 days.
+   * 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 (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
@@ -186,7 +217,7 @@ export class TpsDriver implements CalendarDriver {
       }
     }
 
-    if (typeof input === 'object') {
+    if (typeof input === "object") {
       return (
         input.year !== undefined &&
         input.month !== undefined &&
@@ -207,29 +238,29 @@ export class TpsDriver implements CalendarDriver {
    */
   getMetadata(): CalendarMetadata {
     return {
-      name: 'TPS Canonical (28-day months)',
+      name: "TPS Canonical (28-day months)",
       monthNames: [
-        'Month 1',
-        'Month 2',
-        'Month 3',
-        'Month 4',
-        'Month 5',
-        'Month 6',
-        'Month 7',
-        'Month 8',
-        'Month 9',
-        'Month 10',
-        'Month 11',
-        'Month 12',
+        "Month 1",
+        "Month 2",
+        "Month 3",
+        "Month 4",
+        "Month 5",
+        "Month 6",
+        "Month 7",
+        "Month 8",
+        "Month 9",
+        "Month 10",
+        "Month 11",
+        "Month 12",
       ],
       dayNames: [
-        'Sunday',
-        'Monday',
-        'Tuesday',
-        'Wednesday',
-        'Thursday',
-        'Friday',
-        'Saturday',
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
       ],
       monthsPerYear: this.TPS_MONTHS_PER_YEAR,
       epochYear: 1999,

package/src/index.ts

@@ -2,7 +2,7 @@
  * TPS: Temporal Positioning System
  * The Universal Protocol for Space-Time Coordinates.
  * @packageDocumentation
- * @version 0.5.0
+ * @version 0.5.2
  * @license Apache-2.0
  * @copyright 2026 TPS Standards Working Group
  *
@@ -18,6 +18,10 @@
 import { GregorianDriver } from "./drivers/gregorian";
 import { UnixDriver } from "./drivers/unix";
 import { TpsDriver } from "./drivers/tps";
+import { PersianDriver } from "./drivers/persian";
+import { HijriDriver } from "./drivers/hijri";
+import { JulianDriver } from "./drivers/julian";
+import { HoloceneDriver } from "./drivers/holocene";
 
 // Calendar codes are plain strings to allow arbitrary user-defined
 // calendars.  The library still exports constants for the built-in values but
@@ -26,6 +30,7 @@ export const DefaultCalendars = {
   TPS: "tps",
   GREG: "greg",
   HIJ: "hij",
+  PER: "per",
   JUL: "jul",
   HOLO: "holo",
   UNIX: "unix",
@@ -402,10 +407,8 @@ export class TPS {
     }
 
     // No tokens at all — fill every slot with 0 and return
-    // Use tps as the default calendar if none was specified
-    const resolvedCal = cal || DefaultCalendars.TPS;
     if (!tokenStr) {
-      return `${beforeT}T:${resolvedCal}.m0.c0.y0.m0.d0.h0.m0.s0.m0${timeSuffix}`;
+      return `${beforeT}T:${cal}.m0.c0.y0.m0.d0.h0.m0.s0.m0${timeSuffix}`;
     }
 
     // ── 5. Tokenise ──────────────────────────────────────────────────────────
@@ -464,7 +467,7 @@ export class TPS {
       .map(([p, r]) => p + (byRank.get(r) ?? "0"))
       .join(".");
 
-    return `${beforeT}T:${resolvedCal}.${finalTokenStr}${timeSuffix}`;
+    return `${beforeT}T:${cal}.${finalTokenStr}${timeSuffix}`;
   }
 
   static validate(input: string): boolean {
@@ -1107,6 +1110,10 @@ export class TPS {
 TPS.registerDriver(new TpsDriver());
 TPS.registerDriver(new GregorianDriver());
 TPS.registerDriver(new UnixDriver());
+TPS.registerDriver(new PersianDriver());
+TPS.registerDriver(new HijriDriver());
+TPS.registerDriver(new JulianDriver());
+TPS.registerDriver(new HoloceneDriver());
 
 // --- TPS-UID v1 Types ---
 
@@ -1400,45 +1407,6 @@ export class TPSUID7RB {
   /**
    * Generate a TPS string from a Date and optional location.
    */
-  // NOTE: this helper is primarily used by `generate()`; drivers and
-  // callers should prefer `TPS.fromDate()` when order or calendars matter.
-  private static generateTPSString(
-    date: Date,
-    opts?: {
-      latitude?: number;
-      longitude?: number;
-      altitude?: number;
-      order?: TimeOrder;
-    },
-  ): string {
-    const fullYear = date.getUTCFullYear();
-    const comp: TPSComponents = {
-      calendar: DefaultCalendars.TPS,
-      millennium: Math.floor(fullYear / 1000) + 1,
-      century: Math.floor((fullYear % 1000) / 100) + 1,
-      year: fullYear % 100,
-      month: date.getUTCMonth() + 1,
-      day: date.getUTCDate(),
-      hour: date.getUTCHours(),
-      minute: date.getUTCMinutes(),
-      second: date.getUTCSeconds(),
-      millisecond: date.getUTCMilliseconds(),
-    };
-    if (opts?.order) comp.order = opts.order;
-
-    // note: this method belongs to TPSUID7RB, but buildTimePart lives on TPS
-    const timePart = TPS.buildTimePart(comp);
-
-    let spacePart = "unknown";
-    if (opts?.latitude !== undefined && opts?.longitude !== undefined) {
-      spacePart = `${opts.latitude},${opts.longitude}`;
-      if (opts.altitude !== undefined) {
-        spacePart += `,${opts.altitude}m`;
-      }
-    }
-
-    return `tps://${spacePart}@${timePart}`;
-  }
 
   /**
    * Parse epoch milliseconds from a TPS string.
@@ -1785,46 +1753,38 @@ export class TPSUID7RB {
       try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const crypto = require("crypto");
-        // Node's crypto.sign uses PEM or KeyObject, but for raw Ed25519 keys we might need 'crypto.sign(null, data, key)'
-        // or ensure key is properly formatted.
-        // For simplicity in Node 20+, crypto.sign(null, data, privateKey) works if key is KeyObject.
-        // If raw bytes: establish KeyObject.
-
-        let keyObj;
-        if (Buffer.isBuffer(privateKey) || privateKey instanceof Uint8Array) {
-          // Assuming raw 64-byte private key (or 32-byte seed properly expanded by crypto)
-          // Node < 16 is tricky with raw keys.
-          // Let's assume standard Ed25519 standard implementation pattern logic:
-          keyObj = crypto.createPrivateKey({
-            key: Buffer.from(privateKey),
-            format: "der", // or 'pem' - strict.
+
+        let key: any;
+        if (typeof privateKey === "string") {
+          if (privateKey.includes("PRIVATE KEY")) {
+            // PEM format — use directly
+            key = privateKey;
+          } else {
+            // Hex-encoded DER/PKCS8
+            key = crypto.createPrivateKey({
+              key: Buffer.from(privateKey, "hex"),
+              format: "der",
+              type: "pkcs8",
+            });
+          }
+        } else if (
+          typeof privateKey === "object" &&
+          privateKey !== null &&
+          "asymmetricKeyType" in privateKey
+        ) {
+          // Node.js KeyObject (e.g. from crypto.generateKeyPairSync)
+          key = privateKey;
+        } else {
+          // Buffer or Uint8Array — assume DER/PKCS8 encoded
+          key = crypto.createPrivateKey({
+            key: Buffer.from(privateKey as Uint8Array),
+            format: "der",
             type: "pkcs8",
           });
-          // Actually, simpler: construct key object from raw bytes if possible?
-          // Node's crypto is strict. Let's try the simplest:
-          // If hex string provided, convert to buffer.
         }
 
-        // Simpler fallback: If user passed a PEM string, great.
-        // If they passed raw bytes, we might need 'ed25519' key type.
-        // For this implementation, let's target Node's high-level sign/verify
-        // and assume the user provides a VALID key object or compatible format (PEM/DER).
-        // Handling RAW Ed25519 keys in Node requires specific 'crypto.createPrivateKey' with 'raw' format (Node 11.6+).
-
-        const key =
-          typeof privateKey === "string" && !privateKey.includes("PRIVATE KEY")
-            ? crypto.createPrivateKey({
-                key: Buffer.from(privateKey, "hex"),
-                format: "pem",
-                type: "pkcs8",
-              }) // Fallback guess
-            : privateKey;
-
-        // Note: Raw Ed25519 key support in Node.js 'crypto' acts via 'generateKeyPair' or KeyObject.
-        // Direct raw signing is via crypto.sign(null, data, key).
         return new Uint8Array(crypto.sign(null, data, key));
       } catch (e) {
-        // If standard crypto fails (e.g. key format issue), throw
         throw new Error("TPSUID7RB: signing failed (check key format)");
       }
     }