Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(sdk-recorder): preserve capture when React limits change

Akshar Patel8c17d5bb2d48
diff --git a/packages/sdk-recorder/__tests__/duration-limit.test.ts b/packages/sdk-recorder/__tests__/duration-limit.test.ts
new file mode 100644
index 000000000..f793953ba
--- /dev/null
+++ b/packages/sdk-recorder/__tests__/duration-limit.test.ts
@@ -0,0 +1,89 @@
+import { afterEach, expect, mock, test } from "bun:test";
+import { CapRecorder } from "../src/index";
+
+class Track {
+ readonly kind = "video";
+ readyState = "live";
+ onended: (() => void) | null = null;
+ stop() {
+ this.readyState = "ended";
+ }
+}
+
+class Stream {
+ constructor(private tracks: Track[]) {}
+ getTracks() {
+ return this.tracks;
+ }
+ getVideoTracks() {
+ return this.tracks;
+ }
+ getAudioTracks() {
+ return [];
+ }
+}
+
+class Encoder {
+ state = "inactive";
+ static isTypeSupported() {
+ return true;
+ }
+ start() {
+ this.state = "recording";
+ }
+ stop() {
+ this.state = "inactive";
+ }
+}
+
+const originals = new Map(
+ [
+ "navigator",
+ "MediaStream",
+ "MediaRecorder",
+ "setTimeout",
+ "clearTimeout",
+ ].map((key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)]),
+);
+
+afterEach(() => {
+ for (const [key, descriptor] of originals) {
+ if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+ else Reflect.deleteProperty(globalThis, key);
+ }
+});
+
+test.each([
+ { constructorLimit: undefined, startLimit: undefined, expected: 14_400_000 },
+ { constructorLimit: 1500, startLimit: undefined, expected: 1500 },
+ { constructorLimit: 1500, startLimit: 700, expected: 700 },
+ { constructorLimit: 1500, startLimit: 0, expected: 0 },
+])("schedules $expected ms for the recording", async (scenario) => {
+ const stream = new Stream([new Track()]);
+ const schedule = mock((_callback: () => void, _delay?: number) => 1);
+ const globals = {
+ navigator: { mediaDevices: { getUserMedia: async () => stream } },
+ MediaStream: Stream,
+ MediaRecorder: Encoder,
+ setTimeout: schedule,
+ clearTimeout: mock(() => {}),
+ };
+ for (const [key, value] of Object.entries(globals)) {
+ Object.defineProperty(globalThis, key, { configurable: true, value });
+ }
+ const recorder = new CapRecorder({
+ publicKey: "test-only",
+ mode: "camera",
+ microphone: { enabled: false },
+ maxDurationMs: scenario.constructorLimit,
+ });
+ try {
+ await recorder.start({ maxDurationMs: scenario.startLimit });
+ expect(recorder.phase).toBe("recording");
+ expect(schedule.mock.calls).toEqual([
+ [expect.any(Function), scenario.expected],
+ ]);
+ } finally {
+ recorder.destroy();
+ }
+});
diff --git a/packages/sdk-recorder/src/index.ts b/packages/sdk-recorder/src/index.ts
index 0f7eb10e1..dda03c6bf 100644
--- a/packages/sdk-recorder/src/index.ts
+++ b/packages/sdk-recorder/src/index.ts
@@ -109,10 +109,11 @@ export class CapRecorder {
this.emit("phasechange", { phase });
}
- async start(): Promise<void> {
+ async start(options?: Pick<RecorderOptions, "maxDurationMs">): Promise<void> {
if (this._phase !== "idle") {
throw new Error(`Cannot start from phase "${this._phase}"`);
}
+ const maxDurationMs = options?.maxDurationMs ?? this.maxDurationMs;
try {
this.setPhase("requesting-permission");
@@ -157,7 +158,7 @@ export class CapRecorder {
this.startDurationTimer();
this.maxDurationTimeout = setTimeout(() => {
this.stop();
- }, this.maxDurationMs);
+ }, maxDurationMs);
this.setPhase("recording");
} catch (error) {
this.setPhase("error");
diff --git a/packages/sdk-recorder/src/react/useCapRecorder.ts b/packages/sdk-recorder/src/react/useCapRecorder.ts
index 11662e01d..ddffe69d5 100644
--- a/packages/sdk-recorder/src/react/useCapRecorder.ts
+++ b/packages/sdk-recorder/src/react/useCapRecorder.ts
@@ -37,7 +37,6 @@ export function useCapRecorder(options: RecorderOptions) {
? { enabled: microphoneEnabled, deviceId: microphoneDeviceId }
: undefined,
systemAudio,
- maxDurationMs,
});
recorderRef.current = recorder;
@@ -67,12 +66,11 @@ export function useCapRecorder(options: RecorderOptions) {
microphoneEnabled,
microphoneDeviceId,
systemAudio,
- maxDurationMs,
]);
const start = useCallback(async () => {
- await recorderRef.current?.start();
- }, []);
+ await recorderRef.current?.start({ maxDurationMs });
+ }, [maxDurationMs]);
const pause = useCallback(() => {
recorderRef.current?.pause();