@stringsync/splates 0.0.60 → 1.13.3

package/vendor/core/time/index.js

@@ -0,0 +1,271 @@
+// time/duration.ts
+class Duration {
+  _ms;
+  constructor(_ms) {
+    this._ms = _ms;
+  }
+  static zero() {
+    return new Duration(0);
+  }
+  static ms(ms) {
+    return new Duration(ms);
+  }
+  static secs(secs) {
+    return Duration.ms(secs * 1000);
+  }
+  static mins(mins) {
+    return Duration.secs(mins * 60);
+  }
+  static hrs(hrs) {
+    return Duration.mins(hrs * 60);
+  }
+  static days(days) {
+    return Duration.hrs(days * 24);
+  }
+  static min(...durations) {
+    return durations.reduce((min, duration) => duration.isLessThan(min) ? duration : min, Duration.ms(Number.POSITIVE_INFINITY));
+  }
+  static max(...durations) {
+    return durations.reduce((max, duration) => duration.isGreaterThan(max) ? duration : max, Duration.ms(Number.NEGATIVE_INFINITY));
+  }
+  get ms() {
+    return this._ms;
+  }
+  get secs() {
+    return this._ms / 1000;
+  }
+  get mins() {
+    return this.secs / 60;
+  }
+  get hrs() {
+    return this.mins / 60;
+  }
+  isEqual(other) {
+    return this._ms === other._ms;
+  }
+  isLessThan(other) {
+    return this._ms < other._ms;
+  }
+  isGreaterThan(other) {
+    return this._ms > other._ms;
+  }
+  isLessThanOrEqual(other) {
+    return this._ms <= other._ms;
+  }
+  isGreaterThanOrEqual(other) {
+    return this._ms >= other._ms;
+  }
+  add(other) {
+    return new Duration(this._ms + other._ms);
+  }
+  subtract(other) {
+    return new Duration(this._ms - other._ms);
+  }
+  multiply(factor) {
+    return new Duration(this._ms * factor);
+  }
+  clamp(min, max) {
+    return new Duration(Math.min(Math.max(this._ms, min._ms), max._ms));
+  }
+  negate() {
+    return new Duration(-this._ms);
+  }
+  toString() {
+    return `${this._ms}ms`;
+  }
+  human() {
+    if (this._ms < 1000) {
+      return `${Math.round(this._ms)}ms`;
+    }
+    if (this.secs < 60) {
+      return `${this.secs.toFixed(1)}s`;
+    }
+    const mins = Math.floor(this.mins);
+    return `${mins}m ${String(Math.round(this.secs - mins * 60)).padStart(2, "0")}s`;
+  }
+}
+
+// time/clock/system-clock.ts
+class SystemClock {
+  now() {
+    return Duration.ms(performance.now());
+  }
+}
+// time/debouncer.ts
+class Debouncer {
+  timer;
+  delay;
+  pending = null;
+  fn = null;
+  constructor(timer, delay) {
+    this.timer = timer;
+    this.delay = delay;
+  }
+  call(fn) {
+    this.cancel();
+    this.fn = fn;
+    this.pending = this.timer.setTimeout(() => {
+      this.fn = null;
+      this.pending = null;
+      fn();
+    }, this.delay);
+  }
+  flush() {
+    const fn = this.fn;
+    this.cancel();
+    fn?.();
+  }
+  cancel() {
+    this.pending?.dispose();
+    this.pending = null;
+    this.fn = null;
+  }
+  dispose() {
+    this.cancel();
+  }
+}
+// time/sleep.ts
+function sleep(duration) {
+  return new Promise((resolve) => setTimeout(resolve, duration.ms));
+}
+// time/stopwatch.ts
+class Stopwatch {
+  clock;
+  accumulated = Duration.zero();
+  runningSince = null;
+  constructor(clock) {
+    this.clock = clock;
+  }
+  elapsed() {
+    if (this.runningSince === null) {
+      return this.accumulated;
+    }
+    return this.accumulated.add(this.clock.now().subtract(this.runningSince));
+  }
+  isRunning() {
+    return this.runningSince !== null;
+  }
+  start() {
+    this.accumulated = Duration.zero();
+    this.runningSince = this.clock.now();
+  }
+  stop() {
+    if (this.runningSince === null) {
+      return;
+    }
+    this.accumulated = this.elapsed();
+    this.runningSince = null;
+  }
+  resume() {
+    this.runningSince ??= this.clock.now();
+  }
+  dispose() {
+    this.stop();
+  }
+}
+// time/throttler.ts
+class Throttler {
+  timer;
+  interval;
+  pending = null;
+  fn = null;
+  constructor(timer, interval) {
+    this.timer = timer;
+    this.interval = interval;
+  }
+  call(fn) {
+    if (this.pending !== null) {
+      this.fn = fn;
+      return;
+    }
+    fn();
+    this.pending = this.timer.setTimeout(() => {
+      const queued = this.fn;
+      this.fn = null;
+      this.pending = null;
+      if (queued !== null) {
+        this.call(queued);
+      }
+    }, this.interval);
+  }
+  flush() {
+    const fn = this.fn;
+    this.cancel();
+    fn?.();
+  }
+  cancel() {
+    this.pending?.dispose();
+    this.pending = null;
+    this.fn = null;
+  }
+  dispose() {
+    this.cancel();
+  }
+}
+// time/time-ago.ts
+function timeAgo(elapsed) {
+  const seconds = Math.max(0, Math.floor(elapsed.secs));
+  if (seconds < 5) {
+    return "just now";
+  }
+  if (seconds < 60) {
+    return plural(seconds, "second");
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return plural(minutes, "minute");
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return plural(hours, "hour");
+  }
+  return plural(Math.floor(hours / 24), "day");
+}
+function plural(count, unit) {
+  return `${count} ${unit}${count === 1 ? "" : "s"} ago`;
+}
+// time/timeouts.ts
+class timeouts {
+  constructor() {}
+  static race(timer, promise, timeout) {
+    return new Promise((resolve) => {
+      const deadline = timer.setTimeout(() => resolve(false), timeout);
+      const settled = () => {
+        deadline.dispose();
+        resolve(true);
+      };
+      promise.then(settled, settled);
+    });
+  }
+}
+// time/timer/system-timer.ts
+import { disposables } from "../disposable/index.js";
+
+class SystemTimer {
+  setTimeout(callback, delay) {
+    const id = setTimeout(callback, delay.ms);
+    return disposables.callback(() => clearTimeout(id));
+  }
+  setInterval(callback, interval) {
+    const id = setInterval(callback, interval.ms);
+    return disposables.callback(() => clearInterval(id));
+  }
+}
+// time/wall-clock/system-wall-clock.ts
+class SystemWallClock {
+  now() {
+    return Date.now();
+  }
+}
+export {
+  Debouncer,
+  Duration,
+  Stopwatch,
+  SystemClock,
+  SystemTimer,
+  SystemWallClock,
+  Throttler,
+  sleep,
+  timeAgo,
+  timeouts
+};

package/vendor/core/time/sleep.d.ts

@@ -0,0 +1,2 @@
+import type { Duration } from "./duration";
+export declare function sleep(duration: Duration): Promise<void>;

package/vendor/core/time/stopwatch.d.ts

@@ -0,0 +1,34 @@
+import type { Resource } from "../disposable/index.js";
+import type { Clock } from "./clock/clock";
+import { Duration } from "./duration";
+/**
+ * Elapsed time that can be paused, for measuring how long something took while
+ * leaving out the parts that should not count: a dialog the user left open, a
+ * run they paused, a tab that went to the background.
+ *
+ * ```ts
+ * const stopwatch = new Stopwatch(clock);
+ * stopwatch.start();
+ * stopwatch.stop(); // pauses, keeping what has accrued
+ * stopwatch.resume();
+ * stopwatch.elapsed(); // total, minus the pauses
+ * ```
+ *
+ * It reads a `Clock` rather than a `WallClock`, so it is unmoved by the machine
+ * syncing its date.
+ */
+export declare class Stopwatch implements Resource {
+    private readonly clock;
+    private accumulated;
+    private runningSince;
+    constructor(clock: Clock);
+    elapsed(): Duration;
+    isRunning(): boolean;
+    /** Starts from zero, discarding anything a previous run accrued. */
+    start(): void;
+    /** Pauses, keeping what has accrued so far. */
+    stop(): void;
+    /** Carries on from where `stop` left off. */
+    resume(): void;
+    dispose(): void;
+}

package/vendor/core/time/throttler.d.ts

@@ -0,0 +1,26 @@
+import type { Resource } from "../disposable/index.js";
+import type { Duration } from "./duration";
+import type { Timer } from "./timer/timer";
+/**
+ * Runs the first function it is given straight away, then at most one more per
+ * `interval`. Where a `Debouncer` waits for a burst to end, this one keeps
+ * something happening throughout it.
+ *
+ * ```ts
+ * const throttler = new Throttler(new SystemTimer(), Duration.ms(100));
+ * window.addEventListener("scroll", () => throttler.call(() => reposition()));
+ * ```
+ */
+export declare class Throttler implements Resource {
+    private readonly timer;
+    private readonly interval;
+    private pending;
+    private fn;
+    constructor(timer: Timer, interval: Duration);
+    call(fn: () => void): void;
+    /** Runs whatever is waiting right now, if anything. */
+    flush(): void;
+    /** Drops whatever is waiting, unrun. */
+    cancel(): void;
+    dispose(): void;
+}

package/vendor/core/time/time-ago.d.ts

@@ -0,0 +1,14 @@
+import type { Duration } from "./duration";
+/**
+ * How long ago something was, in words: "just now", "5 minutes ago",
+ * "3 hours ago", "2 days ago".
+ *
+ * ```ts
+ * timeAgo(Duration.ms(wall.now() - row.createdAt));
+ * ```
+ *
+ * The unit climbs with the gap, and anything within five seconds reads as "just
+ * now". A negative duration, which a clock correction can produce, also reads
+ * as "just now" rather than as the future.
+ */
+export declare function timeAgo(elapsed: Duration): string;

package/vendor/core/time/timeouts.d.ts

@@ -0,0 +1,12 @@
+import type { Duration } from "./duration";
+import type { Timer } from "./timer/timer";
+/** Putting a deadline on work that does not take one. */
+export declare class timeouts {
+    private constructor();
+    /**
+     * Resolves `true` if `promise` settles before `timeout` elapses, `false` if
+     * the deadline wins. The work keeps running either way, since a promise
+     * cannot be cancelled: this is how long the caller is willing to wait.
+     */
+    static race(timer: Timer, promise: Promise<unknown>, timeout: Duration): Promise<boolean>;
+}

package/vendor/core/time/timer/system-timer.d.ts

@@ -0,0 +1,7 @@
+import { type Resource } from "../../disposable/index.js";
+import type { Duration } from "../duration";
+import type { Timer } from "./timer";
+export declare class SystemTimer implements Timer {
+    setTimeout(callback: () => void, delay: Duration): Resource;
+    setInterval(callback: () => void, interval: Duration): Resource;
+}

package/vendor/core/time/timer/timer.d.ts

@@ -0,0 +1,11 @@
+import type { Resource } from "../../disposable/index.js";
+import type { Duration } from "../duration";
+/**
+ * Scheduling of future work. Both methods hand back a `Resource` rather than
+ * an id, so cancelling is the same move as releasing any other resource and a
+ * pending callback cannot outlive the thing that scheduled it.
+ */
+export interface Timer {
+    setTimeout(callback: () => void, delay: Duration): Resource;
+    setInterval(callback: () => void, interval: Duration): Resource;
+}

package/vendor/core/time/wall-clock/system-wall-clock.d.ts

@@ -0,0 +1,4 @@
+import type { WallClock } from "./wall-clock";
+export declare class SystemWallClock implements WallClock {
+    now(): number;
+}

package/vendor/core/time/wall-clock/wall-clock.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A source of calendar time, as Unix epoch milliseconds.
+ *
+ * Distinct from `Clock`, which counts from an arbitrary origin and so can only
+ * say how long something took. Only a wall clock can say when it happened,
+ * which is what stamping a row, reading back a stored timestamp or comparing
+ * against someone else's (a JWT `exp`, an HTTP `Date`) all need.
+ *
+ * Measure elapsed time with `Clock` even so: a wall clock steps when the
+ * machine syncs with NTP or the user changes it, and a stopwatch should not.
+ */
+export interface WallClock {
+    now(): number;
+}

package/waiting.d.ts

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /** `splates worker queue`, which `splates worker` mounts. */
-export declare const splatesWaiting: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splatesWaiting: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;

package/worker.d.ts

@@ -1,3 +1,3 @@
-import type { SplatesDeps } from "@stringsync/splates-server/server";
+import type { SplatesDeps } from "./vendor/@stringsync/splates-server/server/index.js";
 /** `splates worker`, which the root cli mounts after `splates slots`. */
-export declare const splatesWorker: import("webappwiz/cmd").Cli<SplatesDeps, SplatesDeps>;
+export declare const splatesWorker: import("./vendor/core/cmd/index.js").Cli<SplatesDeps, SplatesDeps>;