@remotion/serverless 4.0.188

package/dist/constants.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artifactName = exports.overallProgressKey = exports.customOutName = exports.outName = exports.outStillName = exports.rendersPrefix = exports.REMOTION_BUCKET_PREFIX = exports.serverlessCodecs = exports.ServerlessRoutines = exports.expiryDays = void 0;
+// Needs to be in sync with renderer/src/options/delete-after.ts#L7
+exports.expiryDays = {
+    '1-day': 1,
+    '3-days': 3,
+    '7-days': 7,
+    '30-days': 30,
+};
+var ServerlessRoutines;
+(function (ServerlessRoutines) {
+    ServerlessRoutines["info"] = "info";
+    ServerlessRoutines["start"] = "start";
+    ServerlessRoutines["launch"] = "launch";
+    ServerlessRoutines["status"] = "status";
+    ServerlessRoutines["renderer"] = "renderer";
+    ServerlessRoutines["still"] = "still";
+    ServerlessRoutines["compositions"] = "compositions";
+})(ServerlessRoutines || (exports.ServerlessRoutines = ServerlessRoutines = {}));
+exports.serverlessCodecs = [
+    'h264',
+    'h265',
+    'vp8',
+    'vp9',
+    'mp3',
+    'aac',
+    'wav',
+    'gif',
+    'prores',
+];
+exports.REMOTION_BUCKET_PREFIX = 'remotionlambda-';
+const rendersPrefix = (renderId) => `renders/${renderId}`;
+exports.rendersPrefix = rendersPrefix;
+const outStillName = (renderId, imageFormat) => `${(0, exports.rendersPrefix)(renderId)}/out.${imageFormat}`;
+exports.outStillName = outStillName;
+const outName = (renderId, extension) => `${(0, exports.rendersPrefix)(renderId)}/out.${extension}`;
+exports.outName = outName;
+const customOutName = (renderId, bucketName, name) => {
+    var _a;
+    if (typeof name === 'string') {
+        return {
+            renderBucketName: bucketName,
+            key: `${(0, exports.rendersPrefix)(renderId)}/${name}`,
+            customCredentials: null,
+        };
+    }
+    return {
+        key: name.key,
+        renderBucketName: name.bucketName,
+        customCredentials: (_a = name.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+    };
+};
+exports.customOutName = customOutName;
+const overallProgressKey = (renderId) => `${(0, exports.rendersPrefix)(renderId)}/progress.json`;
+exports.overallProgressKey = overallProgressKey;
+const artifactName = (renderId, name) => `${(0, exports.rendersPrefix)(renderId)}/artifacts/${name}`;
+exports.artifactName = artifactName;

package/dist/error-category.d.ts

@@ -0,0 +1,3 @@
+export declare const errorIsOutOfSpaceError: (err: string) => boolean;
+export declare const isErrInsufficientResourcesErr: (err: string) => boolean;
+export declare const isBrowserCrashedError: (err: string) => boolean;

package/dist/error-category.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowserCrashedError = exports.isErrInsufficientResourcesErr = exports.errorIsOutOfSpaceError = void 0;
+const errorIsOutOfSpaceError = (err) => {
+    return (err.includes('ENOSPC') ||
+        err.toLowerCase().includes('no space left on device'));
+};
+exports.errorIsOutOfSpaceError = errorIsOutOfSpaceError;
+const isErrInsufficientResourcesErr = (err) => {
+    return err.includes('net::ERR_INSUFFICIENT_RESOURCES');
+};
+exports.isErrInsufficientResourcesErr = isErrInsufficientResourcesErr;
+const isBrowserCrashedError = (err) => {
+    return err.includes('Target closed.') || err.includes('Session closed');
+};
+exports.isBrowserCrashedError = isBrowserCrashedError;

package/dist/expected-out-name.d.ts

@@ -0,0 +1,5 @@
+import { type CustomCredentials, type OutNameInput, type OutNameOutput } from './constants';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './still';
+export declare const getCredentialsFromOutName: <Provider extends CloudProvider<string, Record<string, unknown>>>(name: OutNameInput<Provider> | null) => CustomCredentials<Provider> | null;
+export declare const getExpectedOutName: <Provider extends CloudProvider<string, Record<string, unknown>>>(renderMetadata: RenderMetadata<Provider>, bucketName: string, customCredentials: CustomCredentials<Provider> | null) => OutNameOutput<Provider>;

package/dist/expected-out-name.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpectedOutName = exports.getCredentialsFromOutName = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const constants_1 = require("./constants");
+const get_custom_out_name_1 = require("./get-custom-out-name");
+const validate_outname_1 = require("./validate-outname");
+const getCredentialsFromOutName = (name) => {
+    var _a;
+    if (typeof name === 'string') {
+        return null;
+    }
+    if (name === null) {
+        return null;
+    }
+    if (typeof name === 'undefined') {
+        return null;
+    }
+    return (_a = name.s3OutputProvider) !== null && _a !== void 0 ? _a : null;
+};
+exports.getCredentialsFromOutName = getCredentialsFromOutName;
+const getExpectedOutName = (renderMetadata, bucketName, customCredentials) => {
+    const outNameValue = (0, get_custom_out_name_1.getCustomOutName)({
+        customCredentials,
+        renderMetadata,
+    });
+    if (outNameValue) {
+        (0, validate_outname_1.validateOutname)({
+            outName: outNameValue,
+            codec: renderMetadata.codec,
+            audioCodecSetting: renderMetadata.audioCodec,
+            separateAudioTo: null,
+        });
+        return (0, constants_1.customOutName)(renderMetadata.renderId, bucketName, outNameValue);
+    }
+    if (renderMetadata.type === 'still') {
+        return {
+            renderBucketName: bucketName,
+            key: (0, constants_1.outStillName)(renderMetadata.renderId, renderMetadata.imageFormat),
+            customCredentials: null,
+        };
+    }
+    if (renderMetadata.type === 'video') {
+        return {
+            renderBucketName: bucketName,
+            key: (0, constants_1.outName)(renderMetadata.renderId, pure_1.NoReactAPIs.getFileExtensionFromCodec(renderMetadata.codec, renderMetadata.audioCodec)),
+            customCredentials: null,
+        };
+    }
+    throw new TypeError('no type passed');
+};
+exports.getExpectedOutName = getExpectedOutName;

package/dist/get-browser-instance.d.ts

@@ -0,0 +1,16 @@
+import type { ChromiumOptions, LogLevel, openBrowser } from '@remotion/renderer';
+import type { Await } from './await';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './still';
+type LaunchedBrowser = {
+    instance: Await<ReturnType<typeof openBrowser>>;
+    configurationString: string;
+};
+export declare const forgetBrowserEventLoop: (logLevel: LogLevel) => void;
+export declare const getBrowserInstance: <Provider extends CloudProvider<string, Record<string, unknown>>>({ logLevel, indent, chromiumOptions, providerSpecifics, }: {
+    logLevel: LogLevel;
+    indent: boolean;
+    chromiumOptions: ChromiumOptions;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => Promise<LaunchedBrowser>;
+export {};

package/dist/get-browser-instance.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserInstance = exports.forgetBrowserEventLoop = void 0;
+const renderer_1 = require("@remotion/renderer");
+const version_1 = require("remotion/version");
+const makeConfigurationString = (options, logLevel) => {
+    var _a, _b, _c;
+    return [
+        `web-security-${Boolean(options.disableWebSecurity)}`,
+        `multi-process-${Boolean(options.enableMultiProcessOnLinux)}`,
+        `ignore-certificate-errors-${Boolean(options.ignoreCertificateErrors)}`,
+        `log-level-${logLevel}`,
+        `gl-${(_a = options.gl) !== null && _a !== void 0 ? _a : null}`,
+        `userAgent-${(_b = options.userAgent) !== null && _b !== void 0 ? _b : null}`,
+        `headless-${(_c = options.headless) !== null && _c !== void 0 ? _c : false}`,
+    ].join('/');
+};
+let _browserInstance;
+let launching = false;
+const waitForLaunched = () => {
+    return new Promise((resolve, reject) => {
+        const check = () => setTimeout(() => {
+            if (launching) {
+                check();
+            }
+            else {
+                resolve();
+            }
+        }, 16);
+        setTimeout(() => reject(new Error('Timeout launching browser')), 5000);
+        check();
+    });
+};
+const forgetBrowserEventLoop = (logLevel) => {
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Keeping browser open for next invocation');
+    _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance.forgetEventLoop();
+};
+exports.forgetBrowserEventLoop = forgetBrowserEventLoop;
+const getBrowserInstance = async ({ logLevel, indent, chromiumOptions, providerSpecifics, }) => {
+    var _a;
+    const actualChromiumOptions = {
+        ...chromiumOptions,
+        // Override the `null` value, which might come from CLI with swANGLE
+        gl: (_a = chromiumOptions.gl) !== null && _a !== void 0 ? _a : 'swangle',
+        enableMultiProcessOnLinux: false,
+    };
+    const configurationString = makeConfigurationString(actualChromiumOptions, logLevel);
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Rendering with Remotion v${version_1.VERSION}.`);
+    if (launching) {
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Already waiting for browser launch...');
+        await waitForLaunched();
+        if (!_browserInstance) {
+            throw new Error('expected to launch');
+        }
+    }
+    if (!_browserInstance) {
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Cold function, launching new browser instance');
+        launching = true;
+        const execPath = providerSpecifics.getChromiumPath();
+        const instance = await renderer_1.RenderInternals.internalOpenBrowser({
+            browser: 'chrome',
+            browserExecutable: execPath,
+            chromiumOptions: actualChromiumOptions,
+            forceDeviceScaleFactor: undefined,
+            indent: false,
+            viewport: null,
+            logLevel,
+            onBrowserDownload: () => {
+                throw new Error('Should not download a browser in serverless');
+            },
+        });
+        instance.on('disconnected', () => {
+            var _a;
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Browser disconnected or crashed.');
+            (0, exports.forgetBrowserEventLoop)(logLevel);
+            (_a = _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance) === null || _a === void 0 ? void 0 : _a.close(true, logLevel, indent).catch((err) => {
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Could not close browser instance', err);
+            });
+            _browserInstance = null;
+        });
+        _browserInstance = {
+            instance,
+            configurationString,
+        };
+        launching = false;
+        return _browserInstance;
+    }
+    if (_browserInstance.configurationString !== configurationString) {
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Warm function, but Browser configuration changed. Killing old browser instance.');
+        _browserInstance.instance.rememberEventLoop();
+        await _browserInstance.instance.close(true, logLevel, indent);
+        _browserInstance = null;
+        return (0, exports.getBrowserInstance)({
+            logLevel,
+            indent,
+            chromiumOptions,
+            providerSpecifics,
+        });
+    }
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Warm function, reusing browser instance');
+    _browserInstance.instance.rememberEventLoop();
+    return _browserInstance;
+};
+exports.getBrowserInstance = getBrowserInstance;

package/dist/get-custom-out-name.d.ts

@@ -0,0 +1,7 @@
+import type { CustomCredentials, OutNameInput } from './constants';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './still';
+export declare const getCustomOutName: <Provider extends CloudProvider<string, Record<string, unknown>>>({ renderMetadata, customCredentials, }: {
+    renderMetadata: RenderMetadata<Provider>;
+    customCredentials: CustomCredentials<Provider> | null;
+}) => OutNameInput<Provider> | null;

package/dist/get-custom-out-name.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomOutName = void 0;
+const getCustomOutName = ({ renderMetadata, customCredentials, }) => {
+    var _a, _b;
+    if (!renderMetadata.outName) {
+        return null;
+    }
+    if (typeof renderMetadata.outName === 'string') {
+        return renderMetadata.outName;
+    }
+    if (renderMetadata.outName.s3OutputProvider) {
+        if (!customCredentials && renderMetadata.privacy === 'private') {
+            throw new TypeError(`The file was rendered with a custom S3 implementation and is not public, but no custom credentials were passed to downloadMedia().`);
+        }
+        return {
+            bucketName: renderMetadata.outName.bucketName,
+            key: renderMetadata.outName.key,
+            s3OutputProvider: {
+                endpoint: renderMetadata.outName.s3OutputProvider.endpoint,
+                accessKeyId: (_a = customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.accessKeyId) !== null && _a !== void 0 ? _a : null,
+                secretAccessKey: (_b = customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.secretAccessKey) !== null && _b !== void 0 ? _b : null,
+                region: customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.region,
+            },
+        };
+    }
+    return {
+        bucketName: renderMetadata.outName.bucketName,
+        key: renderMetadata.outName.key,
+    };
+};
+exports.getCustomOutName = getCustomOutName;

package/dist/get-files-in-folder.d.ts

@@ -0,0 +1,5 @@
+export type FileNameAndSize = {
+    filename: string;
+    size: number;
+};
+export type GetFolderFiles = (folder: string) => FileNameAndSize[];

package/dist/get-files-in-folder.js

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

package/dist/get-or-create-bucket.d.ts

@@ -0,0 +1,20 @@
+import type { CustomCredentials } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './still';
+type GetOrCreateBucketInputInner<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    enableFolderExpiry: boolean | null;
+    customCredentials: CustomCredentials<Provider> | null;
+    providerSpecifics: ProviderSpecifics<Provider>;
+};
+export type GetOrCreateBucketInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    enableFolderExpiry?: boolean;
+    customCredentials?: CustomCredentials<Provider>;
+};
+export type GetOrCreateBucketOutput = {
+    bucketName: string;
+    alreadyExisted: boolean;
+};
+export declare const internalGetOrCreateBucket: <Provider extends CloudProvider<string, Record<string, unknown>>>(params: GetOrCreateBucketInputInner<Provider>) => Promise<GetOrCreateBucketOutput>;
+export {};

package/dist/get-or-create-bucket.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalGetOrCreateBucket = void 0;
+const constants_1 = require("./constants");
+const make_bucket_name_1 = require("./make-bucket-name");
+const internalGetOrCreateBucket = async (params) => {
+    const remotionBuckets = await params.providerSpecifics.getBuckets(params.region);
+    if (remotionBuckets.length > 1) {
+        throw new Error(`You have multiple buckets (${remotionBuckets.map((b) => b.name)}) in your S3 region (${params.region}) starting with "${constants_1.REMOTION_BUCKET_PREFIX}". Please see https://remotion.dev/docs/lambda/multiple-buckets.`);
+    }
+    const { enableFolderExpiry, region } = params;
+    if (remotionBuckets.length === 1) {
+        const existingBucketName = remotionBuckets[0].name;
+        // apply to existing bucket
+        await params.providerSpecifics.applyLifeCycle({
+            enableFolderExpiry: enableFolderExpiry !== null && enableFolderExpiry !== void 0 ? enableFolderExpiry : null,
+            bucketName: existingBucketName,
+            region,
+            customCredentials: params.customCredentials,
+        });
+        return { bucketName: remotionBuckets[0].name, alreadyExisted: true };
+    }
+    const bucketName = (0, make_bucket_name_1.makeBucketName)(params.region, params.providerSpecifics);
+    await params.providerSpecifics.createBucket({
+        bucketName,
+        region: params.region,
+    });
+    // apply to newly created bucket
+    await params.providerSpecifics.applyLifeCycle({
+        enableFolderExpiry: enableFolderExpiry !== null && enableFolderExpiry !== void 0 ? enableFolderExpiry : null,
+        bucketName,
+        region,
+        customCredentials: params.customCredentials,
+    });
+    return { bucketName, alreadyExisted: false };
+};
+exports.internalGetOrCreateBucket = internalGetOrCreateBucket;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { compositionsHandler } from './compositions';
+export { errorIsOutOfSpaceError, isBrowserCrashedError, isErrInsufficientResourcesErr, } from './error-category';
+export { getCredentialsFromOutName } from './expected-out-name';
+export { forgetBrowserEventLoop, getBrowserInstance, } from './get-browser-instance';
+export { infoHandler } from './info';
+export { MakeArtifactWithDetails, ProviderSpecifics, WriteFileInput, } from './provider-implementation';
+export { deserializeArtifact, serializeArtifact } from './serialize-artifact';
+export { CloudProvider, CostsInfo, ReceivedArtifact, RenderStillLambdaResponsePayload, } from './still';
+export { ResponseStream } from './streaming/response-stream';
+export { ResponseStreamWriter, streamWriter } from './streaming/stream-writer';
+export { type OnMessage, type OnStream, type StreamingMessage, type StreamingPayload, } from './streaming/streaming';
+export { validateComposition } from './validate-composition';
+export { validateOutname } from './validate-outname';
+export { MAX_WEBHOOK_CUSTOM_DATA_SIZE, validateWebhook, } from './validate-webhook';
+export { EnhancedErrorInfo, LambdaErrorInfo, getTmpDirStateIfENoSp, } from './write-lambda-error';

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTmpDirStateIfENoSp = exports.validateWebhook = exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = exports.validateOutname = exports.validateComposition = exports.streamWriter = exports.ResponseStream = exports.serializeArtifact = exports.deserializeArtifact = exports.infoHandler = exports.getBrowserInstance = exports.forgetBrowserEventLoop = exports.getCredentialsFromOutName = exports.isErrInsufficientResourcesErr = exports.isBrowserCrashedError = exports.errorIsOutOfSpaceError = exports.compositionsHandler = void 0;
+var compositions_1 = require("./compositions");
+Object.defineProperty(exports, "compositionsHandler", { enumerable: true, get: function () { return compositions_1.compositionsHandler; } });
+var error_category_1 = require("./error-category");
+Object.defineProperty(exports, "errorIsOutOfSpaceError", { enumerable: true, get: function () { return error_category_1.errorIsOutOfSpaceError; } });
+Object.defineProperty(exports, "isBrowserCrashedError", { enumerable: true, get: function () { return error_category_1.isBrowserCrashedError; } });
+Object.defineProperty(exports, "isErrInsufficientResourcesErr", { enumerable: true, get: function () { return error_category_1.isErrInsufficientResourcesErr; } });
+var expected_out_name_1 = require("./expected-out-name");
+Object.defineProperty(exports, "getCredentialsFromOutName", { enumerable: true, get: function () { return expected_out_name_1.getCredentialsFromOutName; } });
+var get_browser_instance_1 = require("./get-browser-instance");
+Object.defineProperty(exports, "forgetBrowserEventLoop", { enumerable: true, get: function () { return get_browser_instance_1.forgetBrowserEventLoop; } });
+Object.defineProperty(exports, "getBrowserInstance", { enumerable: true, get: function () { return get_browser_instance_1.getBrowserInstance; } });
+var info_1 = require("./info");
+Object.defineProperty(exports, "infoHandler", { enumerable: true, get: function () { return info_1.infoHandler; } });
+var serialize_artifact_1 = require("./serialize-artifact");
+Object.defineProperty(exports, "deserializeArtifact", { enumerable: true, get: function () { return serialize_artifact_1.deserializeArtifact; } });
+Object.defineProperty(exports, "serializeArtifact", { enumerable: true, get: function () { return serialize_artifact_1.serializeArtifact; } });
+var response_stream_1 = require("./streaming/response-stream");
+Object.defineProperty(exports, "ResponseStream", { enumerable: true, get: function () { return response_stream_1.ResponseStream; } });
+var stream_writer_1 = require("./streaming/stream-writer");
+Object.defineProperty(exports, "streamWriter", { enumerable: true, get: function () { return stream_writer_1.streamWriter; } });
+var validate_composition_1 = require("./validate-composition");
+Object.defineProperty(exports, "validateComposition", { enumerable: true, get: function () { return validate_composition_1.validateComposition; } });
+var validate_outname_1 = require("./validate-outname");
+Object.defineProperty(exports, "validateOutname", { enumerable: true, get: function () { return validate_outname_1.validateOutname; } });
+var validate_webhook_1 = require("./validate-webhook");
+Object.defineProperty(exports, "MAX_WEBHOOK_CUSTOM_DATA_SIZE", { enumerable: true, get: function () { return validate_webhook_1.MAX_WEBHOOK_CUSTOM_DATA_SIZE; } });
+Object.defineProperty(exports, "validateWebhook", { enumerable: true, get: function () { return validate_webhook_1.validateWebhook; } });
+var write_lambda_error_1 = require("./write-lambda-error");
+Object.defineProperty(exports, "getTmpDirStateIfENoSp", { enumerable: true, get: function () { return write_lambda_error_1.getTmpDirStateIfENoSp; } });

package/dist/info.d.ts

@@ -0,0 +1,6 @@
+import type { ServerlessPayload } from './constants';
+import type { CloudProvider } from './still';
+export declare const infoHandler: <Provider extends CloudProvider<string, Record<string, unknown>>>(serverlessParams: ServerlessPayload<Provider>) => Promise<{
+    version: string;
+    type: "success";
+}>;

package/dist/info.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoHandler = void 0;
+const version_1 = require("remotion/version");
+const constants_1 = require("./constants");
+const infoHandler = (serverlessParams) => {
+    if (serverlessParams.type !== constants_1.ServerlessRoutines.info) {
+        throw new TypeError('Expected info type');
+    }
+    const returnValue = {
+        version: version_1.VERSION,
+        type: 'success',
+    };
+    return Promise.resolve(returnValue);
+};
+exports.infoHandler = infoHandler;

package/dist/input-props-keys.d.ts

@@ -0,0 +1,2 @@
+export declare const inputPropsKey: (hash: string) => string;
+export declare const resolvedPropsKey: (hash: string) => string;

package/dist/input-props-keys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvedPropsKey = exports.inputPropsKey = void 0;
+const inputPropsKey = (hash) => {
+    return `input-props/${hash}.json`;
+};
+exports.inputPropsKey = inputPropsKey;
+const resolvedPropsKey = (hash) => {
+    return `resolved-props/${hash}.json`;
+};
+exports.resolvedPropsKey = resolvedPropsKey;

package/dist/make-bucket-name.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './still';
+export declare const makeBucketName: <Provider extends CloudProvider<string, Record<string, unknown>>>(region: Provider["region"], providerSpecifics: ProviderSpecifics<Provider>) => string;

package/dist/make-bucket-name.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBucketName = void 0;
+const constants_1 = require("./constants");
+const makeBucketName = (region, providerSpecifics) => {
+    return `${constants_1.REMOTION_BUCKET_PREFIX}${region.replace(/-/g, '')}-${providerSpecifics.randomHash()}`;
+};
+exports.makeBucketName = makeBucketName;

package/dist/provider-implementation.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+import type { EmittedArtifact } from '@remotion/renderer';
+import type { Readable } from 'stream';
+import type { CustomCredentials, DownloadBehavior, Privacy } from './constants';
+import type { GetFolderFiles } from './get-files-in-folder';
+import type { CloudProvider, ReceivedArtifact } from './still';
+export type BucketWithLocation<Provider extends CloudProvider> = {
+    name: string;
+    creationDate: number;
+    region: Provider['region'];
+};
+type GetBuckets<Provider extends CloudProvider> = (region: Provider['region'], forceBucketName?: string) => Promise<BucketWithLocation<Provider>[]>;
+type CreateBucket<Provider extends CloudProvider> = (params: {
+    region: Provider['region'];
+    bucketName: string;
+}) => Promise<void>;
+type ApplyLifeCycle<Provider extends CloudProvider> = (params: {
+    enableFolderExpiry: boolean | null;
+    bucketName: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+}) => Promise<void>;
+type BucketObject = {
+    Key: string;
+    LastModified: Date;
+    ETag: string;
+    Size: number;
+};
+type ListObjects<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    prefix: string;
+    region: Provider['region'];
+    expectedBucketOwner: string | null;
+    continuationToken?: string;
+}) => Promise<BucketObject[]>;
+type DeleteFile<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+}) => Promise<void>;
+type BucketExists<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    region: Provider['region'];
+    expectedBucketOwner: string | null;
+}) => Promise<boolean>;
+type ReadFile<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    expectedBucketOwner: string;
+}) => Promise<Readable>;
+export type WriteFileInput<Provider extends CloudProvider> = {
+    bucketName: string;
+    key: string;
+    body: Readable | string | Uint8Array;
+    region: Provider['region'];
+    privacy: Privacy;
+    expectedBucketOwner: string | null;
+    downloadBehavior: DownloadBehavior | null;
+    customCredentials: CustomCredentials<Provider> | null;
+};
+type WriteFile<Provider extends CloudProvider> = (params: WriteFileInput<Provider>) => Promise<void>;
+type HeadFileInput<Provider extends CloudProvider> = {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+};
+type HeadFileOutput = {
+    LastModified?: Date | undefined;
+    ContentLength?: number | undefined;
+};
+type HeadFile<Provider extends CloudProvider> = (params: HeadFileInput<Provider>) => Promise<HeadFileOutput>;
+type RandomHash = () => string;
+type ConvertToServeUrl<Provider extends CloudProvider> = (params: {
+    urlOrId: string;
+    region: Provider['region'];
+    bucketName: string;
+}) => string;
+export type MakeArtifactWithDetails<Provider extends CloudProvider> = (params: {
+    region: Provider['region'];
+    renderBucketName: string;
+    storageKey: string;
+    artifact: EmittedArtifact;
+}) => ReceivedArtifact<Provider>;
+export type ProviderSpecifics<Provider extends CloudProvider> = {
+    getChromiumPath: () => string | null;
+    getCurrentRegionInFunction: () => Provider['region'];
+    getBuckets: GetBuckets<Provider>;
+    createBucket: CreateBucket<Provider>;
+    applyLifeCycle: ApplyLifeCycle<Provider>;
+    listObjects: ListObjects<Provider>;
+    deleteFile: DeleteFile<Provider>;
+    bucketExists: BucketExists<Provider>;
+    randomHash: RandomHash;
+    readFile: ReadFile<Provider>;
+    writeFile: WriteFile<Provider>;
+    headFile: HeadFile<Provider>;
+    convertToServeUrl: ConvertToServeUrl<Provider>;
+    printLoggingHelper: boolean;
+    getFolderFiles: GetFolderFiles;
+    makeArtifactWithDetails: MakeArtifactWithDetails<Provider>;
+};
+export {};

package/dist/provider-implementation.js

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

package/dist/random-hash.d.ts

@@ -0,0 +1,3 @@
+export declare const randomHash: (_options?: {
+    randomInTests: boolean;
+}) => string;

package/dist/random-hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomHash = void 0;
+const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const randomHash = (_options) => {
+    return new Array(10)
+        .fill(1)
+        .map(() => {
+        return alphabet[Math.floor(Math.random() * alphabet.length)];
+    })
+        .join('');
+};
+exports.randomHash = randomHash;

package/dist/region.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_AWS_REGIONS: readonly ["eu-central-1", "eu-west-1", "eu-west-2", "eu-west-3", "eu-north-1", "us-east-1", "us-east-2", "us-west-1", "us-west-2", "ap-south-1", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ap-northeast-2", "ap-northeast-3", "ca-central-1", "sa-east-1"];
+export declare const AWS_REGIONS: readonly ["eu-central-1", "eu-west-1", "eu-west-2", "eu-west-3", "eu-south-1", "eu-north-1", "us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-south-1", "ap-east-1", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ap-northeast-2", "ap-northeast-3", "ca-central-1", "me-south-1", "sa-east-1"];
+export type AwsRegion = (typeof AWS_REGIONS)[number];