@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/compress-audio.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressAudio = void 0;
+const node_fs_1 = require("node:fs");
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const audio_codec_1 = require("./options/audio-codec");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const truthy_1 = require("./truthy");
+const compressAudio = async ({ audioCodec, outName, binariesDirectory, indent, logLevel, audioBitrate, cancelSignal, inName, onProgress, chunkLengthInSeconds, fps, }) => {
+    var _a;
+    if (audioCodec === 'pcm-16') {
+        (0, node_fs_1.cpSync)(inName, outName);
+        return onProgress(1);
+    }
+    const args = [
+        ['-hide_banner'],
+        ['-i', inName],
+        ['-c:a', (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(audioCodec)],
+        audioCodec === 'aac' ? ['-f', 'adts'] : null,
+        audioCodec ? ['-b:a', audioBitrate || '320k'] : null,
+        audioCodec === 'aac' ? '-cutoff' : null,
+        audioCodec === 'aac' ? '18000' : null,
+        ['-y', outName],
+    ]
+        .filter(truthy_1.truthy)
+        .flat(2);
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+        const utf8 = data.toString('utf8');
+        const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(utf8, fps);
+        if (parsed !== undefined) {
+            onProgress(parsed / (chunkLengthInSeconds * fps));
+        }
+    });
+    await task;
+};
+exports.compressAudio = compressAudio;

package/package/dist/convert-number-of-gif-loops-to-ffmpeg.d.ts

@@ -0,0 +1 @@
+export declare const convertNumberOfGifLoopsToFfmpegSyntax: (loops: number | null) => string;

package/package/dist/convert-number-of-gif-loops-to-ffmpeg.js

@@ -0,0 +1,17 @@
+"use strict";
+// https://superuser.com/questions/1607099/how-to-control-gif-loop-settings-in-ffmpeg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNumberOfGifLoopsToFfmpegSyntax = void 0;
+const convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
+    // Infinite loop
+    if (loops === null) {
+        return '0';
+    }
+    // No loops
+    if (loops === 0) {
+        return '-1';
+    }
+    // N amount of loops
+    return String(loops);
+};
+exports.convertNumberOfGifLoopsToFfmpegSyntax = convertNumberOfGifLoopsToFfmpegSyntax;

package/package/dist/convert-to-positive-frame-index.d.ts

@@ -0,0 +1,4 @@
+export declare const convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
+    frame: number;
+    durationInFrames: number;
+}) => number;

package/package/dist/convert-to-positive-frame-index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToPositiveFrameIndex = void 0;
+// Handle negative indices (e.g. -1 being the last frame)
+const convertToPositiveFrameIndex = ({ frame, durationInFrames, }) => {
+    return frame < 0 ? durationInFrames + frame : frame;
+};
+exports.convertToPositiveFrameIndex = convertToPositiveFrameIndex;

package/package/dist/create-audio.d.ts

@@ -0,0 +1,29 @@
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { AudioCodec } from './options/audio-codec';
+import type { FrameAndAssets } from './render-frames';
+export type SeamlessAudioInfo = {
+    chunkLengthInSeconds: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+};
+export declare const createAudio: ({ assets, onDownload, fps, logLevel, onProgress, downloadMap, remotionRoot, indent, binariesDirectory, audioBitrate, audioCodec, cancelSignal, chunkLengthInSeconds, trimLeftOffset, trimRightOffset, forSeamlessAacConcatenation, }: {
+    assets: FrameAndAssets[];
+    onDownload: RenderMediaOnDownload | undefined;
+    fps: number;
+    logLevel: LogLevel;
+    onProgress: (progress: number) => void;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
+    indent: boolean;
+    binariesDirectory: string | null;
+    audioBitrate: string | null;
+    audioCodec: AudioCodec;
+    cancelSignal: CancelSignal | undefined;
+    chunkLengthInSeconds: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    forSeamlessAacConcatenation: boolean;
+}) => Promise<string>;

package/package/dist/create-audio.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAudio = void 0;
+const path_1 = __importDefault(require("path"));
+const calculate_asset_positions_1 = require("./assets/calculate-asset-positions");
+const convert_assets_to_file_urls_1 = require("./assets/convert-assets-to-file-urls");
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const compress_audio_1 = require("./compress-audio");
+const delete_directory_1 = require("./delete-directory");
+const logger_1 = require("./logger");
+const merge_audio_track_1 = require("./merge-audio-track");
+const audio_codec_1 = require("./options/audio-codec");
+const preprocess_audio_track_1 = require("./preprocess-audio-track");
+const truthy_1 = require("./truthy");
+const createAudio = async ({ assets, onDownload, fps, logLevel, onProgress, downloadMap, remotionRoot, indent, binariesDirectory, audioBitrate, audioCodec, cancelSignal, chunkLengthInSeconds, trimLeftOffset, trimRightOffset, forSeamlessAacConcatenation, }) => {
+    const fileUrlAssets = await (0, convert_assets_to_file_urls_1.convertAssetsToFileUrls)({
+        assets,
+        onDownload: onDownload !== null && onDownload !== void 0 ? onDownload : (() => () => undefined),
+        downloadMap,
+        indent,
+        logLevel,
+        binariesDirectory,
+    });
+    (0, download_and_map_assets_to_file_1.markAllAssetsAsDownloaded)(downloadMap);
+    const assetPositions = (0, calculate_asset_positions_1.calculateAssetPositions)(fileUrlAssets);
+    logger_1.Log.verbose({ indent, logLevel, tag: 'audio' }, 'asset positions', JSON.stringify(assetPositions));
+    const preprocessProgress = new Array(assetPositions.length).fill(0);
+    let mergeProgress = 0;
+    let compressProgress = 0;
+    const updateProgress = () => {
+        const preprocessProgressSum = preprocessProgress.length === 0
+            ? 1
+            : preprocessProgress.reduce((a, b) => a + b, 0) / assetPositions.length;
+        const totalProgress = preprocessProgressSum * 0.7 +
+            mergeProgress * 0.1 +
+            compressProgress * 0.2;
+        onProgress(totalProgress);
+    };
+    const audioTracks = await Promise.all(assetPositions.map(async (asset, index) => {
+        const filterFile = path_1.default.join(downloadMap.audioMixing, `${index}.wav`);
+        const result = await (0, preprocess_audio_track_1.preprocessAudioTrack)({
+            outName: filterFile,
+            asset,
+            fps,
+            downloadMap,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+            onProgress: (progress) => {
+                preprocessProgress[index] = progress;
+                updateProgress();
+            },
+            chunkLengthInSeconds,
+            trimLeftOffset,
+            trimRightOffset,
+            forSeamlessAacConcatenation,
+            audioStreamIndex: asset.audioStreamIndex,
+        });
+        preprocessProgress[index] = 1;
+        updateProgress();
+        return result;
+    }));
+    await downloadMap.inlineAudioMixing.finish({
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
+    const preprocessed = [
+        ...audioTracks.filter(truthy_1.truthy),
+        ...inlinedAudio.map((asset) => ({
+            outName: asset,
+            filter: {
+                filter: null,
+                pad_start: null,
+                pad_end: null,
+            },
+        })),
+    ];
+    const merged = path_1.default.join(downloadMap.audioPreprocessing, 'merged.wav');
+    const extension = (0, audio_codec_1.getExtensionFromAudioCodec)(audioCodec);
+    const outName = path_1.default.join(downloadMap.audioPreprocessing, `audio.${extension}`);
+    await (0, merge_audio_track_1.mergeAudioTrack)({
+        files: preprocessed,
+        outName: merged,
+        downloadMap,
+        remotionRoot,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        fps,
+        onProgress: (progress) => {
+            mergeProgress = progress;
+            updateProgress();
+        },
+        chunkLengthInSeconds,
+    });
+    await (0, compress_audio_1.compressAudio)({
+        audioBitrate,
+        audioCodec,
+        binariesDirectory,
+        indent,
+        logLevel,
+        inName: merged,
+        outName,
+        cancelSignal,
+        chunkLengthInSeconds,
+        fps,
+        onProgress: (progress) => {
+            compressProgress = progress;
+            updateProgress();
+        },
+    });
+    (0, delete_directory_1.deleteDirectory)(merged);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.audioMixing);
+    preprocessed.forEach((p) => {
+        (0, delete_directory_1.deleteDirectory)(p.outName);
+    });
+    return outName;
+};
+exports.createAudio = createAudio;

package/package/dist/create-ffmpeg-complex-filter.d.ts

@@ -0,0 +1,10 @@
+import type { DownloadMap } from './assets/download-map';
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const createFfmpegComplexFilter: ({ filters, downloadMap, }: {
+    filters: PreprocessedAudioTrack[];
+    downloadMap: DownloadMap;
+}) => Promise<{
+    complexFilterFlag: [string, string] | null;
+    cleanup: () => void;
+    complexFilter: string | null;
+}>;

package/package/dist/create-ffmpeg-complex-filter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFfmpegComplexFilter = void 0;
+const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
+const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
+const createFfmpegComplexFilter = async ({ filters, downloadMap, }) => {
+    if (filters.length === 0) {
+        return {
+            complexFilterFlag: null,
+            cleanup: () => undefined,
+            complexFilter: null,
+        };
+    }
+    const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)({
+        inputs: filters,
+    });
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFileStr)(complexFilter, downloadMap);
+    return {
+        complexFilterFlag: ['-filter_complex_script', file],
+        cleanup,
+        complexFilter,
+    };
+};
+exports.createFfmpegComplexFilter = createFfmpegComplexFilter;

package/package/dist/create-ffmpeg-merge-filter.d.ts

@@ -0,0 +1,5 @@
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const OUTPUT_FILTER_NAME = "outputaudio";
+export declare const createFfmpegMergeFilter: ({ inputs, }: {
+    inputs: PreprocessedAudioTrack[];
+}) => string;

package/package/dist/create-ffmpeg-merge-filter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFfmpegMergeFilter = exports.OUTPUT_FILTER_NAME = void 0;
+const truthy_1 = require("./truthy");
+exports.OUTPUT_FILTER_NAME = 'outputaudio';
+const createFfmpegMergeFilter = ({ inputs, }) => {
+    const pads = inputs.map((input, index) => {
+        const filters = [
+            input.filter.pad_start ? input.filter.pad_start : null,
+            input.filter.pad_end ? input.filter.pad_end : null,
+            'acopy',
+        ];
+        return `[${index}:a]${filters.filter(truthy_1.truthy).join(',')}[padded${index}]`;
+    });
+    return [
+        ...pads,
+        `${new Array(inputs.length)
+            .fill(true)
+            .map((_, i) => {
+            return `[padded${i}]`;
+        })
+            .join('')}amix=inputs=${inputs.length}:dropout_transition=0:normalize=0[${exports.OUTPUT_FILTER_NAME}]`,
+    ].join(';');
+};
+exports.createFfmpegMergeFilter = createFfmpegMergeFilter;

package/package/dist/create-silent-audio.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const createSilentAudio: ({ outName, indent, logLevel, binariesDirectory, cancelSignal, chunkLengthInSeconds, }: {
+    chunkLengthInSeconds: number;
+    outName: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+}) => Promise<void>;

package/package/dist/create-silent-audio.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSilentAudio = void 0;
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const sample_rate_1 = require("./sample-rate");
+const createSilentAudio = async ({ outName, indent, logLevel, binariesDirectory, cancelSignal, chunkLengthInSeconds, }) => {
+    await (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args: [
+            '-f',
+            'lavfi',
+            '-i',
+            `anullsrc=r=${sample_rate_1.DEFAULT_SAMPLE_RATE}`,
+            '-c:a',
+            'pcm_s16le',
+            '-t',
+            String(chunkLengthInSeconds),
+            '-ar',
+            String(sample_rate_1.DEFAULT_SAMPLE_RATE),
+            outName,
+        ],
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+};
+exports.createSilentAudio = createSilentAudio;

package/package/dist/crf.d.ts

@@ -0,0 +1,13 @@
+import type { HardwareAccelerationOption } from './client';
+import type { Codec } from './codec';
+export type Crf = number | undefined;
+export declare const getDefaultCrfForCodec: (codec: Codec) => number | null;
+export declare const getValidCrfRanges: (codec: Codec) => [number, number];
+export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }: {
+    crf: unknown;
+    codec: Codec;
+    videoBitrate: string | null;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    hardwareAcceleration: HardwareAccelerationOption;
+}) => string[];

package/package/dist/crf.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQualitySettings = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+const is_audio_codec_1 = require("./is-audio-codec");
+const defaultCrfMap = {
+    h264: 18,
+    h265: 23,
+    vp8: 9,
+    vp9: 28,
+    prores: null,
+    gif: null,
+    'h264-mkv': 18,
+    'h264-ts': 18,
+    aac: null,
+    mp3: null,
+    wav: null,
+};
+const getDefaultCrfForCodec = (codec) => {
+    const val = defaultCrfMap[codec];
+    if (val === undefined) {
+        throw new TypeError(`Got unexpected codec "${codec}"`);
+    }
+    return val;
+};
+exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
+const crfRanges = {
+    h264: [1, 51],
+    h265: [0, 51],
+    vp8: [4, 63],
+    vp9: [0, 63],
+    prores: [0, 0],
+    gif: [0, 0],
+    'h264-mkv': [1, 51],
+    'h264-ts': [1, 51],
+    aac: [0, 0],
+    mp3: [0, 0],
+    wav: [0, 0],
+};
+const getValidCrfRanges = (codec) => {
+    const val = crfRanges[codec];
+    if (val === undefined) {
+        throw new TypeError(`Got unexpected codec "${codec}"`);
+    }
+    return val;
+};
+exports.getValidCrfRanges = getValidCrfRanges;
+const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
+    if (crf && videoBitrate) {
+        throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
+    }
+    if (crf && hardwareAcceleration === 'required') {
+        throw new Error('"crf" option is not supported with hardware acceleration');
+    }
+    if (encodingMaxRate && !encodingBufferSize) {
+        throw new Error('"encodingMaxRate" can not be set without also setting "encodingBufferSize".');
+    }
+    const bufSizeArray = encodingBufferSize
+        ? ['-bufsize', encodingBufferSize]
+        : [];
+    const maxRateArray = encodingMaxRate ? ['-maxrate', encodingMaxRate] : [];
+    if (videoBitrate) {
+        if (codec === 'prores') {
+            console.warn('ProRes does not support videoBitrate. Ignoring.');
+            return [];
+        }
+        if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+            console.warn(`${codec} does not support videoBitrate. Ignoring.`);
+            return [];
+        }
+        return ['-b:v', videoBitrate, ...bufSizeArray, ...maxRateArray];
+    }
+    if (crf === null || typeof crf === 'undefined') {
+        const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+        if (actualCrf === null) {
+            return [...bufSizeArray, ...maxRateArray];
+        }
+        return ['-crf', String(actualCrf), ...bufSizeArray, ...maxRateArray];
+    }
+    if (typeof crf !== 'number') {
+        throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
+    }
+    const range = (0, exports.getValidCrfRanges)(codec);
+    if (crf === 0 &&
+        (codec === 'h264' || codec === 'h264-mkv' || codec === 'h264-ts')) {
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably do not want. Set CRF to a higher value to fix this error.");
+    }
+    if (crf < range[0] || crf > range[1]) {
+        if (range[0] === 0 && range[1] === 0) {
+            throw new TypeError(`The "${codec}" codec does not support the --crf option.`);
+        }
+        throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
+    }
+    if (codec === 'prores') {
+        console.warn('ProRes does not support the "crf" option. Ignoring.');
+        return [];
+    }
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        console.warn(`${codec} does not support the "crf" option. Ignoring.`);
+        return [];
+    }
+    return ['-crf', String(crf), ...bufSizeArray, ...maxRateArray];
+};
+exports.validateQualitySettings = validateQualitySettings;

package/package/dist/cycle-browser-tabs.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from './log-level';
+import type { BrowserReplacer } from './replace-browser';
+export declare const cycleBrowserTabs: ({ puppeteerInstance, concurrency, logLevel, indent, }: {
+    puppeteerInstance: BrowserReplacer;
+    concurrency: number;
+    logLevel: LogLevel;
+    indent: boolean;
+}) => {
+    stopCycling: () => void;
+};

package/package/dist/cycle-browser-tabs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cycleBrowserTabs = void 0;
+const logger_1 = require("./logger");
+const cycleBrowserTabs = ({ puppeteerInstance, concurrency, logLevel, indent, }) => {
+    if (concurrency <= 1) {
+        return {
+            stopCycling: () => undefined,
+        };
+    }
+    let interval = null;
+    let i = 0;
+    let stopped = false;
+    const set = () => {
+        interval = setTimeout(() => {
+            puppeteerInstance
+                .getBrowser()
+                .pages()
+                .then((pages) => {
+                if (pages.length === 0) {
+                    return;
+                }
+                const currentPage = pages[i % pages.length];
+                i++;
+                if (!(currentPage === null || currentPage === void 0 ? void 0 : currentPage.closed) &&
+                    !stopped &&
+                    (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
+                    return currentPage.bringToFront();
+                }
+            })
+                .catch((err) => logger_1.Log.error({ indent, logLevel }, err))
+                .finally(() => {
+                if (!stopped) {
+                    set();
+                }
+            });
+        }, 200);
+    };
+    set();
+    return {
+        stopCycling: () => {
+            if (!interval) {
+                return;
+            }
+            stopped = true;
+            return clearTimeout(interval);
+        },
+    };
+};
+exports.cycleBrowserTabs = cycleBrowserTabs;

package/package/dist/default-on-log.d.ts

@@ -0,0 +1,2 @@
+import type { OnLog } from './browser/BrowserPage';
+export declare const defaultOnLog: OnLog;

package/package/dist/default-on-log.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOnLog = void 0;
+const logger_1 = require("./logger");
+const defaultOnLog = ({ logLevel, tag, previewString }) => {
+    logger_1.Log[logLevel]({ logLevel, tag, indent: false }, previewString);
+};
+exports.defaultOnLog = defaultOnLog;

package/package/dist/delay-render-embedded-stack.d.ts

@@ -0,0 +1,2 @@
+import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
+export declare const parseDelayRenderEmbeddedStack: (message: string) => UnsymbolicatedStackFrame[] | null;

package/package/dist/delay-render-embedded-stack.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDelayRenderEmbeddedStack = void 0;
+const no_react_1 = require("remotion/no-react");
+const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+const parseDelayRenderEmbeddedStack = (message) => {
+    const index = message.indexOf(no_react_1.NoReactInternals.DELAY_RENDER_CALLSTACK_TOKEN);
+    if (index === -1) {
+        return null;
+    }
+    const msg = message
+        .substring(index + no_react_1.NoReactInternals.DELAY_RENDER_CALLSTACK_TOKEN.length)
+        .trim();
+    const parsed = (0, parse_browser_error_stack_1.parseStack)(msg.split('\n'));
+    return parsed;
+};
+exports.parseDelayRenderEmbeddedStack = parseDelayRenderEmbeddedStack;

package/package/dist/delete-directory.d.ts

@@ -0,0 +1 @@
+export declare const deleteDirectory: (directory: string) => void;

package/package/dist/delete-directory.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteDirectory = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const is_serve_url_1 = require("./is-serve-url");
+const deleteDirectory = (directory) => {
+    if ((0, is_serve_url_1.isServeUrl)(directory)) {
+        return;
+    }
+    if (!(0, node_fs_1.existsSync)(directory)) {
+        return;
+    }
+    // Working around a bug with NodeJS 16 on Windows:
+    // If a subdirectory is already deleted, it will fail with EPERM
+    // even with force: true and recursive and maxRetries set higher.
+    // This is even with the fixWinEPERMSync function being called by Node.JS.
+    // This is a workaround for this issue.
+    let retries = 2;
+    while (retries >= 0) {
+        try {
+            node_fs_1.default.rmSync(directory, {
+                maxRetries: 2,
+                recursive: true,
+                force: true,
+                retryDelay: 100,
+            });
+        }
+        catch (_a) {
+            retries--;
+            continue;
+        }
+        break;
+    }
+};
+exports.deleteDirectory = deleteDirectory;

package/package/dist/ensure-browser.d.ts

@@ -0,0 +1,24 @@
+import type { BrowserExecutable } from './browser-executable';
+import type { BrowserSafeApis } from './client';
+import type { ChromeMode } from './options/chrome-mode';
+import type { ToOptions } from './options/option';
+export type BrowserStatus = {
+    type: 'user-defined-path';
+    path: string;
+} | {
+    type: 'local-puppeteer-browser';
+    path: string;
+} | {
+    type: 'no-browser';
+};
+type InternalEnsureBrowserOptions = {
+    browserExecutable: BrowserExecutable;
+    indent: boolean;
+    chromeMode: ChromeMode;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.ensureBrowser>;
+export type EnsureBrowserOptions = Partial<{
+    browserExecutable: BrowserExecutable;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.ensureBrowser>>;
+export declare const internalEnsureBrowser: (options: InternalEnsureBrowserOptions) => Promise<BrowserStatus>;
+export declare const ensureBrowser: (options?: EnsureBrowserOptions) => Promise<BrowserStatus>;
+export {};