Skip to content

The swiss army knife of lossless video/audio editing

add types

Mikael Finstadfd27f2178ed8
diff --git a/src/main/pathToFileURL.test.ts b/src/main/pathToFileURL.test.ts
index 8826d0e7..212b1e39 100644
--- a/src/main/pathToFileURL.test.ts
+++ b/src/main/pathToFileURL.test.ts
@@ -1,3 +1,4 @@
+// eslint-disable-line unicorn/filename-case
// eslint-disable-next-line import/no-extraneous-dependencies
import { test, expect, describe } from 'vitest';
diff --git a/src/renderer/src/dialogs/index.tsx b/src/renderer/src/dialogs/index.tsx
index 5287567f..a2c3a82d 100644
--- a/src/renderer/src/dialogs/index.tsx
+++ b/src/renderer/src/dialogs/index.tsx
@@ -14,6 +14,7 @@ import CopyClipboardButton from '../components/CopyClipboardButton';
import Checkbox from '../components/Checkbox';
import { isWindows, showItemInFolder } from '../util';
import { ParseTimecode, SegmentBase } from '../types';
+import { FindKeyframeMode } from '../ffmpeg';
const remote = window.require('@electron/remote');
const { dialog, shell } = remote;
@@ -291,8 +292,8 @@ async function askForSegmentsRandomDurationRange() {
return parse(value);
}
-async function askForSegmentsStartOrEnd(text) {
- const { value } = await Swal.fire({
+async function askForSegmentsStartOrEnd(text: string) {
+ const { value } = await Swal.fire<string>({
input: 'radio',
showCancelButton: true,
inputOptions: {
@@ -323,7 +324,7 @@ export async function askForShiftSegments({ inputPlaceholder, parseTimecode }: {
return undefined;
}
- const { value } = await Swal.fire({
+ const { value } = await Swal.fire<string>({
input: 'text',
showCancelButton: true,
inputValue: inputPlaceholder,
@@ -352,14 +353,14 @@ export async function askForAlignSegments() {
const startOrEnd = await askForSegmentsStartOrEnd(i18n.t('Do you want to align the segment start or end timestamps to keyframes?'));
if (startOrEnd == null) return undefined;
- const { value: mode } = await Swal.fire({
+ const { value: mode } = await Swal.fire<FindKeyframeMode>({
input: 'radio',
showCancelButton: true,
inputOptions: {
nearest: i18n.t('Nearest keyframe'),
before: i18n.t('Previous keyframe'),
after: i18n.t('Next keyframe'),
- },
+ } satisfies Record<FindKeyframeMode, unknown>,
inputValue: 'before',
text: i18n.t('Do you want to align segment times to the nearest, previous or next keyframe?'),
});
diff --git a/src/renderer/src/hooks/useSegments.ts b/src/renderer/src/hooks/useSegments.ts
index 81aa83b1..b48fba38 100644
--- a/src/renderer/src/hooks/useSegments.ts
+++ b/src/renderer/src/hooks/useSegments.ts
@@ -13,15 +13,28 @@ import { createNumSegments as createNumSegmentsDialog, createFixedDurationSegmen
import { createSegment, findSegmentsAtCursor, sortSegments, invertSegments, combineOverlappingSegments as combineOverlappingSegments2, combineSelectedSegments as combineSelectedSegments2, isDurationValid, getSegApparentStart, getSegApparentEnd as getSegApparentEnd2, addSegmentColorIndex } from '../segments';
import * as ffmpegParameters from '../ffmpeg-parameters';
import { maxSegmentsAllowed } from '../util/constants';
-import { ParseTimecode, SegmentBase, SegmentToExport, StateSegment, UpdateSegAtIndex } from '../types';
+import { ApparentCutSegment, ParseTimecode, SegmentBase, SegmentToExport, StateSegment, UpdateSegAtIndex } from '../types';
import safeishEval from '../worker/eval';
import { ScopeSegment } from '../../../../types';
+import { FFprobeStream } from '../../../../ffprobe';
const { ffmpeg: { blackDetect, silenceDetect } } = window.require('@electron/remote').require('./index.js');
function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoStream, duration, getRelevantTime, maxLabelLength, checkFileOpened, invertCutSegments, segmentsToChaptersOnly, timecodePlaceholder, parseTimecode }: {
- filePath?: string | undefined, workingRef: MutableRefObject<boolean>, setWorking: (w: { text: string, abortController?: AbortController } | undefined) => void, setCutProgress: (a: number | undefined) => void, videoStream, duration?: number | undefined, getRelevantTime: () => number, maxLabelLength: number, checkFileOpened: () => boolean, invertCutSegments: boolean, segmentsToChaptersOnly: boolean, timecodePlaceholder: string, parseTimecode: ParseTimecode,
+ filePath?: string | undefined,
+ workingRef: MutableRefObject<boolean>,
+ setWorking: (w: { text: string, abortController?: AbortController } | undefined) => void,
+ setCutProgress: (a: number | undefined) => void,
+ videoStream: FFprobeStream | undefined,
+ duration?: number | undefined,
+ getRelevantTime: () => number,
+ maxLabelLength: number,
+ checkFileOpened: () => boolean,
+ invertCutSegments: boolean,
+ segmentsToChaptersOnly: boolean,
+ timecodePlaceholder: string,
+ parseTimecode: ParseTimecode,
}) {
// Segment related state
const segCounterRef = useRef(0);
@@ -165,7 +178,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
loadCutSegments(newSegments, true);
}, [currentApparentCutSeg.end, currentApparentCutSeg.start, filePath, loadCutSegments, videoStream]);
- const removeSegments = useCallback((removeSegmentIds) => {
+ const removeSegments = useCallback((removeSegmentIds: string[]) => {
setCutSegments((existingSegments) => {
if (existingSegments.length === 1 && existingSegments[0]!.start == null && existingSegments[0]!.end == null) {
return existingSegments; // We are at initial segment, nothing more we can do (it cannot be removed)
@@ -181,7 +194,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
});
}, [clearSegCounter, createInitialCutSegments, setCutSegments]);
- const removeCutSegment = useCallback((index) => {
+ const removeCutSegment = useCallback((index: number) => {
removeSegments([cutSegments[index]!.segId]);
}, [cutSegments, removeSegments]);
@@ -247,9 +260,9 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
updateSegAtIndex(currentSegIndexSafe, { [type]: Math.min(Math.max(time, 0), duration) });
}, [currentSegIndexSafe, getSegApparentEnd, currentCutSeg, duration, updateSegAtIndex]);
- const modifySelectedSegmentTimes = useCallback(async (transformSegment, concurrency = 5) => {
+ const modifySelectedSegmentTimes = useCallback(async (transformSegment: <T extends ApparentCutSegment>(s: T) => Promise<T> | T, concurrency = 5) => {
if (duration == null) throw new Error();
- const clampValue = (val) => Math.min(Math.max(val, 0), duration);
+ const clampValue = (val: number) => Math.min(Math.max(val, 0), duration);
let newSegments = await pMap(apparentCutSegments, async (segment) => {
if (!isSegmentSelected(segment)) return segment; // pass thru non-selected segments
@@ -287,13 +300,13 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
await modifySelectedSegmentTimes(async (segment) => {
const newSegment = { ...segment };
- async function align(key) {
+ const align = async (key: 'start' | 'end') => {
const time = newSegment[key];
if (filePath == null) throw new Error();
const keyframe = await findKeyframeNearTime({ filePath, streamIndex: videoStream.index, time, mode });
if (keyframe == null) throw new Error(`Cannot find any keyframe within 60 seconds of frame ${time}`);
newSegment[key] = keyframe;
- }
+ };
if (startOrEnd.includes('start')) await align('start');
if (startOrEnd.includes('end')) await align('end');
return newSegment;
@@ -305,7 +318,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
}
}, [filePath, videoStream, modifySelectedSegmentTimes, setWorking, workingRef]);
- const updateSegOrder = useCallback((index, newOrder) => {
+ const updateSegOrder = useCallback((index: number, newOrder: number) => {
if (newOrder > cutSegments.length - 1 || newOrder < 0) return;
const newSegments = [...cutSegments];
const removedSeg = newSegments.splice(index, 1)[0];
@@ -315,7 +328,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
setCurrentSegIndex(newOrder);
}, [cutSegments, setCurrentSegIndex, setCutSegments]);
- const updateSegOrders = useCallback((newOrders) => {
+ const updateSegOrders = useCallback((newOrders: string[]) => {
const newSegments = sortBy(cutSegments, (seg) => newOrders.indexOf(seg.segId));
const newCurrentSegIndex = newOrders.indexOf(currentCutSeg.segId);
setCutSegments(newSegments);
@@ -351,7 +364,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
}
}, [currentCutSeg.start, currentCutSeg.end, getRelevantTime, duration, cutSegments, createIndexedSegment, setCutSegments, setCurrentSegIndex]);
- const duplicateSegment = useCallback((segment) => {
+ const duplicateSegment = useCallback((segment: Pick<StateSegment, 'start' | 'end'> & Partial<Pick<StateSegment, 'name'>>) => {
try {
// Cannot duplicate if seg is not finished
if (segment.start === undefined && segment.end === undefined) return;
@@ -411,7 +424,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
}
}, [checkFileOpened, getRelevantTime, setCutTime]);
- const onLabelSegment = useCallback(async (index) => {
+ const onLabelSegment = useCallback(async (index: number) => {
const { name } = cutSegments[index]!;
const value = await labelSegmentDialog({ currentName: name, maxLength: maxLabelLength });
if (value != null) updateSegAtIndex(index, { name: value });
@@ -438,7 +451,7 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
const segment = cutSegments[firstSegmentAtCursorIndex];
if (segment == null) throw new Error();
- const getNewName = (oldName, suffix) => oldName && `${segment.name} ${suffix}`;
+ const getNewName = (oldName: string, suffix: string) => oldName && `${segment.name} ${suffix}`;
const firstPart = createIndexedSegment({ segment: { name: getNewName(segment.name, '1'), start: segment.start, end: relevantTime }, incrementCount: false });
const secondPart = createIndexedSegment({ segment: { name: getNewName(segment.name, '2'), start: relevantTime, end: segment.end }, incrementCount: true });
@@ -544,8 +557,8 @@ function useSegments({ filePath, workingRef, setWorking, setCutProgress, videoSt
const removeSelectedSegments = useCallback(() => removeSegments(selectedSegmentsRaw.map((seg) => seg.segId)), [removeSegments, selectedSegmentsRaw]);
- const selectOnlySegment = useCallback((seg) => setDeselectedSegmentIds(Object.fromEntries(cutSegments.filter((s) => s.segId !== seg.segId).map((s) => [s.segId, true]))), [cutSegments]);
- const toggleSegmentSelected = useCallback((seg) => setDeselectedSegmentIds((existing) => ({ ...existing, [seg.segId]: !existing[seg.segId] })), []);
+ const selectOnlySegment = useCallback((seg: Pick<StateSegment, 'segId'>) => setDeselectedSegmentIds(Object.fromEntries(cutSegments.filter((s) => s.segId !== seg.segId).map((s) => [s.segId, true]))), [cutSegments]);
+ const toggleSegmentSelected = useCallback((seg: Pick<StateSegment, 'segId'>) => setDeselectedSegmentIds((existing) => ({ ...existing, [seg.segId]: !existing[seg.segId] })), []);
const deselectAllSegments = useCallback(() => setDeselectedSegmentIds(Object.fromEntries(cutSegments.map((s) => [s.segId, true]))), [cutSegments]);
const invertSelectedSegments = useCallback(() => setDeselectedSegmentIds((existing) => Object.fromEntries(cutSegments.map((s) => [s.segId, !existing[s.segId]]))), [cutSegments]);
const selectAllSegments = useCallback(() => setDeselectedSegmentIds({}), []);