@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-lambda.3

package/dist/assets/cleanup-assets.d.ts

@@ -0,0 +1,2 @@
+export declare type RenderCleanupFn = () => Promise<void>;
+export declare type AddRenderCleanupFunction = (cleanup: RenderCleanupFn) => void;

package/dist/assets/cleanup-assets.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/assets/download-and-map-assets-to-file.d.ts

@@ -2,6 +2,7 @@ import { TAsset } from 'remotion';
 export declare type RenderMediaOnDownload = (src: string) => ((progress: {
     percent: number;
 }) => void) | undefined | void;
+export declare const waitForAssetToBeDownloaded: (src: string, to: string) => Promise<void>;
 export declare const markAllAssetsAsDownloaded: () => void;
 export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, }: {
     src: string;
@@ -12,3 +13,8 @@ export declare const downloadAndMapAssetsToFileUrl: ({ asset, downloadDir, onDow
     downloadDir: string;
     onDownload: RenderMediaOnDownload;
 }) => Promise<TAsset>;
+export declare const startDownloadForSrc: ({ src, downloadDir, onDownload, }: {
+    src: string;
+    downloadDir: string;
+    onDownload: RenderMediaOnDownload;
+}) => Promise<string>;

package/dist/assets/download-and-map-assets-to-file.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = void 0;
+exports.startDownloadForSrc = exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.waitForAssetToBeDownloaded = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const remotion_1 = require("remotion");
@@ -13,21 +13,38 @@ const sanitize_filepath_1 = require("./sanitize-filepath");
 const isDownloadingMap = {};
 const hasBeenDownloadedMap = {};
 const listeners = {};
-const waitForAssetToBeDownloaded = (src) => {
+const waitForAssetToBeDownloaded = (src, to) => {
+    var _a;
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[to]) {
+        return Promise.resolve();
+    }
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][to]) {
+        listeners[src][to] = [];
     }
     return new Promise((resolve) => {
-        listeners[src].push(() => resolve());
+        listeners[src][to].push(() => resolve());
     });
 };
-const notifyAssetIsDownloaded = (src) => {
+exports.waitForAssetToBeDownloaded = waitForAssetToBeDownloaded;
+const notifyAssetIsDownloaded = (src, to) => {
     if (!listeners[src]) {
-        listeners[src] = [];
+        listeners[src] = {};
+    }
+    if (!listeners[src][to]) {
+        listeners[src][to] = [];
     }
-    listeners[src].forEach((fn) => fn());
-    isDownloadingMap[src] = false;
-    hasBeenDownloadedMap[src] = true;
+    listeners[src][to].forEach((fn) => fn());
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
+    }
+    isDownloadingMap[src][to] = false;
+    if (!hasBeenDownloadedMap[src]) {
+        hasBeenDownloadedMap[src] = {};
+    }
+    hasBeenDownloadedMap[src][to] = true;
 };
 const validateMimeType = (mimeType, src) => {
     if (!mimeType.includes('/')) {
@@ -69,13 +86,17 @@ function validateBufferEncoding(potentialEncoding, dataUrl) {
     }
 }
 const downloadAsset = async (src, to, onDownload) => {
-    if (hasBeenDownloadedMap[src]) {
+    var _a, _b;
+    if ((_a = hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[to]) {
         return;
     }
-    if (isDownloadingMap[src]) {
-        return waitForAssetToBeDownloaded(src);
+    if ((_b = isDownloadingMap[src]) === null || _b === void 0 ? void 0 : _b[to]) {
+        return (0, exports.waitForAssetToBeDownloaded)(src, to);
+    }
+    if (!isDownloadingMap[src]) {
+        isDownloadingMap[src] = {};
     }
-    isDownloadingMap[src] = true;
+    isDownloadingMap[src][to] = true;
     const onProgress = onDownload(src);
     (0, ensure_output_directory_1.ensureOutputDirectory)(to);
     if (src.startsWith('data:')) {
@@ -94,7 +115,7 @@ const downloadAsset = async (src, to, onDownload) => {
         validateBufferEncoding(encoding, src);
         const buff = Buffer.from(assetData, encoding);
         await fs_1.default.promises.writeFile(to, buff);
-        notifyAssetIsDownloaded(src);
+        notifyAssetIsDownloaded(src, to);
         return;
     }
     await (0, download_file_1.downloadFile)(src, to, ({ progress }) => {
@@ -102,7 +123,7 @@ const downloadAsset = async (src, to, onDownload) => {
             percent: progress,
         });
     });
-    notifyAssetIsDownloaded(src);
+    notifyAssetIsDownloaded(src, to);
 };
 const markAllAssetsAsDownloaded = () => {
     Object.keys(hasBeenDownloadedMap).forEach((key) => {
@@ -127,16 +148,22 @@ const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, }) => {
 };
 exports.getSanitizedFilenameForAssetUrl = getSanitizedFilenameForAssetUrl;
 const downloadAndMapAssetsToFileUrl = async ({ asset, downloadDir, onDownload, }) => {
-    const newSrc = (0, exports.getSanitizedFilenameForAssetUrl)({
+    const newSrc = await (0, exports.startDownloadForSrc)({
         src: asset.src,
         downloadDir,
+        onDownload,
     });
-    if (!remotion_1.Internals.AssetCompression.isAssetCompressed(newSrc)) {
-        await downloadAsset(asset.src, newSrc, onDownload);
-    }
     return {
         ...asset,
         src: newSrc,
     };
 };
 exports.downloadAndMapAssetsToFileUrl = downloadAndMapAssetsToFileUrl;
+const startDownloadForSrc = async ({ src, downloadDir, onDownload, }) => {
+    const newSrc = (0, exports.getSanitizedFilenameForAssetUrl)({ downloadDir, src });
+    if (!remotion_1.Internals.AssetCompression.isAssetCompressed(newSrc)) {
+        await downloadAsset(src, newSrc, onDownload);
+    }
+    return newSrc;
+};
+exports.startDownloadForSrc = startDownloadForSrc;

package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -4,9 +4,10 @@ declare type FfmpegVolumeExpression = {
     eval: FfmpegEval;
     value: string;
 };
-export declare const ffmpegVolumeExpression: ({ volume, startInVideo, fps, }: {
+export declare const ffmpegVolumeExpression: ({ volume, startInVideo, fps, trimLeft, }: {
     volume: AssetVolume;
     startInVideo: number;
+    trimLeft: number;
     fps: number;
 }) => FfmpegVolumeExpression;
 export {};

package/dist/assets/ffmpeg-volume-expression.js

@@ -12,12 +12,12 @@ const FFMPEG_TIME_VARIABLE = 't';
 const ffmpegIfOrElse = (condition, then, elseDo) => {
     return `if(${condition},${then},${elseDo})`;
 };
-const ffmpegIsOneOfFrames = (frames, fps) => {
+const ffmpegIsOneOfFrames = ({ frames, trimLeft, fps, }) => {
     const consecutiveArrays = [];
     for (let i = 0; i < frames.length; i++) {
         const previousFrame = frames[i - 1];
         const frame = frames[i];
-        if (!previousFrame || frame !== previousFrame + 1) {
+        if (previousFrame === undefined || frame !== previousFrame + 1) {
             consecutiveArrays.push([]);
         }
         consecutiveArrays[consecutiveArrays.length - 1].push(frame);
@@ -28,25 +28,22 @@ const ffmpegIsOneOfFrames = (frames, fps) => {
         const lastFrame = f[f.length - 1];
         const before = (firstFrame - 0.5) / fps;
         const after = (lastFrame + 0.5) / fps;
-        return `between(${FFMPEG_TIME_VARIABLE},${before.toFixed(4)},${after.toFixed(4)})`;
+        return `between(${FFMPEG_TIME_VARIABLE},${(before + trimLeft).toFixed(4)},${(after + trimLeft).toFixed(4)})`;
     })
         .join('+');
 };
-const ffmpegBuildVolumeExpression = (arr, fps) => {
+const ffmpegBuildVolumeExpression = (arr, delay, fps) => {
     if (arr.length === 0) {
         throw new Error('Volume array expression should never have length 0');
     }
     if (arr.length === 1) {
-        // FFMpeg tends to request volume for frames outside the range
-        // where the audio actually plays.
-        // If this is the case, we just return volume 0 to clip it.
-        return ffmpegIfOrElse(ffmpegIsOneOfFrames(arr[0][1], fps), String(arr[0][0]), String(0));
+        return String(arr[0][0]);
     }
     const [first, ...rest] = arr;
     const [volume, frames] = first;
-    return ffmpegIfOrElse(ffmpegIsOneOfFrames(frames, fps), String(volume), ffmpegBuildVolumeExpression(rest, fps));
+    return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression(rest, delay, fps));
 };
-const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
+const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
     // If it's a static volume, we return it and tell
     // FFMPEG it only has to evaluate it once
     if (typeof volume === 'number') {
@@ -60,14 +57,20 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
             volume: volume[0],
             startInVideo,
             fps,
+            trimLeft,
         });
     }
+    // A 1 sec video with frames 0-29 would mean that
+    // frame 29 corresponds to timestamp 0.966666...
+    // but the audio is actually 1 sec long. For that reason we pad the last
+    // timestamp.
+    const paddedVolume = [...volume, volume[volume.length - 1]];
     // Otherwise, we construct an FFMPEG expression. First step:
     // Make a map of all possible volumes
     // {possibleVolume1} => [frame1, frame2]
     // {possibleVolume2} => [frame3, frame4]
     const volumeMap = {};
-    volume.forEach((baseVolume, frame) => {
+    paddedVolume.forEach((baseVolume, frame) => {
         // Adjust volume based on how many other tracks have not yet finished
         const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(Math.min(1, baseVolume));
         if (!volumeMap[actualVolume]) {
@@ -81,7 +84,7 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
         .map((key) => [Number(key), volumeMap[key]])
         .sort((a, b) => a[1].length - b[1].length);
     // Construct and tell FFMPEG it has to evaluate expression on each frame
-    const expression = ffmpegBuildVolumeExpression(volumeArray, fps);
+    const expression = ffmpegBuildVolumeExpression(volumeArray, trimLeft, fps);
     return {
         eval: 'frame',
         value: `'${expression}'`,

package/dist/assets/get-audio-channels.d.ts

@@ -1,4 +1,7 @@
-export declare function getAudioChannelsAndDuration(path: string): Promise<{
+import { FfmpegExecutable } from 'remotion';
+declare type Result = {
     channels: number;
     duration: number | null;
-}>;
+};
+export declare const getAudioChannelsAndDuration: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
+export {};

package/dist/assets/get-audio-channels.js

@@ -5,21 +5,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioChannelsAndDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
-async function getAudioChannelsAndDuration(path) {
+const p_limit_1 = require("../p-limit");
+const durationOfAssetCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+async function getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable) {
+    if (durationOfAssetCache[src]) {
+        return durationOfAssetCache[src];
+    }
     const args = [
         ['-v', 'error'],
         ['-show_entries', 'stream=channels:format=duration'],
         ['-of', 'default=nw=1'],
-        [path],
+        [src],
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, execa_1.default)('ffprobe', args);
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
     const channels = task.stdout.match(/channels=([0-9]+)/);
     const duration = task.stdout.match(/duration=([0-9.]+)/);
-    return {
+    const result = {
         channels: channels ? parseInt(channels[1], 10) : 0,
         duration: duration ? parseFloat(duration[1]) : null,
     };
+    durationOfAssetCache[src] = result;
+    return result;
 }
+const getAudioChannelsAndDuration = (src, ffprobeExecutable) => {
+    return limit(() => getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable));
+};
 exports.getAudioChannelsAndDuration = getAudioChannelsAndDuration;

package/dist/browser/Accessibility.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Copyright 2018 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CDPSession } from './Connection';
+import { ElementHandle } from './JSHandle';
+/**
+ * Represents a Node and the properties of it that are relevant to Accessibility.
+ * @public
+ */
+export interface SerializedAXNode {
+    /**
+     * The {@link https://www.w3.org/TR/wai-aria/#usage_intro | role} of the node.
+     */
+    role: string;
+    /**
+     * A human readable name for the node.
+     */
+    name?: string;
+    /**
+     * The current value of the node.
+     */
+    value?: string | number;
+    /**
+     * An additional human readable description of the node.
+     */
+    description?: string;
+    /**
+     * Any keyboard shortcuts associated with this node.
+     */
+    keyshortcuts?: string;
+    /**
+     * A human readable alternative to the role.
+     */
+    roledescription?: string;
+    /**
+     * A description of the current value.
+     */
+    valuetext?: string;
+    disabled?: boolean;
+    expanded?: boolean;
+    focused?: boolean;
+    modal?: boolean;
+    multiline?: boolean;
+    /**
+     * Whether more than one child can be selected.
+     */
+    multiselectable?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    selected?: boolean;
+    /**
+     * Whether the checkbox is checked, or in a
+     * {@link https://www.w3.org/TR/wai-aria-practices/examples/checkbox/checkbox-2/checkbox-2.html | mixed state}.
+     */
+    checked?: boolean | 'mixed';
+    /**
+     * Whether the node is checked or in a mixed state.
+     */
+    pressed?: boolean | 'mixed';
+    /**
+     * The level of a heading.
+     */
+    level?: number;
+    valuemin?: number;
+    valuemax?: number;
+    autocomplete?: string;
+    haspopup?: string;
+    /**
+     * Whether and in what way this node's value is invalid.
+     */
+    invalid?: string;
+    orientation?: string;
+    /**
+     * Children of this node, if there are any.
+     */
+    children?: SerializedAXNode[];
+}
+/**
+ * @public
+ */
+export interface SnapshotOptions {
+    /**
+     * Prune uninteresting nodes from the tree.
+     * @defaultValue true
+     */
+    interestingOnly?: boolean;
+    /**
+     * Root node to get the accessibility tree for
+     * @defaultValue The root node of the entire page.
+     */
+    root?: ElementHandle;
+}
+/**
+ * The Accessibility class provides methods for inspecting Chromium's
+ * accessibility tree. The accessibility tree is used by assistive technology
+ * such as {@link https://en.wikipedia.org/wiki/Screen_reader | screen readers} or
+ * {@link https://en.wikipedia.org/wiki/Switch_access | switches}.
+ *
+ * @remarks
+ *
+ * Accessibility is a very platform-specific thing. On different platforms,
+ * there are different screen readers that might have wildly different output.
+ *
+ * Blink - Chrome's rendering engine - has a concept of "accessibility tree",
+ * which is then translated into different platform-specific APIs. Accessibility
+ * namespace gives users access to the Blink Accessibility Tree.
+ *
+ * Most of the accessibility tree gets filtered out when converting from Blink
+ * AX Tree to Platform-specific AX-Tree or by assistive technologies themselves.
+ * By default, Puppeteer tries to approximate this filtering, exposing only
+ * the "interesting" nodes of the tree.
+ *
+ * @public
+ */
+export declare class Accessibility {
+    #private;
+    /**
+     * @internal
+     */
+    constructor(client: CDPSession);
+    /**
+     * Captures the current state of the accessibility tree.
+     * The returned object represents the root accessible node of the page.
+     *
+     * @remarks
+     *
+     * **NOTE** The Chromium accessibility tree contains nodes that go unused on
+     * most platforms and by most screen readers. Puppeteer will discard them as
+     * well for an easier to process tree, unless `interestingOnly` is set to
+     * `false`.
+     *
+     * @example
+     * An example of dumping the entire accessibility tree:
+     * ```js
+     * const snapshot = await page.accessibility.snapshot();
+     * console.log(snapshot);
+     * ```
+     *
+     * @example
+     * An example of logging the focused node's name:
+     * ```js
+     * const snapshot = await page.accessibility.snapshot();
+     * const node = findFocusedNode(snapshot);
+     * console.log(node && node.name);
+     *
+     * function findFocusedNode(node) {
+     *   if (node.focused)
+     *     return node;
+     *   for (const child of node.children || []) {
+     *     const foundNode = findFocusedNode(child);
+     *     return foundNode;
+     *   }
+     *   return null;
+     * }
+     * ```
+     *
+     * @returns An AXNode object representing the snapshot.
+     *
+     */
+    snapshot(options?: SnapshotOptions): Promise<SerializedAXNode | null>;
+    private serializeTree;
+    private collectInterestingNodes;
+}