remotion 4.0.514 → 4.0.516

package/dist/cjs/get-asset-file-name.js

@@ -2,9 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAssetDisplayName = void 0;
 const getAssetDisplayName = (filename) => {
-    if (/data:|blob:/.test(filename.substring(0, 5))) {
+    var _a;
+    if (filename.startsWith('data:')) {
         return 'Data URL';
     }
+    if (filename.startsWith('blob:')) {
+        const staticFile = typeof window === 'undefined'
+            ? undefined
+            : (_a = window.remotion_staticFiles) === null || _a === void 0 ? void 0 : _a.find((file) => file.src === filename);
+        return staticFile ? (0, exports.getAssetDisplayName)(staticFile.name) : 'Blob URL';
+    }
     const splitted = filename
         .split('/')
         .map((s) => s.split('\\'))

package/dist/cjs/input-props-serialization.d.ts

@@ -12,6 +12,7 @@ export declare const serializeJSONWithSpecialTypes: ({ data, indent, staticBase,
     indent: number | undefined;
     staticBase: string | null;
 }) => SerializedJSONWithCustomFields;
+export declare const resolveFileTokenToUrl: (value: string) => string;
 export declare const deserializeJSONWithSpecialTypes: <T = Record<string, unknown>>(data: string) => T;
 export declare const serializeThenDeserialize: (props: Record<string, unknown>) => Record<string, unknown>;
 export declare const serializeThenDeserializeInStudio: (props: Record<string, unknown>) => Record<string, unknown>;

package/dist/cjs/input-props-serialization.js

@@ -1,7 +1,7 @@
 "use strict";
 // Must keep this file in sync with the one in packages/lambda/src/shared/serialize-props.ts!
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeThenDeserializeInStudio = exports.serializeThenDeserialize = exports.deserializeJSONWithSpecialTypes = exports.serializeJSONWithSpecialTypes = exports.FILE_TOKEN = exports.DATE_TOKEN = void 0;
+exports.serializeThenDeserializeInStudio = exports.serializeThenDeserialize = exports.deserializeJSONWithSpecialTypes = exports.resolveFileTokenToUrl = exports.serializeJSONWithSpecialTypes = exports.FILE_TOKEN = exports.DATE_TOKEN = void 0;
 const get_remotion_environment_js_1 = require("./get-remotion-environment.js");
 exports.DATE_TOKEN = 'remotion-date:';
 exports.FILE_TOKEN = 'remotion-file:';
@@ -27,6 +27,7 @@ const serializeJSONWithSpecialTypes = ({ data, indent, staticBase, }) => {
             }
             if (typeof item === 'string' &&
                 staticBase !== null &&
+                staticBase !== '' &&
                 item.startsWith(staticBase)) {
                 customFileUsed = true;
                 return `${exports.FILE_TOKEN}${item.replace(staticBase + '/', '')}`;
@@ -41,13 +42,30 @@ const serializeJSONWithSpecialTypes = ({ data, indent, staticBase, }) => {
     }
 };
 exports.serializeJSONWithSpecialTypes = serializeJSONWithSpecialTypes;
+const resolveFileTokenToUrl = (value) => {
+    var _a;
+    const encodedName = value.replace(exports.FILE_TOKEN, '');
+    let name = encodedName;
+    try {
+        name = encodedName.split('/').map(decodeURIComponent).join('/');
+    }
+    catch (_b) {
+        // Keep the encoded name if it contains an invalid escape sequence.
+    }
+    const matchingStaticFile = (_a = window.remotion_staticFiles) === null || _a === void 0 ? void 0 : _a.find((file) => file.name === name);
+    if (matchingStaticFile) {
+        return matchingStaticFile.src;
+    }
+    return `${window.remotion_staticBase}/${encodedName}`;
+};
+exports.resolveFileTokenToUrl = resolveFileTokenToUrl;
 const deserializeJSONWithSpecialTypes = (data) => {
     return JSON.parse(data, (_, value) => {
         if (typeof value === 'string' && value.startsWith(exports.DATE_TOKEN)) {
             return new Date(value.replace(exports.DATE_TOKEN, ''));
         }
         if (typeof value === 'string' && value.startsWith(exports.FILE_TOKEN)) {
-            return `${window.remotion_staticBase}/${value.replace(exports.FILE_TOKEN, '')}`;
+            return (0, exports.resolveFileTokenToUrl)(value);
         }
         return value;
     });

package/dist/cjs/internals.d.ts

@@ -27,6 +27,15 @@ export type { EffectChainState } from './effects/run-effect-chain.js';
 export declare const Internals: {
     readonly AbsoluteFillElement: import("react").ForwardRefExoticComponent<Omit<import("./AbsoluteFillElement.js").AbsoluteFillElementProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
     readonly MaxMediaCacheSizeContext: import("react").Context<number | null>;
+    readonly getMediabunnyInputResourceKey: ({ src, credentials, requestInitFingerprint, revision, }: {
+        src: string;
+        credentials: RequestCredentials | null;
+        requestInitFingerprint: unknown;
+        revision: string | null;
+    }) => string;
+    readonly globalMediaResourceManager: import("./media-resource-manager.js").MediaResourceManager;
+    readonly makeMediaResourceManager: () => import("./media-resource-manager.js").MediaResourceManager;
+    readonly MEDIABUNNY_DURATION_VALUE_KEY: "mediabunny-duration";
     readonly makeRenderResourceManager: () => import("./render-resource-manager.js").RenderResourceManager;
     readonly RenderResourceManagerContext: import("react").Context<import("./render-resource-manager.js").RenderResourceManager | null>;
     readonly useUnsafeVideoConfig: () => import("./video-config.js").VideoConfig | null;

package/dist/cjs/internals.js

@@ -70,6 +70,7 @@ const is_player_js_1 = require("./is-player.js");
 const log_level_context_js_1 = require("./log-level-context.js");
 const log_js_1 = require("./log.js");
 const max_video_cache_size_js_1 = require("./max-video-cache-size.js");
+const media_resource_manager_js_1 = require("./media-resource-manager.js");
 const nonce_js_1 = require("./nonce.js");
 const playback_logging_js_1 = require("./playback-logging.js");
 const portal_node_js_1 = require("./portal-node.js");
@@ -126,6 +127,10 @@ const compositionSelectorRef = (0, react_1.createRef)();
 exports.Internals = {
     AbsoluteFillElement: AbsoluteFillElement_js_1.AbsoluteFillElement,
     MaxMediaCacheSizeContext: max_video_cache_size_js_1.MaxMediaCacheSizeContext,
+    getMediabunnyInputResourceKey: media_resource_manager_js_1.getMediabunnyInputResourceKey,
+    globalMediaResourceManager: media_resource_manager_js_1.globalMediaResourceManager,
+    makeMediaResourceManager: media_resource_manager_js_1.makeMediaResourceManager,
+    MEDIABUNNY_DURATION_VALUE_KEY: media_resource_manager_js_1.MEDIABUNNY_DURATION_VALUE_KEY,
     makeRenderResourceManager: render_resource_manager_js_1.makeRenderResourceManager,
     RenderResourceManagerContext: render_resource_manager_js_1.RenderResourceManagerContext,
     useUnsafeVideoConfig: use_unsafe_video_config_js_1.useUnsafeVideoConfig,

package/dist/cjs/interpolate-translate.d.ts

@@ -0,0 +1,8 @@
+import { type InterpolateOptions } from './interpolate.js';
+export type InterpolateTranslateOptions = InterpolateOptions;
+export declare const interpolateTranslate: (input: number, inputRange: readonly number[], outputRange: readonly string[], options?: Partial<{
+    easing: import("./interpolate.js").EasingFunction | readonly import("./interpolate.js").EasingFunction[];
+    extrapolateLeft: import("./interpolate.js").ExtrapolateType;
+    extrapolateRight: import("./interpolate.js").ExtrapolateType;
+    posterize: number;
+}> | undefined) => string;

package/dist/cjs/interpolate-translate.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateTranslate = void 0;
+const interpolate_js_1 = require("./interpolate.js");
+const pixelValueRegex = /^([+-]?(?:\d+\.?\d*|\.\d+))px$/;
+const parseTranslate = (value) => {
+    if (typeof value !== 'string') {
+        throw new TypeError(`outputRange must contain only strings, but got ${typeof value}`);
+    }
+    const parts = value.trim().split(/\s+/);
+    if (parts.length < 1 || parts.length > 3 || parts[0] === '') {
+        throw new TypeError(`translate values must contain 1 to 3 pixel values, but got "${value}"`);
+    }
+    return parts.map((part) => {
+        const match = pixelValueRegex.exec(part);
+        if (match === null) {
+            throw new TypeError(`interpolateTranslate() only supports px values, but got "${part}" in "${value}"`);
+        }
+        return Number(match[1]);
+    });
+};
+/*
+ * @description Allows you to map a range of values to CSS translate values using pixel units.
+ * @see [Documentation](https://remotion.dev/docs/interpolate-translate)
+ */
+const interpolateTranslate = (input, inputRange, outputRange, options) => {
+    var _a;
+    if (typeof input === 'undefined') {
+        throw new TypeError('input can not be undefined');
+    }
+    if (typeof inputRange === 'undefined') {
+        throw new TypeError('inputRange can not be undefined');
+    }
+    if (typeof outputRange === 'undefined') {
+        throw new TypeError('outputRange can not be undefined');
+    }
+    if (inputRange.length !== outputRange.length) {
+        throw new TypeError('inputRange (' +
+            inputRange.length +
+            ' values provided) and outputRange (' +
+            outputRange.length +
+            ' values provided) must have the same length');
+    }
+    const parsedOutputRange = outputRange.map((translateValue) => parseTranslate(translateValue));
+    const firstValueLength = (_a = parsedOutputRange[0]) === null || _a === void 0 ? void 0 : _a.length;
+    if (firstValueLength === undefined) {
+        throw new TypeError('outputRange must have at least 1 element');
+    }
+    for (const parsedTranslate of parsedOutputRange) {
+        if (parsedTranslate.length !== firstValueLength) {
+            throw new TypeError(`All translate values must have the same number of pixel values, but got ${firstValueLength} and ${parsedTranslate.length}`);
+        }
+    }
+    return new Array(firstValueLength)
+        .fill(true)
+        .map((_, index) => {
+        const outputValues = [];
+        for (const translateValue of parsedOutputRange) {
+            const value = translateValue[index];
+            if (value === undefined) {
+                throw new TypeError(`All translate values must have the same number of pixel values, but got ${firstValueLength} and ${translateValue.length}`);
+            }
+            outputValues.push(value);
+        }
+        const interpolatedValue = (0, interpolate_js_1.interpolate)(input, inputRange, outputValues, options);
+        return `${interpolatedValue}px`;
+    })
+        .join(' ');
+};
+exports.interpolateTranslate = interpolateTranslate;

package/dist/cjs/media-resource-manager.d.ts

@@ -0,0 +1,25 @@
+export type MediaResourceLease<T> = {
+    resource: T;
+    getOrCreateValue: <Value>(key: string, create: () => Value) => Value;
+    release: () => void;
+};
+export type MediaResourceManager = {
+    acquire: <T>({ key, create }: {
+        key: string;
+        create: () => {
+            resource: T;
+            dispose: () => void;
+        };
+    }) => MediaResourceLease<T>;
+    invalidate: (key: string) => void;
+    dispose: () => void;
+};
+export declare const makeMediaResourceManager: () => MediaResourceManager;
+export declare const getMediabunnyInputResourceKey: ({ src, credentials, requestInitFingerprint, revision, }: {
+    src: string;
+    credentials: RequestCredentials | null;
+    requestInitFingerprint: unknown;
+    revision: string | null;
+}) => string;
+export declare const MEDIABUNNY_DURATION_VALUE_KEY = "mediabunny-duration";
+export declare const globalMediaResourceManager: MediaResourceManager;

package/dist/cjs/media-resource-manager.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalMediaResourceManager = exports.MEDIABUNNY_DURATION_VALUE_KEY = exports.getMediabunnyInputResourceKey = exports.makeMediaResourceManager = void 0;
+const disposeResource = (resource) => {
+    if (resource.disposed) {
+        return;
+    }
+    resource.disposed = true;
+    resource.values.clear();
+    resource.dispose();
+};
+const makeMediaResourceManager = () => {
+    const resources = new Map();
+    let disposed = false;
+    return {
+        acquire: ({ key, create, }) => {
+            if (disposed) {
+                throw new Error('Media resource manager has already been disposed');
+            }
+            let entry = resources.get(key);
+            if (!entry) {
+                const created = create();
+                entry = {
+                    resource: created.resource,
+                    dispose: created.dispose,
+                    refCount: 0,
+                    disposeGeneration: 0,
+                    disposed: false,
+                    values: new Map(),
+                };
+                resources.set(key, entry);
+            }
+            entry.refCount++;
+            entry.disposeGeneration++;
+            let released = false;
+            return {
+                resource: entry.resource,
+                getOrCreateValue: (valueKey, createValue) => {
+                    if (entry.values.has(valueKey)) {
+                        return entry.values.get(valueKey);
+                    }
+                    const value = createValue();
+                    entry.values.set(valueKey, value);
+                    return value;
+                },
+                release: () => {
+                    if (released) {
+                        return;
+                    }
+                    released = true;
+                    entry.refCount--;
+                    if (entry.refCount !== 0) {
+                        return;
+                    }
+                    const disposeGeneration = ++entry.disposeGeneration;
+                    queueMicrotask(() => {
+                        if (entry.refCount !== 0 ||
+                            entry.disposeGeneration !== disposeGeneration) {
+                            return;
+                        }
+                        if (resources.get(key) === entry) {
+                            resources.delete(key);
+                        }
+                        disposeResource(entry);
+                    });
+                },
+            };
+        },
+        invalidate: (key) => {
+            const entry = resources.get(key);
+            if (!entry) {
+                return;
+            }
+            resources.delete(key);
+            entry.disposeGeneration++;
+            if (entry.refCount === 0) {
+                disposeResource(entry);
+            }
+        },
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            const entries = Array.from(resources.values());
+            resources.clear();
+            let firstError = null;
+            for (const entry of entries) {
+                try {
+                    disposeResource(entry);
+                }
+                catch (error) {
+                    firstError !== null && firstError !== void 0 ? firstError : (firstError = error);
+                }
+            }
+            if (firstError !== null) {
+                throw firstError;
+            }
+        },
+    };
+};
+exports.makeMediaResourceManager = makeMediaResourceManager;
+const getMediabunnyInputResourceKey = ({ src, credentials, requestInitFingerprint, revision, }) => JSON.stringify([
+    'mediabunny-input',
+    src,
+    credentials,
+    requestInitFingerprint,
+    revision,
+]);
+exports.getMediabunnyInputResourceKey = getMediabunnyInputResourceKey;
+exports.MEDIABUNNY_DURATION_VALUE_KEY = 'mediabunny-duration';
+exports.globalMediaResourceManager = (0, exports.makeMediaResourceManager)();