tui-cap 0.1.0

package/dist/web/timing-model.js

@@ -0,0 +1,115 @@
+// Single source of truth for the GUI's playback / timeline / export timing math.
+//
+// This mirrors the canonical, unit-tested server-side math in `src/animation.ts`
+// (`applyTimeline` / `cfrCounts`). The browser can't import the TypeScript module
+// directly, so the logic is duplicated here once — and `test/playback-timing.test.ts`
+// asserts byte-for-byte parity between the two across a grid of inputs so they can
+// never silently drift. Keep any change here in lock-step with `src/animation.ts`.
+
+/** Playback-only visibility floor (ms): the play loop never holds a frame for
+ *  less than this so a sub-perception burst still registers on screen. NOT part
+ *  of the readout/timeline/export totals — those use the raw effective hold. */
+export const PLAYBACK_MIN_MS = 40;
+
+/** Fallback hold (ms) when a frame carries no captured timing. */
+export const UNIFORM_FRAME_MS = 1000;
+
+/** Default cap on any single frame's hold (ms); mirrors animation.DEFAULT_IDLE_CAP_MS. */
+export const DEFAULT_IDLE_CAP_MS = 1500;
+
+/**
+ * Effective on-screen hold (ms) for one raw duration under the given settings.
+ * An override wins outright (no cap, no speed); smooth-typing then retimes a
+ * flagged typing frame to `typedChars / typingCps` (no cap, no speed);
+ * otherwise the raw hold is capped to `idleCapMs` then divided by `speed`.
+ * Equivalent to `animation.applyTimeline([rawMs], { idleCapMs, speed, minMs: 0,
+ * smoothTyping, typingCps, isTyping:[isTyping], typedChars:[typedChars] })[0]`.
+ */
+export function effectiveDuration(rawMs, settings = {}) {
+  const {
+    idleCapMs = DEFAULT_IDLE_CAP_MS,
+    speed = 1,
+    override,
+    smoothTyping = false,
+    typingCps = 30,
+    isTyping = false,
+    typedChars = 0,
+  } = settings;
+  if (typeof override === 'number' && isFinite(override)) return Math.max(0, override);
+  if (smoothTyping && isTyping && typedChars > 0) {
+    const cps = typingCps > 0 ? typingCps : 30;
+    return (typedChars / cps) * 1000;
+  }
+  let v = Math.max(0, rawMs);
+  if (idleCapMs > 0) v = Math.min(v, idleCapMs);
+  const sp = speed > 0 ? speed : 1;
+  return v / sp;
+}
+
+/** Raw on-screen hold for a frame record, before caps/speed/overrides. */
+export function rawDurationMs(frame) {
+  const d = frame && frame.durationMs;
+  return typeof d === 'number' && isFinite(d) ? d : UNIFORM_FRAME_MS;
+}
+
+/**
+ * Effective per-frame durations (ms) for a list of frame records.
+ * `settings`: `{ idleCapMs, speed, overrides: { [index]: ms }, smoothTyping,
+ * typingCps }`. A per-frame override (keyed by stringified index) bypasses cap +
+ * speed; smooth-typing retimes frames whose record carries `isTyping`/
+ * `typedChars`.
+ */
+export function effectiveDurations(frames, settings = {}) {
+  const {
+    idleCapMs = DEFAULT_IDLE_CAP_MS,
+    speed = 1,
+    overrides = {},
+    smoothTyping = false,
+    typingCps = 30,
+  } = settings;
+  return frames.map((f, i) => {
+    const ov = overrides[String(i)];
+    return effectiveDuration(rawDurationMs(f), {
+      idleCapMs,
+      speed,
+      override: ov,
+      smoothTyping,
+      typingCps,
+      isTyping: !!(f && f.isTyping),
+      typedChars: f && typeof f.typedChars === 'number' ? f.typedChars : 0,
+    });
+  });
+}
+
+/** Playback hold (ms): the effective duration floored to PLAYBACK_MIN_MS. */
+export function playbackHold(effMs) {
+  return Math.max(PLAYBACK_MIN_MS, Math.max(0, effMs));
+}
+
+/** CFR repeat count for a frame held `ms` at `fps` (at least one). Mirrors
+ *  animation.cfrCounts' per-frame value. */
+export function cfrCount(ms, fps) {
+  const f = fps > 0 ? fps : 1;
+  return Math.max(1, Math.round((Math.max(0, ms) / 1000) * f));
+}
+
+/** Readout / timeline total (ms): plain sum of effective holds over `indices`. */
+export function readoutTotalMs(eff, indices) {
+  return indices.reduce((a, i) => a + Math.max(0, eff[i]), 0);
+}
+
+/** Playback total (ms): sum of floored holds — what the play loop targets. */
+export function playbackTotalMs(eff, indices) {
+  return indices.reduce((a, i) => a + playbackHold(eff[i]), 0);
+}
+
+/** CFR output-frame total over `indices` at `fps`. */
+export function cfrTotalFrames(eff, indices, fps) {
+  return indices.reduce((a, i) => a + cfrCount(eff[i], fps), 0);
+}
+
+/** CFR export wall-clock (ms): output frames / fps. */
+export function cfrTotalMs(eff, indices, fps) {
+  const f = fps > 0 ? fps : 1;
+  return (cfrTotalFrames(eff, indices, f) / f) * 1000;
+}

package/dist/web/vendor/mp4-muxer.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Vanilagy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.