Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { makePersisted } from "@solid-primitives/storage";
import { listen } from "@tauri-apps/api/event";
import {
availableMonitors,
currentMonitor,
getCurrentWindow,
LogicalPosition,
LogicalSize,
} from "@tauri-apps/api/window";
import { type } from "@tauri-apps/plugin-os";
import { cx } from "cva";
import {
type Accessor,
createEffect,
createResource,
createSignal,
on,
onCleanup,
onMount,
Show,
Suspense,
} from "solid-js";
import { createStore } from "solid-js/store";
import {
CAMERA_DEFAULT_SIZE,
CAMERA_MAX_SIZE,
CAMERA_MIN_SIZE,
CAMERA_PRESET_LARGE,
CAMERA_TOOLBAR_HEIGHT,
CAMERA_WINDOW_STATE_STORAGE_KEY,
CameraPreviewToolbar,
CameraResizeHandles,
type CameraWindowState,
cameraBorderRadius,
cameraPreviewDimensions,
cameraToolbarScale,
getDefaultCameraWindowState,
normalizeBackgroundBlurMode,
} from "~/components/CameraPreviewChrome";
import { generalSettingsStore } from "~/store";
import { cameraPresentationInput } from "~/utils/camera-presentation";
import { createTauriEventListener } from "~/utils/createEventListener";
import {
createCameraMutation,
createCurrentRecordingQuery,
revealRecordingWindow,
} from "~/utils/queries";
import {
type CanvasControls,
createImageDataWS,
type FrameData,
} from "~/utils/socket";
import { commands, events } from "~/utils/tauri";
import {
RecordingOptionsProvider,
useRecordingOptions,
} from "./(window-chrome)/OptionsContext";
type CameraPreviewIssue = {
title: string;
message: string;
};
const CAMERA_PREVIEW_ERROR_EVENT = "camera-preview-error";
const CAMERA_PREVIEW_CLEAR_EVENT = "camera-preview-clear";
const CAMERA_DISCONNECTED_ISSUE: CameraPreviewIssue = {
title: "Camera disconnected",
message: "The selected camera stopped sending video.",
};
const getCameraOnlyMode = () => {
return window.__CAP__?.cameraOnlyMode === true;
};
const getNativeCameraPreviewInitialState = () => {
return window.__CAP__?.enableNativeCameraPreview === true;
};
let ignoreMoveUntil = 0;
let performanceHarnessCameraOpen = false;
const ignoreMoveFor = (durationMs: number) => {
ignoreMoveUntil = Date.now() + durationMs;
};
const shouldIgnoreMove = () => Date.now() < ignoreMoveUntil;
function createCameraWindowChromeVisibility() {
const [visible, setVisible] = createSignal(false);
return {
visible,
show: () => setVisible(true),
hide: () => setVisible(false),
};
}
const queueCameraPositionSave = (() => {
let pending: { x: number; y: number } | null = null;
let timeout: ReturnType<typeof setTimeout> | null = null;
return (pos: { x: number; y: number }) => {
pending = pos;
if (timeout) return;
timeout = setTimeout(async () => {
timeout = null;
const next = pending;
pending = null;
if (!next || shouldIgnoreMove()) return;
try {
await commands.setCameraWindowPosition(next.x, next.y);
} catch (error) {
console.error("Failed to save camera window position", error);
}
}, 200);
};
})();
async function centerCurrentWindow() {
const monitor = await currentMonitor();
if (!monitor) return;
const window = getCurrentWindow();
const scaleFactor = monitor.scaleFactor;
const monitorPosition = monitor.position.toLogical(scaleFactor);
const monitorSize = monitor.size.toLogical(scaleFactor);
const windowSize = (await window.outerSize()).toLogical(scaleFactor);
const x = monitorPosition.x + (monitorSize.width - windowSize.width) / 2;
const y = monitorPosition.y + (monitorSize.height - windowSize.height) / 2;
await window.setPosition(new LogicalPosition(x, y));
}
export default function () {
document.documentElement.classList.toggle("dark", true);
const generalSettings = generalSettingsStore.createQuery();
const isNativePreviewEnabled = () => {
if (type() === "windows" || type() === "linux") return false;
if (generalSettings.isPending) return getNativeCameraPreviewInitialState();
return (
generalSettings.data?.enableNativeCameraPreview ??
getNativeCameraPreviewInitialState()
);
};
const [cameraIssue, setCameraIssue] = createSignal<CameraPreviewIssue | null>(
null,
);
const unlistenCameraPreviewError = listen<CameraPreviewIssue>(
CAMERA_PREVIEW_ERROR_EVENT,
({ payload }) => setCameraIssue(payload),
);
const unlistenCameraPreviewClear = listen(CAMERA_PREVIEW_CLEAR_EVENT, () =>
setCameraIssue(null),
);
onCleanup(() => {
void unlistenCameraPreviewError.then((unlisten) => unlisten());
void unlistenCameraPreviewClear.then((unlisten) => unlisten());
});
createTauriEventListener(events.recordingEvent, (payload) => {
if (payload.variant === "InputLost" && payload.input === "camera") {
setCameraIssue(CAMERA_DISCONNECTED_ISSUE);
} else if (
payload.variant === "InputRestored" &&
payload.input === "camera"
) {
setCameraIssue(null);
}
});
onMount(() => {
const currentWindow = getCurrentWindow();
let unlistenMoved: (() => void) | null = null;
let syncingPosition = false;
let lastSavedPosition: { x: number; y: number } | null = null;
const queueIfChanged = (x: number, y: number) => {
if (shouldIgnoreMove()) return;
if (
lastSavedPosition &&
Math.abs(lastSavedPosition.x - x) < 1 &&
Math.abs(lastSavedPosition.y - y) < 1
) {
return;
}
lastSavedPosition = { x, y };
queueCameraPositionSave({ x, y });
};
const syncCurrentPosition = async () => {
if (syncingPosition || shouldIgnoreMove()) return;
syncingPosition = true;
try {
const scaleFactor = await currentWindow.scaleFactor();
const outerPosition = await currentWindow.outerPosition();
const logicalPosition = outerPosition.toLogical(scaleFactor);
queueIfChanged(logicalPosition.x, logicalPosition.y);
} catch (error) {
console.error("Failed to read camera window position", error);
}
syncingPosition = false;
};
void currentWindow
.onMoved(async ({ payload }) => {
const scaleFactor = await currentWindow.scaleFactor();
const logicalPos = payload.toLogical(scaleFactor);
queueIfChanged(logicalPos.x, logicalPos.y);
})
.then((unlisten) => {
unlistenMoved = unlisten;
});
const interval = window.setInterval(() => {
void syncCurrentPosition();
}, 400);
onCleanup(() => {
window.clearInterval(interval);
unlistenMoved?.();
});
});
return (
<RecordingOptionsProvider>
<Show
when={isNativePreviewEnabled()}
fallback={<LegacyCameraPreviewPage issue={cameraIssue} />}
>
<NativeCameraPreviewPage issue={cameraIssue} />
</Show>
</RecordingOptionsProvider>
);
}
function NativeCameraPreviewPage(props: {
issue: Accessor<CameraPreviewIssue | null>;
}) {
const isCameraOnlyMode = () => getCameraOnlyMode();
const [state, setState] = makePersisted(
createStore<CameraWindowState>(getDefaultCameraWindowState()),
{ name: CAMERA_WINDOW_STATE_STORAGE_KEY },
);
const centerCameraOnlyWindow = () => {
ignoreMoveFor(1500);
void commands.ignoreCameraWindowPosition(1500);
void centerCurrentWindow();
setTimeout(() => {
void centerCurrentWindow();
}, 120);
};
onMount(() => {
if (isCameraOnlyMode()) {
centerCameraOnlyWindow();
}
const handleVisibilityChange = () => {
if (!document.hidden) {
setTimeout(() => {
commands.refreshCameraFeed().catch(() => {});
}, 500);
}
};
document.addEventListener("visibilitychange", handleVisibilityChange);
onCleanup(() =>
document.removeEventListener("visibilitychange", handleVisibilityChange),
);
});
createEffect(
on(
() => isCameraOnlyMode(),
(isCameraOnly, wasCameraOnly) => {
if (isCameraOnly && !wasCameraOnly) {
centerCameraOnlyWindow();
}
},
),
);
createEffect(() => {
let currentSize = state.size as number | string;
if (typeof currentSize !== "number" || Number.isNaN(currentSize)) {
currentSize =
currentSize === "lg" ? CAMERA_PRESET_LARGE : CAMERA_DEFAULT_SIZE;
setState("size", currentSize);
return;
}
const clampedSize = Math.max(
CAMERA_MIN_SIZE,
Math.min(CAMERA_MAX_SIZE, currentSize),
);
if (clampedSize !== currentSize) {
setState("size", clampedSize);
}
commands.setCameraPreviewState({
size: state.size,
shape: state.shape,
mirrored: state.mirrored,
background_blur: normalizeBackgroundBlurMode(state.backgroundBlur),
});
});
const [cameraPreviewReady] = createResource(() =>
commands.awaitCameraPreviewReady(),
);
const _setCamera = createCameraMutation();
const scale = () => cameraToolbarScale(state.size);
const chrome = createCameraWindowChromeVisibility();
return (
<div
data-tauri-drag-region
class="flex relative flex-col w-screen h-screen cursor-move"
onPointerMove={chrome.show}
onPointerLeave={chrome.hide}
onPointerCancel={chrome.hide}
>
<Show when={props.issue()}>
{(issue) => (
<CameraIssueOverlay
issue={issue()}
size={state.size}
class="inset-x-0 bottom-0"
top={CAMERA_TOOLBAR_HEIGHT}
borderRadius={cameraBorderRadius(state)}
/>
)}
</Show>
<div class="h-14">
<div class="flex flex-row justify-center items-center">
<CameraPreviewToolbar
state={state}
setState={setState}
visible={chrome.visible()}
scale={scale()}
onClose={() => getCurrentWindow().close()}
/>
</div>
</div>
<CameraResizeHandles
state={state}
setState={setState}
toolbarHeight={CAMERA_TOOLBAR_HEIGHT}
visible={chrome.visible()}
/>
<Show when={cameraPreviewReady.loading}>
<div class="w-full flex-1 flex items-center justify-center">
<div class="text-gray-11">Loading camera...</div>
</div>
</Show>
</div>
);
}
// Legacy stuff below
function LegacyCameraPreviewPage(props: {
issue: Accessor<CameraPreviewIssue | null>;
}) {
const isCameraOnlyMode = () => getCameraOnlyMode();
const currentRecording = createCurrentRecordingQuery();
const isInstantRecording = () => currentRecording.data?.mode === "instant";
const [state, setState] = makePersisted(
createStore<CameraWindowState>(getDefaultCameraWindowState()),
{ name: CAMERA_WINDOW_STATE_STORAGE_KEY },
);
const centerCameraOnlyWindow = () => {
ignoreMoveFor(1500);
void commands.ignoreCameraWindowPosition(1500);
void centerCurrentWindow();
setTimeout(() => {
void centerCurrentWindow();
}, 120);
};
onMount(() => {
if (isCameraOnlyMode()) {
centerCameraOnlyWindow();
}
});
createEffect(
on(
() => isCameraOnlyMode(),
(isCameraOnly, wasCameraOnly) => {
if (isCameraOnly && !wasCameraOnly) {
centerCameraOnlyWindow();
}
},
),
);
createEffect(() => {
const currentSize = state.size as number | string;
if (typeof currentSize !== "number" || Number.isNaN(currentSize)) {
setState(
"size",
currentSize === "lg" ? CAMERA_PRESET_LARGE : CAMERA_DEFAULT_SIZE,
);
}
});
let layoutRevision = 0;
let previewStateSync: Promise<unknown> = Promise.resolve();
createEffect(() => {
layoutRevision = (layoutRevision + 1) >>> 0;
previewStateSync = commands.setCameraPreviewState({
size: state.size,
shape: state.shape,
mirrored: state.mirrored,
background_blur: normalizeBackgroundBlurMode(state.backgroundBlur),
});
void previewStateSync.catch((error) =>
console.error("Camera preview state sync failed", error),
);
});
const [hasPositioned, setHasPositioned] = createSignal(isCameraOnlyMode());
const [hasFrame, setHasFrame] = createSignal(false);
const [hasRetainedFrame, setHasRetainedFrame] = createSignal(false);
const retainedCanvas = document.createElement("canvas");
const { rawOptions } = useRecordingOptions();
let retainedFrameTimeout: ReturnType<typeof setTimeout> | undefined;
let retainedFrameCapturedAt: number | undefined;
const clearRetainedFrame = () => {
clearTimeout(retainedFrameTimeout);
retainedFrameCapturedAt = undefined;
setHasRetainedFrame(false);
retainedCanvas.width = 0;
retainedCanvas.height = 0;
};
const scheduleRetainedFrameExpiry = () => {
clearTimeout(retainedFrameTimeout);
if (retainedFrameCapturedAt === undefined) return;
const remaining = 60_000 - (performance.now() - retainedFrameCapturedAt);
retainedFrameTimeout = setTimeout(
clearRetainedFrame,
Math.max(0, remaining),
);
};
const [frameDimensions, setFrameDimensions] = createSignal<{
width: number;
height: number;
} | null>(null);
const [externalContainerSize, setExternalContainerSize] = createSignal<{
width: number;
height: number;
} | null>(null);
let containerRef: HTMLDivElement | undefined;
onMount(() => {
if (!containerRef) return;
const updateContainerSize = () => {
if (!containerRef) return;
const rect = containerRef.getBoundingClientRect();
const currentSize = externalContainerSize();
if (
!currentSize ||
Math.abs(currentSize.width - rect.width) > 1 ||
Math.abs(currentSize.height - rect.height) > 1
) {
layoutRevision = (layoutRevision + 1) >>> 0;
setExternalContainerSize({ width: rect.width, height: rect.height });
}
};
const resizeObserver = new ResizeObserver(updateContainerSize);
resizeObserver.observe(containerRef);
updateContainerSize();
onCleanup(() => resizeObserver.disconnect());
});
const STALL_TIMEOUT_MS = 2000;
const WS_INITIAL_BACKOFF_MS = 1000;
const WS_MAX_BACKOFF_MS = 30000;
const WS_MAX_RETRIES = 10;
const { cameraWsPort } = window.__CAP__;
const [isWindowVisible, setIsWindowVisible] = createSignal(
performanceHarnessCameraOpen || !document.hidden,
);
let ws: Omit<WebSocket, "onmessage"> | undefined;
let canvasControls: CanvasControls | undefined;
let reconnectTimeout: ReturnType<typeof setTimeout> | undefined;
let stallCheckInterval: ReturnType<typeof setInterval> | undefined;
let retryCount = 0;
let isCleanedUp = false;
let lastFrameTime = 0;
let cameraCanvasRef: HTMLCanvasElement | undefined;
const retainCurrentFrame = (controls: CanvasControls | undefined) => {
if (!rawOptions.cameraID || props.issue()) {
clearRetainedFrame();
return;
}
try {
if (
controls?.hasRenderedFrame() &&
controls.drawLatestFrameToCanvas(retainedCanvas)
) {
retainedFrameCapturedAt = performance.now();
setHasRetainedFrame(true);
}
} catch {
clearRetainedFrame();
}
};
const closeSocket = () => {
const socket = ws;
const controls = canvasControls;
ws = undefined;
canvasControls = undefined;
retainCurrentFrame(controls);
controls?.dispose();
setHasFrame(false);
scheduleRetainedFrameExpiry();
if (
socket &&
socket.readyState !== WebSocket.CLOSING &&
socket.readyState !== WebSocket.CLOSED
) {
socket.close();
}
};
const initCanvasControls = () => {
if (!canvasControls || !cameraCanvasRef) return;
canvasControls.initDirectCanvas(cameraCanvasRef);
};
const updateFrameState = (frame: FrameData) => {
retryCount = 0;
lastFrameTime = Date.now();
const currentDimensions = frameDimensions();
if (
!currentDimensions ||
currentDimensions.width !== frame.width ||
currentDimensions.height !== frame.height
) {
setFrameDimensions({ width: frame.width, height: frame.height });
}
if (canvasControls?.hasRenderedFrame() && !hasFrame()) {
setHasFrame(true);
clearTimeout(retainedFrameTimeout);
retainedFrameTimeout = setTimeout(clearRetainedFrame, 180);
}
};
onMount(() => {
const unlistenHarnessCameraOpened = listen(
"instant-mode-harness-camera-opened",
() => {
performanceHarnessCameraOpen = true;
setIsWindowVisible(true);
lastFrameTime = Date.now();
},
);
const handleVisibilityChange = () => {
const visible = performanceHarnessCameraOpen || !document.hidden;
setIsWindowVisible(visible);
if (visible) {
lastFrameTime = Date.now();
commands.refreshCameraFeed().catch(() => {});
}
};
document.addEventListener("visibilitychange", handleVisibilityChange);
onCleanup(() => {
document.removeEventListener("visibilitychange", handleVisibilityChange);
void unlistenHarnessCameraOpened.then((unlisten) => unlisten());
});
});
const createSocket = () => {
const instantQuery = isInstantRecording() ? "?instant=true" : "";
const [socket, _isConnected, _isWorkerReady, controls] = createImageDataWS(
`ws://localhost:${cameraWsPort}${instantQuery}`,
(frame) => {
if (canvasControls === controls) updateFrameState(frame);
},
() => commands.refreshCameraFeed().catch(() => {}),
{ powerPreference: "low-power", preserveAlpha: type() === "macos" },
);
canvasControls = controls;
initCanvasControls();
socket.addEventListener("open", () => {
if (ws !== socket) return;
lastFrameTime = Date.now();
setHasFrame(false);
});
const captureBeforeCleanup = () => {
if (ws !== socket || canvasControls !== controls) return;
retainCurrentFrame(controls);
setHasFrame(false);
scheduleRetainedFrameExpiry();
};
// Capture listeners run before the transport discards its frame buffers.
socket.addEventListener("close", captureBeforeCleanup, { capture: true });
socket.addEventListener("error", captureBeforeCleanup, { capture: true });
socket.addEventListener("close", () => {
if (canvasControls === controls) {
canvasControls = undefined;
}
if (ws !== socket) return;
ws = undefined;
setHasFrame(false);
scheduleRetainedFrameExpiry();
scheduleReconnect();
});
socket.addEventListener("error", () => {
controls.dispose();
});
return socket;
};
const scheduleReconnect = () => {
if (
isCleanedUp ||
reconnectTimeout ||
ws ||
!isWindowVisible() ||
retryCount >= WS_MAX_RETRIES
) {
return;
}
const backoffMs = Math.min(
WS_INITIAL_BACKOFF_MS * 2 ** retryCount,
WS_MAX_BACKOFF_MS,
);
reconnectTimeout = setTimeout(() => {
reconnectTimeout = undefined;
if (isCleanedUp || ws || !isWindowVisible()) return;
retryCount += 1;
lastFrameTime = Date.now();
ws = createSocket();
}, backoffMs);
};
const stopSocket = () => {
if (reconnectTimeout) {
clearTimeout(reconnectTimeout);
reconnectTimeout = undefined;
}
if (stallCheckInterval) {
clearInterval(stallCheckInterval);
stallCheckInterval = undefined;
}
closeSocket();
};
const startSocket = () => {
if (ws || !isWindowVisible()) return;
retryCount = 0;
lastFrameTime = Date.now();
ws = createSocket();
stallCheckInterval = setInterval(() => {
if (
!performanceHarnessCameraOpen &&
ws?.readyState === WebSocket.OPEN &&
isWindowVisible() &&
lastFrameTime > 0 &&
Date.now() - lastFrameTime > STALL_TIMEOUT_MS
) {
lastFrameTime = Date.now();
commands.refreshCameraFeed().catch(() => {});
ws.close();
}
}, STALL_TIMEOUT_MS);
};
createEffect(() => {
if (isWindowVisible()) {
startSocket();
} else {
stopSocket();
}
});
createEffect(
on(
isInstantRecording,
() => {
if (!isWindowVisible()) return;
stopSocket();
startSocket();
},
{ defer: true },
),
);
createEffect(
on(
() => JSON.stringify(rawOptions.cameraID),
() => {
stopSocket();
clearRetainedFrame();
setFrameDimensions(null);
if (rawOptions.cameraID) startSocket();
},
{ defer: true },
),
);
createEffect(() => {
if (props.issue()) clearRetainedFrame();
});
onCleanup(() => {
isCleanedUp = true;
stopSocket();
clearRetainedFrame();
});
const scale = () => cameraToolbarScale(state.size);
const chrome = createCameraWindowChromeVisibility();
const [_windowSize] = createResource(
() =>
[
state.size,
state.shape,
frameDimensions()?.width,
frameDimensions()?.height,
] as const,
async ([size, shape, frameWidth, frameHeight]) => {
const { width: windowWidth, height: windowHeight } =
cameraPreviewDimensions(
size,
shape,
frameWidth && frameHeight ? frameWidth / frameHeight : undefined,
);
const totalHeight = windowHeight + CAMERA_TOOLBAR_HEIGHT;
const currentWindow = getCurrentWindow();
await currentWindow.setSize(new LogicalSize(windowWidth, totalHeight));
const monitor = await currentMonitor();
const monitors = await availableMonitors();
const activeMonitor = monitor ?? monitors[0];
if (!activeMonitor) {
return {
size: Math.min(windowWidth, windowHeight),
windowWidth,
windowHeight,
};
}
const scalingFactor = activeMonitor.scaleFactor;
const width =
activeMonitor.size.width / scalingFactor - windowWidth - 100;
const height =
activeMonitor.size.height / scalingFactor - totalHeight - 100;
if (!hasPositioned()) {
ignoreMoveFor(1500);
const settings = await generalSettingsStore.get();
const saved = settings?.cameraWindowPosition ?? null;
if (saved) {
const onMonitor = monitors.some((m) => {
const scale = m.scaleFactor;
const pos = m.position.toLogical(scale);
const size = m.size.toLogical(scale);
return (
saved.x >= pos.x &&
saved.x < pos.x + size.width &&
saved.y >= pos.y &&
saved.y < pos.y + size.height
);
});
if (onMonitor) {
await currentWindow.setPosition(
new LogicalPosition(saved.x, saved.y),
);
} else {
await currentWindow.setPosition(
new LogicalPosition(
width + activeMonitor.position.toLogical(scalingFactor).x,
height + activeMonitor.position.toLogical(scalingFactor).y,
),
);
}
} else {
await currentWindow.setPosition(
new LogicalPosition(
width + activeMonitor.position.toLogical(scalingFactor).x,
height + activeMonitor.position.toLogical(scalingFactor).y,
),
);
}
setHasPositioned(true);
} else {
const outerPos = await currentWindow.outerPosition();
const logicalPos = outerPos.toLogical(scalingFactor);
const monitorLogicalPos =
activeMonitor.position.toLogical(scalingFactor);
const monitorLogicalSize = activeMonitor.size.toLogical(scalingFactor);
let newX = logicalPos.x;
let newY = logicalPos.y;
// Right edge
if (
newX + windowWidth >
monitorLogicalPos.x + monitorLogicalSize.width
) {
newX = monitorLogicalPos.x + monitorLogicalSize.width - windowWidth;
}
// Bottom edge
if (
newY + totalHeight >
monitorLogicalPos.y + monitorLogicalSize.height
) {
newY = monitorLogicalPos.y + monitorLogicalSize.height - totalHeight;
}
// Left edge
if (newX < monitorLogicalPos.x) {
newX = monitorLogicalPos.x;
}
// Top edge
if (newY < monitorLogicalPos.y) {
newY = monitorLogicalPos.y;
}
if (
Math.abs(newX - logicalPos.x) > 1 ||
Math.abs(newY - logicalPos.y) > 1
) {
ignoreMoveFor(1000);
await currentWindow.setPosition(new LogicalPosition(newX, newY));
}
}
return { width, height, size, windowWidth, windowHeight };
},
);
onMount(() => {
let disposed = false;
let requestRevision = 0;
const unlisten = events.cameraPresentationRequested.listen(
async ({ payload }) => {
const request = ++requestRevision;
try {
if (
type() !== "linux" ||
isCameraOnlyMode() ||
!containerRef ||
!hasFrame()
) {
throw new Error(
"Wait for the selected camera preview before recording",
);
}
const sync = previewStateSync;
await sync;
const deadline = performance.now() + 900;
while (_windowSize.loading) {
if (performance.now() >= deadline)
throw new Error("Camera layout did not settle");
await new Promise<void>((resolve) => setTimeout(resolve, 16));
}
const measuredRevision = layoutRevision;
await Promise.race([
new Promise<void>((resolve) =>
requestAnimationFrame(() =>
requestAnimationFrame(() => resolve()),
),
),
new Promise<never>((_, reject) =>
setTimeout(
() =>
reject(new Error("Camera window did not render its layout")),
500,
),
),
]);
if (disposed || request !== requestRevision) return;
if (
sync !== previewStateSync ||
measuredRevision !== layoutRevision ||
_windowSize.loading
) {
throw new Error(
"Camera appearance changed while measuring; start again",
);
}
const rect = containerRef.getBoundingClientRect();
const clip = getComputedStyle(containerRef);
const input = cameraPresentationInput(
{
viewportWidth: window.innerWidth,
viewportHeight: window.innerHeight,
left: rect.left,
top: rect.top,
width: rect.width,
height: rect.height,
cornerRadii: [
clip.borderTopLeftRadius,
clip.borderTopRightRadius,
clip.borderBottomRightRadius,
clip.borderBottomLeftRadius,
],
},
{
size: state.size,
shape: state.shape,
mirrored: state.mirrored,
background_blur: normalizeBackgroundBlurMode(
state.backgroundBlur,
),
},
measuredRevision,
);
await commands.submitCameraPresentation(payload.nonce, input, null);
} catch (error) {
if (!disposed && request === requestRevision) {
await commands
.submitCameraPresentation(payload.nonce, null, String(error))
.catch(() => {});
}
}
},
);
onCleanup(() => {
disposed = true;
requestRevision += 1;
void unlisten.then((remove) => remove());
});
});
const initialGeneration = (
window.__CAP__ as { cleanCaptureGeneration?: number } | undefined
)?.cleanCaptureGeneration;
const revealGeneration =
initialGeneration === undefined
? commands.getCleanCaptureState().then((state) => state.generation)
: Promise.resolve(initialGeneration);
onMount(() => {
void revealGeneration.then((generation) =>
revealRecordingWindow(generation),
);
});
return (
<div
data-tauri-drag-region
class="flex relative flex-col w-screen h-screen cursor-move"
style={{ "border-radius": cameraBorderRadius(state) }}
onPointerMove={chrome.show}
onPointerLeave={chrome.hide}
onPointerCancel={chrome.hide}
>
<div class="h-14">
<div class="flex flex-row justify-center items-center">
<CameraPreviewToolbar
state={state}
setState={setState}
visible={chrome.visible()}
scale={scale()}
onClose={() => getCurrentWindow().close()}
/>
</div>
</div>
<CameraResizeHandles
state={state}
setState={setState}
toolbarHeight={CAMERA_TOOLBAR_HEIGHT}
visible={chrome.visible()}
/>
<div
ref={containerRef}
class={cx(
"flex flex-col flex-1 relative overflow-hidden pointer-events-none border-none text-gray-12",
state.backgroundBlur !== "remove" && "shadow-lg bg-gray-1",
state.backgroundBlur === "remove"
? "rounded-none"
: state.shape === "round"
? "rounded-full"
: "rounded-3xl",
)}
data-tauri-drag-region
>
<Suspense fallback={<CameraLoadingState />}>
<Canvas
frameDimensions={frameDimensions}
state={state}
onCanvas={(canvas) => {
cameraCanvasRef = canvas;
initCanvasControls();
}}
containerSize={externalContainerSize() ?? undefined}
/>
<Canvas
frameDimensions={frameDimensions}
state={state}
canvas={retainedCanvas}
onCanvas={() => {}}
containerSize={externalContainerSize() ?? undefined}
opacity={hasRetainedFrame() && !hasFrame() ? 1 : 0}
/>
<Show when={!hasFrame() && !hasRetainedFrame()}>
<CameraLoadingState />
</Show>
</Suspense>
<Show when={props.issue()}>
{(issue) => <CameraIssueOverlay issue={issue()} size={state.size} />}
</Show>
</div>
</div>
);
}
function Canvas(props: {
frameDimensions: Accessor<
{ width: number; height: number } | null | undefined
>;
state: CameraWindowState;
onCanvas: (canvas: HTMLCanvasElement) => void;
containerSize?: { width: number; height: number };
canvas?: HTMLCanvasElement;
opacity?: number;
}) {
const style = () => {
const dimensions = props.frameDimensions();
if (!dimensions) return {};
const aspectRatio = dimensions.width / dimensions.height;
const targetSize =
props.containerSize ??
cameraPreviewDimensions(props.state.size, props.state.shape, aspectRatio);
const targetAspectRatio = targetSize.width / targetSize.height;
const size =
aspectRatio > targetAspectRatio
? {
height: targetSize.height,
width: targetSize.height * aspectRatio,
}
: {
height: targetSize.width / aspectRatio,
width: targetSize.width,
};
const left = (size.width - targetSize.width) / 2;
const top = (size.height - targetSize.height) / 2;
return {
opacity: props.opacity,
width: `${size.width}px`,
height: `${size.height}px`,
left: `-${left}px`,
top: `-${top}px`,
transform: props.state.mirrored ? "scaleX(-1)" : "scaleX(1)",
};
};
if (props.canvas) {
const canvas = props.canvas;
canvas.className =
"absolute pointer-events-none motion-reduce:transition-none";
createEffect(() => {
canvas.style.transition =
props.opacity === 0 &&
!matchMedia("(prefers-reduced-motion: reduce)").matches
? "opacity 180ms ease-out"
: "none";
Object.assign(canvas.style, style());
});
return canvas;
}
return (
<canvas
data-tauri-drag-region
class={cx("absolute")}
style={style()}
ref={(canvas) => props.onCanvas(canvas)}
/>
);
}
function CameraLoadingState() {
return (
<div class="w-full flex-1 flex items-center justify-center">
<div class="text-gray-11">Loading camera...</div>
</div>
);
}
function cameraOverlayTextMetrics(size: number) {
const normalized =
(Math.max(CAMERA_MIN_SIZE, Math.min(CAMERA_MAX_SIZE, size)) -
CAMERA_MIN_SIZE) /
(CAMERA_MAX_SIZE - CAMERA_MIN_SIZE);
const titleSize = 0.75 + normalized * 0.375;
const messageSize = 0.625 + normalized * 0.25;
const lineHeight = 1.2 + normalized * 0.2;
const gap = 0.375 + normalized * 0.25;
const maxWidth = Math.max(7.5, Math.min(18, size / 16));
return {
gap: `${gap}rem`,
maxWidth: `${maxWidth}rem`,
messageLineHeight: `${lineHeight}rem`,
messageSize: `${messageSize}rem`,
titleSize: `${titleSize}rem`,
};
}
function CameraIssueOverlay(props: {
issue: CameraPreviewIssue;
size: number;
class?: string;
top?: number;
borderRadius?: string;
}) {
const textMetrics = () => cameraOverlayTextMetrics(props.size);
const style = () => {
const base = { "border-radius": props.borderRadius ?? "inherit" };
if (props.top === undefined) return base;
return { ...base, top: `${props.top}px` };
};
return (
<div
class={cx(
"absolute z-10 flex items-center justify-center overflow-hidden bg-black/75 backdrop-blur-xs px-4 pointer-events-none",
props.class ?? "inset-0",
)}
style={style()}
>
<div
class="flex flex-col items-center text-center text-white"
style={{ gap: textMetrics().gap, "max-width": textMetrics().maxWidth }}
>
<p
class="font-semibold text-white"
style={{ "font-size": textMetrics().titleSize }}
>
{props.issue.title}
</p>
<p
class="text-white/75"
style={{
"font-size": textMetrics().messageSize,
"line-height": textMetrics().messageLineHeight,
}}
>
{props.issue.message}
</p>
</div>
</div>
);
}