@remotion/player 3.3.55 → 3.3.56

package/dist/esm/utils/calculate-player-size.js

@@ -1,24 +0,0 @@
-export const calculatePlayerSize = ({ currentSize, width, height, compositionWidth, compositionHeight, }) => {
-    if (width !== undefined && height === undefined) {
-        return {
-            aspectRatio: [compositionWidth, compositionHeight].join('/'),
-        };
-    }
-    // Opposite: If has height specified, evaluate the height and specify a default width.
-    if (height !== undefined && width === undefined) {
-        return {
-            // Aspect ratio CSS prop will work
-            aspectRatio: [compositionWidth, compositionHeight].join('/'),
-        };
-    }
-    if (!currentSize) {
-        return {
-            width: compositionWidth,
-            height: compositionHeight,
-        };
-    }
-    return {
-        width: compositionWidth,
-        height: compositionHeight,
-    };
-};

package/dist/esm/utils/cancellable-promise.js

@@ -1,22 +0,0 @@
-export const cancellablePromise = (promise) => {
-    let isCanceled = false;
-    const wrappedPromise = new Promise((resolve, reject) => {
-        promise
-            .then((value) => {
-            if (isCanceled) {
-                reject({ isCanceled, value });
-                return;
-            }
-            resolve(value);
-        })
-            .catch((error) => {
-            reject({ isCanceled, error });
-        });
-    });
-    return {
-        promise: wrappedPromise,
-        cancel: () => {
-            isCanceled = true;
-        },
-    };
-};

package/dist/esm/utils/delay.js

@@ -1,2 +0,0 @@
-/* eslint-disable no-promise-executor-return */
-export const delay = (n) => new Promise((resolve) => setTimeout(resolve, n));

package/dist/esm/utils/is-node.js

@@ -1 +0,0 @@
-export const IS_NODE = typeof document === 'undefined';

package/dist/esm/utils/preview-size.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils/props-if-has-props.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils/use-cancellable-promises.js

@@ -1,18 +0,0 @@
-import { useCallback, useMemo, useRef } from 'react';
-const useCancellablePromises = () => {
-    const pendingPromises = useRef([]);
-    const appendPendingPromise = useCallback((promise) => {
-        pendingPromises.current = [...pendingPromises.current, promise];
-    }, []);
-    const removePendingPromise = useCallback((promise) => {
-        pendingPromises.current = pendingPromises.current.filter((p) => p !== promise);
-    }, []);
-    const clearPendingPromises = useCallback(() => pendingPromises.current.map((p) => p.cancel()), []);
-    const api = useMemo(() => ({
-        appendPendingPromise,
-        removePendingPromise,
-        clearPendingPromises,
-    }), [appendPendingPromise, clearPendingPromises, removePendingPromise]);
-    return api;
-};
-export { useCancellablePromises };

package/dist/esm/utils/use-click-prevention-on-double-click.js

@@ -1,42 +0,0 @@
-import { useCallback, useMemo } from 'react';
-import { cancellablePromise } from './cancellable-promise.js';
-import { delay } from './delay.js';
-import { useCancellablePromises } from './use-cancellable-promises.js';
-const useClickPreventionOnDoubleClick = (onClick, onDoubleClick, doubleClickToFullscreen) => {
-    const api = useCancellablePromises();
-    const handleClick = useCallback(async (e) => {
-        api.clearPendingPromises();
-        const waitForClick = cancellablePromise(delay(200));
-        api.appendPendingPromise(waitForClick);
-        try {
-            await waitForClick.promise;
-            api.removePendingPromise(waitForClick);
-            onClick(e);
-        }
-        catch (errorInfo) {
-            const info = errorInfo;
-            api.removePendingPromise(waitForClick);
-            if (!info.isCanceled) {
-                throw info.error;
-            }
-        }
-    }, [api, onClick]);
-    const handleDoubleClick = useCallback(() => {
-        api.clearPendingPromises();
-        onDoubleClick();
-    }, [api, onDoubleClick]);
-    const returnValue = useMemo(() => {
-        if (!doubleClickToFullscreen) {
-            return [onClick, onDoubleClick];
-        }
-        return [handleClick, handleDoubleClick];
-    }, [
-        doubleClickToFullscreen,
-        handleClick,
-        handleDoubleClick,
-        onClick,
-        onDoubleClick,
-    ]);
-    return returnValue;
-};
-export { useClickPreventionOnDoubleClick };

package/dist/esm/utils/use-element-size.js

@@ -1,93 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-let elementSizeHooks = [];
-export const updateAllElementsSizes = () => {
-    for (const listener of elementSizeHooks) {
-        listener();
-    }
-};
-export const useElementSize = (ref, options) => {
-    const [size, setSize] = useState(null);
-    const observer = useMemo(() => {
-        if (typeof ResizeObserver === 'undefined') {
-            return null;
-        }
-        return new ResizeObserver((entries) => {
-            // The contentRect returns the width without any `scale()`'s being applied. The height is wrong
-            const { contentRect } = entries[0];
-            // The clientRect returns the size with `scale()` being applied.
-            const newSize = entries[0].target.getClientRects();
-            if (!newSize || !newSize[0]) {
-                setSize(null);
-                return;
-            }
-            const probableCssParentScale = newSize[0].width / contentRect.width;
-            const width = options.shouldApplyCssTransforms
-                ? newSize[0].width
-                : newSize[0].width * (1 / probableCssParentScale);
-            const height = options.shouldApplyCssTransforms
-                ? newSize[0].height
-                : newSize[0].height * (1 / probableCssParentScale);
-            setSize({
-                width,
-                height,
-                left: newSize[0].x,
-                top: newSize[0].y,
-                windowSize: {
-                    height: window.innerHeight,
-                    width: window.innerWidth,
-                },
-            });
-        });
-    }, [options.shouldApplyCssTransforms]);
-    const updateSize = useCallback(() => {
-        if (!ref.current) {
-            return;
-        }
-        const rect = ref.current.getClientRects();
-        if (!rect[0]) {
-            setSize(null);
-            return;
-        }
-        setSize({
-            width: rect[0].width,
-            height: rect[0].height,
-            left: rect[0].x,
-            top: rect[0].y,
-            windowSize: {
-                height: window.innerHeight,
-                width: window.innerWidth,
-            },
-        });
-    }, [ref]);
-    useEffect(() => {
-        if (!observer) {
-            return;
-        }
-        updateSize();
-        const { current } = ref;
-        if (ref.current) {
-            observer.observe(ref.current);
-        }
-        return () => {
-            if (current) {
-                observer.unobserve(current);
-            }
-        };
-    }, [observer, ref, updateSize]);
-    useEffect(() => {
-        if (!options.triggerOnWindowResize) {
-            return;
-        }
-        window.addEventListener('resize', updateSize);
-        return () => {
-            window.removeEventListener('resize', updateSize);
-        };
-    }, [options.triggerOnWindowResize, updateSize]);
-    useEffect(() => {
-        elementSizeHooks.push(updateSize);
-        return () => {
-            elementSizeHooks = elementSizeHooks.filter((e) => e !== updateSize);
-        };
-    }, [updateSize]);
-    return size ? { ...size, refresh: updateSize } : null;
-};

package/dist/esm/utils/validate-in-out-frame.js

@@ -1,49 +0,0 @@
-export const validateSingleFrame = (frame, variableName) => {
-    if (typeof frame === 'undefined' || frame === null) {
-        return frame !== null && frame !== void 0 ? frame : null;
-    }
-    if (typeof frame !== 'number') {
-        throw new TypeError(`"${variableName}" must be a number, but is ${JSON.stringify(frame)}`);
-    }
-    if (Number.isNaN(frame)) {
-        throw new TypeError(`"${variableName}" must not be NaN, but is ${JSON.stringify(frame)}`);
-    }
-    if (!Number.isFinite(frame)) {
-        throw new TypeError(`"${variableName}" must be finite, but is ${JSON.stringify(frame)}`);
-    }
-    if (frame % 1 !== 0) {
-        throw new TypeError(`"${variableName}" must be an integer, but is ${JSON.stringify(frame)}`);
-    }
-    return frame;
-};
-export const validateInOutFrames = ({ inFrame, durationInFrames, outFrame, }) => {
-    const validatedInFrame = validateSingleFrame(inFrame, 'inFrame');
-    const validatedOutFrame = validateSingleFrame(outFrame, 'outFrame');
-    if (validatedInFrame === null && validatedOutFrame === null) {
-        return;
-    }
-    // Must not be over the duration
-    if (validatedInFrame !== null && validatedInFrame > durationInFrames - 1) {
-        throw new Error('inFrame must be less than (durationInFrames - 1), but is ' +
-            validatedInFrame);
-    }
-    if (validatedOutFrame !== null && validatedOutFrame > durationInFrames - 1) {
-        throw new Error('outFrame must be less than (durationInFrames - 1), but is ' +
-            validatedOutFrame);
-    }
-    // Must not be under 0
-    if (validatedInFrame !== null && validatedInFrame < 0) {
-        throw new Error('inFrame must be greater than 0, but is ' + validatedInFrame);
-    }
-    if (validatedOutFrame !== null && validatedOutFrame <= 0) {
-        throw new Error(`outFrame must be greater than 0, but is ${validatedOutFrame}. If you want to render a single frame, use <Thumbnail /> instead.`);
-    }
-    if (validatedOutFrame !== null &&
-        validatedInFrame !== null &&
-        validatedOutFrame <= validatedInFrame) {
-        throw new Error('outFrame must be greater than inFrame, but is ' +
-            validatedOutFrame +
-            ' <= ' +
-            validatedInFrame);
-    }
-};

package/dist/esm/utils/validate-initial-frame.js

@@ -1,23 +0,0 @@
-export const validateInitialFrame = ({ initialFrame, durationInFrames, }) => {
-    if (typeof durationInFrames !== 'number') {
-        throw new Error(`\`durationInFrames\` must be a number, but is ${JSON.stringify(durationInFrames)}`);
-    }
-    if (typeof initialFrame === 'undefined') {
-        return;
-    }
-    if (typeof initialFrame !== 'number') {
-        throw new Error(`\`initialFrame\` must be a number, but is ${JSON.stringify(initialFrame)}`);
-    }
-    if (Number.isNaN(initialFrame)) {
-        throw new Error(`\`initialFrame\` must be a number, but is NaN`);
-    }
-    if (!Number.isFinite(initialFrame)) {
-        throw new Error(`\`initialFrame\` must be a number, but is Infinity`);
-    }
-    if (initialFrame % 1 !== 0) {
-        throw new Error(`\`initialFrame\` must be an integer, but is ${JSON.stringify(initialFrame)}`);
-    }
-    if (initialFrame > durationInFrames - 1) {
-        throw new Error(`\`initialFrame\` must be less or equal than \`durationInFrames - 1\`, but is ${JSON.stringify(initialFrame)}`);
-    }
-};

package/dist/esm/utils/validate-playbackrate.js

@@ -1,14 +0,0 @@
-export const validatePlaybackRate = (playbackRate) => {
-    if (playbackRate === undefined) {
-        return;
-    }
-    if (playbackRate > 4) {
-        throw new Error(`The highest possible playback rate is 4. You passed: ${playbackRate}`);
-    }
-    if (playbackRate < -4) {
-        throw new Error(`The lowest possible playback rate is -4. You passed: ${playbackRate}`);
-    }
-    if (playbackRate === 0) {
-        throw new Error(`A playback rate of 0 is not supported.`);
-    }
-};

package/dist/esm/volume-persistance.js

@@ -1,14 +0,0 @@
-const VOLUME_PERSISTANCE_KEY = 'remotion.volumePreference';
-export const persistVolume = (volume) => {
-    if (typeof window === 'undefined') {
-        return;
-    }
-    window.localStorage.setItem(VOLUME_PERSISTANCE_KEY, String(volume));
-};
-export const getPreferredVolume = () => {
-    if (typeof window === 'undefined') {
-        return 1;
-    }
-    const val = window.localStorage.getItem(VOLUME_PERSISTANCE_KEY);
-    return val ? Number(val) : 1;
-};