Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import type { VideoEditRange, VideoEditSpec } from "@cap/database/types";
const EPSILON = 0.001;
const MIN_RANGE_DURATION = 0.05;
export type VideoTimelineState = {
duration: number;
trimStart: number;
trimEnd: number;
splitPoints: number[];
deletedRanges: VideoEditRange[];
selectedSegmentId: string | null;
};
export type VideoTimelineSegment = VideoEditRange & {
id: string;
deleted: boolean;
selected: boolean;
};
export type VideoTimelineDisplaySegment = VideoTimelineSegment & {
displayStart: number;
displayEnd: number;
};
export type VideoTimelineDisplaySplitPoint = {
id: string;
time: number;
sourceTime: number;
sourceTimes: number[];
splitIndices: number[];
};
export type VideoTimelineDisplaySplitDragHandle = "center" | "left" | "right";
export type TimelineHistory = {
entries: VideoTimelineState[];
index: number;
};
const isFiniteNumber = (value: number) => Number.isFinite(value);
export function roundEditTime(value: number) {
return Math.round(value * 1000) / 1000;
}
export function clampEditTime(value: number, min: number, max: number) {
return Math.min(Math.max(value, min), max);
}
function normalizeDuration(duration: number) {
return isFiniteNumber(duration) && duration > 0 ? roundEditTime(duration) : 0;
}
function getSegmentId(start: number, end: number) {
return `${roundEditTime(start)}:${roundEditTime(end)}`;
}
function getDisplayDeletedRanges(state: VideoTimelineState) {
return normalizeKeepRanges(state.deletedRanges, state.duration).keepRanges;
}
export function normalizeKeepRanges(
keepRanges: VideoEditRange[],
sourceDuration: number,
): VideoEditSpec {
const duration = normalizeDuration(sourceDuration);
if (duration <= 0) {
return { version: 1, sourceDuration: 0, keepRanges: [] };
}
const sortedRanges = keepRanges
.map((range) => {
const start = isFiniteNumber(range.start)
? clampEditTime(range.start, 0, duration)
: 0;
const end = isFiniteNumber(range.end)
? clampEditTime(range.end, 0, duration)
: 0;
return {
start: roundEditTime(Math.min(start, end)),
end: roundEditTime(Math.max(start, end)),
};
})
.filter((range) => range.end - range.start >= MIN_RANGE_DURATION)
.sort((a, b) => a.start - b.start || a.end - b.end);
const mergedRanges: VideoEditRange[] = [];
for (const range of sortedRanges) {
const previous = mergedRanges.at(-1);
if (previous && range.start <= previous.end + EPSILON) {
previous.end = roundEditTime(Math.max(previous.end, range.end));
continue;
}
mergedRanges.push({ ...range });
}
return {
version: 1,
sourceDuration: duration,
keepRanges: mergedRanges,
};
}
export function createIdentityEditSpec(sourceDuration: number): VideoEditSpec {
const duration = normalizeDuration(sourceDuration);
return normalizeKeepRanges(
duration > 0 ? [{ start: 0, end: duration }] : [],
duration,
);
}
export function areEditSpecsEquivalent(
left: VideoEditSpec,
right: VideoEditSpec,
) {
const normalizedLeft = normalizeKeepRanges(
left.keepRanges,
left.sourceDuration,
);
const normalizedRight = normalizeKeepRanges(
right.keepRanges,
right.sourceDuration,
);
if (
Math.abs(normalizedLeft.sourceDuration - normalizedRight.sourceDuration) >
EPSILON
) {
return false;
}
if (normalizedLeft.keepRanges.length !== normalizedRight.keepRanges.length) {
return false;
}
return normalizedLeft.keepRanges.every((leftRange, index) => {
const rightRange = normalizedRight.keepRanges[index];
return (
rightRange !== undefined &&
Math.abs(leftRange.start - rightRange.start) <= EPSILON &&
Math.abs(leftRange.end - rightRange.end) <= EPSILON
);
});
}
export function areTimelineStatesEquivalent(
left: VideoTimelineState,
right: VideoTimelineState,
) {
const normalizedLeft = normalizeTimelineState(left);
const normalizedRight = normalizeTimelineState(right);
if (
Math.abs(normalizedLeft.duration - normalizedRight.duration) > EPSILON ||
Math.abs(normalizedLeft.trimStart - normalizedRight.trimStart) > EPSILON ||
Math.abs(normalizedLeft.trimEnd - normalizedRight.trimEnd) > EPSILON
) {
return false;
}
if (
normalizedLeft.splitPoints.length !== normalizedRight.splitPoints.length ||
normalizedLeft.deletedRanges.length !== normalizedRight.deletedRanges.length
) {
return false;
}
return (
normalizedLeft.splitPoints.every(
(point, index) =>
Math.abs(point - (normalizedRight.splitPoints[index] ?? 0)) <= EPSILON,
) &&
normalizedLeft.deletedRanges.every((leftRange, index) => {
const rightRange = normalizedRight.deletedRanges[index];
return (
rightRange !== undefined &&
Math.abs(leftRange.start - rightRange.start) <= EPSILON &&
Math.abs(leftRange.end - rightRange.end) <= EPSILON
);
})
);
}
export function getEditSpecOutputDuration(editSpec: VideoEditSpec) {
return roundEditTime(
editSpec.keepRanges.reduce(
(total, range) => total + Math.max(0, range.end - range.start),
0,
),
);
}
export function mapSourceTimeToOutputTime(
sourceTime: number,
editSpec: VideoEditSpec,
) {
if (!isFiniteNumber(sourceTime)) return null;
const normalized = normalizeKeepRanges(
editSpec.keepRanges,
editSpec.sourceDuration,
);
let outputTime = 0;
for (const range of normalized.keepRanges) {
if (
sourceTime >= range.start - EPSILON &&
sourceTime <= range.end + EPSILON
) {
return roundEditTime(
outputTime +
clampEditTime(sourceTime - range.start, 0, range.end - range.start),
);
}
outputTime += range.end - range.start;
}
return null;
}
export function mapOutputTimeToSourceTime(
outputTime: number,
editSpec: VideoEditSpec,
) {
if (!isFiniteNumber(outputTime)) return null;
const normalized = normalizeKeepRanges(
editSpec.keepRanges,
editSpec.sourceDuration,
);
let elapsed = 0;
for (const range of normalized.keepRanges) {
const rangeDuration = range.end - range.start;
if (outputTime <= elapsed + rangeDuration + EPSILON) {
return roundEditTime(
range.start + clampEditTime(outputTime - elapsed, 0, rangeDuration),
);
}
elapsed += rangeDuration;
}
return null;
}
export function mapOutputRangeToSourceRanges(
outputRange: VideoEditRange,
editSpec: VideoEditSpec,
) {
const normalized = normalizeKeepRanges(
editSpec.keepRanges,
editSpec.sourceDuration,
);
const sourceRanges: VideoEditRange[] = [];
let outputCursor = 0;
for (const sourceRange of normalized.keepRanges) {
const sourceRangeDuration = sourceRange.end - sourceRange.start;
const outputStart = outputCursor;
const outputEnd = outputCursor + sourceRangeDuration;
const overlapStart = Math.max(outputRange.start, outputStart);
const overlapEnd = Math.min(outputRange.end, outputEnd);
if (overlapEnd - overlapStart >= MIN_RANGE_DURATION) {
sourceRanges.push({
start: roundEditTime(sourceRange.start + overlapStart - outputStart),
end: roundEditTime(sourceRange.start + overlapEnd - outputStart),
});
}
outputCursor = outputEnd;
}
return normalizeKeepRanges(sourceRanges, normalized.sourceDuration)
.keepRanges;
}
export function composeEditSpecs(
previousSourceSpec: VideoEditSpec,
nextOutputSpec: VideoEditSpec,
) {
const previous = normalizeKeepRanges(
previousSourceSpec.keepRanges,
previousSourceSpec.sourceDuration,
);
const previousOutputDuration = getEditSpecOutputDuration(previous);
const next = normalizeKeepRanges(
nextOutputSpec.keepRanges,
previousOutputDuration,
);
const sourceRanges = next.keepRanges.flatMap((range) =>
mapOutputRangeToSourceRanges(range, previous),
);
return normalizeKeepRanges(sourceRanges, previous.sourceDuration);
}
export function remapCurrentOutputTimeThroughEdit(
currentOutputTime: number | null,
previousSourceSpec: VideoEditSpec,
nextSourceSpec: VideoEditSpec,
) {
if (currentOutputTime === null) return null;
const sourceTime = mapOutputTimeToSourceTime(
currentOutputTime,
previousSourceSpec,
);
if (sourceTime === null) return null;
return mapSourceTimeToOutputTime(sourceTime, nextSourceSpec);
}
export function subtractRanges(
baseRanges: VideoEditRange[],
deletedRanges: VideoEditRange[],
sourceDuration: number,
) {
let ranges = normalizeKeepRanges(baseRanges, sourceDuration).keepRanges;
const deleted = normalizeKeepRanges(deletedRanges, sourceDuration).keepRanges;
for (const deletedRange of deleted) {
ranges = ranges.flatMap((range) => {
if (
deletedRange.end <= range.start + EPSILON ||
deletedRange.start >= range.end - EPSILON
) {
return [range];
}
const nextRanges: VideoEditRange[] = [];
if (deletedRange.start - range.start >= MIN_RANGE_DURATION) {
nextRanges.push({
start: range.start,
end: roundEditTime(deletedRange.start),
});
}
if (range.end - deletedRange.end >= MIN_RANGE_DURATION) {
nextRanges.push({
start: roundEditTime(deletedRange.end),
end: range.end,
});
}
return nextRanges;
});
}
return normalizeKeepRanges(ranges, sourceDuration).keepRanges;
}
export function createTimelineState(duration: number): VideoTimelineState {
const normalizedDuration = normalizeDuration(duration);
return {
duration: normalizedDuration,
trimStart: 0,
trimEnd: normalizedDuration,
splitPoints: [],
deletedRanges: [],
selectedSegmentId: null,
};
}
export function normalizeTimelineState(
state: VideoTimelineState,
): VideoTimelineState {
const duration = normalizeDuration(state.duration);
const trimStart = clampEditTime(state.trimStart, 0, duration);
const trimEnd = clampEditTime(state.trimEnd, 0, duration);
const start = roundEditTime(Math.min(trimStart, trimEnd));
const end = roundEditTime(Math.max(trimStart, trimEnd));
const rawSplitPoints = Array.from(
new Set(
state.splitPoints
.filter((point) => isFiniteNumber(point))
.map((point) => roundEditTime(clampEditTime(point, start, end)))
.filter(
(point) =>
point - start >= MIN_RANGE_DURATION &&
end - point >= MIN_RANGE_DURATION,
),
),
).sort((a, b) => a - b);
const deletedRanges = subtractRanges(
normalizeKeepRanges(state.deletedRanges, duration).keepRanges,
[],
duration,
).filter((range) => range.end > start && range.start < end);
const splitPoints = rawSplitPoints.filter(
(point) =>
!deletedRanges.some(
(range) => point > range.start + EPSILON && point < range.end - EPSILON,
),
);
const segments = getTimelineSegments({
...state,
duration,
trimStart: start,
trimEnd: end,
splitPoints,
deletedRanges,
});
const selectedSegmentId =
state.selectedSegmentId &&
segments.some((segment) => segment.id === state.selectedSegmentId)
? state.selectedSegmentId
: null;
return {
duration,
trimStart: start,
trimEnd: end,
splitPoints,
deletedRanges,
selectedSegmentId,
};
}
export function getTimelineSegments(
state: VideoTimelineState,
): VideoTimelineSegment[] {
const boundaries = [
state.trimStart,
...state.splitPoints.filter(
(point) => point > state.trimStart && point < state.trimEnd,
),
state.trimEnd,
]
.map(roundEditTime)
.sort((a, b) => a - b);
const segments: VideoTimelineSegment[] = [];
for (let index = 0; index < boundaries.length - 1; index++) {
const start = boundaries[index] ?? 0;
const end = boundaries[index + 1] ?? 0;
if (end - start < MIN_RANGE_DURATION) continue;
const id = getSegmentId(start, end);
const midpoint = start + (end - start) / 2;
const deleted = state.deletedRanges.some(
(range) =>
midpoint >= range.start - EPSILON && midpoint <= range.end + EPSILON,
);
segments.push({
id,
start,
end,
deleted,
selected: state.selectedSegmentId === id,
});
}
return segments;
}
export function getTimelineDisplayDuration(state: VideoTimelineState) {
const duration = normalizeDuration(state.duration);
const deletedDuration = getDisplayDeletedRanges({
...state,
duration,
}).reduce((total, range) => total + Math.max(0, range.end - range.start), 0);
return roundEditTime(Math.max(0, duration - deletedDuration));
}
export function mapTimelineSourceTimeToDisplayTime(
state: VideoTimelineState,
sourceTime: number,
) {
const duration = normalizeDuration(state.duration);
if (duration <= 0 || !isFiniteNumber(sourceTime)) return 0;
const time = clampEditTime(sourceTime, 0, duration);
let deletedBefore = 0;
for (const range of getDisplayDeletedRanges({ ...state, duration })) {
if (time <= range.start + EPSILON) break;
if (time < range.end - EPSILON) {
return roundEditTime(range.start - deletedBefore);
}
deletedBefore += range.end - range.start;
}
return roundEditTime(Math.max(0, time - deletedBefore));
}
export function mapTimelineDisplayTimeToSourceTime(
state: VideoTimelineState,
displayTime: number,
) {
const duration = normalizeDuration(state.duration);
const displayDuration = getTimelineDisplayDuration({ ...state, duration });
if (duration <= 0 || displayDuration <= 0 || !isFiniteNumber(displayTime)) {
return 0;
}
const time = clampEditTime(displayTime, 0, displayDuration);
let sourceCursor = 0;
let displayCursor = 0;
for (const range of getDisplayDeletedRanges({ ...state, duration })) {
const keptDuration = Math.max(0, range.start - sourceCursor);
const displayEnd = displayCursor + keptDuration;
if (time <= displayEnd + EPSILON) {
return roundEditTime(
clampEditTime(
sourceCursor + time - displayCursor,
sourceCursor,
range.start,
),
);
}
sourceCursor = range.end;
displayCursor = displayEnd;
}
return roundEditTime(
clampEditTime(sourceCursor + time - displayCursor, sourceCursor, duration),
);
}
export function getTimelineDisplaySegments(
state: VideoTimelineState,
): VideoTimelineDisplaySegment[] {
const normalized = normalizeTimelineState(state);
const keepRanges = getTimelineKeepRanges(normalized);
const segments: VideoTimelineDisplaySegment[] = [];
let deletedRangeIndex = 0;
let deletedBefore = 0;
for (const range of keepRanges) {
let deletedRange = normalized.deletedRanges[deletedRangeIndex];
while (deletedRange && deletedRange.end <= range.start + EPSILON) {
deletedBefore += deletedRange.end - deletedRange.start;
deletedRangeIndex++;
deletedRange = normalized.deletedRanges[deletedRangeIndex];
}
const boundaries = [
range.start,
...normalized.splitPoints.filter(
(point) => point > range.start + EPSILON && point < range.end - EPSILON,
),
range.end,
].sort((a, b) => a - b);
for (let index = 0; index < boundaries.length - 1; index++) {
const start = boundaries[index] ?? 0;
const end = boundaries[index + 1] ?? 0;
if (end - start < MIN_RANGE_DURATION) continue;
const id = getSegmentId(start, end);
const displayStart = roundEditTime(Math.max(0, start - deletedBefore));
const displayEnd = roundEditTime(Math.max(0, end - deletedBefore));
if (displayEnd - displayStart < MIN_RANGE_DURATION) continue;
segments.push({
id,
start,
end,
displayStart,
displayEnd,
deleted: false,
selected: normalized.selectedSegmentId === id,
});
}
}
return segments;
}
export function getTimelineDisplaySplitPoints(
state: VideoTimelineState,
): VideoTimelineDisplaySplitPoint[] {
const normalized = normalizeTimelineState(state);
const segments = getTimelineDisplaySegments(normalized);
const sortedSplitPoints = [...normalized.splitPoints].sort((a, b) => a - b);
const markers: VideoTimelineDisplaySplitPoint[] = [];
let splitIndex = 0;
for (let index = 0; index < segments.length - 1; index++) {
const current = segments[index];
const next = segments[index + 1];
if (!current || !next) continue;
const sourceTimes = [current.end];
if (Math.abs(current.end - next.start) > EPSILON) {
sourceTimes.push(next.start);
}
const splitIndices: number[] = [];
for (const sourceTime of sourceTimes) {
let point = sortedSplitPoints[splitIndex];
while (point !== undefined && point - sourceTime <= EPSILON) {
if (Math.abs(point - sourceTime) <= EPSILON) {
splitIndices.push(splitIndex);
}
splitIndex++;
point = sortedSplitPoints[splitIndex];
}
}
const time = current.displayEnd;
markers.push({
id: `${roundEditTime(time)}:${sourceTimes.map(roundEditTime).join(":")}`,
time,
sourceTime: current.end,
sourceTimes,
splitIndices,
});
}
return markers;
}
function getTimelineDisplaySplitDragSourceTime(
splitPoint: VideoTimelineDisplaySplitPoint,
handle: VideoTimelineDisplaySplitDragHandle,
) {
if (splitPoint.sourceTimes.length === 1) return splitPoint.sourceTime;
if (handle === "left") return Math.min(...splitPoint.sourceTimes);
if (handle === "right") return Math.max(...splitPoint.sourceTimes);
return splitPoint.sourceTime;
}
export function getTimelineDisplaySplitDragTargetTime(
state: VideoTimelineState,
splitPointIndex: number,
handle: VideoTimelineDisplaySplitDragHandle,
sourceTime: number,
) {
const splitPoint = getTimelineDisplaySplitPoints(state)[splitPointIndex];
if (!splitPoint || !isFiniteNumber(sourceTime)) return null;
if (splitPoint.sourceTimes.length === 1) return sourceTime;
const leftSourceTime = Math.min(...splitPoint.sourceTimes);
const rightSourceTime = Math.max(...splitPoint.sourceTimes);
if (handle === "left") return Math.min(sourceTime, leftSourceTime);
if (handle === "right") return Math.max(sourceTime, rightSourceTime);
if (sourceTime <= leftSourceTime + EPSILON) return sourceTime;
if (sourceTime >= rightSourceTime - EPSILON) return sourceTime;
return sourceTime - leftSourceTime < rightSourceTime - sourceTime
? leftSourceTime
: rightSourceTime;
}
export function dragTimelineDisplaySplitPoint(
state: VideoTimelineState,
splitPointIndex: number,
handle: VideoTimelineDisplaySplitDragHandle,
sourceTime: number,
) {
const splitPoint = getTimelineDisplaySplitPoints(state)[splitPointIndex];
if (!splitPoint) return state;
const targetTime = getTimelineDisplaySplitDragTargetTime(
state,
splitPointIndex,
handle,
sourceTime,
);
if (targetTime === null) return state;
return dragSplitForShrink(
state,
getTimelineDisplaySplitDragSourceTime(splitPoint, handle),
targetTime,
);
}
export function removeTimelineDisplaySplitPoint(
state: VideoTimelineState,
splitPointIndex: number,
): VideoTimelineState {
const splitPoint = getTimelineDisplaySplitPoints(state)[splitPointIndex];
if (!splitPoint) return state;
if (splitPoint.sourceTimes.length === 1) {
const splitIndex = splitPoint.splitIndices[0];
return splitIndex === undefined
? state
: removeSplitPoint(state, splitIndex);
}
const restoreStart = Math.min(...splitPoint.sourceTimes);
const restoreEnd = Math.max(...splitPoint.sourceTimes);
const deletedRanges = normalizeKeepRanges(
state.deletedRanges,
state.duration,
).keepRanges.flatMap((range) => {
if (
range.end <= restoreStart + EPSILON ||
range.start >= restoreEnd - EPSILON
) {
return [range];
}
const nextRanges: VideoEditRange[] = [];
if (restoreStart - range.start >= MIN_RANGE_DURATION) {
nextRanges.push({ start: range.start, end: restoreStart });
}
if (range.end - restoreEnd >= MIN_RANGE_DURATION) {
nextRanges.push({ start: restoreEnd, end: range.end });
}
return nextRanges;
});
const splitPoints = state.splitPoints.filter(
(point) =>
!splitPoint.sourceTimes.some(
(sourceTime) => Math.abs(point - sourceTime) <= EPSILON,
),
);
return normalizeTimelineState({
...state,
splitPoints,
deletedRanges,
selectedSegmentId: null,
});
}
export function selectTimelineSegment(
state: VideoTimelineState,
segmentId: string,
): VideoTimelineState {
const segments = getTimelineSegments(state);
const segment = segments.find((segment) => segment.id === segmentId);
if (!segment || segment.deleted) return state;
return normalizeTimelineState({ ...state, selectedSegmentId: segmentId });
}
export function splitTimelineAt(
state: VideoTimelineState,
playheadTime: number,
): VideoTimelineState {
if (
!isFiniteNumber(playheadTime) ||
playheadTime - state.trimStart < MIN_RANGE_DURATION ||
state.trimEnd - playheadTime < MIN_RANGE_DURATION
) {
return state;
}
const normalizedTime = roundEditTime(
clampEditTime(playheadTime, state.trimStart, state.trimEnd),
);
const isDuplicate = state.splitPoints.some(
(point) => Math.abs(point - normalizedTime) < MIN_RANGE_DURATION,
);
const isDeleted = state.deletedRanges.some(
(range) =>
normalizedTime > range.start + EPSILON &&
normalizedTime < range.end - EPSILON,
);
if (isDuplicate || isDeleted) return state;
return normalizeTimelineState({
...state,
splitPoints: [...state.splitPoints, normalizedTime],
selectedSegmentId: null,
});
}
export function deleteSelectedTimelineSegment(
state: VideoTimelineState,
): VideoTimelineState {
if (!state.selectedSegmentId) return state;
const segment = getTimelineSegments(state).find(
(segment) => segment.id === state.selectedSegmentId,
);
if (!segment || segment.deleted) return state;
return normalizeTimelineState({
...state,
deletedRanges: [...state.deletedRanges, segment],
selectedSegmentId: null,
});
}
export function deleteTimelineRanges(
state: VideoTimelineState,
ranges: readonly VideoEditRange[],
): VideoTimelineState {
const normalized = normalizeTimelineState(state);
const deletionRanges = normalizeKeepRanges(
ranges.map((range) => ({
start: clampEditTime(
range.start,
normalized.trimStart,
normalized.trimEnd,
),
end: clampEditTime(range.end, normalized.trimStart, normalized.trimEnd),
})),
normalized.duration,
).keepRanges;
if (deletionRanges.length === 0) return normalized;
const nextState = normalizeTimelineState({
...normalized,
splitPoints: [
...normalized.splitPoints,
...deletionRanges.flatMap((range) => [range.start, range.end]),
],
deletedRanges: [...normalized.deletedRanges, ...deletionRanges],
selectedSegmentId: null,
});
return getTimelineKeepRanges(nextState).length > 0 ? nextState : normalized;
}
export function setTimelineTrim(
state: VideoTimelineState,
start: number,
end: number,
): VideoTimelineState {
const trimStart = clampEditTime(start, 0, state.duration);
const trimEnd = clampEditTime(end, 0, state.duration);
if (Math.abs(trimEnd - trimStart) < MIN_RANGE_DURATION) return state;
return normalizeTimelineState({
...state,
trimStart,
trimEnd,
selectedSegmentId: null,
});
}
export function moveSplitPoint(
state: VideoTimelineState,
splitIndex: number,
newTime: number,
): VideoTimelineState {
const sorted = [...state.splitPoints].sort((a, b) => a - b);
if (splitIndex < 0 || splitIndex >= sorted.length) return state;
const lowerBound =
splitIndex > 0
? (sorted[splitIndex - 1] ?? state.trimStart)
: state.trimStart;
const upperBound =
splitIndex < sorted.length - 1
? (sorted[splitIndex + 1] ?? state.trimEnd)
: state.trimEnd;
sorted[splitIndex] = clampEditTime(
newTime,
lowerBound + MIN_RANGE_DURATION,
upperBound - MIN_RANGE_DURATION,
);
return normalizeTimelineState({
...state,
splitPoints: sorted,
selectedSegmentId: null,
});
}
export function removeSplitPoint(
state: VideoTimelineState,
splitIndex: number,
): VideoTimelineState {
const sorted = [...state.splitPoints].sort((a, b) => a - b);
if (splitIndex < 0 || splitIndex >= sorted.length) return state;
const currentSegments = getTimelineSegments(state);
sorted.splice(splitIndex, 1);
const nextSegments = getTimelineSegments({ ...state, splitPoints: sorted });
const deletedRanges = nextSegments
.filter((segment) => {
const coveredSegments = currentSegments.filter(
(currentSegment) =>
currentSegment.start >= segment.start - EPSILON &&
currentSegment.end <= segment.end + EPSILON,
);
return (
coveredSegments.length > 0 &&
coveredSegments.every((currentSegment) => currentSegment.deleted)
);
})
.map(({ start, end }) => ({ start, end }));
return normalizeTimelineState({
...state,
splitPoints: sorted,
deletedRanges,
selectedSegmentId: null,
});
}
export function dragSplitForShrink(
state: VideoTimelineState,
originalPos: number,
newPos: number,
): VideoTimelineState {
if (Math.abs(newPos - originalPos) < EPSILON) return state;
const lo = clampEditTime(
Math.min(originalPos, newPos),
state.trimStart,
state.trimEnd,
);
const hi = clampEditTime(
Math.max(originalPos, newPos),
state.trimStart,
state.trimEnd,
);
if (hi - lo < MIN_RANGE_DURATION) return state;
const splits = [...state.splitPoints];
if (!splits.some((p) => Math.abs(p - originalPos) < EPSILON)) {
splits.push(originalPos);
}
if (!splits.some((p) => Math.abs(p - newPos) < EPSILON)) {
splits.push(newPos);
}
return normalizeTimelineState({
...state,
splitPoints: splits,
deletedRanges: [...state.deletedRanges, { start: lo, end: hi }],
selectedSegmentId: null,
});
}
/**
* Trim a single clip (display segment) from one of its edges, Loom-style.
*
* Outer edges (the first clip's left edge, the last clip's right edge) move the
* global in/out point (`trimStart`/`trimEnd`). Inner edges carve footage off the
* clip via {@link dragSplitForShrink}, leaving the neighbouring clips untouched.
* The carve only ever shrinks the clip it belongs to — it can never eat into an
* adjacent clip — so dragging clip A's right edge and clip B's left edge are
* independent operations even when A and B touch at a pure split.
*/
export function trimTimelineClipEdge(
state: VideoTimelineState,
clipId: string,
edge: "start" | "end",
sourceTime: number,
): VideoTimelineState {
if (!isFiniteNumber(sourceTime)) return state;
const normalized = normalizeTimelineState(state);
const segments = getTimelineDisplaySegments(normalized);
const clip = segments.find((segment) => segment.id === clipId);
if (!clip) return state;
// An outer edge moves the global in/out point ONLY when the clip actually sits
// at that boundary. If footage was already carved off the front/back (a
// collapsed deletedRange before/after this clip), moving the trim would
// un-collapse it and balloon the timeline — so we carve instead, keeping the
// display tight like every other clip edge.
const movesTrimStart =
segments[0]?.id === clipId && clip.start <= normalized.trimStart + EPSILON;
const movesTrimEnd =
segments[segments.length - 1]?.id === clipId &&
clip.end >= normalized.trimEnd - EPSILON;
if (edge === "start") {
if (movesTrimStart) {
const target = clampEditTime(
sourceTime,
0,
clip.end - MIN_RANGE_DURATION,
);
return setTimelineTrim(normalized, target, normalized.trimEnd);
}
const target = clampEditTime(
sourceTime,
clip.start,
clip.end - MIN_RANGE_DURATION,
);
if (target - clip.start < MIN_RANGE_DURATION) return normalized;
return dragSplitForShrink(normalized, clip.start, target);
}
if (movesTrimEnd) {
const target = clampEditTime(
sourceTime,
clip.start + MIN_RANGE_DURATION,
normalized.duration,
);
return setTimelineTrim(normalized, normalized.trimStart, target);
}
const target = clampEditTime(
sourceTime,
clip.start + MIN_RANGE_DURATION,
clip.end,
);
if (clip.end - target < MIN_RANGE_DURATION) return normalized;
return dragSplitForShrink(normalized, clip.end, target);
}
export function getTimelineKeepRanges(
state: VideoTimelineState,
): VideoEditRange[] {
const normalized = normalizeTimelineState(state);
return subtractRanges(
[{ start: normalized.trimStart, end: normalized.trimEnd }],
normalized.deletedRanges,
normalized.duration,
);
}
export function getTimelineEditSpec(state: VideoTimelineState): VideoEditSpec {
const normalized = normalizeTimelineState(state);
return normalizeKeepRanges(
getTimelineKeepRanges(normalized),
normalized.duration,
);
}
export function findNextPlayableTime(
currentTime: number,
editSpec: VideoEditSpec,
) {
const normalized = normalizeKeepRanges(
editSpec.keepRanges,
editSpec.sourceDuration,
);
return findNextPlayableTimeInRanges(currentTime, normalized.keepRanges);
}
export function findNextPlayableTimeInRanges(
currentTime: number,
keepRanges: readonly VideoEditRange[],
) {
const rangeIndex = findNextPlayableRangeIndex(currentTime, keepRanges);
if (rangeIndex < 0) return null;
const range = keepRanges[rangeIndex];
if (!range) return null;
return currentTime < range.start - EPSILON ? range.start : currentTime;
}
function findNextPlayableRangeIndex(
currentTime: number,
keepRanges: readonly VideoEditRange[],
) {
if (!isFiniteNumber(currentTime) || keepRanges.length === 0) return -1;
let low = 0;
let high = keepRanges.length;
while (low < high) {
const middle = Math.floor((low + high) / 2);
const range = keepRanges[middle];
if (range && currentTime < range.end - EPSILON) {
high = middle;
} else {
low = middle + 1;
}
}
return low < keepRanges.length ? low : -1;
}
export function findPlayableRangeIndex(
currentTime: number,
keepRanges: readonly VideoEditRange[],
) {
const rangeIndex = findNextPlayableRangeIndex(currentTime, keepRanges);
if (rangeIndex < 0) return -1;
const range = keepRanges[rangeIndex];
if (!range || currentTime < range.start - EPSILON) return -1;
return rangeIndex;
}
export function createTimelineHistory(
initialState: VideoTimelineState,
): TimelineHistory {
return {
entries: [normalizeTimelineState(initialState)],
index: 0,
};
}
export function pushTimelineHistory(
history: TimelineHistory,
nextState: VideoTimelineState,
): TimelineHistory {
const normalized = normalizeTimelineState(nextState);
const current = history.entries[history.index];
if (current && JSON.stringify(current) === JSON.stringify(normalized)) {
return history;
}
return {
entries: [...history.entries.slice(0, history.index + 1), normalized],
index: history.index + 1,
};
}
export function undoTimelineHistory(history: TimelineHistory): TimelineHistory {
return {
...history,
index: Math.max(0, history.index - 1),
};
}
export function redoTimelineHistory(history: TimelineHistory): TimelineHistory {
return {
...history,
index: Math.min(history.entries.length - 1, history.index + 1),
};
}