Skip to content

🎥 Make videos programmatically with React

8.8 KB
Raw Blame
import type {KeyframeEasing} from './keyframe-easing-presets';
import {
	isKeyframeInterpolationFunction,
	type KeyframeInterpolationFunction,
} from './keyframe-interpolation-function';

export type EffectClipboardPasteType = 'effects-additive' | 'effects-replacing';

export type EffectClipboardStaticParam = {
	readonly type: 'static';
	readonly value: unknown;
};

export type EffectClipboardInterpolationFunction =
	KeyframeInterpolationFunction;

export type EffectClipboardKeyframe = {
	readonly frame: number;
	readonly value: unknown;
};

export type EffectClipboardEasing = KeyframeEasing;

export type EffectClipboardExtrapolateType =
	| 'extend'
	| 'identity'
	| 'clamp'
	| 'wrap';

export type EffectClipboardClamping = {
	readonly left: EffectClipboardExtrapolateType;
	readonly right: EffectClipboardExtrapolateType;
};

export type EffectClipboardOutput = 'linear' | 'perceptual-scale';

export type EffectClipboardKeyframedParam = {
	readonly type: 'keyframed';
	readonly interpolationFunction: EffectClipboardInterpolationFunction;
	readonly keyframes: EffectClipboardKeyframe[];
	readonly easing: EffectClipboardEasing[];
	readonly clamping: EffectClipboardClamping;
	readonly output?: EffectClipboardOutput;
	readonly posterize?: number;
};

export type EffectClipboardParam =
	| EffectClipboardStaticParam
	| EffectClipboardKeyframedParam;

export type EffectClipboardSnapshot = {
	readonly callee: string;
	readonly importPath: string;
	readonly params: Record<string, EffectClipboardParam>;
};

export type EffectClipboardData = {
	readonly type: EffectClipboardPasteType;
	readonly version: 3;
	readonly remotionClipboard: 'effects';
	readonly effects: EffectClipboardSnapshot[];
};

export type EffectPropClipboardData = {
	readonly type: 'effect-prop';
	readonly version: 1;
	readonly remotionClipboard: 'effect-prop';
	readonly effect: {
		readonly callee: string;
		readonly importPath: string;
	};
	readonly key: string;
	readonly param: EffectClipboardParam;
};

export type EffectClipboardDataParseResult =
	| {
			readonly status: 'valid';
			readonly data: EffectClipboardData;
	  }
	| {
			readonly status: 'unsupported-version';
			readonly version: unknown;
	  }
	| {
			readonly status: 'invalid';
	  };

export type EffectPropClipboardDataParseResult =
	| {
			readonly status: 'valid';
			readonly data: EffectPropClipboardData;
	  }
	| {
			readonly status: 'unsupported-version';
			readonly version: unknown;
	  }
	| {
			readonly status: 'invalid';
	  };

const isRecord = (value: unknown): value is Record<string, unknown> => {
	return typeof value === 'object' && value !== null && !Array.isArray(value);
};

const extrapolateTypes = new Set(['extend', 'identity', 'clamp', 'wrap']);
const outputOptions = new Set(['linear', 'perceptual-scale']);

const isFiniteNumber = (value: unknown): value is number => {
	return typeof value === 'number' && Number.isFinite(value);
};

const isEasing = (value: unknown): value is EffectClipboardEasing => {
	return (
		isRecord(value) &&
		(value.type === 'linear' ||
			value.type === 'step1' ||
			(value.type === 'bezier' &&
				isFiniteNumber(value.x1) &&
				isFiniteNumber(value.y1) &&
				isFiniteNumber(value.x2) &&
				isFiniteNumber(value.y2)) ||
			(value.type === 'spring' &&
				isFiniteNumber(value.damping) &&
				isFiniteNumber(value.mass) &&
				isFiniteNumber(value.stiffness) &&
				(value.allowTail === undefined ||
					value.allowTail === null ||
					typeof value.allowTail === 'boolean') &&
				(value.durationRestThreshold === undefined ||
					value.durationRestThreshold === null ||
					isFiniteNumber(value.durationRestThreshold)) &&
				typeof value.overshootClamping === 'boolean'))
	);
};

const normalizeEasing = (
	easing: EffectClipboardEasing,
): EffectClipboardEasing => {
	if (easing.type !== 'spring') {
		return easing;
	}

	return {
		...easing,
		allowTail: easing.allowTail ?? null,
		durationRestThreshold: easing.durationRestThreshold ?? null,
	};
};

export const normalizeEffectClipboardParam = (
	param: EffectClipboardParam,
): EffectClipboardParam => {
	if (param.type === 'static') {
		return param;
	}

	return {
		...param,
		easing: param.easing.map(normalizeEasing),
	};
};

const normalizeSnapshot = (
	snapshot: EffectClipboardSnapshot,
): EffectClipboardSnapshot => {
	return {
		...snapshot,
		params: Object.fromEntries(
			Object.entries(snapshot.params).map(([key, param]) => [
				key,
				normalizeEffectClipboardParam(param),
			]),
		),
	};
};

const isKeyframe = (value: unknown): value is EffectClipboardKeyframe => {
	return isRecord(value) && isFiniteNumber(value.frame) && 'value' in value;
};

const isClamping = (value: unknown): value is EffectClipboardClamping => {
	return (
		isRecord(value) &&
		typeof value.left === 'string' &&
		extrapolateTypes.has(value.left) &&
		typeof value.right === 'string' &&
		extrapolateTypes.has(value.right)
	);
};

export const isEffectClipboardParam = (
	value: unknown,
): value is EffectClipboardParam => {
	if (!isRecord(value)) {
		return false;
	}

	if (value.type === 'static') {
		return 'value' in value;
	}

	if (value.type !== 'keyframed') {
		return false;
	}

	const {posterize} = value;
	const {output} = value;
	const easingLength =
		Array.isArray(value.keyframes) && value.keyframes.length > 0
			? value.keyframes.length - 1
			: null;
	return (
		typeof value.interpolationFunction === 'string' &&
		isKeyframeInterpolationFunction(value.interpolationFunction) &&
		Array.isArray(value.keyframes) &&
		value.keyframes.length > 0 &&
		value.keyframes.every(isKeyframe) &&
		Array.isArray(value.easing) &&
		value.easing.length === easingLength &&
		value.easing.every(isEasing) &&
		isClamping(value.clamping) &&
		(output === undefined ||
			(value.interpolationFunction === 'interpolate' &&
				typeof output === 'string' &&
				outputOptions.has(output))) &&
		(posterize === undefined || (isFiniteNumber(posterize) && posterize > 0))
	);
};

const isEffectClipboardSnapshotV3 = (
	value: unknown,
): value is EffectClipboardSnapshot => {
	if (!isRecord(value)) {
		return false;
	}

	return (
		typeof value.callee === 'string' &&
		typeof value.importPath === 'string' &&
		isRecord(value.params) &&
		Object.values(value.params).every(isEffectClipboardParam)
	);
};

export const parseEffectClipboardDataResult = (
	value: string,
): EffectClipboardDataParseResult => {
	try {
		const parsed: unknown = JSON.parse(value);
		if (!isRecord(parsed)) {
			return {status: 'invalid'};
		}

		if (parsed.remotionClipboard !== 'effects') {
			return {status: 'invalid'};
		}

		if (parsed.version !== 3) {
			return {
				status: 'unsupported-version',
				version: parsed.version,
			};
		}

		if (
			parsed.type !== 'effects-additive' &&
			parsed.type !== 'effects-replacing'
		) {
			return {status: 'invalid'};
		}

		if (!Array.isArray(parsed.effects)) {
			return {status: 'invalid'};
		}

		const effects: EffectClipboardSnapshot[] = [];
		for (const effect of parsed.effects) {
			if (!isEffectClipboardSnapshotV3(effect)) {
				return {status: 'invalid'};
			}

			effects.push(normalizeSnapshot(effect));
		}

		return {
			status: 'valid',
			data: {
				type: parsed.type,
				version: 3,
				remotionClipboard: 'effects',
				effects,
			},
		};
	} catch {
		return {status: 'invalid'};
	}
};

export const parseEffectClipboardData = (
	value: string,
): EffectClipboardData | null => {
	const result = parseEffectClipboardDataResult(value);
	if (result.status !== 'valid') {
		return null;
	}

	return result.data;
};

export const parseEffectPropClipboardDataResult = (
	value: string,
): EffectPropClipboardDataParseResult => {
	try {
		const parsed: unknown = JSON.parse(value);
		if (!isRecord(parsed)) {
			return {status: 'invalid'};
		}

		if (parsed.remotionClipboard !== 'effect-prop') {
			return {status: 'invalid'};
		}

		if (parsed.version !== 1) {
			return {
				status: 'unsupported-version',
				version: parsed.version,
			};
		}

		if (parsed.type !== 'effect-prop') {
			return {status: 'invalid'};
		}

		if (!isRecord(parsed.effect)) {
			return {status: 'invalid'};
		}

		if (
			typeof parsed.effect.callee !== 'string' ||
			typeof parsed.effect.importPath !== 'string'
		) {
			return {status: 'invalid'};
		}

		if (typeof parsed.key !== 'string') {
			return {status: 'invalid'};
		}

		if (!isEffectClipboardParam(parsed.param)) {
			return {status: 'invalid'};
		}

		return {
			status: 'valid',
			data: {
				type: 'effect-prop',
				version: 1,
				remotionClipboard: 'effect-prop',
				effect: {
					callee: parsed.effect.callee,
					importPath: parsed.effect.importPath,
				},
				key: parsed.key,
				param: normalizeEffectClipboardParam(parsed.param),
			},
		};
	} catch {
		return {status: 'invalid'};
	}
};

export const parseEffectPropClipboardData = (
	value: string,
): EffectPropClipboardData | null => {
	const result = parseEffectPropClipboardDataResult(value);
	if (result.status !== 'valid') {
		return null;
	}

	return result.data;
};