@pawells/typescript-common 1.0.0

package/build/time/stopwatch/stopwatch.d.ts

@@ -0,0 +1,232 @@
+import { ElapsedTime } from '../elapsed-time/elapsed-time.js';
+import { StopwatchEntry } from './entry.js';
+/**
+ * Represents a stopwatch for measuring time intervals.
+ *
+ * A `Stopwatch` records a chronological list of {@link StopwatchEntry} timestamps
+ * and can be started, stopped, paused, resumed, lapped, and reset. The elapsed
+ * time is computed from the recorded entries rather than an active timer, so it
+ * is always accurate even after the stopwatch has been stopped.
+ *
+ * @example
+ * ```typescript
+ * // Basic start/stop usage
+ * const sw = new Stopwatch();
+ * sw.Start();
+ * // ... do work ...
+ * sw.Stop();
+ * console.log(sw.Elapsed.Format('CONCISE')); // e.g. "1s 250ms"
+ *
+ * // Start immediately via constructor
+ * const sw2 = new Stopwatch(true);
+ * // ... do work ...
+ * console.log(sw2.Elapsed.Format('MEDIUM')); // e.g. "2 sec 300 ms"
+ * ```
+ */
+export declare class Stopwatch {
+    private _times;
+    private _pausedAt;
+    /**
+     * Creates a new `Stopwatch` instance.
+     *
+     * @param startImmediately - When `true`, calls {@link Start} automatically
+     *   so the stopwatch begins tracking time as soon as it is constructed.
+     *   Defaults to `false`.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch();          // not yet running
+     * const sw2 = new Stopwatch(true);     // running immediately
+     * ```
+     */
+    constructor(startImmediately?: boolean);
+    /**
+     * Whether the stopwatch is currently running (started and not paused/stopped).
+     *
+     * @returns `true` if the stopwatch has been started and is not currently paused or stopped.
+     */
+    get Running(): boolean;
+    /**
+     * The first entry recorded by this stopwatch (i.e. the start entry).
+     *
+     * @returns The first {@link StopwatchEntry}, or `undefined` if the stopwatch
+     *   has never been started.
+     */
+    get First(): StopwatchEntry | undefined;
+    /**
+     * The most recently recorded entry.
+     *
+     * @returns The latest {@link StopwatchEntry}, or `undefined` if no entries
+     *   have been recorded yet.
+     */
+    get Latest(): StopwatchEntry | undefined;
+    /**
+     * The total time elapsed since the stopwatch was first started.
+     *
+     * - While the stopwatch is **running**, this reflects the time between the
+     *   first entry and `Date.now()`.
+     * - While the stopwatch is **paused or stopped**, this reflects the time
+     *   between the first entry and the moment it was paused/stopped.
+     * - Returns an {@link ElapsedTime} of `0` if the stopwatch has never been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 500ms later ...
+     * sw.Stop();
+     * console.log(sw.Elapsed.Format()); // "500ms"
+     * ```
+     */
+    get Elapsed(): ElapsedTime;
+    /**
+     * A shallow copy of all recorded {@link StopwatchEntry} objects in
+     * chronological order.
+     *
+     * Modifying the returned array does not affect the internal state.
+     */
+    get Times(): StopwatchEntry[];
+    /**
+     * Alias for {@link Times}. Returns a shallow copy of all recorded entries.
+     */
+    get Entries(): StopwatchEntry[];
+    /**
+     * The timestamp (milliseconds since epoch) at which the stopwatch was last
+     * paused or stopped, or `null` if it is currently running.
+     */
+    get PausedAt(): number | null;
+    /**
+     * Starts the stopwatch by recording an initial timestamp entry.
+     *
+     * If the stopwatch has already been started, this is a no-op and the
+     * existing latest entry is returned without creating a new one.
+     *
+     * @returns The start {@link StopwatchEntry} that was recorded, or `undefined`
+     *   if the stopwatch was already running (should not happen in practice).
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch();
+     * const entry = sw.Start();
+     * console.log(sw.Running); // true
+     * ```
+     */
+    Start(): StopwatchEntry | undefined;
+    /**
+     * Stops the stopwatch by recording a final timestamp entry.
+     *
+     * - If the stopwatch is currently running, the current time is recorded as
+     *   the stop entry and `_pausedAt` is set to freeze the elapsed time.
+     * - If the stopwatch has already been stopped, the latest entry is returned
+     *   unchanged (idempotent).
+     * - If the stopwatch was never started, returns `undefined`.
+     *
+     * @returns The stop {@link StopwatchEntry}, or `undefined` if the stopwatch
+     *   had not been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... some work ...
+     * const stopEntry = sw.Stop();
+     * console.log(sw.Running); // false
+     * console.log(sw.Elapsed.Format()); // e.g. "500ms"
+     * ```
+     */
+    Stop(): StopwatchEntry | undefined;
+    /**
+     * Pauses the stopwatch, freezing the elapsed time at the current moment.
+     *
+     * If the stopwatch has not been started, returns `null`. Unlike {@link Stop},
+     * `Pause` does not record a new timestamp entry — it only sets the internal
+     * pause marker so that subsequent reads of {@link Elapsed} return a frozen value.
+     *
+     * @returns The latest {@link StopwatchEntry} at the time of pausing, or `null`
+     *   if the stopwatch had not been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 200ms ...
+     * sw.Pause();
+     * // ... 500ms later ...
+     * console.log(sw.Elapsed.Format()); // still "200ms"
+     * sw.Resume();
+     * ```
+     */
+    Pause(): StopwatchEntry | null;
+    /**
+     * Resumes a paused stopwatch by recording a new timestamp entry.
+     *
+     * If the stopwatch is not currently paused, returns `null` and has no effect.
+     * After resuming, elapsed-time calculations continue to accumulate from where
+     * they left off.
+     *
+     * @returns A new {@link StopwatchEntry} recording the resume time, or `null`
+     *   if the stopwatch was not paused.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * sw.Pause();
+     * const resumeEntry = sw.Resume();
+     * console.log(sw.Running); // true
+     * ```
+     */
+    Resume(): StopwatchEntry | null;
+    /**
+     * Records a click entry at the current moment without changing the
+     * running/paused state.
+     *
+     * If the stopwatch has no entries yet, the first click implicitly starts it.
+     * Use this for arbitrary timestamp recording or as the building block for
+     * {@link Lap}.
+     *
+     * @returns The newly recorded {@link StopwatchEntry}.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * const mark = sw.Click();
+     * console.log(mark.Elapsed.Format()); // time since last click / start
+     * ```
+     */
+    Click(): StopwatchEntry;
+    /**
+     * Records a lap by clicking the stopwatch and returning the elapsed time
+     * since the previous entry.
+     *
+     * Internally calls {@link Click} to record a new entry, then computes the
+     * difference between the new entry's timestamp and the previous one.
+     * Returns `ElapsedTime(0)` if this is the very first entry recorded.
+     *
+     * @returns An {@link ElapsedTime} representing the lap duration.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 300ms ...
+     * const lap1 = sw.Lap(); // ~300ms
+     * // ... 150ms ...
+     * const lap2 = sw.Lap(); // ~150ms
+     * ```
+     */
+    Lap(): ElapsedTime;
+    /**
+     * Resets the stopwatch to its initial state by clearing all recorded entries
+     * and removing any pause/stop marker.
+     *
+     * After calling `Reset()`, the stopwatch is in the same state as a freshly
+     * constructed instance. Call {@link Start} to begin timing again.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * sw.Stop();
+     * sw.Reset();
+     * console.log(sw.Running); // false
+     * console.log(sw.Times);   // []
+     * ```
+     */
+    Reset(): void;
+}
+//# sourceMappingURL=stopwatch.d.ts.map

package/build/time/stopwatch/stopwatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopwatch.d.ts","sourceRoot":"","sources":["../../../src/time/stopwatch/stopwatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,SAAS;IACrB,OAAO,CAAC,MAAM,CAAwB;IAEtC,OAAO,CAAC,SAAS,CAAuB;IAExC;;;;;;;;;;;;OAYG;gBACS,gBAAgB,GAAE,OAAe;IAM7C;;;;OAIG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED;;;;;OAKG;IACH,IAAW,KAAK,IAAI,cAAc,GAAG,SAAS,CAE7C;IAED;;;;;OAKG;IACH,IAAW,MAAM,IAAI,cAAc,GAAG,SAAS,CAE9C;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,IAAW,OAAO,IAAI,WAAW,CAYhC;IAED;;;;;OAKG;IACH,IAAW,KAAK,IAAI,cAAc,EAAE,CAEnC;IAED;;OAEG;IACH,IAAW,OAAO,IAAI,cAAc,EAAE,CAErC;IAED;;;OAGG;IACH,IAAW,QAAQ,IAAI,MAAM,GAAG,IAAI,CAEnC;IAED;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,cAAc,GAAG,SAAS;IAU1C;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,IAAI,IAAI,cAAc,GAAG,SAAS;IAkBzC;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,IAAI,cAAc,GAAG,IAAI;IAQrC;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,IAAI,cAAc,GAAG,IAAI;IAWtC;;;;;;;;;;;;;;;;OAgBG;IACI,KAAK,IAAI,cAAc;IAW9B;;;;;;;;;;;;;;;;;;OAkBG;IACI,GAAG,IAAI,WAAW;IAUzB;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,IAAI;CAIpB"}

package/build/time/stopwatch/stopwatch.js

@@ -0,0 +1,315 @@
+import { ElapsedTime } from '../elapsed-time/elapsed-time.js';
+import { StopwatchEntry } from './entry.js';
+/**
+ * Represents a stopwatch for measuring time intervals.
+ *
+ * A `Stopwatch` records a chronological list of {@link StopwatchEntry} timestamps
+ * and can be started, stopped, paused, resumed, lapped, and reset. The elapsed
+ * time is computed from the recorded entries rather than an active timer, so it
+ * is always accurate even after the stopwatch has been stopped.
+ *
+ * @example
+ * ```typescript
+ * // Basic start/stop usage
+ * const sw = new Stopwatch();
+ * sw.Start();
+ * // ... do work ...
+ * sw.Stop();
+ * console.log(sw.Elapsed.Format('CONCISE')); // e.g. "1s 250ms"
+ *
+ * // Start immediately via constructor
+ * const sw2 = new Stopwatch(true);
+ * // ... do work ...
+ * console.log(sw2.Elapsed.Format('MEDIUM')); // e.g. "2 sec 300 ms"
+ * ```
+ */
+export class Stopwatch {
+    _times = [];
+    _pausedAt = null;
+    /**
+     * Creates a new `Stopwatch` instance.
+     *
+     * @param startImmediately - When `true`, calls {@link Start} automatically
+     *   so the stopwatch begins tracking time as soon as it is constructed.
+     *   Defaults to `false`.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch();          // not yet running
+     * const sw2 = new Stopwatch(true);     // running immediately
+     * ```
+     */
+    constructor(startImmediately = false) {
+        if (startImmediately) {
+            this.Start();
+        }
+    }
+    /**
+     * Whether the stopwatch is currently running (started and not paused/stopped).
+     *
+     * @returns `true` if the stopwatch has been started and is not currently paused or stopped.
+     */
+    get Running() {
+        return this.First !== undefined && this._pausedAt === null;
+    }
+    /**
+     * The first entry recorded by this stopwatch (i.e. the start entry).
+     *
+     * @returns The first {@link StopwatchEntry}, or `undefined` if the stopwatch
+     *   has never been started.
+     */
+    get First() {
+        return this._times.length === 0 ? undefined : this._times[0];
+    }
+    /**
+     * The most recently recorded entry.
+     *
+     * @returns The latest {@link StopwatchEntry}, or `undefined` if no entries
+     *   have been recorded yet.
+     */
+    get Latest() {
+        return this._times.length === 0 ? undefined : this._times[this._times.length - 1];
+    }
+    /**
+     * The total time elapsed since the stopwatch was first started.
+     *
+     * - While the stopwatch is **running**, this reflects the time between the
+     *   first entry and `Date.now()`.
+     * - While the stopwatch is **paused or stopped**, this reflects the time
+     *   between the first entry and the moment it was paused/stopped.
+     * - Returns an {@link ElapsedTime} of `0` if the stopwatch has never been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 500ms later ...
+     * sw.Stop();
+     * console.log(sw.Elapsed.Format()); // "500ms"
+     * ```
+     */
+    get Elapsed() {
+        const current = Date.now();
+        if (!this.Latest)
+            return new ElapsedTime(0);
+        const first = this.First;
+        if (!first)
+            return new ElapsedTime(0);
+        if (this._pausedAt !== null) {
+            return new ElapsedTime(this._pausedAt - first.timestamp);
+        }
+        return new ElapsedTime(current - first.timestamp);
+    }
+    /**
+     * A shallow copy of all recorded {@link StopwatchEntry} objects in
+     * chronological order.
+     *
+     * Modifying the returned array does not affect the internal state.
+     */
+    get Times() {
+        return [...this._times];
+    }
+    /**
+     * Alias for {@link Times}. Returns a shallow copy of all recorded entries.
+     */
+    get Entries() {
+        return this.Times;
+    }
+    /**
+     * The timestamp (milliseconds since epoch) at which the stopwatch was last
+     * paused or stopped, or `null` if it is currently running.
+     */
+    get PausedAt() {
+        return this._pausedAt;
+    }
+    /**
+     * Starts the stopwatch by recording an initial timestamp entry.
+     *
+     * If the stopwatch has already been started, this is a no-op and the
+     * existing latest entry is returned without creating a new one.
+     *
+     * @returns The start {@link StopwatchEntry} that was recorded, or `undefined`
+     *   if the stopwatch was already running (should not happen in practice).
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch();
+     * const entry = sw.Start();
+     * console.log(sw.Running); // true
+     * ```
+     */
+    Start() {
+        if (this.Latest)
+            return this.Latest;
+        this._pausedAt = null;
+        const entry = new StopwatchEntry(Date.now(), this, this._times.length);
+        this._times.push(entry);
+        return entry;
+    }
+    /**
+     * Stops the stopwatch by recording a final timestamp entry.
+     *
+     * - If the stopwatch is currently running, the current time is recorded as
+     *   the stop entry and `_pausedAt` is set to freeze the elapsed time.
+     * - If the stopwatch has already been stopped, the latest entry is returned
+     *   unchanged (idempotent).
+     * - If the stopwatch was never started, returns `undefined`.
+     *
+     * @returns The stop {@link StopwatchEntry}, or `undefined` if the stopwatch
+     *   had not been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... some work ...
+     * const stopEntry = sw.Stop();
+     * console.log(sw.Running); // false
+     * console.log(sw.Elapsed.Format()); // e.g. "500ms"
+     * ```
+     */
+    Stop() {
+        const latest = this.Latest;
+        if (!latest)
+            return undefined;
+        if (this._pausedAt === null) {
+            // Not stopped yet, so stop it
+            const current = Date.now();
+            this._pausedAt = current;
+            const entry = new StopwatchEntry(current, this, this._times.length);
+            this._times.push(entry);
+            return entry;
+        }
+        else {
+            // Already stopped, just return latest
+            return latest;
+        }
+    }
+    /**
+     * Pauses the stopwatch, freezing the elapsed time at the current moment.
+     *
+     * If the stopwatch has not been started, returns `null`. Unlike {@link Stop},
+     * `Pause` does not record a new timestamp entry — it only sets the internal
+     * pause marker so that subsequent reads of {@link Elapsed} return a frozen value.
+     *
+     * @returns The latest {@link StopwatchEntry} at the time of pausing, or `null`
+     *   if the stopwatch had not been started.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 200ms ...
+     * sw.Pause();
+     * // ... 500ms later ...
+     * console.log(sw.Elapsed.Format()); // still "200ms"
+     * sw.Resume();
+     * ```
+     */
+    Pause() {
+        const latest = this.Latest;
+        if (!latest)
+            return null;
+        this._pausedAt = Date.now();
+        return latest;
+    }
+    /**
+     * Resumes a paused stopwatch by recording a new timestamp entry.
+     *
+     * If the stopwatch is not currently paused, returns `null` and has no effect.
+     * After resuming, elapsed-time calculations continue to accumulate from where
+     * they left off.
+     *
+     * @returns A new {@link StopwatchEntry} recording the resume time, or `null`
+     *   if the stopwatch was not paused.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * sw.Pause();
+     * const resumeEntry = sw.Resume();
+     * console.log(sw.Running); // true
+     * ```
+     */
+    Resume() {
+        if (this._pausedAt === null)
+            return null;
+        const current = Date.now();
+        this._pausedAt = null;
+        const entry = new StopwatchEntry(current, this, this._times.length);
+        this._times.push(entry);
+        return entry;
+    }
+    /**
+     * Records a click entry at the current moment without changing the
+     * running/paused state.
+     *
+     * If the stopwatch has no entries yet, the first click implicitly starts it.
+     * Use this for arbitrary timestamp recording or as the building block for
+     * {@link Lap}.
+     *
+     * @returns The newly recorded {@link StopwatchEntry}.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * const mark = sw.Click();
+     * console.log(mark.Elapsed.Format()); // time since last click / start
+     * ```
+     */
+    Click() {
+        const current = Date.now();
+        if (this._times.length === 0) {
+            // First click starts the stopwatch
+            this._pausedAt = null;
+        }
+        const entry = new StopwatchEntry(current, this, this._times.length);
+        this._times.push(entry);
+        return entry;
+    }
+    /**
+     * Records a lap by clicking the stopwatch and returning the elapsed time
+     * since the previous entry.
+     *
+     * Internally calls {@link Click} to record a new entry, then computes the
+     * difference between the new entry's timestamp and the previous one.
+     * Returns `ElapsedTime(0)` if this is the very first entry recorded.
+     *
+     * @returns An {@link ElapsedTime} representing the lap duration.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * // ... 300ms ...
+     * const lap1 = sw.Lap(); // ~300ms
+     * // ... 150ms ...
+     * const lap2 = sw.Lap(); // ~150ms
+     * ```
+     */
+    Lap() {
+        const previousLatest = this.Latest;
+        const newEntry = this.Click();
+        if (!previousLatest) {
+            return new ElapsedTime(0);
+        }
+        return new ElapsedTime(newEntry.timestamp - previousLatest.timestamp);
+    }
+    /**
+     * Resets the stopwatch to its initial state by clearing all recorded entries
+     * and removing any pause/stop marker.
+     *
+     * After calling `Reset()`, the stopwatch is in the same state as a freshly
+     * constructed instance. Call {@link Start} to begin timing again.
+     *
+     * @example
+     * ```typescript
+     * const sw = new Stopwatch(true);
+     * sw.Stop();
+     * sw.Reset();
+     * console.log(sw.Running); // false
+     * console.log(sw.Times);   // []
+     * ```
+     */
+    Reset() {
+        this._times = [];
+        this._pausedAt = null;
+    }
+}
+//# sourceMappingURL=stopwatch.js.map

package/build/time/stopwatch/stopwatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopwatch.js","sourceRoot":"","sources":["../../../src/time/stopwatch/stopwatch.ts"],"names":[],"mappings":"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"}

package/build/time/time.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=time.test.d.ts.map

package/build/time/time.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.test.d.ts","sourceRoot":"","sources":["../../src/time/time.test.ts"],"names":[],"mappings":""}