@remotion/studio 4.0.474 → 4.0.476

package/dist/components/Timeline/transform-origin-utils.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOriginPercentToUv = exports.parsedTransformOriginToPercent = exports.serializeTransformOrigin = exports.parsedTransformOriginToUv = exports.axisValueToUv = exports.parseTransformOrigin = void 0;
+const timeline_field_utils_1 = require("./timeline-field-utils");
+const cssNumberWithUnit = /^([+-]?(?:\d+\.?\d*|\.\d+))(px|%)$/i;
+const cssLength = /^([+-]?(?:\d+\.?\d*|\.\d+))[a-zA-Z]+$/;
+const keywords = new Set(['left', 'center', 'right', 'top', 'bottom']);
+const center = { value: 50, unit: '%' };
+const keywordOptions = (keyword) => {
+    if (keyword === 'left') {
+        return [{ axis: 'x', value: { value: 0, unit: '%' } }];
+    }
+    if (keyword === 'right') {
+        return [{ axis: 'x', value: { value: 100, unit: '%' } }];
+    }
+    if (keyword === 'top') {
+        return [{ axis: 'y', value: { value: 0, unit: '%' } }];
+    }
+    if (keyword === 'bottom') {
+        return [{ axis: 'y', value: { value: 100, unit: '%' } }];
+    }
+    return [
+        { axis: 'x', value: center },
+        { axis: 'y', value: center },
+    ];
+};
+const parseLengthPercentage = (token) => {
+    const match = cssNumberWithUnit.exec(token);
+    if (!match) {
+        return null;
+    }
+    const value = Number(match[1]);
+    if (!Number.isFinite(value)) {
+        return null;
+    }
+    return { value, unit: match[2].toLowerCase() };
+};
+const parseToken = (token) => {
+    const lower = token.toLowerCase();
+    if (keywords.has(lower)) {
+        return { type: 'keyword', keyword: lower };
+    }
+    const value = parseLengthPercentage(token);
+    return value === null ? null : { type: 'length-percentage', value };
+};
+const parseTwoKeywords = (first, second) => {
+    var _a;
+    const candidates = [];
+    for (const firstOption of keywordOptions(first)) {
+        for (const secondOption of keywordOptions(second)) {
+            if (firstOption.axis === secondOption.axis) {
+                continue;
+            }
+            candidates.push(firstOption.axis === 'x'
+                ? [firstOption.value, secondOption.value]
+                : [secondOption.value, firstOption.value]);
+        }
+    }
+    return (_a = candidates[0]) !== null && _a !== void 0 ? _a : null;
+};
+const parseXY = (parts) => {
+    if (parts.length === 1) {
+        const token = parseToken(parts[0]);
+        if (token === null) {
+            return null;
+        }
+        if (token.type === 'length-percentage') {
+            return [token.value, center];
+        }
+        if (token.keyword === 'top' || token.keyword === 'bottom') {
+            return [center, keywordOptions(token.keyword)[0].value];
+        }
+        return [keywordOptions(token.keyword)[0].value, center];
+    }
+    const first = parseToken(parts[0]);
+    const second = parseToken(parts[1]);
+    if (first === null || second === null) {
+        return null;
+    }
+    if (first.type === 'length-percentage' &&
+        second.type === 'length-percentage') {
+        return [first.value, second.value];
+    }
+    if (first.type === 'keyword' && second.type === 'keyword') {
+        return parseTwoKeywords(first.keyword, second.keyword);
+    }
+    const keyword = first.type === 'keyword'
+        ? first
+        : second.type === 'keyword'
+            ? second
+            : null;
+    const length = first.type === 'length-percentage'
+        ? first.value
+        : second.type === 'length-percentage'
+            ? second.value
+            : null;
+    if (keyword === null || length === null) {
+        return null;
+    }
+    const keywordIsFirst = first.type === 'keyword';
+    if (keyword.keyword === 'left' || keyword.keyword === 'right') {
+        return keywordIsFirst
+            ? [keywordOptions(keyword.keyword)[0].value, length]
+            : null;
+    }
+    if (keyword.keyword === 'top' || keyword.keyword === 'bottom') {
+        return [length, keywordOptions(keyword.keyword)[0].value];
+    }
+    return keywordIsFirst ? [center, length] : [length, center];
+};
+const isSupportedZ = (token) => {
+    if (token.includes('%')) {
+        return false;
+    }
+    return cssLength.test(token);
+};
+const parseTransformOrigin = (value) => {
+    var _a;
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const parts = value.trim().split(/\s+/);
+    if (parts.length < 1 || parts.length > 3 || parts[0] === '') {
+        return null;
+    }
+    const xy = parseXY(parts.length === 1 ? [parts[0]] : [parts[0], parts[1]]);
+    if (xy === null) {
+        return null;
+    }
+    const z = (_a = parts[2]) !== null && _a !== void 0 ? _a : null;
+    if (z !== null && !isSupportedZ(z)) {
+        return null;
+    }
+    return { x: xy[0], y: xy[1], z };
+};
+exports.parseTransformOrigin = parseTransformOrigin;
+const axisValueToUv = (axis, size) => {
+    if (!Number.isFinite(size) || size <= 0) {
+        return null;
+    }
+    if (axis.unit === '%') {
+        return axis.value / 100;
+    }
+    return axis.value / size;
+};
+exports.axisValueToUv = axisValueToUv;
+const parsedTransformOriginToUv = ({ parsed, width, height, }) => {
+    const x = (0, exports.axisValueToUv)(parsed.x, width);
+    const y = (0, exports.axisValueToUv)(parsed.y, height);
+    return x === null || y === null ? null : [x, y];
+};
+exports.parsedTransformOriginToUv = parsedTransformOriginToUv;
+const formatPercent = (value, decimalPlaces) => {
+    const rounded = (0, timeline_field_utils_1.roundToDecimalPlaces)((0, timeline_field_utils_1.normalizeTimelineNumber)(value * 100), decimalPlaces);
+    return String(Object.is(rounded, -0) ? 0 : rounded);
+};
+const serializeTransformOrigin = ({ uv, z, decimalPlaces = 2, }) => {
+    const xy = `${formatPercent(uv[0], decimalPlaces)}% ${formatPercent(uv[1], decimalPlaces)}%`;
+    return z === null ? xy : `${xy} ${z}`;
+};
+exports.serializeTransformOrigin = serializeTransformOrigin;
+const parsedTransformOriginToPercent = (parsed) => {
+    if (parsed.x.unit !== '%' || parsed.y.unit !== '%') {
+        return null;
+    }
+    return [parsed.x.value, parsed.y.value];
+};
+exports.parsedTransformOriginToPercent = parsedTransformOriginToPercent;
+const transformOriginPercentToUv = (percent) => [percent[0] / 100, percent[1] / 100];
+exports.transformOriginPercentToUv = transformOriginPercentToUv;

package/dist/components/Timeline/update-selected-easing.d.ts

@@ -0,0 +1,35 @@
+import type { OverrideIdToNodePaths, PropStatuses, TSequence } from 'remotion';
+import type { SetPropStatuses } from './save-sequence-prop';
+import type { TimelineEasingSelection, TimelineSelection } from './TimelineSelection';
+export type EasingSelection = TimelineEasingSelection;
+export type TimelineEasingValue = 'linear' | [number, number, number, number];
+export declare const getEasingSelections: (selections: readonly TimelineSelection[]) => ({
+    readonly nodePathInfo: import("../../helpers/get-timeline-sequence-sort-key").SequenceNodePathInfo;
+} & {
+    readonly type: "easing";
+    readonly fromFrame: number;
+    readonly toFrame: number;
+    readonly segmentIndex: number;
+})[];
+export declare const getTimelineEasingValueForSelection: ({ selection, sequences, overrideIdsToNodePaths, propStatuses, }: {
+    selection: {
+        readonly nodePathInfo: import("../../helpers/get-timeline-sequence-sort-key").SequenceNodePathInfo;
+    } & {
+        readonly type: "easing";
+        readonly fromFrame: number;
+        readonly toFrame: number;
+        readonly segmentIndex: number;
+    };
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    propStatuses: PropStatuses;
+}) => TimelineEasingValue | null;
+export declare const updateSelectedTimelineEasings: ({ selections, sequences, overrideIdsToNodePaths, propStatuses, setPropStatuses, clientId, easing, }: {
+    selections: readonly TimelineSelection[];
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    propStatuses: PropStatuses;
+    setPropStatuses: SetPropStatuses;
+    clientId: string;
+    easing: TimelineEasingValue;
+}) => Promise<void> | null;

package/dist/components/Timeline/update-selected-easing.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSelectedTimelineEasings = exports.getTimelineEasingValueForSelection = exports.getEasingSelections = void 0;
+const remotion_1 = require("remotion");
+const call_update_keyframe_settings_1 = require("./call-update-keyframe-settings");
+const find_track_for_node_path_info_1 = require("./find-track-for-node-path-info");
+const parse_keyframe_field_from_node_path_1 = require("./parse-keyframe-field-from-node-path");
+const canEditEasingForInterpolationFunction = (interpolationFunction) => interpolationFunction === 'interpolate' ||
+    interpolationFunction === 'interpolateColors';
+const isEasingSelection = (selection) => selection.type === 'easing';
+const getSelectedEasingUpdate = ({ selection, sequences, overrideIdsToNodePaths, propStatuses, }) => {
+    var _a;
+    var _b, _c, _d;
+    const field = (0, parse_keyframe_field_from_node_path_1.parseKeyframeFieldFromNodePath)(selection.nodePathInfo.auxiliaryKeys);
+    if (field === null) {
+        return null;
+    }
+    const track = (0, find_track_for_node_path_info_1.findTrackForNodePathInfo)({
+        sequences,
+        overrideIdsToNodePaths,
+        nodePathInfo: selection.nodePathInfo,
+    });
+    const sequence = (_b = track === null || track === void 0 ? void 0 : track.sequence) !== null && _b !== void 0 ? _b : null;
+    if (!sequence) {
+        return null;
+    }
+    const nodePath = selection.nodePathInfo.sequenceSubscriptionKey;
+    const fileName = nodePath.absolutePath;
+    if (field.type === 'sequence') {
+        if (!sequence.controls) {
+            return null;
+        }
+        const sequencePropStatus = (_a = remotion_1.Internals.getPropStatusesCtx(propStatuses, nodePath)) === null || _a === void 0 ? void 0 : _a[field.fieldKey];
+        if ((sequencePropStatus === null || sequencePropStatus === void 0 ? void 0 : sequencePropStatus.status) !== 'keyframed' ||
+            !canEditEasingForInterpolationFunction(sequencePropStatus.interpolationFunction)) {
+            return null;
+        }
+        return {
+            type: 'sequence',
+            fileName,
+            nodePath,
+            fieldKey: field.fieldKey,
+            schema: sequence.controls.schema,
+            segmentIndex: selection.segmentIndex,
+            currentEasing: (_c = sequencePropStatus.easing[selection.segmentIndex]) !== null && _c !== void 0 ? _c : 'linear',
+        };
+    }
+    const effect = sequence.effects[field.effectIndex];
+    if (!effect) {
+        return null;
+    }
+    const effectStatus = remotion_1.Internals.getEffectPropStatusesCtx({
+        propStatuses,
+        nodePath,
+        effectIndex: field.effectIndex,
+    });
+    const effectPropStatus = effectStatus.type === 'can-update-effect'
+        ? effectStatus.props[field.fieldKey]
+        : null;
+    if ((effectPropStatus === null || effectPropStatus === void 0 ? void 0 : effectPropStatus.status) !== 'keyframed' ||
+        !canEditEasingForInterpolationFunction(effectPropStatus.interpolationFunction)) {
+        return null;
+    }
+    return {
+        type: 'effect',
+        fileName,
+        nodePath,
+        effectIndex: field.effectIndex,
+        fieldKey: field.fieldKey,
+        schema: effect.schema,
+        segmentIndex: selection.segmentIndex,
+        currentEasing: (_d = effectPropStatus.easing[selection.segmentIndex]) !== null && _d !== void 0 ? _d : 'linear',
+    };
+};
+const getEasingSelections = (selections) => selections.filter(isEasingSelection);
+exports.getEasingSelections = getEasingSelections;
+const getTimelineEasingValueForSelection = ({ selection, sequences, overrideIdsToNodePaths, propStatuses, }) => {
+    var _a;
+    var _b;
+    return ((_b = (_a = getSelectedEasingUpdate({
+        selection,
+        sequences,
+        overrideIdsToNodePaths,
+        propStatuses,
+    })) === null || _a === void 0 ? void 0 : _a.currentEasing) !== null && _b !== void 0 ? _b : null);
+};
+exports.getTimelineEasingValueForSelection = getTimelineEasingValueForSelection;
+const updateSelectedTimelineEasings = ({ selections, sequences, overrideIdsToNodePaths, propStatuses, setPropStatuses, clientId, easing, }) => {
+    const easingSelections = (0, exports.getEasingSelections)(selections);
+    if (easingSelections.length === 0) {
+        return null;
+    }
+    const updates = easingSelections
+        .map((selection) => getSelectedEasingUpdate({
+        selection,
+        sequences,
+        overrideIdsToNodePaths,
+        propStatuses,
+    }))
+        .filter((update) => update !== null);
+    if (updates.length === 0) {
+        return null;
+    }
+    return Promise.all(updates.map((update) => {
+        const settings = {
+            type: 'easing',
+            segmentIndex: update.segmentIndex,
+            easing,
+        };
+        if (update.type === 'sequence') {
+            return (0, call_update_keyframe_settings_1.callUpdateSequenceKeyframeSettings)({
+                fileName: update.fileName,
+                nodePath: update.nodePath,
+                fieldKey: update.fieldKey,
+                settings,
+                schema: update.schema,
+                setPropStatuses,
+                clientId,
+            });
+        }
+        return (0, call_update_keyframe_settings_1.callUpdateEffectKeyframeSettings)({
+            fileName: update.fileName,
+            nodePath: update.nodePath,
+            effectIndex: update.effectIndex,
+            fieldKey: update.fieldKey,
+            settings,
+            schema: update.schema,
+            setPropStatuses,
+            clientId,
+        });
+    })).then(() => undefined);
+};
+exports.updateSelectedTimelineEasings = updateSelectedTimelineEasings;

package/dist/components/Timeline/use-expanded-track-keyframe-rows.d.ts

@@ -4,6 +4,7 @@ import type { getTimelineKeyframes } from './get-timeline-keyframes';
 export type ExpandedTrackKeyframeRow = {
     readonly height: number;
     readonly keyframes: ReturnType<typeof getTimelineKeyframes>;
+    readonly canEditEasing: boolean;
     readonly nodePathInfo: SequenceNodePathInfo;
     readonly rowKey: string;
 };

package/dist/components/Timeline/use-expanded-track-keyframe-rows.js

@@ -7,6 +7,29 @@ const timeline_layout_1 = require("../../helpers/timeline-layout");
 const timeline_node_path_key_1 = require("../../helpers/timeline-node-path-key");
 const ExpandedTracksProvider_1 = require("../ExpandedTracksProvider");
 const get_node_keyframes_1 = require("./get-node-keyframes");
+const canEditEasingForInterpolationFunction = (interpolationFunction) => interpolationFunction === 'interpolate' ||
+    interpolationFunction === 'interpolateColors';
+const getNodeCanEditEasing = ({ node, nodePath, propStatuses, }) => {
+    var _a;
+    if (node.kind !== 'field' || node.field === null) {
+        return false;
+    }
+    if (node.field.kind === 'sequence-field') {
+        const sequencePropStatus = (_a = remotion_1.Internals.getPropStatusesCtx(propStatuses, nodePath)) === null || _a === void 0 ? void 0 : _a[node.field.key];
+        return ((sequencePropStatus === null || sequencePropStatus === void 0 ? void 0 : sequencePropStatus.status) === 'keyframed' &&
+            canEditEasingForInterpolationFunction(sequencePropStatus.interpolationFunction));
+    }
+    const effectStatus = remotion_1.Internals.getEffectPropStatusesCtx({
+        propStatuses,
+        nodePath,
+        effectIndex: node.field.effectIndex,
+    });
+    const effectPropStatus = effectStatus.type === 'can-update-effect'
+        ? effectStatus.props[node.field.key]
+        : null;
+    return ((effectPropStatus === null || effectPropStatus === void 0 ? void 0 : effectPropStatus.status) === 'keyframed' &&
+        canEditEasingForInterpolationFunction(effectPropStatus.interpolationFunction));
+};
 const useExpandedTrackKeyframeRows = ({ sequence, nodePathInfo, keyframeDisplayOffset, }) => {
     const { getIsExpanded } = (0, react_1.useContext)(ExpandedTracksProvider_1.ExpandedTracksGetterContext);
     const { propStatuses } = (0, react_1.useContext)(remotion_1.Internals.VisualModePropStatusesContext);
@@ -43,6 +66,11 @@ const useExpandedTrackKeyframeRows = ({ sequence, nodePathInfo, keyframeDisplayO
             getEffectDragOverrides,
             timelinePosition,
         }),
+        canEditEasing: getNodeCanEditEasing({
+            node,
+            nodePath: nodePathInfo.sequenceSubscriptionKey,
+            propStatuses,
+        }),
         rowKey: (0, timeline_node_path_key_1.timelineNodePathInfoToKey)(node.nodePathInfo),
         nodePathInfo: node.nodePathInfo,
     })), [

package/dist/components/Timeline/use-timeline-keyframe-drag.js

@@ -121,21 +121,16 @@ const makeMovedKeyframedDragOverride = ({ group, delta, }) => {
     if (!first) {
         throw new Error('Expected a keyframe drag target');
     }
-    const moves = new Map(getMovesForGroup({ group, delta }).map((move) => [move.fromFrame, move.toFrame]));
+    const movedStatus = (0, studio_shared_1.moveKeyframesInPropStatus)({
+        status: first.propStatus,
+        moves: getMovesForGroup({ group, delta }),
+    });
+    if (movedStatus.status !== 'keyframed') {
+        throw new Error('Expected keyframed status');
+    }
     return {
         type: 'keyframed',
-        status: {
-            ...first.propStatus,
-            keyframes: first.propStatus.keyframes
-                .map((keyframe) => {
-                var _a;
-                return ({
-                    ...keyframe,
-                    frame: (_a = moves.get(keyframe.frame)) !== null && _a !== void 0 ? _a : keyframe.frame,
-                });
-            })
-                .sort((a, b) => a.frame - b.frame),
-        },
+        status: movedStatus,
     };
 };
 const applyDragOverrides = ({ delta, setDragOverrides, setEffectDragOverrides, targets, }) => {

package/dist/components/canvas-capture-enabled.d.ts

@@ -0,0 +1 @@
+export declare const CANVAS_CAPTURE_ENABLED = false;

package/dist/components/canvas-capture-enabled.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANVAS_CAPTURE_ENABLED = void 0;
+exports.CANVAS_CAPTURE_ENABLED = false;

package/dist/components/effect-drag-and-drop.d.ts

@@ -0,0 +1,11 @@
+import { type EffectDragData } from '@remotion/studio-shared';
+import type { SequencePropsSubscriptionKey } from 'remotion';
+export declare const hasEffectDragType: (dataTransfer: DataTransfer) => boolean;
+export declare const hasExplicitEffectDragType: (dataTransfer: DataTransfer) => boolean;
+export declare const getEffectDragData: (dataTransfer: DataTransfer) => EffectDragData | null;
+export declare const addEffectFromDragData: ({ clientId, dragData, fileName, nodePath, }: {
+    readonly clientId: string;
+    readonly dragData: EffectDragData;
+    readonly fileName: string;
+    readonly nodePath: SequencePropsSubscriptionKey;
+}) => Promise<void>;

package/dist/components/effect-drag-and-drop.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addEffectFromDragData = exports.getEffectDragData = exports.hasExplicitEffectDragType = exports.hasEffectDragType = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const install_required_package_1 = require("../helpers/install-required-package");
+const call_api_1 = require("./call-api");
+const NotificationCenter_1 = require("./Notifications/NotificationCenter");
+const hasEffectDragType = (dataTransfer) => {
+    const types = Array.from(dataTransfer.types);
+    const hasExplicitEffectType = types.includes(studio_shared_1.EFFECT_DRAG_MIME_TYPE);
+    if (!hasExplicitEffectType && hasImportableAssetDragType(dataTransfer)) {
+        return false;
+    }
+    return types.some((type) => type === studio_shared_1.EFFECT_DRAG_MIME_TYPE || isGenericDragType(type));
+};
+exports.hasEffectDragType = hasEffectDragType;
+const hasExplicitEffectDragType = (dataTransfer) => {
+    return Array.from(dataTransfer.types).includes(studio_shared_1.EFFECT_DRAG_MIME_TYPE);
+};
+exports.hasExplicitEffectDragType = hasExplicitEffectDragType;
+const isGenericDragType = (type) => {
+    return type === 'application/json' || type === 'text/plain';
+};
+const hasImportableAssetDragType = (dataTransfer) => {
+    return Array.from(dataTransfer.types).some((type) => type === 'Files' ||
+        type === studio_shared_1.ASSET_DRAG_MIME_TYPE ||
+        type === studio_shared_1.COMPONENT_DRAG_MIME_TYPE ||
+        type === studio_shared_1.SFX_DRAG_MIME_TYPE ||
+        type === 'text/uri-list' ||
+        type === 'text/html');
+};
+const getEffectDragData = (dataTransfer) => {
+    for (const type of [
+        studio_shared_1.EFFECT_DRAG_MIME_TYPE,
+        'application/json',
+        'text/plain',
+    ]) {
+        const value = dataTransfer.getData(type);
+        if (!value) {
+            continue;
+        }
+        const parsed = (0, studio_shared_1.parseEffectDragData)(value);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return null;
+};
+exports.getEffectDragData = getEffectDragData;
+const addEffectFromDragData = async ({ clientId, dragData, fileName, nodePath, }) => {
+    try {
+        const requiredPackage = (0, studio_shared_1.getRequiredPackageForEffectImportPath)(dragData.effect.importPath);
+        await (0, install_required_package_1.installRequiredPackages)(requiredPackage ? [requiredPackage] : []);
+        const result = await (0, call_api_1.callApi)('/api/add-effect', {
+            fileName,
+            sequenceNodePath: nodePath,
+            effectName: dragData.effect.name,
+            effectImportPath: dragData.effect.importPath,
+            effectConfig: dragData.effect.config,
+            clientId,
+        });
+        if (result.success) {
+            (0, NotificationCenter_1.showNotification)(`Added ${dragData.effect.name}()`, 2000);
+        }
+        else {
+            (0, NotificationCenter_1.showNotification)(result.reason, 4000);
+        }
+    }
+    catch (err) {
+        (0, NotificationCenter_1.showNotification)(err.message, 4000);
+    }
+};
+exports.addEffectFromDragData = addEffectFromDragData;

package/dist/components/selected-outline-geometry.d.ts

@@ -0,0 +1,20 @@
+export type OutlinePoint = {
+    readonly x: number;
+    readonly y: number;
+};
+export type SelectedOutline = {
+    readonly key: string;
+    readonly dimensions: {
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    readonly points: readonly [
+        OutlinePoint,
+        OutlinePoint,
+        OutlinePoint,
+        OutlinePoint
+    ];
+};
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const mix: (from: number, to: number, progress: number) => number;
+export declare const mixPoint: (from: OutlinePoint, to: OutlinePoint, progress: number) => OutlinePoint;

package/dist/components/selected-outline-geometry.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mixPoint = exports.mix = exports.clamp = void 0;
+const clamp = (value, min, max) => {
+    return Math.min(max, Math.max(min, value));
+};
+exports.clamp = clamp;
+const mix = (from, to, progress) => {
+    return from + (to - from) * progress;
+};
+exports.mix = mix;
+const mixPoint = (from, to, progress) => {
+    return {
+        x: (0, exports.mix)(from.x, to.x, progress),
+        y: (0, exports.mix)(from.y, to.y, progress),
+    };
+};
+exports.mixPoint = mixPoint;

package/dist/components/selected-outline-uv.d.ts

@@ -0,0 +1,46 @@
+import type { CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, GetEffectDragOverrides, PropStatuses, SequenceFieldSchema, SequencePropsSubscriptionKey, SequenceSchema, TSequence } from 'remotion';
+import { type OutlinePoint } from './selected-outline-geometry';
+export type UvCoordinate = readonly [number, number];
+export type UvCoordinateFieldSchema = Extract<SequenceFieldSchema, {
+    type: 'uv-coordinate';
+}>;
+export type SelectedOutlineUvHandle = {
+    readonly clientId: string;
+    readonly propStatus: CanUpdateSequencePropStatusStatic | CanUpdateSequencePropStatusKeyframed;
+    readonly effectIndex: number;
+    readonly fieldDefault: UvCoordinate | undefined;
+    readonly fieldKey: string;
+    readonly fieldSchema: UvCoordinateFieldSchema;
+    readonly nodePath: SequencePropsSubscriptionKey;
+    readonly schema: SequenceSchema;
+    readonly sourceFrame: number;
+    readonly value: UvCoordinate;
+};
+type UvConnectionHandle = Pick<SelectedOutlineUvHandle, 'effectIndex' | 'fieldKey' | 'fieldSchema' | 'value'>;
+type UvHandleConnectionLine = {
+    readonly key: string;
+    readonly from: OutlinePoint;
+    readonly to: OutlinePoint;
+};
+type SelectedEffectFields = {
+    readonly allFields: boolean;
+    readonly fieldKeys: ReadonlySet<string>;
+};
+export declare const tuplesEqual: (left: unknown, right: UvCoordinate) => boolean;
+export declare const getUvHandlePosition: (points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint], uv: UvCoordinate) => OutlinePoint;
+export declare const getUvHandleConnectionLines: ({ handles, points, }: {
+    readonly handles: readonly UvConnectionHandle[];
+    readonly points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint];
+}) => UvHandleConnectionLine[];
+export declare const getUvCoordinateForPoint: (points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint], point: OutlinePoint) => UvCoordinate;
+export declare function constrainUv(value: UvCoordinate, schema: UvCoordinateFieldSchema): UvCoordinate;
+export declare const getSelectedUvHandles: ({ propStatuses, clientId, getEffectDragOverrides, nodePath, selectedEffects, sequence, sourceFrame, }: {
+    readonly propStatuses: PropStatuses;
+    readonly clientId: string | null;
+    readonly getEffectDragOverrides: GetEffectDragOverrides;
+    readonly nodePath: SequencePropsSubscriptionKey;
+    readonly selectedEffects: Map<number, SelectedEffectFields> | undefined;
+    readonly sequence: TSequence;
+    readonly sourceFrame: number;
+}) => SelectedOutlineUvHandle[];
+export {};