@hla4ts/session 0.1.0 → 0.1.1

package/src/timeout-timer.ts

@@ -1,204 +1,204 @@
-/**
- * Timeout Timer
- *
- * Utility class to execute a callback after a timer expires.
- * Supports extending the timeout and pausing/resuming.
- *
- * Can be configured as "eager" (may trigger early) or "lazy" (never triggers early).
- */
-
-/**
- * Timer that executes a callback after a timeout.
- * Supports extending, pausing, and resuming.
- */
-export class TimeoutTimer {
-  private readonly _timeoutDurationMs: number;
-  private readonly _checkIntervalMs: number;
-  private readonly _offsetTimeMs: number;
-  private _timeoutTimestampMs: number = Number.MAX_SAFE_INTEGER;
-  private _intervalHandle: ReturnType<typeof setInterval> | null = null;
-  private _onTimeout: (() => void) | null = null;
-  private _cancelled: boolean = false;
-
-  /**
-   * Create a new timeout timer.
-   *
-   * @param timeoutDurationMs - Duration until timeout in milliseconds
-   * @param eager - If true, timeout may trigger early but never late. If false, never triggers early.
-   */
-  private constructor(timeoutDurationMs: number, eager: boolean) {
-    this._timeoutDurationMs = timeoutDurationMs;
-
-    // Calculate check interval (check 6 times per timeout period)
-    const wakeUpTimesPerInterval = 6;
-    this._checkIntervalMs = Math.max(
-      1,
-      Math.floor(timeoutDurationMs / wakeUpTimesPerInterval)
-    );
-
-    // For eager mode, trigger slightly before the full timeout
-    this._offsetTimeMs = eager
-      ? this._checkIntervalMs * (wakeUpTimesPerInterval - 1)
-      : timeoutDurationMs;
-  }
-
-  /**
-   * Create a lazy timeout timer (never triggers early, may trigger late)
-   */
-  static createLazy(timeoutDurationMs: number): TimeoutTimer {
-    return new TimeoutTimer(timeoutDurationMs, false);
-  }
-
-  /**
-   * Create an eager timeout timer (may trigger early, never triggers late)
-   */
-  static createEager(timeoutDurationMs: number): TimeoutTimer {
-    return new TimeoutTimer(timeoutDurationMs, true);
-  }
-
-  /**
-   * Get the configured timeout duration
-   */
-  get timeoutDurationMs(): number {
-    return this._timeoutDurationMs;
-  }
-
-  /**
-   * Check if the timer is currently running
-   */
-  get isRunning(): boolean {
-    return this._intervalHandle !== null && !this._cancelled;
-  }
-
-  /**
-   * Start the timer with a callback to execute on timeout.
-   *
-   * @param onTimeout - Callback to execute when the timer expires
-   */
-  start(onTimeout: () => void): void {
-    if (this._timeoutDurationMs === 0) {
-      // Zero timeout means no timeout checking
-      return;
-    }
-
-    if (this._cancelled) {
-      throw new Error("Cannot start a cancelled timer");
-    }
-
-    this._onTimeout = onTimeout;
-
-    // Start the periodic check
-    this._intervalHandle = setInterval(() => {
-      this._checkTimeout();
-    }, this._checkIntervalMs);
-
-    // Set initial timeout timestamp
-    this.extend();
-  }
-
-  /**
-   * Check if the timeout has been reached
-   */
-  private _checkTimeout(): void {
-    const now = Date.now();
-    if (now >= this._timeoutTimestampMs) {
-      this.pause();
-      this._onTimeout?.();
-    }
-  }
-
-  /**
-   * Pause the timer (prevents timeout from triggering)
-   */
-  pause(): void {
-    this._timeoutTimestampMs = Number.MAX_SAFE_INTEGER;
-  }
-
-  /**
-   * Resume the timer after being paused
-   */
-  resume(): void {
-    this.extend();
-  }
-
-  /**
-   * Extend the timeout by resetting the timer
-   */
-  extend(): void {
-    this._timeoutTimestampMs = Date.now() + this._offsetTimeMs;
-  }
-
-  /**
-   * Cancel the timer permanently
-   */
-  cancel(): void {
-    this._cancelled = true;
-    if (this._intervalHandle !== null) {
-      clearInterval(this._intervalHandle);
-      this._intervalHandle = null;
-    }
-    this._onTimeout = null;
-  }
-
-  /**
-   * Get remaining time until timeout (approximate)
-   */
-  get remainingMs(): number {
-    const remaining = this._timeoutTimestampMs - Date.now();
-    return Math.max(0, remaining);
-  }
-}
-
-/**
- * Simple one-shot timer that executes a callback after a delay.
- * Can be cancelled before execution.
- */
-export class OneShotTimer {
-  private _handle: ReturnType<typeof setTimeout> | null = null;
-  private _cancelled: boolean = false;
-
-  /**
-   * Schedule a callback to execute after the specified delay.
-   *
-   * @param callback - Callback to execute
-   * @param delayMs - Delay in milliseconds
-   */
-  schedule(callback: () => void, delayMs: number): void {
-    if (this._cancelled) {
-      throw new Error("Cannot schedule on a cancelled timer");
-    }
-
-    this.clear();
-    this._handle = setTimeout(() => {
-      this._handle = null;
-      if (!this._cancelled) {
-        callback();
-      }
-    }, delayMs);
-  }
-
-  /**
-   * Clear the scheduled callback without executing it
-   */
-  clear(): void {
-    if (this._handle !== null) {
-      clearTimeout(this._handle);
-      this._handle = null;
-    }
-  }
-
-  /**
-   * Cancel the timer permanently
-   */
-  cancel(): void {
-    this._cancelled = true;
-    this.clear();
-  }
-
-  /**
-   * Check if a callback is currently scheduled
-   */
-  get isScheduled(): boolean {
-    return this._handle !== null;
-  }
-}
+/**
+ * Timeout Timer
+ *
+ * Utility class to execute a callback after a timer expires.
+ * Supports extending the timeout and pausing/resuming.
+ *
+ * Can be configured as "eager" (may trigger early) or "lazy" (never triggers early).
+ */
+
+/**
+ * Timer that executes a callback after a timeout.
+ * Supports extending, pausing, and resuming.
+ */
+export class TimeoutTimer {
+  private readonly _timeoutDurationMs: number;
+  private readonly _checkIntervalMs: number;
+  private readonly _offsetTimeMs: number;
+  private _timeoutTimestampMs: number = Number.MAX_SAFE_INTEGER;
+  private _intervalHandle: ReturnType<typeof setInterval> | null = null;
+  private _onTimeout: (() => void) | null = null;
+  private _cancelled: boolean = false;
+
+  /**
+   * Create a new timeout timer.
+   *
+   * @param timeoutDurationMs - Duration until timeout in milliseconds
+   * @param eager - If true, timeout may trigger early but never late. If false, never triggers early.
+   */
+  private constructor(timeoutDurationMs: number, eager: boolean) {
+    this._timeoutDurationMs = timeoutDurationMs;
+
+    // Calculate check interval (check 6 times per timeout period)
+    const wakeUpTimesPerInterval = 6;
+    this._checkIntervalMs = Math.max(
+      1,
+      Math.floor(timeoutDurationMs / wakeUpTimesPerInterval)
+    );
+
+    // For eager mode, trigger slightly before the full timeout
+    this._offsetTimeMs = eager
+      ? this._checkIntervalMs * (wakeUpTimesPerInterval - 1)
+      : timeoutDurationMs;
+  }
+
+  /**
+   * Create a lazy timeout timer (never triggers early, may trigger late)
+   */
+  static createLazy(timeoutDurationMs: number): TimeoutTimer {
+    return new TimeoutTimer(timeoutDurationMs, false);
+  }
+
+  /**
+   * Create an eager timeout timer (may trigger early, never triggers late)
+   */
+  static createEager(timeoutDurationMs: number): TimeoutTimer {
+    return new TimeoutTimer(timeoutDurationMs, true);
+  }
+
+  /**
+   * Get the configured timeout duration
+   */
+  get timeoutDurationMs(): number {
+    return this._timeoutDurationMs;
+  }
+
+  /**
+   * Check if the timer is currently running
+   */
+  get isRunning(): boolean {
+    return this._intervalHandle !== null && !this._cancelled;
+  }
+
+  /**
+   * Start the timer with a callback to execute on timeout.
+   *
+   * @param onTimeout - Callback to execute when the timer expires
+   */
+  start(onTimeout: () => void): void {
+    if (this._timeoutDurationMs === 0) {
+      // Zero timeout means no timeout checking
+      return;
+    }
+
+    if (this._cancelled) {
+      throw new Error("Cannot start a cancelled timer");
+    }
+
+    this._onTimeout = onTimeout;
+
+    // Start the periodic check
+    this._intervalHandle = setInterval(() => {
+      this._checkTimeout();
+    }, this._checkIntervalMs);
+
+    // Set initial timeout timestamp
+    this.extend();
+  }
+
+  /**
+   * Check if the timeout has been reached
+   */
+  private _checkTimeout(): void {
+    const now = Date.now();
+    if (now >= this._timeoutTimestampMs) {
+      this.pause();
+      this._onTimeout?.();
+    }
+  }
+
+  /**
+   * Pause the timer (prevents timeout from triggering)
+   */
+  pause(): void {
+    this._timeoutTimestampMs = Number.MAX_SAFE_INTEGER;
+  }
+
+  /**
+   * Resume the timer after being paused
+   */
+  resume(): void {
+    this.extend();
+  }
+
+  /**
+   * Extend the timeout by resetting the timer
+   */
+  extend(): void {
+    this._timeoutTimestampMs = Date.now() + this._offsetTimeMs;
+  }
+
+  /**
+   * Cancel the timer permanently
+   */
+  cancel(): void {
+    this._cancelled = true;
+    if (this._intervalHandle !== null) {
+      clearInterval(this._intervalHandle);
+      this._intervalHandle = null;
+    }
+    this._onTimeout = null;
+  }
+
+  /**
+   * Get remaining time until timeout (approximate)
+   */
+  get remainingMs(): number {
+    const remaining = this._timeoutTimestampMs - Date.now();
+    return Math.max(0, remaining);
+  }
+}
+
+/**
+ * Simple one-shot timer that executes a callback after a delay.
+ * Can be cancelled before execution.
+ */
+export class OneShotTimer {
+  private _handle: ReturnType<typeof setTimeout> | null = null;
+  private _cancelled: boolean = false;
+
+  /**
+   * Schedule a callback to execute after the specified delay.
+   *
+   * @param callback - Callback to execute
+   * @param delayMs - Delay in milliseconds
+   */
+  schedule(callback: () => void, delayMs: number): void {
+    if (this._cancelled) {
+      throw new Error("Cannot schedule on a cancelled timer");
+    }
+
+    this.clear();
+    this._handle = setTimeout(() => {
+      this._handle = null;
+      if (!this._cancelled) {
+        callback();
+      }
+    }, delayMs);
+  }
+
+  /**
+   * Clear the scheduled callback without executing it
+   */
+  clear(): void {
+    if (this._handle !== null) {
+      clearTimeout(this._handle);
+      this._handle = null;
+    }
+  }
+
+  /**
+   * Cancel the timer permanently
+   */
+  cancel(): void {
+    this._cancelled = true;
+    this.clear();
+  }
+
+  /**
+   * Check if a callback is currently scheduled
+   */
+  get isScheduled(): boolean {
+    return this._handle !== null;
+  }
+}