@remotion/studio 4.0.471 → 4.0.472

package/dist/esm/renderEntry.mjs

@@ -209,7 +209,7 @@ var renderContent = (Root) => {
     renderToDOM(/* @__PURE__ */ jsx("div", {
       children: /* @__PURE__ */ jsx(DelayedSpinner, {})
     }));
-    import("./chunk-z0z9d4r0.js").then(({ StudioInternals }) => {
+    import("./chunk-48grt472.js").then(({ StudioInternals }) => {
       window.remotion_isStudio = true;
       window.remotion_isReadOnlyStudio = true;
       window.remotion_inputProps = "{}";

package/dist/helpers/calculate-timeline.js

@@ -21,8 +21,8 @@ const getInheritedLoopDisplay = (sequence, sequences) => {
     return getInheritedLoopDisplay(parent, sequences);
 };
 const calculateTimeline = ({ sequences, overrideIdsToNodePaths, }) => {
-    var _a;
-    var _b;
+    var _a, _b;
+    var _c;
     const sortedSequences = (0, sort_by_nonce_history_1.sortItemsByNonceHistory)(sequences);
     const tracks = [];
     if (sortedSequences.length === 0) {
@@ -44,7 +44,7 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, }) => {
         const cascadedStart = (0, get_sequence_visible_range_1.getCascadedStart)(sequence, sortedSequences);
         const visibleStart = (0, get_sequence_visible_range_1.getTimelineVisibleStart)(sequence, sortedSequences);
         const visibleDuration = (0, get_sequence_visible_range_1.getTimelineVisibleDuration)(sequence, sortedSequences);
-        const overrideId = (_b = (_a = sequence.controls) === null || _a === void 0 ? void 0 : _a.overrideId) !== null && _b !== void 0 ? _b : null;
+        const overrideId = (_c = (_a = sequence.controls) === null || _a === void 0 ? void 0 : _a.overrideId) !== null && _c !== void 0 ? _c : null;
         const nodePath = overrideId ? overrideIdsToNodePaths[overrideId] : null;
         const hasKeyframeRows = sequence.controls !== null || sequence.effects.length > 0;
         tracks.push({
@@ -63,12 +63,14 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, }) => {
             keyframeDisplayOffset: hasKeyframeRows
                 ? cascadedStart - sequence.from
                 : 0,
+            sequenceFrameOffset: visibleStart - cascadedStart,
             nodePathInfo: nodePath
                 ? {
                     sequenceSubscriptionKey: nodePath,
                     auxiliaryKeys: [],
                     index: 0,
                     numberOfSequencesWithThisNodePath: 0,
+                    supportsEffects: ((_b = sequence.controls) === null || _b === void 0 ? void 0 : _b.supportsEffects) === true,
                 }
                 : null,
         });
@@ -106,6 +108,7 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, }) => {
                 auxiliaryKeys: track.nodePathInfo.auxiliaryKeys,
                 index,
                 numberOfSequencesWithThisNodePath: 0,
+                supportsEffects: track.nodePathInfo.supportsEffects,
             },
         };
     })
@@ -122,6 +125,7 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, }) => {
                 auxiliaryKeys: track.nodePathInfo.auxiliaryKeys,
                 index: track.nodePathInfo.index,
                 numberOfSequencesWithThisNodePath: (_a = nodePathIndexCounters.get(key)) !== null && _a !== void 0 ? _a : 0,
+                supportsEffects: track.nodePathInfo.supportsEffects,
             },
         };
     });

package/dist/helpers/create-folder-tree.js

@@ -113,6 +113,7 @@ const createFolderIfDoesNotExist = (items, availableFolders, folderItem, folders
     }
     itemList.push({
         type: 'folder',
+        folder: folderItem,
         folderName: folderItem.name,
         items: [],
         key: folderItem.name,

package/dist/helpers/detect-file-type.d.ts

@@ -0,0 +1,69 @@
+export type FileDimensions = {
+    readonly width: number;
+    readonly height: number;
+};
+export declare const matchesPattern: (pattern: Uint8Array<ArrayBufferLike>) => (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isRiffAvi: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isRiffWave: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isWebm: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isIsoBaseMedia: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isTransportStream: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isMp3: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isAac: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isFlac: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export declare const isM3u: (data: Uint8Array<ArrayBufferLike>) => boolean;
+export type RiffType = {
+    type: 'riff';
+};
+export type WebmType = {
+    type: 'webm';
+};
+export type IsoBaseMediaType = {
+    type: 'iso-base-media';
+};
+export type TransportStreamType = {
+    type: 'transport-stream';
+};
+export type Mp3Type = {
+    type: 'mp3';
+};
+export type AacType = {
+    type: 'aac';
+};
+export type WavType = {
+    type: 'wav';
+};
+export type GifType = {
+    type: 'gif';
+    dimensions: FileDimensions;
+};
+export type FlacType = {
+    type: 'flac';
+};
+export type M3uType = {
+    type: 'm3u';
+};
+export type PngType = {
+    type: 'png';
+    dimensions: FileDimensions | null;
+};
+export type JpegType = {
+    type: 'jpeg';
+    dimensions: FileDimensions | null;
+};
+export type WebpType = {
+    type: 'webp';
+    dimensions: FileDimensions | null;
+};
+export type BmpType = {
+    type: 'bmp';
+    dimensions: FileDimensions | null;
+};
+export type PdfType = {
+    type: 'pdf';
+};
+export type UnknownType = {
+    type: 'unknown';
+};
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | FlacType | M3uType | UnknownType;
+export declare const detectFileType: (data: Uint8Array<ArrayBufferLike>) => FileType;

package/dist/helpers/detect-file-type.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = exports.isM3u = exports.isFlac = exports.isAac = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+exports.matchesPattern = matchesPattern;
+const isRiffAvi = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    const aviPattern = new Uint8Array([0x41, 0x56, 0x49, 0x20]);
+    return (0, exports.matchesPattern)(aviPattern)(fileType);
+};
+exports.isRiffAvi = isRiffAvi;
+const isRiffWave = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    const wavePattern = new Uint8Array([0x57, 0x41, 0x56, 0x45]);
+    return (0, exports.matchesPattern)(wavePattern)(fileType);
+};
+exports.isRiffWave = isRiffWave;
+const isWebm = (data) => {
+    return (0, exports.matchesPattern)(webmPattern)(data.subarray(0, 4));
+};
+exports.isWebm = isWebm;
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return (0, exports.matchesPattern)(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+exports.isIsoBaseMedia = isIsoBaseMedia;
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+exports.isTransportStream = isTransportStream;
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3]);
+    const mpegPattern2 = new Uint8Array([0xff, 0xfb]);
+    const id3v4Pattern = new Uint8Array([0x49, 0x44, 0x33, 4]);
+    const id3v3Pattern = new Uint8Array([0x49, 0x44, 0x33, 3]);
+    const id3v2Pattern = new Uint8Array([0x49, 0x44, 0x33, 2]);
+    const subarray = data.subarray(0, 4);
+    return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(mpegPattern2)(subarray) ||
+        (0, exports.matchesPattern)(id3v4Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v3Pattern)(subarray) ||
+        (0, exports.matchesPattern)(id3v2Pattern)(subarray));
+};
+exports.isMp3 = isMp3;
+const isAac = (data) => {
+    const aacPattern = new Uint8Array([0xff, 0xf1]);
+    return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
+};
+exports.isAac = isAac;
+const isFlac = (data) => {
+    const flacPattern = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
+    return (0, exports.matchesPattern)(flacPattern)(data.subarray(0, 4));
+};
+exports.isFlac = isFlac;
+const isM3u = (data) => {
+    return new TextDecoder('utf-8').decode(data.slice(0, 7)) === '#EXTM3U';
+};
+exports.isM3u = isM3u;
+const getPngDimensions = (pngData) => {
+    if (pngData.length < 24) {
+        return null;
+    }
+    const view = new DataView(pngData.buffer, pngData.byteOffset);
+    const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (pngData[i] !== pngSignature[i]) {
+            return null;
+        }
+    }
+    return {
+        width: view.getUint32(16, false),
+        height: view.getUint32(20, false),
+    };
+};
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    if ((0, exports.matchesPattern)(pngPattern)(data.subarray(0, 4))) {
+        const png = getPngDimensions(data);
+        return { dimensions: png, type: 'png' };
+    }
+    return null;
+};
+const getJpegDimensions = (data) => {
+    let offset = 0;
+    const readUint16BE = (o) => {
+        return (data[o] << 8) | data[o + 1];
+    };
+    if (readUint16BE(offset) !== 0xffd8) {
+        return null;
+    }
+    offset += 2;
+    while (offset < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            offset += length + 2;
+        }
+        else {
+            offset++;
+        }
+    }
+    return null;
+};
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = (0, exports.matchesPattern)(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return null;
+    }
+    const dim = getJpegDimensions(data);
+    return { dimensions: dim, type: 'jpeg' };
+};
+const getGifDimensions = (data) => {
+    const view = new DataView(data.buffer, data.byteOffset);
+    const width = view.getUint16(6, true);
+    const height = view.getUint16(8, true);
+    return { width, height };
+};
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    if ((0, exports.matchesPattern)(gifPattern)(data.subarray(0, 4))) {
+        return { type: 'gif', dimensions: getGifDimensions(data) };
+    }
+    return null;
+};
+const getWebPDimensions = (bytes) => {
+    if (bytes.length < 30) {
+        return null;
+    }
+    if (bytes[0] !== 0x52 ||
+        bytes[1] !== 0x49 ||
+        bytes[2] !== 0x46 ||
+        bytes[3] !== 0x46 ||
+        bytes[8] !== 0x57 ||
+        bytes[9] !== 0x45 ||
+        bytes[10] !== 0x42 ||
+        bytes[11] !== 0x50) {
+        return null;
+    }
+    if (bytes[12] === 0x56 && bytes[13] === 0x50 && bytes[14] === 0x38) {
+        if (bytes[15] === 0x20) {
+            return {
+                width: bytes[26] | ((bytes[27] << 8) & 0x3fff),
+                height: bytes[28] | ((bytes[29] << 8) & 0x3fff),
+            };
+        }
+    }
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x4c) {
+        return {
+            width: 1 + (bytes[21] | ((bytes[22] & 0x3f) << 8)),
+            height: 1 +
+                (((bytes[22] & 0xc0) >> 6) |
+                    (bytes[23] << 2) |
+                    ((bytes[24] & 0x0f) << 10)),
+        };
+    }
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x58) {
+        return {
+            width: 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)),
+            height: 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)),
+        };
+    }
+    return null;
+};
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if ((0, exports.matchesPattern)(webpPattern)(data.subarray(0, 4))) {
+        return {
+            type: 'webp',
+            dimensions: getWebPDimensions(data),
+        };
+    }
+    return null;
+};
+const getBmpDimensions = (bmpData) => {
+    if (bmpData.length < 26) {
+        return null;
+    }
+    const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+    return {
+        width: view.getUint32(18, true),
+        height: Math.abs(view.getInt32(22, true)),
+    };
+};
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    if ((0, exports.matchesPattern)(bmpPattern)(data.subarray(0, 2))) {
+        const bmp = getBmpDimensions(data);
+        return { dimensions: bmp, type: 'bmp' };
+    }
+    return null;
+};
+const isPdf = (data) => {
+    if (data.length < 4) {
+        return null;
+    }
+    const pdfPattern = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
+    return (0, exports.matchesPattern)(pdfPattern)(data.subarray(0, 4)) ? { type: 'pdf' } : null;
+};
+const detectFileType = (data) => {
+    if ((0, exports.isRiffWave)(data)) {
+        return { type: 'wav' };
+    }
+    if ((0, exports.isRiffAvi)(data)) {
+        return { type: 'riff' };
+    }
+    if ((0, exports.isAac)(data)) {
+        return { type: 'aac' };
+    }
+    if ((0, exports.isFlac)(data)) {
+        return { type: 'flac' };
+    }
+    if ((0, exports.isM3u)(data)) {
+        return { type: 'm3u' };
+    }
+    const webp = isWebp(data);
+    if (webp) {
+        return webp;
+    }
+    if ((0, exports.isWebm)(data)) {
+        return { type: 'webm' };
+    }
+    if ((0, exports.isIsoBaseMedia)(data)) {
+        return { type: 'iso-base-media' };
+    }
+    if ((0, exports.isTransportStream)(data)) {
+        return { type: 'transport-stream' };
+    }
+    if ((0, exports.isMp3)(data)) {
+        return { type: 'mp3' };
+    }
+    const gif = isGif(data);
+    if (gif) {
+        return gif;
+    }
+    const png = isPng(data);
+    if (png) {
+        return png;
+    }
+    const pdf = isPdf(data);
+    if (pdf) {
+        return pdf;
+    }
+    const bmp = isBmp(data);
+    if (bmp) {
+        return bmp;
+    }
+    const jpeg = isJpeg(data);
+    if (jpeg) {
+        return jpeg;
+    }
+    return { type: 'unknown' };
+};
+exports.detectFileType = detectFileType;

package/dist/helpers/get-folder-id.d.ts

@@ -0,0 +1,4 @@
+export declare const getFolderId: ({ folderName, parentName, }: {
+    folderName: string;
+    parentName: string | null;
+}) => string;

package/dist/helpers/get-folder-id.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderId = void 0;
+const getFolderId = ({ folderName, parentName, }) => {
+    return [parentName, folderName].filter(Boolean).join('/');
+};
+exports.getFolderId = getFolderId;

package/dist/helpers/get-timeline-sequence-sort-key.d.ts

@@ -4,12 +4,14 @@ export type SequenceNodePathInfo = {
     auxiliaryKeys: string[];
     index: number;
     numberOfSequencesWithThisNodePath: number;
+    supportsEffects: boolean;
 };
 type Track = {
     sequence: TSequence;
     depth: number;
     nodePathInfo: SequenceNodePathInfo | null;
     keyframeDisplayOffset: number;
+    sequenceFrameOffset: number;
 };
 export type TrackWithHash = Track & {
     hash: string;

package/dist/helpers/timeline-layout.js

@@ -15,7 +15,7 @@ exports.EXPANDED_SECTION_PADDING_RIGHT = 10;
 const buildTimelineTree = ({ sequence, nodePathInfo, getDragOverrides, getEffectDragOverrides, codeValues, }) => {
     var _a;
     const roots = [];
-    const { sequenceSubscriptionKey, index, auxiliaryKeys } = nodePathInfo;
+    const { sequenceSubscriptionKey, index, auxiliaryKeys, supportsEffects } = nodePathInfo;
     const controlFields = (0, studio_shared_1.getFieldsToShow)({
         schema: sequence.controls.schema,
         currentRuntimeValueDotNotation: sequence.controls.currentRuntimeValueDotNotation,
@@ -32,6 +32,7 @@ const buildTimelineTree = ({ sequence, nodePathInfo, getDragOverrides, getEffect
                     auxiliaryKeys: [...auxiliaryKeys, 'controls', f.key],
                     index,
                     numberOfSequencesWithThisNodePath: 0,
+                    supportsEffects,
                 },
                 label: (_a = f.description) !== null && _a !== void 0 ? _a : f.key,
                 field: f,
@@ -46,6 +47,7 @@ const buildTimelineTree = ({ sequence, nodePathInfo, getDragOverrides, getEffect
                 auxiliaryKeys: [...auxiliaryKeys, 'effects'],
                 index,
                 numberOfSequencesWithThisNodePath: 0,
+                supportsEffects,
             },
             label: 'Effects',
             effectInfo: null,
@@ -65,6 +67,7 @@ const buildTimelineTree = ({ sequence, nodePathInfo, getDragOverrides, getEffect
                         auxiliaryKeys: [...auxiliaryKeys, 'effects', i.toString()],
                         index,
                         numberOfSequencesWithThisNodePath: 0,
+                        supportsEffects,
                     },
                     label: effect.label,
                     effectInfo: {
@@ -86,6 +89,7 @@ const buildTimelineTree = ({ sequence, nodePathInfo, getDragOverrides, getEffect
                                 ],
                                 index,
                                 numberOfSequencesWithThisNodePath: 0,
+                                supportsEffects,
                             },
                             label: (_a = f.description) !== null && _a !== void 0 ? _a : f.key,
                             field: f,

package/dist/helpers/validate-folder-rename.d.ts

@@ -0,0 +1,6 @@
+export declare const validateFolderRename: ({ folders, newName, originalName, parentName, }: {
+    folders: import("remotion").TFolder[];
+    newName: string;
+    originalName: string;
+    parentName: string | null;
+}) => string | null;

package/dist/helpers/validate-folder-rename.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFolderRename = void 0;
+const remotion_1 = require("remotion");
+const validateFolderRename = ({ folders, newName, originalName, parentName, }) => {
+    if (!remotion_1.Internals.isFolderNameValid(newName)) {
+        return remotion_1.Internals.invalidFolderNameErrorMessage;
+    }
+    if (newName === originalName) {
+        return null;
+    }
+    if (folders.find((folder) => {
+        return folder.name === newName && folder.parent === parentName;
+    })) {
+        return `A folder with that name already exists.`;
+    }
+    return null;
+};
+exports.validateFolderRename = validateFolderRename;

package/dist/state/modals.d.ts

@@ -96,6 +96,16 @@ export type ModalState = {
 } | {
     type: 'rename-comp';
     compositionId: string;
+} | {
+    type: 'delete-folder';
+    folderName: string;
+    parentName: string | null;
+    stack: string | null;
+} | {
+    type: 'rename-folder';
+    folderName: string;
+    parentName: string | null;
+    stack: string | null;
 } | {
     type: 'input-props-override';
 } | RenderModalState | WebRenderModalState | {

package/dist/state/scale-lock.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { SequencePropsSubscriptionKey } from 'remotion';
+export type ScaleLockContextValue = {
+    readonly getScaleLockState: ({ defaultValue, fieldKey, nodePath }: {
+        readonly defaultValue: boolean;
+        readonly fieldKey: string;
+        readonly nodePath: SequencePropsSubscriptionKey;
+    }) => boolean;
+    readonly setScaleLockState: ({ fieldKey, linked, nodePath }: {
+        readonly fieldKey: string;
+        readonly linked: boolean;
+        readonly nodePath: SequencePropsSubscriptionKey;
+    }) => void;
+};
+export declare const ScaleLockContext: React.Context<ScaleLockContextValue>;
+export declare const ScaleLockProvider: React.FC<{
+    readonly children: React.ReactNode;
+}>;

package/dist/state/scale-lock.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleLockProvider = exports.ScaleLockContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importStar(require("react"));
+const remotion_1 = require("remotion");
+const makeScaleLockKey = ({ fieldKey, nodePath, }) => `${remotion_1.Internals.makeSequencePropsSubscriptionKey(nodePath)}.${fieldKey}`;
+exports.ScaleLockContext = react_1.default.createContext({
+    getScaleLockState: ({ defaultValue }) => defaultValue,
+    setScaleLockState: () => undefined,
+});
+const ScaleLockProvider = ({ children }) => {
+    const [states, setStates] = (0, react_1.useState)({});
+    const getScaleLockState = (0, react_1.useCallback)(({ defaultValue, fieldKey, nodePath }) => {
+        var _a;
+        const key = makeScaleLockKey({ fieldKey, nodePath });
+        return (_a = states[key]) !== null && _a !== void 0 ? _a : defaultValue;
+    }, [states]);
+    const setScaleLockState = (0, react_1.useCallback)(({ fieldKey, linked, nodePath }) => {
+        const key = makeScaleLockKey({ fieldKey, nodePath });
+        setStates((current) => ({ ...current, [key]: linked }));
+    }, []);
+    const value = (0, react_1.useMemo)(() => ({ getScaleLockState, setScaleLockState }), [getScaleLockState, setScaleLockState]);
+    return (jsx_runtime_1.jsx(exports.ScaleLockContext.Provider, { value: value, children: children }));
+};
+exports.ScaleLockProvider = ScaleLockProvider;

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/studio"
 	},
 	"name": "@remotion/studio",
-	"version": "4.0.471",
+	"version": "4.0.472",
 	"description": "APIs for interacting with the Remotion Studio",
 	"main": "dist",
 	"scripts": {
@@ -25,14 +25,14 @@
 	},
 	"dependencies": {
 		"semver": "7.5.3",
-		"remotion": "4.0.471",
-		"@remotion/player": "4.0.471",
-		"@remotion/media-utils": "4.0.471",
-		"@remotion/renderer": "4.0.471",
-		"@remotion/web-renderer": "4.0.471",
-		"@remotion/studio-shared": "4.0.471",
-		"@remotion/timeline-utils": "4.0.471",
-		"@remotion/zod-types": "4.0.471",
+		"remotion": "4.0.472",
+		"@remotion/player": "4.0.472",
+		"@remotion/media-utils": "4.0.472",
+		"@remotion/renderer": "4.0.472",
+		"@remotion/web-renderer": "4.0.472",
+		"@remotion/studio-shared": "4.0.472",
+		"@remotion/timeline-utils": "4.0.472",
+		"@remotion/zod-types": "4.0.472",
 		"@jridgewell/trace-mapping": "0.3.31",
 		"mediabunny": "1.45.0",
 		"memfs": "3.4.3",
@@ -43,7 +43,7 @@
 		"react": "19.2.3",
 		"react-dom": "19.2.3",
 		"@types/semver": "7.5.3",
-		"@remotion/eslint-config-internal": "4.0.471",
+		"@remotion/eslint-config-internal": "4.0.472",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},