@remotion/studio-shared 4.0.472 → 4.0.474

package/dist/optimistic-move-keyframe.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticMoveEffectKeyframes = exports.optimisticMoveSequenceKeyframes = exports.canMoveKeyframesWithoutCollisions = void 0;
+const getMoveMap = (moves) => {
+    const moveMap = new Map();
+    for (const move of moves) {
+        if (move.fromFrame === move.toFrame) {
+            continue;
+        }
+        if (moveMap.has(move.fromFrame)) {
+            return null;
+        }
+        moveMap.set(move.fromFrame, move.toFrame);
+    }
+    return moveMap;
+};
+const canMoveKeyframesWithoutCollisions = ({ status, moves, }) => {
+    var _a;
+    if (status.status !== 'keyframed') {
+        return false;
+    }
+    const moveMap = getMoveMap(moves);
+    if (moveMap === null) {
+        return false;
+    }
+    if (moveMap.size === 0) {
+        return true;
+    }
+    const frames = new Set(status.keyframes.map((keyframe) => keyframe.frame));
+    for (const fromFrame of moveMap.keys()) {
+        if (!frames.has(fromFrame)) {
+            return false;
+        }
+    }
+    const nextFrames = new Set();
+    for (const keyframe of status.keyframes) {
+        const frame = (_a = moveMap.get(keyframe.frame)) !== null && _a !== void 0 ? _a : keyframe.frame;
+        if (nextFrames.has(frame)) {
+            return false;
+        }
+        nextFrames.add(frame);
+    }
+    return true;
+};
+exports.canMoveKeyframesWithoutCollisions = canMoveKeyframesWithoutCollisions;
+const moveKeyframesInPropStatus = ({ status, moves, }) => {
+    if (status.status !== 'keyframed') {
+        return status;
+    }
+    if (!(0, exports.canMoveKeyframesWithoutCollisions)({ status, moves })) {
+        return status;
+    }
+    const moveMap = getMoveMap(moves);
+    if (moveMap === null) {
+        return status;
+    }
+    if (moveMap.size === 0) {
+        return status;
+    }
+    return {
+        ...status,
+        keyframes: status.keyframes
+            .map((keyframe) => {
+            var _a;
+            return ({
+                ...keyframe,
+                frame: (_a = moveMap.get(keyframe.frame)) !== null && _a !== void 0 ? _a : keyframe.frame,
+            });
+        })
+            .sort((a, b) => a.frame - b.frame),
+    };
+};
+const optimisticMoveSequenceKeyframes = ({ previous, keyframes, }) => {
+    var _a;
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const movesByField = new Map();
+    for (const keyframe of keyframes) {
+        const moves = (_a = movesByField.get(keyframe.fieldKey)) !== null && _a !== void 0 ? _a : [];
+        moves.push(keyframe);
+        movesByField.set(keyframe.fieldKey, moves);
+    }
+    const props = { ...previous.props };
+    for (const [fieldKey, moves] of movesByField) {
+        const status = props[fieldKey];
+        if (!status) {
+            continue;
+        }
+        props[fieldKey] = moveKeyframesInPropStatus({ status, moves });
+    }
+    return {
+        ...previous,
+        props,
+    };
+};
+exports.optimisticMoveSequenceKeyframes = optimisticMoveSequenceKeyframes;
+const optimisticMoveEffectKeyframes = ({ previous, keyframes, }) => {
+    var _a;
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const movesByEffect = new Map();
+    for (const keyframe of keyframes) {
+        const moves = (_a = movesByEffect.get(keyframe.effectIndex)) !== null && _a !== void 0 ? _a : [];
+        moves.push(keyframe);
+        movesByEffect.set(keyframe.effectIndex, moves);
+    }
+    const effects = previous.effects.map((effect) => {
+        var _a;
+        if (!effect.canUpdate) {
+            return effect;
+        }
+        const movesForEffect = movesByEffect.get(effect.effectIndex);
+        if (!movesForEffect) {
+            return effect;
+        }
+        const props = { ...effect.props };
+        const movesByField = new Map();
+        for (const move of movesForEffect) {
+            const moves = (_a = movesByField.get(move.fieldKey)) !== null && _a !== void 0 ? _a : [];
+            moves.push(move);
+            movesByField.set(move.fieldKey, moves);
+        }
+        for (const [fieldKey, moves] of movesByField) {
+            const status = props[fieldKey];
+            if (!status) {
+                continue;
+            }
+            props[fieldKey] = moveKeyframesInPropStatus({ status, moves });
+        }
+        return {
+            ...effect,
+            props,
+        };
+    });
+    return {
+        ...previous,
+        effects,
+    };
+};
+exports.optimisticMoveEffectKeyframes = optimisticMoveEffectKeyframes;

package/dist/optimistic-update-for-effect-prop-statuses.d.ts

@@ -0,0 +1,8 @@
+import { type CanUpdateSequencePropsResponse, type SequenceSchema } from 'remotion';
+export declare const optimisticUpdateForEffectPropStatuses: ({ previous, effectIndex, fieldKey, value, schema, }: {
+    previous: CanUpdateSequencePropsResponse;
+    effectIndex: number;
+    fieldKey: string;
+    value: unknown;
+    schema: SequenceSchema;
+}) => CanUpdateSequencePropsResponse;

package/dist/optimistic-update-for-effect-prop-statuses.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticUpdateForEffectPropStatuses = void 0;
+const no_react_1 = require("remotion/no-react");
+const optimisticUpdateForEffectPropStatuses = ({ previous, effectIndex, fieldKey, value, schema, }) => {
+    var _a;
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const targetIndex = previous.effects.findIndex((e) => e.effectIndex === effectIndex);
+    if (targetIndex === -1) {
+        return previous;
+    }
+    const target = previous.effects[targetIndex];
+    if (!target.canUpdate) {
+        return previous;
+    }
+    const props = {
+        ...target.props,
+        [fieldKey]: { status: 'static', codeValue: value },
+    };
+    if (((_a = schema[fieldKey]) === null || _a === void 0 ? void 0 : _a.type) === 'enum') {
+        const propsToDelete = no_react_1.NoReactInternals.findPropsToDelete({
+            schema,
+            key: fieldKey,
+            value,
+        });
+        for (const propToDelete of propsToDelete) {
+            delete props[propToDelete];
+        }
+    }
+    const updatedEffect = {
+        ...target,
+        props,
+    };
+    const effects = [...previous.effects];
+    effects[targetIndex] = updatedEffect;
+    return {
+        ...previous,
+        effects,
+    };
+};
+exports.optimisticUpdateForEffectPropStatuses = optimisticUpdateForEffectPropStatuses;

package/dist/optimistic-update-for-prop-statuses.d.ts

@@ -0,0 +1,7 @@
+import { type CanUpdateSequencePropsResponse, type SequenceSchema } from 'remotion';
+export declare const optimisticUpdateForPropStatuses: ({ previous, fieldKey, value, schema, }: {
+    previous: CanUpdateSequencePropsResponse;
+    fieldKey: string;
+    value: unknown;
+    schema: SequenceSchema;
+}) => CanUpdateSequencePropsResponse;

package/dist/optimistic-update-for-prop-statuses.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticUpdateForPropStatuses = void 0;
+const no_react_1 = require("remotion/no-react");
+const optimisticUpdateForPropStatuses = ({ previous, fieldKey, value, schema, }) => {
+    var _a;
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const props = {
+        ...previous.props,
+        [fieldKey]: { status: 'static', codeValue: value },
+    };
+    if (((_a = schema[fieldKey]) === null || _a === void 0 ? void 0 : _a.type) === 'enum') {
+        const propsToDelete = no_react_1.NoReactInternals.findPropsToDelete({
+            schema,
+            key: fieldKey,
+            value,
+        });
+        for (const propToDelete of propsToDelete) {
+            delete props[propToDelete];
+        }
+    }
+    return {
+        canUpdate: true,
+        props,
+        effects: previous.effects,
+    };
+};
+exports.optimisticUpdateForPropStatuses = optimisticUpdateForPropStatuses;

package/dist/optimistic-update-keyframe-settings.d.ts

@@ -0,0 +1,13 @@
+import type { CanUpdateSequencePropsResponse } from 'remotion';
+import type { KeyframeSettings } from './api-requests';
+export declare const optimisticUpdateSequenceKeyframeSettings: ({ previous, fieldKey, settings, }: {
+    previous: CanUpdateSequencePropsResponse;
+    fieldKey: string;
+    settings: KeyframeSettings;
+}) => CanUpdateSequencePropsResponse;
+export declare const optimisticUpdateEffectKeyframeSettings: ({ previous, effectIndex, fieldKey, settings, }: {
+    previous: CanUpdateSequencePropsResponse;
+    effectIndex: number;
+    fieldKey: string;
+    settings: KeyframeSettings;
+}) => CanUpdateSequencePropsResponse;

package/dist/optimistic-update-keyframe-settings.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticUpdateEffectKeyframeSettings = exports.optimisticUpdateSequenceKeyframeSettings = void 0;
+const applySettingsToStatus = (status, settings) => {
+    if (!status || status.status !== 'keyframed') {
+        throw new Error('Expected keyframed status');
+    }
+    return {
+        ...status,
+        ...(settings.clamping ? { clamping: settings.clamping } : {}),
+        posterize: settings.posterize,
+    };
+};
+const optimisticUpdateSequenceKeyframeSettings = ({ previous, fieldKey, settings, }) => {
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const status = previous.props[fieldKey];
+    if (!status || status.status !== 'keyframed') {
+        return previous;
+    }
+    return {
+        ...previous,
+        props: {
+            ...previous.props,
+            [fieldKey]: applySettingsToStatus(status, settings),
+        },
+    };
+};
+exports.optimisticUpdateSequenceKeyframeSettings = optimisticUpdateSequenceKeyframeSettings;
+const optimisticUpdateEffectKeyframeSettings = ({ previous, effectIndex, fieldKey, settings, }) => {
+    if (!previous.canUpdate) {
+        return previous;
+    }
+    const targetIndex = previous.effects.findIndex((effect) => effect.effectIndex === effectIndex);
+    if (targetIndex === -1) {
+        return previous;
+    }
+    const target = previous.effects[targetIndex];
+    if (!target.canUpdate) {
+        return previous;
+    }
+    const status = target.props[fieldKey];
+    if (!status || status.status !== 'keyframed') {
+        return previous;
+    }
+    const effects = [...previous.effects];
+    effects[targetIndex] = {
+        ...target,
+        props: {
+            ...target.props,
+            [fieldKey]: applySettingsToStatus(status, settings),
+        },
+    };
+    return {
+        ...previous,
+        effects,
+    };
+};
+exports.optimisticUpdateEffectKeyframeSettings = optimisticUpdateEffectKeyframeSettings;

package/dist/required-package.d.ts

@@ -0,0 +1,4 @@
+import type { InsertableCompositionElement } from './api-requests';
+export declare const getRequiredPackageForImportPath: (importPath: string) => string | null;
+export declare const getRequiredPackageForInsertableElement: (element: InsertableCompositionElement) => string | null;
+export declare const getRequiredPackageForEffectImportPath: (importPath: string) => string | null;

package/dist/required-package.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequiredPackageForEffectImportPath = exports.getRequiredPackageForInsertableElement = exports.getRequiredPackageForImportPath = void 0;
+const getRequiredPackageForImportPath = (importPath) => {
+    if (importPath === 'remotion' || importPath.startsWith('.')) {
+        return null;
+    }
+    if (importPath.startsWith('@')) {
+        const [scope, scopedPackageName] = importPath.split('/');
+        return scope && scopedPackageName ? `${scope}/${scopedPackageName}` : null;
+    }
+    const [packageName] = importPath.split('/');
+    return packageName || null;
+};
+exports.getRequiredPackageForImportPath = getRequiredPackageForImportPath;
+const getRequiredPackageForInsertableElement = (element) => {
+    if (element.type === 'solid') {
+        return null;
+    }
+    if (element.type === 'component') {
+        return (0, exports.getRequiredPackageForImportPath)(element.importPath);
+    }
+    if (element.assetType === 'video' || element.assetType === 'audio') {
+        return '@remotion/media';
+    }
+    if (element.assetType === 'gif') {
+        return '@remotion/gif';
+    }
+    return null;
+};
+exports.getRequiredPackageForInsertableElement = getRequiredPackageForInsertableElement;
+const getRequiredPackageForEffectImportPath = (importPath) => {
+    if (importPath.startsWith('@remotion/effects/')) {
+        return '@remotion/effects';
+    }
+    if (importPath === '@remotion/light-leaks' ||
+        importPath === '@remotion/starburst') {
+        return importPath;
+    }
+    return null;
+};
+exports.getRequiredPackageForEffectImportPath = getRequiredPackageForEffectImportPath;

package/dist/schema-field-info.d.ts

@@ -1,5 +1,5 @@
-import type { CodeValues, DragOverrides, EffectDefinition, GetDragOverrides, GetEffectDragOverrides, SequenceControls, SequencePropsSubscriptionKey, SequenceSchema, VisibleFieldSchema } from 'remotion';
-export type { CodeValues, DragOverrides, SequenceControls };
+import type { DragOverrides, EffectDefinition, GetDragOverrides, GetEffectDragOverrides, PropStatuses, SequenceControls, SequencePropsSubscriptionKey, SequenceSchema, VisibleFieldSchema } from 'remotion';
+export type { DragOverrides, PropStatuses, SequenceControls };
 export type SchemaFieldInfo = {
     key: string;
     description: string | undefined;
@@ -19,17 +19,17 @@ export type AnySchemaFieldInfo = SequenceSchemaFieldInfo | EffectSchemaFieldInfo
 export declare const SCHEMA_FIELD_ROW_HEIGHT = 22;
 declare const SUPPORTED_SCHEMA_TYPES: readonly ["number", "boolean", "rotation-css", "rotation-degrees", "translate", "scale", "uv-coordinate", "color", "array", "enum", "hidden"];
 type SupportedSchemaType = (typeof SUPPORTED_SCHEMA_TYPES)[number];
-export declare const getFieldsToShow: ({ getDragOverrides, codeValues, nodePath, schema, currentRuntimeValueDotNotation, }: {
+export declare const getFieldsToShow: ({ getDragOverrides, propStatuses, nodePath, schema, currentRuntimeValueDotNotation, }: {
     schema: SequenceSchema;
     currentRuntimeValueDotNotation: Record<string, unknown>;
     getDragOverrides: GetDragOverrides;
-    codeValues: CodeValues;
+    propStatuses: PropStatuses;
     nodePath: SequencePropsSubscriptionKey;
 }) => SequenceSchemaFieldInfo[] | null;
-export declare const getEffectFieldsToShow: ({ effect, effectIndex, nodePath, codeValues, getEffectDragOverrides, }: {
+export declare const getEffectFieldsToShow: ({ effect, effectIndex, nodePath, propStatuses, getEffectDragOverrides, }: {
     effect: EffectDefinition<unknown>;
     effectIndex: number;
     nodePath: SequencePropsSubscriptionKey | null;
-    codeValues: CodeValues;
+    propStatuses: PropStatuses;
     getEffectDragOverrides: GetEffectDragOverrides;
 }) => EffectSchemaFieldInfo[];

package/dist/schema-field-info.js

@@ -50,12 +50,12 @@ const getEffectFieldValue = ({ key, dragOverrides, effectStatus, }) => {
     }
     return propStatus.codeValue;
 };
-const getFieldsToShow = ({ getDragOverrides, codeValues, nodePath, schema, currentRuntimeValueDotNotation, }) => {
+const getFieldsToShow = ({ getDragOverrides, propStatuses, nodePath, schema, currentRuntimeValueDotNotation, }) => {
     const { merged: valuesDotNotation } = remotion_1.Internals.computeEffectiveSchemaValuesDotNotation({
         schema,
         currentValue: currentRuntimeValueDotNotation,
         overrideValues: getDragOverrides(nodePath),
-        propStatus: remotion_1.Internals.getCodeValuesCtx(codeValues, nodePath),
+        propStatus: remotion_1.Internals.getPropStatusesCtx(propStatuses, nodePath),
         frame: null,
     });
     const activeSchema = remotion_1.Internals.flattenActiveSchema(schema, (key) => valuesDotNotation[key]);
@@ -91,11 +91,11 @@ const getFieldsToShow = ({ getDragOverrides, codeValues, nodePath, schema, curre
         .filter(no_react_1.NoReactInternals.truthy);
 };
 exports.getFieldsToShow = getFieldsToShow;
-const getEffectFieldsToShow = ({ effect, effectIndex, nodePath, codeValues, getEffectDragOverrides, }) => {
+const getEffectFieldsToShow = ({ effect, effectIndex, nodePath, propStatuses, getEffectDragOverrides, }) => {
     const effectStatus = nodePath === null
         ? null
-        : remotion_1.Internals.getEffectCodeValuesCtx({
-            codeValues,
+        : remotion_1.Internals.getEffectPropStatusesCtx({
+            propStatuses,
             nodePath,
             effectIndex,
         });

package/dist/sfx-drag-data.d.ts

@@ -0,0 +1,10 @@
+export declare const SFX_DRAG_MIME_TYPE = "application/vnd.remotion.sfx+json";
+export type SfxDragData = {
+    type: 'remotion-sfx';
+    version: 1;
+    sfx: {
+        name: string;
+        url: string;
+    };
+};
+export declare const parseSfxDragData: (value: string) => SfxDragData | null;

package/dist/sfx-drag-data.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSfxDragData = exports.SFX_DRAG_MIME_TYPE = void 0;
+const url_1 = require("./url");
+exports.SFX_DRAG_MIME_TYPE = 'application/vnd.remotion.sfx+json';
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const parseSfxDragData = (value) => {
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed)) {
+            return null;
+        }
+        if (parsed.type !== 'remotion-sfx' || parsed.version !== 1) {
+            return null;
+        }
+        if (!isRecord(parsed.sfx)) {
+            return null;
+        }
+        const { name, url } = parsed.sfx;
+        if (typeof name !== 'string' ||
+            name.length === 0 ||
+            typeof url !== 'string' ||
+            !(0, url_1.isUrl)(url)) {
+            return null;
+        }
+        return {
+            type: 'remotion-sfx',
+            version: 1,
+            sfx: {
+                name,
+                url,
+            },
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.parseSfxDragData = parseSfxDragData;

package/dist/url.d.ts

@@ -0,0 +1 @@
+export declare const isUrl: (value: string) => boolean;

package/dist/url.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUrl = void 0;
+const isUrl = (value) => {
+    try {
+        const parsed = new URL(value);
+        return parsed.href.length > 0;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.isUrl = isUrl;

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/studio-shared"
 	},
 	"name": "@remotion/studio-shared",
-	"version": "4.0.472",
+	"version": "4.0.474",
 	"description": "Internal package for shared objects between the Studio backend and frontend",
 	"main": "dist",
 	"scripts": {
@@ -20,11 +20,11 @@
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"remotion": "4.0.472"
+		"remotion": "4.0.474"
 	},
 	"devDependencies": {
-		"@remotion/renderer": "4.0.472",
-		"@remotion/eslint-config-internal": "4.0.472",
+		"@remotion/renderer": "4.0.474",
+		"@remotion/eslint-config-internal": "4.0.474",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},