import {
DesktopPendingSnapShot,
DesktopSnapShot as DesktopSnapShotSchema,
DesktopSnapShotAnimationDestination,
DesktopSnapShotId,
DesktopSnapShotShortcutAvailability,
DesktopSnapShotState,
DesktopSnapShotSetupAction,
SnapShotShortcut,
DesktopCaptureConfigRequest,
DesktopCaptureConfigPreview,
DesktopCaptureConfigApplied,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import type * as Electron from "electron";
import * as ElectronWindow from "../../electron/ElectronWindow.ts";
import * as ElectronDialog from "../../electron/ElectronDialog.ts";
import * as DesktopSnapShot from "../../snapShot/DesktopSnapShot.ts";
import * as IpcChannels from "../channels.ts";
import * as DesktopIpc from "../DesktopIpc.ts";
class SnapShotIpcUnauthorizedSenderError extends Schema.TaggedError<SnapShotIpcUnauthorizedSenderError>()(
"SnapShotIpcUnauthorizedSenderError",
{},
) {
override get message(): string {
return "Snapshot request was rejected.";
}
}
const ensureTrustedSnapShotSender = Effect.fn("desktop.ipc.snapShot.ensureTrustedSender")(
function* (event: DesktopIpc.DesktopIpcInvokeEvent | undefined) {
const main = yield* (yield* ElectronWindow.ElectronWindow).main;
if (
event === undefined ||
Option.isNone(main) ||
main.value.webContents.id !== event.sender.id
) {
return yield* new SnapShotIpcUnauthorizedSenderError();
}
return main.value;
},
);
function snapShotScreenFrame(
viewportFrame: DesktopSnapShotAnimationDestination["viewportFrame"],
contentBounds: Electron.Rectangle,
zoomFactor: number,
): Electron.Rectangle {
return {
x: contentBounds.x + viewportFrame.x * zoomFactor,
y: contentBounds.y + viewportFrame.y * zoomFactor,
width: viewportFrame.width * zoomFactor,
height: viewportFrame.height * zoomFactor,
};
}
export function snapShotRelativeFrame(
frame: DesktopSnapShotAnimationDestination["viewportFrame"],
bounds: Electron.Rectangle,
zoom: number,
): Electron.Rectangle | undefined {
if (bounds.width <= 0 || bounds.height <= 0) return undefined;
return {
x: (frame.x * zoom) / bounds.width,
y: (frame.y * zoom) / bounds.height,
width: (frame.width * zoom) / bounds.width,
height: (frame.height * zoom) / bounds.height,
};
}
export const getSnapShotState = DesktopIpc.makeIpcMethod({
channel: IpcChannels.GET_SNAP_SHOT_STATE_CHANNEL,
payload: Schema.Void,
result: DesktopSnapShotState,
handler: Effect.fn("desktop.ipc.snapShot.getState")(function* () {
return yield* (yield* DesktopSnapShot.DesktopSnapShot).state;
}),
});
export const requestSnapShotPermissions = DesktopIpc.makeIpcMethod({
channel: IpcChannels.REQUEST_SNAP_SHOT_PERMISSIONS_CHANNEL,
payload: Schema.Boolean,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.requestPermissions")(
function* (includeAccessibility, event) {
yield* ensureTrustedSnapShotSender(event);
yield* (yield* DesktopSnapShot.DesktopSnapShot).requestPermissions(includeAccessibility);
},
),
});
export const setupSnapShot = DesktopIpc.makeIpcMethod({
channel: IpcChannels.SETUP_SNAP_SHOT_CHANNEL,
payload: DesktopSnapShotSetupAction,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.setup")(function* (action, event) {
yield* ensureTrustedSnapShotSender(event);
yield* (yield* DesktopSnapShot.DesktopSnapShot).setup(action);
}),
});
export const previewSnapShotConfig = DesktopIpc.makeIpcMethod({
channel: IpcChannels.PREVIEW_SNAP_SHOT_CONFIG_CHANNEL,
payload: DesktopCaptureConfigRequest,
result: Schema.NullOr(DesktopCaptureConfigPreview),
handler: Effect.fn("desktop.ipc.snapShot.previewConfig")(function* (request, event) {
const window = yield* ensureTrustedSnapShotSender(event);
const capture = yield* DesktopSnapShot.DesktopSnapShot;
let selectedPath: string | undefined;
if (request.chooseFile) {
const state = yield* capture.state;
const paths = yield* (yield* ElectronDialog.ElectronDialog).pickFiles({
owner: Option.some(window),
defaultPath: Option.fromUndefinedOr(state.shortcutConfigPath),
filters: [
{
name: "Desktop config",
extensions: state.linuxBackend === "niri" ? ["kdl"] : ["conf", "lua"],
},
],
multiple: false,
});
selectedPath = paths[0];
if (!selectedPath) return null;
}
return yield* capture.previewConfig(request, selectedPath);
}),
});
export const applySnapShotConfig = DesktopIpc.makeIpcMethod({
channel: IpcChannels.APPLY_SNAP_SHOT_CONFIG_CHANNEL,
payload: DesktopSnapShotId,
result: DesktopCaptureConfigApplied,
handler: Effect.fn("desktop.ipc.snapShot.applyConfig")(function* (id, event) {
yield* ensureTrustedSnapShotSender(event);
return yield* (yield* DesktopSnapShot.DesktopSnapShot).applyConfig(id);
}),
});
export const checkSnapShotShortcut = DesktopIpc.makeIpcMethod({
channel: IpcChannels.CHECK_SNAP_SHOT_SHORTCUT_CHANNEL,
payload: SnapShotShortcut,
result: DesktopSnapShotShortcutAvailability,
handler: Effect.fn("desktop.ipc.snapShot.checkShortcut")(function* (shortcut, event) {
yield* ensureTrustedSnapShotSender(event);
return yield* (yield* DesktopSnapShot.DesktopSnapShot).checkShortcut(shortcut);
}),
});
export const setSnapShotShortcutSuppressed = DesktopIpc.makeIpcMethod({
channel: IpcChannels.SET_SNAP_SHOT_SHORTCUT_SUPPRESSED_CHANNEL,
payload: Schema.Boolean,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.setShortcutSuppressed")(function* (suppressed, event) {
yield* ensureTrustedSnapShotSender(event);
yield* (yield* DesktopSnapShot.DesktopSnapShot).setShortcutSuppressed(suppressed);
}),
});
export const listPendingSnapShots = DesktopIpc.makeIpcMethod({
channel: IpcChannels.LIST_PENDING_SNAP_SHOTS_CHANNEL,
payload: Schema.Void,
result: Schema.Array(DesktopPendingSnapShot),
handler: Effect.fn("desktop.ipc.snapShot.listPending")(function* (_, event) {
yield* ensureTrustedSnapShotSender(event);
return yield* (yield* DesktopSnapShot.DesktopSnapShot).listPending;
}),
});
export const readSnapShot = DesktopIpc.makeIpcMethod({
channel: IpcChannels.READ_SNAP_SHOT_CHANNEL,
payload: DesktopSnapShotId,
result: DesktopSnapShotSchema,
handler: Effect.fn("desktop.ipc.snapShot.read")(function* (id, event) {
yield* ensureTrustedSnapShotSender(event);
return yield* (yield* DesktopSnapShot.DesktopSnapShot).read(id);
}),
});
export const setSnapShotAnimationDestination = DesktopIpc.makeIpcMethod({
channel: IpcChannels.SET_SNAP_SHOT_ANIMATION_DESTINATION_CHANNEL,
payload: DesktopSnapShotAnimationDestination,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.setAnimationDestination")(
function* (destination, event) {
const window = yield* ensureTrustedSnapShotSender(event);
if (
destination.viewportFrame.width <= 0 ||
destination.viewportFrame.height <= 0 ||
destination.borderWidth < 0 ||
destination.cornerRadius < 0
) {
return;
}
yield* (yield* DesktopSnapShot.DesktopSnapShot).setAnimationDestination(destination.id, {
relativeFrame: snapShotRelativeFrame(
destination.viewportFrame,
window.getContentBounds(),
window.webContents.getZoomFactor(),
),
frame: snapShotScreenFrame(
destination.viewportFrame,
window.getContentBounds(),
window.webContents.getZoomFactor(),
),
backgroundColor: destination.backgroundColor,
borderColor: destination.borderColor,
borderWidth: destination.borderWidth * window.webContents.getZoomFactor(),
cornerRadius: destination.cornerRadius * window.webContents.getZoomFactor(),
scaleFactor: window.webContents.getZoomFactor(),
details: destination.details,
});
},
),
});
export const dismissSnapShotAnimation = DesktopIpc.makeIpcMethod({
channel: IpcChannels.DISMISS_SNAP_SHOT_ANIMATION_CHANNEL,
payload: DesktopSnapShotId,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.dismissAnimation")(function* (id, event) {
yield* ensureTrustedSnapShotSender(event);
yield* (yield* DesktopSnapShot.DesktopSnapShot).dismissAnimation(id);
}),
});
export const acknowledgeSnapShot = DesktopIpc.makeIpcMethod({
channel: IpcChannels.ACKNOWLEDGE_SNAP_SHOT_CHANNEL,
payload: DesktopSnapShotId,
result: Schema.Void,
handler: Effect.fn("desktop.ipc.snapShot.acknowledge")(function* (id, event) {
yield* ensureTrustedSnapShotSender(event);
yield* (yield* DesktopSnapShot.DesktopSnapShot).acknowledge(id);
}),
});