remotion 3.3.45 → 3.3.52

package/dist/esm/get-static-files.js

@@ -0,0 +1,27 @@
+let warnedServer = false;
+let warnedPlayer = false;
+const warnServerOnce = () => {
+    if (warnedServer) {
+        return;
+    }
+    warnedServer = true;
+    console.warn('Called getStaticFiles() on the server. The API is only available in the browser. An empty array was returned.');
+};
+const warnPlayerOnce = () => {
+    if (warnedPlayer) {
+        return;
+    }
+    warnedPlayer = true;
+    console.warn('Called getStaticFiles() while using the Remotion Player. The API is only available while using the Remotion Preview. An empty array was returned.');
+};
+export const getStaticFiles = () => {
+    if (typeof document === 'undefined') {
+        warnServerOnce();
+        return [];
+    }
+    if (window.remotion_isPlayer) {
+        warnPlayerOnce();
+        return [];
+    }
+    return window.remotion_staticFiles;
+};

package/dist/esm/get-timeline-clip-name.d.ts

@@ -0,0 +1 @@
+export declare const getTimelineClipName: (children: React.ReactNode) => string;

package/dist/esm/get-timeline-clip-name.js

@@ -0,0 +1,21 @@
+import { Children, isValidElement } from 'react';
+const HIDDEN_NAMES = ['__WEBPACK_DEFAULT_EXPORT__'];
+export const getTimelineClipName = (children) => {
+    var _a;
+    const tree = (_a = Children.map(children, (ch) => {
+        if (!isValidElement(ch)) {
+            return null;
+        }
+        // Must be name, not ID
+        const name = typeof ch.type !== 'string' && ch.type.name;
+        if (name && !HIDDEN_NAMES.includes(name)) {
+            return name;
+        }
+        if (ch.props.children) {
+            const chName = getTimelineClipName(ch.props.children);
+            return chName;
+        }
+        return null;
+    })) === null || _a === void 0 ? void 0 : _a.filter(Boolean);
+    return (tree === null || tree === void 0 ? void 0 : tree.length) ? tree[0] : '';
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,92 @@
+import './asset-types.js';
+import type { TAsset, TCompMetadata } from './CompositionManager.js';
+import type { StaticFile } from './get-static-files.js';
+import type { ClipRegion } from './NativeLayers.js';
+declare global {
+    interface Window {
+        ready: boolean;
+        remotion_cancelledError: string | undefined;
+        getStaticCompositions: () => TCompMetadata[];
+        setBundleMode: (bundleMode: BundleState) => void;
+        remotion_staticBase: string;
+        remotion_staticFiles: StaticFile[];
+        remotion_editorName: string | null;
+        remotion_numberOfAudioTags: number;
+        remotion_projectName: string;
+        remotion_cwd: string;
+        remotion_previewServerCommand: string;
+        remotion_setFrame: (frame: number) => void;
+        remotion_initialFrame: number;
+        remotion_proxyPort: number;
+        remotion_audioEnabled: boolean;
+        remotion_videoEnabled: boolean;
+        remotion_puppeteerTimeout: number;
+        remotion_inputProps: string;
+        remotion_envVariables: string;
+        remotion_collectAssets: () => TAsset[];
+        remotion_getClipRegion: () => ClipRegion | null;
+        remotion_isPlayer: boolean;
+        remotion_isBuilding: undefined | (() => void);
+        remotion_finishedBuilding: undefined | (() => void);
+        siteVersion: '4';
+        remotion_version: string;
+        remotion_imported: string | boolean;
+    }
+}
+export declare type BundleState = {
+    type: 'index';
+} | {
+    type: 'evaluation';
+} | {
+    type: 'composition';
+    compositionName: string;
+    compositionDefaultProps: unknown;
+    compositionHeight: number;
+    compositionDurationInFrames: number;
+    compositionWidth: number;
+    compositionFps: number;
+};
+export * from './AbsoluteFill.js';
+export * from './audio';
+export { cancelRender } from './cancel-render.js';
+export * from './Composition.js';
+export { SmallTCompMetadata, TAsset, TCompMetadata } from './CompositionManager.js';
+export { Config, ConfigType } from './config';
+export { getInputProps } from './config/input-props.js';
+export { continueRender, delayRender } from './delay-render.js';
+export * from './easing.js';
+export * from './Folder.js';
+export * from './freeze.js';
+export { getStaticFiles, StaticFile } from './get-static-files.js';
+export * from './IFrame.js';
+export * from './Img.js';
+export * from './internals.js';
+export * from './interpolate.js';
+export { interpolateColors } from './interpolate-colors.js';
+export { Loop } from './loop';
+export { ClipRegion } from './NativeLayers.js';
+export { prefetch } from './prefetch.js';
+export { random, RandomSeed } from './random.js';
+export { registerRoot } from './register-root.js';
+export { Sequence } from './Sequence.js';
+export { Series } from './series';
+export * from './spring';
+export { staticFile } from './static-file.js';
+export * from './Still.js';
+export type { PlayableMediaTag } from './timeline-position-state.js';
+export { useCurrentFrame } from './use-current-frame.js';
+export * from './use-video-config.js';
+export * from './version.js';
+export * from './video';
+export * from './video-config.js';
+export declare const Experimental: {
+    Clipper: import("react").FC<{
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }>;
+    Null: import("react").FC<{}>;
+    useIsPlayer: () => boolean;
+};
+export declare type WebpackOverrideFn = "The 'WebpackOverrideFn' has been moved to '@remotion/bundler'. Update your imports and install '@remotion/bundler' if necessary.";

package/dist/esm/index.js

@@ -0,0 +1,41 @@
+import './asset-types.js';
+import { Clipper } from './Clipper.js';
+import { useIsPlayer } from './is-player.js';
+import { checkMultipleRemotionVersions } from './multiple-versions-warning.js';
+import { Null } from './Null.js';
+checkMultipleRemotionVersions();
+export * from './AbsoluteFill.js';
+export * from './audio';
+export { cancelRender } from './cancel-render.js';
+export * from './Composition.js';
+export { Config } from './config';
+export { getInputProps } from './config/input-props.js';
+export { continueRender, delayRender } from './delay-render.js';
+export * from './easing.js';
+export * from './Folder.js';
+export * from './freeze.js';
+export { getStaticFiles } from './get-static-files.js';
+export * from './IFrame.js';
+export * from './Img.js';
+export * from './internals.js';
+export * from './interpolate.js';
+export { interpolateColors } from './interpolate-colors.js';
+export { Loop } from './loop';
+export { prefetch } from './prefetch.js';
+export { random } from './random.js';
+export { registerRoot } from './register-root.js';
+export { Sequence } from './Sequence.js';
+export { Series } from './series';
+export * from './spring';
+export { staticFile } from './static-file.js';
+export * from './Still.js';
+export { useCurrentFrame } from './use-current-frame.js';
+export * from './use-video-config.js';
+export * from './version.js';
+export * from './video';
+export * from './video-config.js';
+export const Experimental = {
+    Clipper,
+    Null,
+    useIsPlayer,
+};

package/dist/esm/internals.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="react" />
+import type { CompProps } from './Composition.js';
+import type { CompositionManagerContext, TAsset, TCompMetadata, TComposition, TSequence } from './CompositionManager.js';
+import * as CSSUtils from './default-css.js';
+import type { RemotionEnvironment } from './get-environment.js';
+import type { SetTimelineContextValue, TimelineContextValue } from './timeline-position-state.js';
+import * as TimelinePosition from './timeline-position-state.js';
+import { truthy } from './truthy.js';
+import type { MediaVolumeContextValue, SetMediaVolumeContextValue } from './volume-position-state.js';
+import { useRemotionContexts } from './wrap-remotion-context.js';
+declare const Timeline: typeof TimelinePosition;
+export declare const Internals: {
+    useUnsafeVideoConfig: () => import("./video-config").VideoConfig | null;
+    Timeline: typeof TimelinePosition;
+    CompositionManager: import("react").Context<CompositionManagerContext>;
+    RemotionRoot: import("react").FC<{
+        children: import("react").ReactNode;
+        numberOfAudioTags: number;
+    }>;
+    useVideo: () => {
+        height: number;
+        width: number;
+        fps: number;
+        durationInFrames: number;
+        defaultProps: unknown;
+        id: string;
+        folderName: string | null;
+        parentFolderName: string | null;
+        component: import("react").LazyExoticComponent<import("react").ComponentType<unknown>>;
+        nonce: number;
+    } | null;
+    getRoot: () => import("react").FC<{}> | null;
+    useMediaVolumeState: () => readonly [number, (u: number) => void];
+    useMediaMutedState: () => readonly [boolean, (u: import("react").SetStateAction<boolean>) => void];
+    useLazyComponent: <T>(compProps: CompProps<T>) => import("react").ExoticComponent<(import("react").PropsWithoutRef<T> & import("react").RefAttributes<import("react").Component<T, any, any>>) | import("react").PropsWithRef<T>> & {
+        readonly _result: import("react").ComponentType<T>;
+    };
+    truthy: typeof truthy;
+    SequenceContext: import("react").Context<import("./Sequence.js").SequenceContextType | null>;
+    useRemotionContexts: typeof useRemotionContexts;
+    RemotionContextProvider: (props: import("./wrap-remotion-context.js").RemotionContextProviderProps) => JSX.Element;
+    CSSUtils: typeof CSSUtils;
+    setupEnvVariables: () => void;
+    ENV_VARIABLES_ENV_NAME: "ENV_VARIABLES";
+    MediaVolumeContext: import("react").Context<MediaVolumeContextValue>;
+    SetMediaVolumeContext: import("react").Context<SetMediaVolumeContextValue>;
+    validateDurationInFrames: (durationInFrames: number, component: string) => void;
+    validateFps: (fps: number, location: string, isGif: boolean) => void;
+    validateDimension: (amount: number, nameOfProp: string, location: string) => void;
+    getRemotionEnvironment: () => RemotionEnvironment;
+    SharedAudioContext: import("react").Context<{
+        registerAudio: (aud: import("./audio").RemotionAudioProps, audioId: string) => {
+            id: number;
+            props: import("./audio").RemotionAudioProps;
+            el: import("react").RefObject<HTMLAudioElement>;
+            audioId: string;
+        };
+        unregisterAudio: (id: number) => void;
+        updateAudio: (options: {
+            id: number;
+            aud: import("./audio").RemotionAudioProps;
+            audioId: string;
+        }) => void;
+        playAllAudios: () => void;
+        numberOfAudioTags: number;
+    } | null>;
+    SharedAudioContextProvider: import("react").FC<{
+        numberOfAudioTags: number;
+        children: import("react").ReactNode;
+    }>;
+    invalidCompositionErrorMessage: string;
+    isCompositionIdValid: (id: string) => RegExpMatchArray | null;
+    getPreviewDomElement: () => HTMLElement | null;
+    compositionsRef: import("react").RefObject<{
+        getCompositions: () => TCompMetadata[];
+    }>;
+    DELAY_RENDER_CALLSTACK_TOKEN: string;
+    portalNode: () => HTMLElement;
+    waitForRoot: (fn: (comp: import("react").FC<{}>) => void) => () => void;
+    validateOffthreadVideoImageFormat: (input: unknown) => void;
+    CanUseRemotionHooksProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    CanUseRemotionHooks: import("react").Context<boolean>;
+    enableLegacyRemotionConfig: () => void;
+    PrefetchProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    DurationsContextProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    IsPlayerContextProvider: import("react").FC<{
+        children?: import("react").ReactNode;
+    }>;
+    useIsPlayer: () => boolean;
+    useRemotionEnvironment: () => RemotionEnvironment;
+    validateFrame: (frame: number, durationInFrames: number) => void;
+};
+export type { TComposition, Timeline, TCompMetadata, TSequence, TAsset, TimelineContextValue, SetTimelineContextValue, CompProps, CompositionManagerContext, MediaVolumeContextValue, SetMediaVolumeContextValue, RemotionEnvironment, };

package/dist/esm/internals.js

@@ -0,0 +1,75 @@
+import { enableLegacyRemotionConfig } from './config';
+import { SharedAudioContext, SharedAudioContextProvider, } from './audio/shared-audio-tags.js';
+import { CanUseRemotionHooks, CanUseRemotionHooksProvider, } from './CanUseRemotionHooks.js';
+import { CompositionManager, compositionsRef } from './CompositionManager.js';
+import * as CSSUtils from './default-css.js';
+import { DELAY_RENDER_CALLSTACK_TOKEN } from './delay-render.js';
+import { getRemotionEnvironment, useRemotionEnvironment, } from './get-environment.js';
+import { getPreviewDomElement } from './get-preview-dom-element.js';
+import { IsPlayerContextProvider, useIsPlayer } from './is-player.js';
+import { portalNode } from './portal-node.js';
+import { PrefetchProvider } from './prefetch-state.js';
+import { getRoot, waitForRoot } from './register-root.js';
+import { RemotionRoot } from './RemotionRoot.js';
+import { SequenceContext } from './Sequence.js';
+import { ENV_VARIABLES_ENV_NAME, setupEnvVariables, } from './setup-env-variables.js';
+import * as TimelinePosition from './timeline-position-state.js';
+import { truthy } from './truthy.js';
+import { useLazyComponent } from './use-lazy-component.js';
+import { useUnsafeVideoConfig } from './use-unsafe-video-config.js';
+import { useVideo } from './use-video.js';
+import { validateFrame } from './validate-frame.js';
+import { invalidCompositionErrorMessage, isCompositionIdValid, } from './validation/validate-composition-id.js';
+import { validateDimension } from './validation/validate-dimensions.js';
+import { validateDurationInFrames } from './validation/validate-duration-in-frames.js';
+import { validateFps } from './validation/validate-fps.js';
+import { validateOffthreadVideoImageFormat } from './validation/validate-offthreadvideo-image-format.js';
+import { DurationsContextProvider } from './video/duration-state.js';
+import { MediaVolumeContext, SetMediaVolumeContext, useMediaMutedState, useMediaVolumeState, } from './volume-position-state.js';
+import { RemotionContextProvider, useRemotionContexts, } from './wrap-remotion-context.js';
+const Timeline = TimelinePosition;
+// Mark them as Internals so use don't assume this is public
+// API and are less likely to use it
+export const Internals = {
+    useUnsafeVideoConfig,
+    Timeline,
+    CompositionManager,
+    RemotionRoot,
+    useVideo,
+    getRoot,
+    useMediaVolumeState,
+    useMediaMutedState,
+    useLazyComponent,
+    truthy,
+    SequenceContext,
+    useRemotionContexts,
+    RemotionContextProvider,
+    CSSUtils,
+    setupEnvVariables,
+    ENV_VARIABLES_ENV_NAME,
+    MediaVolumeContext,
+    SetMediaVolumeContext,
+    validateDurationInFrames,
+    validateFps,
+    validateDimension,
+    getRemotionEnvironment,
+    SharedAudioContext,
+    SharedAudioContextProvider,
+    invalidCompositionErrorMessage,
+    isCompositionIdValid,
+    getPreviewDomElement,
+    compositionsRef,
+    DELAY_RENDER_CALLSTACK_TOKEN,
+    portalNode,
+    waitForRoot,
+    validateOffthreadVideoImageFormat,
+    CanUseRemotionHooksProvider,
+    CanUseRemotionHooks,
+    enableLegacyRemotionConfig,
+    PrefetchProvider,
+    DurationsContextProvider,
+    IsPlayerContextProvider,
+    useIsPlayer,
+    useRemotionEnvironment,
+    validateFrame,
+};

package/dist/esm/interpolate-colors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copied from:
+ * https://github.com/software-mansion/react-native-reanimated/blob/master/src/reanimated2/Colors.ts
+ */
+export declare const interpolateColors: (input: number, inputRange: readonly number[], outputRange: readonly string[]) => string;