@remotion/studio 4.0.520 → 4.0.521

package/dist/components/composition-selector-drag-data.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionSelectorDragDataToSymbolicatedStack = exports.parseCompositionSelectorDragData = exports.hasCompositionSelectorDragData = exports.makeCompositionSelectorDragData = void 0;
+const MIME_TYPE = 'application/remotion-composition-selector-reorder';
+const isSafeString = (value, maxLength) => {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= maxLength &&
+        !value.includes('\0'));
+};
+const isCompositionOrFolder = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const item = value;
+    if (item.type === 'composition') {
+        return isSafeString(item.compositionId, 500);
+    }
+    return (item.type === 'folder' &&
+        isSafeString(item.folderName, 500) &&
+        (item.parentName === null || isSafeString(item.parentName, 2000)));
+};
+const isSafeSourceFile = (value) => {
+    return (value === null ||
+        (isSafeString(value, 2000) &&
+            !value.includes('\\') &&
+            !value.startsWith('/') &&
+            !value.split('/').includes('..')));
+};
+const makeCompositionSelectorDragData = ({ item, sourceFile, }) => {
+    const data = {
+        type: 'remotion-composition-selector',
+        version: 1,
+        item,
+        sourceFile,
+    };
+    return { mimeType: MIME_TYPE, payload: JSON.stringify(data), data };
+};
+exports.makeCompositionSelectorDragData = makeCompositionSelectorDragData;
+const hasCompositionSelectorDragData = (mimeTypes) => {
+    return Array.from(mimeTypes).includes(MIME_TYPE);
+};
+exports.hasCompositionSelectorDragData = hasCompositionSelectorDragData;
+const parseCompositionSelectorDragData = (dataTransfer) => {
+    if (!(0, exports.hasCompositionSelectorDragData)(dataTransfer.types)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(dataTransfer.getData(MIME_TYPE));
+        if (parsed.type !== 'remotion-composition-selector' ||
+            parsed.version !== 1 ||
+            !isCompositionOrFolder(parsed.item) ||
+            !isSafeSourceFile(parsed.sourceFile)) {
+            return null;
+        }
+        return {
+            type: 'remotion-composition-selector',
+            version: 1,
+            item: parsed.item,
+            sourceFile: parsed.sourceFile,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.parseCompositionSelectorDragData = parseCompositionSelectorDragData;
+const compositionSelectorDragDataToSymbolicatedStack = (dragData) => {
+    if (dragData.sourceFile === null) {
+        return null;
+    }
+    return {
+        originalColumnNumber: null,
+        originalFileName: dragData.sourceFile,
+        originalFunctionName: null,
+        originalLineNumber: null,
+        originalScriptCode: null,
+    };
+};
+exports.compositionSelectorDragDataToSymbolicatedStack = compositionSelectorDragDataToSymbolicatedStack;

package/dist/components/import-assets.d.ts

@@ -77,8 +77,9 @@ export declare const getDurationInFrames: ({ durationInSeconds, fps, }: {
     durationInSeconds: number | null;
     fps: number;
 }) => number | null;
-export declare const pickFilesToImport: ({ multiple, }?: {
+export declare const pickFilesToImport: ({ multiple, accept, }?: {
     readonly multiple?: boolean | undefined;
+    readonly accept: string | null;
 }) => Promise<File[]>;
 export declare const importAssets: ({ compositionFile, compositionId, destinationDimensions, dropPosition, files, fps, from, preferCompositionStart, svgImportMode, }: {
     compositionFile: string;

package/dist/components/import-assets.js

@@ -425,11 +425,14 @@ const getAssetElementFromStaticAsset = async (assetPath) => {
     }
     return (0, exports.getAssetElementFromPath)(assetPath);
 };
-const pickFilesToImport = ({ multiple = true, } = {}) => {
+const pickFilesToImport = ({ multiple = true, accept, } = { accept: null }) => {
     return new Promise((resolve) => {
         const input = document.createElement('input');
         input.type = 'file';
         input.multiple = multiple;
+        if (accept !== null) {
+            input.accept = accept;
+        }
         input.style.display = 'none';
         let didResolve = false;
         const resolveOnce = (files) => {
@@ -480,6 +483,7 @@ const insertCompositionElement = async ({ compositionFile, compositionId, elemen
         (0, inserted_element_selection_1.requestInsertedElementSelection)({
             compositionId,
             nodePath: result.insertedNodePath,
+            notification: null,
         });
     }
     return true;
@@ -897,7 +901,13 @@ const insertElement = async ({ compositionFile, compositionId, element, expected
                 ? response.reason
                 : `Element file changed: ${response.conflict.filePath}`;
             (0, NotificationCenter_1.showNotification)(`Could not add Element: ${reason}`, 4000);
+            return;
         }
+        (0, inserted_element_selection_1.requestInsertedElementSelection)({
+            compositionId,
+            nodePath: null,
+            notification: `Installed ${element.displayName}`,
+        });
     }
     catch (error) {
         (0, NotificationCenter_1.showNotification)(`Could not add Element: ${error instanceof Error ? error.message : String(error)}`, 4000);

package/dist/components/parse-caption-file.d.ts

@@ -0,0 +1,5 @@
+import type { Caption } from '@remotion/captions';
+export declare const parseCaptionFile: ({ fileName, contents, }: {
+    fileName: string;
+    contents: string;
+}) => Caption[];

package/dist/components/parse-caption-file.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCaptionFile = void 0;
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const isFiniteNumber = (value) => {
+    return typeof value === 'number' && Number.isFinite(value);
+};
+const parseCaptionFile = ({ fileName, contents, }) => {
+    if (!fileName.toLowerCase().endsWith('.json')) {
+        throw new Error('Unsupported caption file. Choose a .json file.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error('Expected a Remotion Caption[] JSON array.');
+    }
+    let previousStart = null;
+    for (const [index, caption] of parsed.entries()) {
+        const path = `captions[${index}]`;
+        if (!isObject(caption)) {
+            throw new Error(`${path} must be an object.`);
+        }
+        if (typeof caption.text !== 'string') {
+            throw new Error(`${path}.text must be a string.`);
+        }
+        if (!isFiniteNumber(caption.startMs) || caption.startMs < 0) {
+            throw new Error(`${path}.startMs must be a finite, non-negative number.`);
+        }
+        if (!isFiniteNumber(caption.endMs) || caption.endMs < 0) {
+            throw new Error(`${path}.endMs must be a finite, non-negative number.`);
+        }
+        if (caption.endMs < caption.startMs) {
+            throw new Error(`${path}.endMs must not be earlier than startMs.`);
+        }
+        if (caption.timestampMs !== null && !isFiniteNumber(caption.timestampMs)) {
+            throw new Error(`${path}.timestampMs must be a finite number or null.`);
+        }
+        if (caption.confidence !== null && !isFiniteNumber(caption.confidence)) {
+            throw new Error(`${path}.confidence must be a finite number or null.`);
+        }
+        if (typeof caption.confidence === 'number' &&
+            (caption.confidence < 0 || caption.confidence > 1)) {
+            throw new Error(`${path}.confidence must be between 0 and 1.`);
+        }
+        if (caption.pageBreakAfter !== undefined &&
+            typeof caption.pageBreakAfter !== 'boolean') {
+            throw new Error(`${path}.pageBreakAfter must be a boolean when provided.`);
+        }
+        if (previousStart !== null && caption.startMs < previousStart) {
+            throw new Error(`${path}.startMs is out of timestamp order.`);
+        }
+        previousStart = caption.startMs;
+    }
+    return parsed;
+};
+exports.parseCaptionFile = parseCaptionFile;