@gravity-ui/app-builder 0.0.1

package/dist/common/logger/index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const colors_1 = require("./colors");
+const pretty_time_1 = require("./pretty-time");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const allColors = [
+    colors_1.colors.cyan.bold,
+    colors_1.colors.blue.bold,
+    colors_1.colors.yellow.bold,
+    colors_1.colors.magenta.bold,
+    colors_1.colors.green.bold,
+    colors_1.colors.grey.bold,
+];
+function selectColor(namespace) {
+    var _a;
+    let hash = 0;
+    for (let i = 0; i < namespace.length; i++) {
+        /* eslint-disable no-bitwise */
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0; // Convert to 32bit integer
+        /* eslint-enable no-bitwise */
+    }
+    return (_a = allColors[Math.abs(hash) % allColors.length]) !== null && _a !== void 0 ? _a : colors_1.colors.green.bold;
+}
+class Logger {
+    constructor(namespace = '', verbose = false) {
+        this.colors = colors_1.colors;
+        this._verbose = false;
+        this._namespace = '';
+        this._timestamp = BigInt(0);
+        this._color = colors_1.colors.black;
+        this.print = (message, { verbose = false, wrap = false } = {}) => {
+            if (verbose && !this._verbose) {
+                return;
+            }
+            const prefix = this._namespace ? this._color(`[${this._namespace}]`) + ' ' : '';
+            const postfix = this._timestamp > 0 ? ' ' + this._color(`+${(0, pretty_time_1.elapsedTime)(this._timestamp)}`) : '';
+            let output = prefix + message + postfix;
+            if (wrap) {
+                const width = process.stdout.columns || (process.stdout.isTTY ? 80 : 200);
+                if ((0, strip_ansi_1.default)(output).length > width) {
+                    output =
+                        prefix + message.slice(0, width - (0, strip_ansi_1.default)(prefix + postfix).length) + postfix;
+                }
+            }
+            process.stdout.write(output);
+        };
+        this.printLn = (message, { verbose = false } = {}) => {
+            if (verbose && !this._verbose) {
+                return;
+            }
+            this.clearLine();
+            this.print(message);
+            process.stdout.write('\n');
+            this._timestamp = process.hrtime.bigint();
+        };
+        this.clearLine = () => {
+            if (process.stdout.isTTY) {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+            }
+        };
+        this.status = (msg) => {
+            if (process.stdout.isTTY) {
+                this.clearLine();
+                this.print(msg, { wrap: true });
+            }
+        };
+        this.message = (...args) => {
+            this.printLn(args.join(' '));
+        };
+        this.success = (...args) => {
+            this.printLn(this.colors.green(...args));
+        };
+        this.warning = (...args) => {
+            this.printLn(this.colors.yellow(...args));
+        };
+        this.error = (...args) => {
+            this.printLn(this.colors.red(...args));
+        };
+        this.logError = (errorMeta, error) => {
+            this.error(errorMeta);
+            if (error) {
+                const { name, message, stack } = error;
+                this.error(name);
+                this.error(message);
+                if (stack) {
+                    this.error(stack);
+                }
+            }
+        };
+        this.panic = (errorMeta, error) => {
+            this.logError(errorMeta, error);
+            process.exit(1);
+        };
+        this.setVerbose = (verbose) => {
+            this._verbose = verbose;
+        };
+        this.verbose = (...args) => {
+            this.printLn(this.colors.dim(...args), { verbose: true });
+        };
+        this.setNamespace = (namespace) => {
+            this._namespace = namespace;
+            this._color = selectColor(namespace);
+        };
+        this._verbose = verbose;
+        if (namespace) {
+            this.setNamespace(namespace);
+        }
+    }
+    get isVerbose() {
+        return this._verbose;
+    }
+}
+exports.Logger = Logger;
+exports.default = new Logger();

package/dist/common/logger/pretty-time.d.ts

@@ -0,0 +1,2 @@
+export declare function elapsedTime(time: bigint, smallest?: string): string;
+export declare function prettyTime(time: bigint, smallest?: string): string;

package/dist/common/logger/pretty-time.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyTime = exports.elapsedTime = void 0;
+const scale = {
+    w: BigInt(6048e11),
+    d: BigInt(864e11),
+    h: BigInt(36e11),
+    m: BigInt(6e10),
+    s: BigInt(1e9),
+    ms: BigInt(1e6),
+    μs: BigInt(1e3),
+    ns: BigInt(1),
+};
+function elapsedTime(time, smallest = 'ms') {
+    const elapsed = process.hrtime.bigint() - time;
+    return prettyTime(elapsed, smallest);
+}
+exports.elapsedTime = elapsedTime;
+function prettyTime(time, smallest = 'ms') {
+    let elapsed = time;
+    let res = '';
+    let count = 0;
+    for (const [uom, step] of Object.entries(scale)) {
+        if (count === 3) {
+            break;
+        }
+        let inc = elapsed / step;
+        if (inc === BigInt(0)) {
+            if (smallest === uom) {
+                break;
+            }
+            if (count > 0) {
+                count++;
+            }
+            continue;
+        }
+        count++;
+        elapsed -= inc * step;
+        if (count === 3 || smallest === uom) {
+            if (inc < BigInt(999) && (elapsed * BigInt(10)) / step >= BigInt(5)) {
+                inc = inc + BigInt(1);
+            }
+        }
+        res += inc + uom + ' ';
+        if (smallest === uom) {
+            break;
+        }
+    }
+    return res || '0ms';
+}
+exports.prettyTime = prettyTime;

package/dist/common/models/index.d.ts

@@ -0,0 +1,184 @@
+import type { EditorLanguage } from 'monaco-editor-webpack-plugin/out/languages';
+import type { EditorFeature } from 'monaco-editor-webpack-plugin/out/features';
+import type { IFeatureDefinition } from 'monaco-editor-webpack-plugin/out/types';
+import type { Options as MomentTzOptions } from 'moment-timezone-data-webpack-plugin';
+import type { Configuration, ResolveOptions, DefinePlugin } from 'webpack';
+import type { ServerConfiguration } from 'webpack-dev-server';
+import type { Options as CircularDependenciesOptions } from 'circular-dependency-plugin';
+export interface Entities<T> {
+    data: Record<string, T>;
+    keys: string[];
+}
+export interface LinkedPackage {
+    name: string;
+    location: string;
+    nodeModules: string[];
+    package?: string;
+    restorePackageFrom?: string;
+    typescript?: boolean;
+}
+interface DevServerConfig {
+    ipc?: string;
+    port?: number | true;
+    webSocketPath?: string;
+    type?: 'https';
+    options?: import('https').ServerOptions;
+}
+interface ContextReplacement {
+    'highlight.js'?: string[];
+    moment?: string[];
+}
+export interface LibraryConfig {
+    lib?: {
+        internalDirs?: string[];
+    };
+    /**
+     * Use new JSX Transform
+     */
+    newJsxTransform?: boolean;
+    verbose?: boolean;
+}
+export interface ClientConfig {
+    modules?: string[];
+    /**
+     * Resolve [alias](https://webpack.js.org/configuration/resolve/#resolvealias)
+     */
+    alias?: Record<string, string>;
+    /**
+     * Additional compilation paths
+     */
+    includes?: string[];
+    /**
+     * Additional paths fro images
+     */
+    images?: string[];
+    /**
+     * Additional paths for svg icons
+     */
+    icons?: string[];
+    devServer?: DevServerConfig;
+    contextReplacement?: ContextReplacement;
+    /**
+     *  publicPath prefix, will be added to '/build/'
+     */
+    publicPathPrefix?: string;
+    /**
+     * Add monaco-editor support
+     */
+    monaco?: {
+        filename?: string;
+        languages?: EditorLanguage[];
+        features?: EditorFeature[];
+        customLanguages?: IFeatureDefinition[];
+    };
+    /**
+     * if false - source maps will be generated for prod builds,
+     */
+    hiddenSourceMap?: boolean;
+    /**
+     * additional libraries for vendor chunk
+     */
+    vendors?: string[];
+    /**
+     * [settings](https://www.npmjs.com/package/moment-timezone-data-webpack-plugin) for moment-timezone (by default data is truncated)
+     */
+    momentTz?: MomentTzOptions;
+    /**
+     * Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.
+     */
+    externals?: Configuration['externals'];
+    /**
+     * Include polyfills or mocks for various node stuff.
+     */
+    node?: Configuration['node'];
+    /**
+     * Redirect module requests when normal resolving fails.
+     */
+    fallback?: ResolveOptions['fallback'];
+    /**
+     * Follow symbolic links while looking for a file. [more](https://webpack.js.org/configuration/resolve/#resolvesymlinks)
+     */
+    symlinks?: boolean;
+    /**
+     * Enables `safari10` terser's option. [Terser options](https://github.com/terser/terser#minify-options)
+     */
+    safari10?: boolean;
+    /**
+     * svgr plugin options.
+     */
+    svgr?: Object;
+    entryFilter?: string[];
+    excludeFromClean?: string[];
+    analyzeBundle?: 'true' | 'statoscope';
+    reactProfiling?: boolean;
+    /**
+     *  Disable react-refresh in dev mode
+     */
+    disableReactRefresh?: boolean;
+    /**
+     * Detect modules with circular dependencies
+     */
+    detectCircularDependencies?: true | CircularDependenciesOptions;
+    /**
+     * use new JSX Transform
+     */
+    newJsxTransform?: boolean;
+    disableForkTsChecker?: boolean;
+    disableSourceMapGeneration?: boolean;
+    lazyCompilation?: boolean | {
+        port?: number;
+    };
+    polyfill?: {
+        process?: boolean;
+    };
+    definitions?: DefinePlugin['definitions'];
+    watchOptions?: Configuration['watchOptions'];
+    cdn?: {
+        bucket: string;
+        prefix?: string;
+        region?: string;
+        endpoint?: string;
+        compress?: boolean;
+    };
+}
+export interface ServerConfig {
+    port?: number | true;
+    watch?: string[];
+    watchThrottle?: number;
+    inspect?: number;
+    inspectBrk?: number;
+}
+export interface ServiceConfig {
+    target?: 'client' | 'server';
+    client?: ClientConfig;
+    server?: ServerConfig;
+    link?: string;
+    verbose?: boolean;
+}
+export type NormalizedClientConfig = Omit<ClientConfig, 'publicPathPrefix' | 'hiddenSourceMap' | 'svgr' | 'lazyCompilation' | 'devServer'> & {
+    publicPathPrefix: string;
+    hiddenSourceMap: boolean;
+    svgr: NonNullable<ClientConfig['svgr']>;
+    lazyCompilation?: {
+        port: number;
+    };
+    devServer: Omit<DevServerConfig, 'port' | 'type' | 'options'> & {
+        port?: number;
+        server: ServerConfiguration;
+    };
+    verbose?: boolean;
+};
+export type NormalizedServerConfig = Omit<ServerConfig, 'serverPort'> & {
+    serverPort?: number;
+    verbose?: boolean;
+};
+export type NormalizedServiceConfig = Omit<ServiceConfig, 'client' | 'server'> & {
+    client: NormalizedClientConfig;
+    server: NormalizedServerConfig;
+};
+export type ProjectConfig = {} & (ServiceConfig | LibraryConfig);
+export type AppBuilderConfigPackage = (options?: unknown) => ProjectConfig;
+export type ProjectFileConfig = ProjectConfig | ((mode: 'dev' | 'build', env?: Record<string, any>) => ProjectConfig);
+export declare function isServiceConfig(config: ProjectConfig): config is ServiceConfig;
+export declare function isLibraryConfig(config: ProjectConfig): config is LibraryConfig;
+export {};

package/dist/common/models/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLibraryConfig = exports.isServiceConfig = void 0;
+function isServiceConfig(config) {
+    return !('lib' in config);
+}
+exports.isServiceConfig = isServiceConfig;
+function isLibraryConfig(config) {
+    return 'lib' in config;
+}
+exports.isLibraryConfig = isLibraryConfig;

package/dist/common/package.d.ts

@@ -0,0 +1,19 @@
+import type { Entities, ProjectConfig } from './models';
+interface PackageInfo {
+    name: string;
+    version: string;
+    peerDependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    location: string;
+    'app-builder'?: ProjectConfig;
+}
+export declare function readPackage(location: string): {
+    location: string;
+    name: string;
+    version: string;
+    peerDependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    'app-builder'?: ProjectConfig | undefined;
+};
+export declare function readNodeModules(location: string): Entities<PackageInfo>;
+export {};

package/dist/common/package.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNodeModules = exports.readPackage = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readPackage(location) {
+    const packageJsonLocation = path_1.default.resolve(location, 'package.json');
+    if (!fs_1.default.existsSync(packageJsonLocation)) {
+        throw new Error(`package.json not found in ${location}`);
+    }
+    try {
+        const packageJson = fs_1.default.readFileSync(packageJsonLocation, 'utf-8');
+        return Object.assign(Object.assign({}, JSON.parse(packageJson)), { location });
+    }
+    catch (e) {
+        throw new Error(`Couldn't read package.json at ${location}`);
+    }
+}
+exports.readPackage = readPackage;
+function readNodeModules(location) {
+    const dirContents = fs_1.default.readdirSync(location);
+    return dirContents.reduce((acc, nodeModule) => {
+        if (!nodeModule.startsWith('.')) {
+            const nodeModulePath = path_1.default.resolve(location, nodeModule);
+            if (fs_1.default.existsSync(path_1.default.resolve(nodeModulePath, 'package.json'))) {
+                const packageInfo = readPackage(nodeModulePath);
+                acc.data[packageInfo.name] = packageInfo;
+                acc.keys.push(packageInfo.name);
+            }
+            else {
+                const { data, keys } = readNodeModules(nodeModulePath);
+                acc.data = Object.assign(Object.assign({}, acc.data), data);
+                acc.keys = [...acc.keys, ...keys];
+            }
+        }
+        return acc;
+    }, { data: {}, keys: [] });
+}
+exports.readNodeModules = readNodeModules;

package/dist/common/paths.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    app: string;
+    appNodeModules: string;
+    appClient: string;
+    appServer: string;
+    appEntry: string;
+    appDist: string;
+    appRun: string;
+    appBuild: string;
+    src: string;
+    libBuild: string;
+    libBuildEsm: string;
+    libBuildCjs: string;
+    libAssets: string;
+    libGlobalStyles: string;
+    libCompiledGlobalStyles: string;
+    libCompiledAssetsEsm: string;
+    libCompiledAssetsCjs: string;
+};
+export default _default;

package/dist/common/paths.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const appDirectory = fs_1.default.realpathSync(process.cwd());
+const resolveApp = (relativePath) => path_1.default.resolve(appDirectory, relativePath);
+exports.default = {
+    app: resolveApp('.'),
+    appNodeModules: resolveApp('node_modules'),
+    appClient: resolveApp('src/ui'),
+    appServer: resolveApp('src/server'),
+    appEntry: resolveApp('src/ui/entries'),
+    appDist: resolveApp('dist'),
+    appRun: resolveApp('dist/run'),
+    appBuild: resolveApp('dist/public/build'),
+    src: resolveApp('src'),
+    libBuild: resolveApp('build'),
+    libBuildEsm: resolveApp('build/esm'),
+    libBuildCjs: resolveApp('build/cjs'),
+    libAssets: resolveApp('assets'),
+    libGlobalStyles: resolveApp('styles'),
+    libCompiledGlobalStyles: resolveApp('build/styles'),
+    libCompiledAssetsEsm: resolveApp('build/esm/assets'),
+    libCompiledAssetsCjs: resolveApp('build/cjs/assets'),
+};

package/dist/common/s3-upload/compress.d.ts

@@ -0,0 +1,2 @@
+export declare function gzip(sourcePath: string): Promise<string>;
+export declare function brotli(sourcePath: string): Promise<string>;

package/dist/common/s3-upload/compress.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brotli = exports.gzip = void 0;
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+function compressor(sourcePath, destinationPath, transformer) {
+    return new Promise((resolve, reject) => {
+        const sourceStream = (0, fs_1.createReadStream)(sourcePath);
+        sourceStream.on('error', reject);
+        const destinationStream = (0, fs_1.createWriteStream)(destinationPath);
+        destinationStream.on('finish', () => resolve(destinationPath));
+        destinationStream.on('error', reject);
+        sourceStream.pipe(transformer).pipe(destinationStream);
+    });
+}
+function gzip(sourcePath) {
+    return compressor(sourcePath, `${sourcePath}.gz`, (0, zlib_1.createGzip)({}));
+}
+exports.gzip = gzip;
+function brotli(sourcePath) {
+    return compressor(sourcePath, `${sourcePath}.br`, (0, zlib_1.createBrotliCompress)());
+}
+exports.brotli = brotli;

package/dist/common/s3-upload/index.d.ts

@@ -0,0 +1,3 @@
+export { S3UploadPlugin } from './webpack-plugin';
+export { uploadFiles } from './upload';
+export type { UploadFilesOptions } from './upload';

package/dist/common/s3-upload/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFiles = exports.S3UploadPlugin = void 0;
+var webpack_plugin_1 = require("./webpack-plugin");
+Object.defineProperty(exports, "S3UploadPlugin", { enumerable: true, get: function () { return webpack_plugin_1.S3UploadPlugin; } });
+var upload_1 = require("./upload");
+Object.defineProperty(exports, "uploadFiles", { enumerable: true, get: function () { return upload_1.uploadFiles; } });

package/dist/common/s3-upload/s3-client.d.ts

@@ -0,0 +1,20 @@
+import type { S3ClientConfig, PutObjectCommandInput } from '@aws-sdk/client-s3';
+export type S3ClientOptions = S3ClientConfig;
+export declare function getS3Client(options: S3ClientOptions): {
+    headObject(bucket: string, key: string): Promise<import("@aws-sdk/client-s3").HeadObjectCommandOutput>;
+    uploadFile(bucket: string, localFileOrPath: string | Buffer, key: string, opts?: S3UploadFileOptions): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    uploadDir(bucket: string, dirPath: string, keyPrefix?: string, { concurrency, ...opts }?: S3UploadDirOptions): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput[]>;
+    deleteObject(bucket: string, key: string): Promise<import("@aws-sdk/client-s3").DeleteObjectCommandOutput>;
+};
+interface UploadOptionsCommon {
+    expires?: PutObjectCommandInput['Expires'];
+    meta?: PutObjectCommandInput['Metadata'];
+}
+export interface S3UploadDirOptions extends UploadOptionsCommon {
+    concurrency?: number;
+}
+export interface S3UploadFileOptions extends UploadOptionsCommon {
+    contentType?: string;
+    contentEncoding?: string;
+}
+export {};

package/dist/common/s3-upload/s3-client.js

@@ -0,0 +1,111 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getS3Client = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const file_type_1 = require("file-type");
+const mime = __importStar(require("mime-types"));
+const p_map_1 = __importDefault(require("p-map"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+function getS3Client(options) {
+    const s3Client = new client_s3_1.S3Client(options);
+    return {
+        headObject(bucket, key) {
+            return s3Client.send(new client_s3_1.HeadObjectCommand({ Bucket: bucket, Key: key }));
+        },
+        async uploadFile(bucket, localFileOrPath, key, opts = {}) {
+            const isBuffer = Buffer.isBuffer(localFileOrPath);
+            const bodyBuffer = isBuffer ? localFileOrPath : await fs.readFile(localFileOrPath);
+            let contentType = opts.contentType;
+            if (!contentType) {
+                contentType = isBuffer
+                    ? await detectContentTypeFromBuffer(localFileOrPath)
+                    : detectContentTypeFromExt(localFileOrPath);
+            }
+            const meta = opts.meta;
+            const expires = opts.expires;
+            const contentEncoding = opts.contentEncoding;
+            const params = {
+                Bucket: bucket,
+                Key: key,
+                Body: bodyBuffer,
+                Metadata: meta,
+                Expires: expires,
+                ContentEncoding: contentEncoding,
+                ContentType: contentType,
+            };
+            if (expires) {
+                params.Metadata = Object.assign(Object.assign({}, params.Metadata), { Expires: expires.toString() });
+            }
+            return s3Client.send(new client_s3_1.PutObjectCommand(params));
+        },
+        uploadDir(bucket, dirPath, keyPrefix = '', _a = {}) {
+            var { concurrency = 512 } = _a, opts = __rest(_a, ["concurrency"]);
+            const files = fast_glob_1.default.sync('**', { cwd: dirPath });
+            return (0, p_map_1.default)(files, (filePath) => {
+                const sourcePath = path.join(dirPath, filePath);
+                return this.uploadFile(bucket, sourcePath, keyPrefix + filePath, opts);
+            }, { concurrency });
+        },
+        deleteObject(bucket, key) {
+            return s3Client.send(new client_s3_1.DeleteObjectCommand({ Bucket: bucket, Key: key }));
+        },
+    };
+}
+exports.getS3Client = getS3Client;
+async function detectContentTypeFromBuffer(buffer) {
+    const type = await (0, file_type_1.fromBuffer)(buffer);
+    if (!type) {
+        throw Error('Cannot detect content type for buffer');
+    }
+    return type.mime;
+}
+function detectContentTypeFromExt(filePath) {
+    // Compressed file Content-type must be the same as original file Content-type
+    if (filePath.endsWith('.br') || filePath.endsWith('.gz')) {
+        filePath = filePath.slice(0, -3);
+    }
+    const type = mime.lookup(filePath);
+    if (!type) {
+        throw Error(`Cannot detect content type for file ${filePath}`);
+    }
+    return type;
+}

package/dist/common/s3-upload/upload.d.ts

@@ -0,0 +1,14 @@
+import { S3ClientOptions } from './s3-client.js';
+export interface UploadOptions {
+    bucket: string;
+    sourcePath: string;
+    targetPath?: string;
+    existsBehavior?: 'overwrite' | 'throw' | 'ignore';
+}
+export interface UploadFilesOptions {
+    s3: S3ClientOptions;
+    concurrency?: number;
+    compress?: boolean;
+    options: UploadOptions;
+}
+export declare function uploadFiles(files: string[], config: UploadFilesOptions): Promise<string[]>;