@webiny/app-file-manager-s3 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/MultiPartUploadAPI.d.ts

@@ -0,0 +1,26 @@
+import type { UploadedFile } from "@webiny/app/types.js";
+export interface CreateUploadParams {
+    data: {
+        size: number;
+        name: string;
+        type: string;
+    };
+    numberOfParts: number;
+}
+export interface CompleteUploadParams {
+    fileKey: string;
+    uploadId: string;
+}
+export interface FilePart {
+    partNumber: number;
+    url: string;
+}
+export interface MultiPartUpload {
+    file: UploadedFile;
+    uploadId: string;
+    parts: FilePart[];
+}
+export interface MultiPartUploadAPI {
+    createUpload(params: CreateUploadParams): Promise<MultiPartUpload>;
+    completeUpload(params: CompleteUploadParams): Promise<boolean>;
+}

package/MultiPartUploadGraphQLAPI.d.ts

@@ -0,0 +1,8 @@
+import type { UploadOptions } from "@webiny/app/types.js";
+import type { CompleteUploadParams, CreateUploadParams, MultiPartUpload, MultiPartUploadAPI } from "./MultiPartUploadAPI.js";
+export declare class MultiPartUploadGraphQLAPI implements MultiPartUploadAPI {
+    private client;
+    constructor(client: UploadOptions["apolloClient"]);
+    createUpload(params: CreateUploadParams): Promise<MultiPartUpload>;
+    completeUpload(params: CompleteUploadParams): Promise<boolean>;
+}

package/MultiPartUploadGraphQLAPI.js

@@ -0,0 +1,72 @@
+import graphql_tag from "graphql-tag";
+class MultiPartUploadGraphQLAPI {
+    constructor(client){
+        this.client = client;
+    }
+    async createUpload(params) {
+        const { data, errors } = await this.client.mutate({
+            mutation: CREATE_UPLOAD,
+            variables: params
+        });
+        if (!data) {
+            console.error(errors);
+            throw new Error("Failed to initialize a multi-part file upload!");
+        }
+        return data.fileManager.createMultiPartUpload.data;
+    }
+    async completeUpload(params) {
+        const { data, errors } = await this.client.mutate({
+            mutation: COMPLETE_UPLOAD,
+            variables: params
+        });
+        if (!data) {
+            console.error(errors);
+            throw new Error("Failed to complete a multi-part file upload!");
+        }
+        return data.fileManager.completeMultiPartUpload.data;
+    }
+}
+const CREATE_UPLOAD = graphql_tag`
+    mutation CreateMultiPartUpload($data: PreSignedPostPayloadInput!, $numberOfParts: Number!) {
+        fileManager {
+            createMultiPartUpload(data: $data, numberOfParts: $numberOfParts) {
+                data {
+                    file {
+                        id
+                        key
+                        name
+                        size
+                        type
+                    }
+                    uploadId
+                    parts {
+                        partNumber
+                        url
+                    }
+                }
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+const COMPLETE_UPLOAD = graphql_tag`
+    mutation CompleteMultiPartUpload($fileKey: String!, $uploadId: String!) {
+        fileManager {
+            completeMultiPartUpload(fileKey: $fileKey, uploadId: $uploadId) {
+                data
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+export { MultiPartUploadGraphQLAPI };
+
+//# sourceMappingURL=MultiPartUploadGraphQLAPI.js.map

package/MultiPartUploadGraphQLAPI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiPartUploadGraphQLAPI.js","sources":["../src/MultiPartUploadGraphQLAPI.ts"],"sourcesContent":["import type { UploadOptions } from \"@webiny/app/types.js\";\nimport gql from \"graphql-tag\";\nimport type {\n    CompleteUploadParams,\n    CreateUploadParams,\n    MultiPartUpload,\n    MultiPartUploadAPI\n} from \"~/MultiPartUploadAPI.js\";\n\nexport class MultiPartUploadGraphQLAPI implements MultiPartUploadAPI {\n    private client: UploadOptions[\"apolloClient\"];\n\n    constructor(client: UploadOptions[\"apolloClient\"]) {\n        this.client = client;\n    }\n\n    async createUpload(params: CreateUploadParams): Promise<MultiPartUpload> {\n        const { data, errors } = await this.client.mutate<CreateUploadResponse>({\n            mutation: CREATE_UPLOAD,\n            variables: params\n        });\n\n        if (!data) {\n            console.error(errors);\n            throw new Error(`Failed to initialize a multi-part file upload!`);\n        }\n\n        return data.fileManager.createMultiPartUpload.data;\n    }\n\n    async completeUpload(params: CompleteUploadParams): Promise<boolean> {\n        const { data, errors } = await this.client.mutate<CompleteUploadResponse>({\n            mutation: COMPLETE_UPLOAD,\n            variables: params\n        });\n\n        if (!data) {\n            console.error(errors);\n            throw new Error(`Failed to complete a multi-part file upload!`);\n        }\n\n        return data.fileManager.completeMultiPartUpload.data;\n    }\n}\n\nconst CREATE_UPLOAD = gql`\n    mutation CreateMultiPartUpload($data: PreSignedPostPayloadInput!, $numberOfParts: Number!) {\n        fileManager {\n            createMultiPartUpload(data: $data, numberOfParts: $numberOfParts) {\n                data {\n                    file {\n                        id\n                        key\n                        name\n                        size\n                        type\n                    }\n                    uploadId\n                    parts {\n                        partNumber\n                        url\n                    }\n                }\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ninterface CreateUploadResponse {\n    fileManager: {\n        createMultiPartUpload: {\n            data: MultiPartUpload;\n            error: {\n                code: string;\n                message: string;\n                data: Record<string, any>;\n            };\n        };\n    };\n}\n\nconst COMPLETE_UPLOAD = gql`\n    mutation CompleteMultiPartUpload($fileKey: String!, $uploadId: String!) {\n        fileManager {\n            completeMultiPartUpload(fileKey: $fileKey, uploadId: $uploadId) {\n                data\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ninterface CompleteUploadResponse {\n    fileManager: {\n        completeMultiPartUpload: {\n            data: boolean;\n            error: {\n                code: string;\n                message: string;\n                data: Record<string, any>;\n            };\n        };\n    };\n}\n"],"names":["MultiPartUploadGraphQLAPI","client","params","data","errors","CREATE_UPLOAD","console","Error","COMPLETE_UPLOAD","gql"],"mappings":";AASO,MAAMA;IAGT,YAAYC,MAAqC,CAAE;QAC/C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAM,aAAaC,MAA0B,EAA4B;QACrE,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAuB;YACpE,UAAUC;YACV,WAAWH;QACf;QAEA,IAAI,CAACC,MAAM;YACPG,QAAQ,KAAK,CAACF;YACd,MAAM,IAAIG,MAAM;QACpB;QAEA,OAAOJ,KAAK,WAAW,CAAC,qBAAqB,CAAC,IAAI;IACtD;IAEA,MAAM,eAAeD,MAA4B,EAAoB;QACjE,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAyB;YACtE,UAAUI;YACV,WAAWN;QACf;QAEA,IAAI,CAACC,MAAM;YACPG,QAAQ,KAAK,CAACF;YACd,MAAM,IAAIG,MAAM;QACpB;QAEA,OAAOJ,KAAK,WAAW,CAAC,uBAAuB,CAAC,IAAI;IACxD;AACJ;AAEA,MAAME,gBAAgBI,WAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0B1B,CAAC;AAeD,MAAMD,kBAAkBC,WAAG,CAAC;;;;;;;;;;;;;AAa5B,CAAC"}

package/MultiPartUploadStrategy.d.ts

@@ -0,0 +1,7 @@
+import type { UploadedFile, UploadOptions } from "@webiny/app/types.js";
+import type { FileUploadStrategy } from "./index.js";
+export declare class MultiPartUploadStrategy implements FileUploadStrategy {
+    upload(file: File, options: UploadOptions): Promise<UploadedFile>;
+    private detectChunkSize;
+    private detectParallelChunks;
+}

package/MultiPartUploadStrategy.js

@@ -0,0 +1,32 @@
+import { MultiPartUploader } from "./MultiPartUploader.js";
+import { MultiPartUploadGraphQLAPI } from "./MultiPartUploadGraphQLAPI.js";
+class MultiPartUploadStrategy {
+    async upload(file, options) {
+        const api = new MultiPartUploadGraphQLAPI(options.apolloClient);
+        const uploader = new MultiPartUploader(api, {
+            chunkSize: this.detectChunkSize(),
+            parallelUploads: this.detectParallelChunks()
+        });
+        if (options.onProgress) uploader.onProgress(options.onProgress);
+        return uploader.uploadFile(file);
+    }
+    detectChunkSize() {
+        const envSize = parseInt(process.env.WEBINY_FILE_UPLOAD_CHUNK_SIZE || "0");
+        if ("development" === process.env.NODE_ENV) {
+            const windowSize = window["fmUploadChunkSize"];
+            if (windowSize) return windowSize;
+        }
+        return envSize || 50;
+    }
+    detectParallelChunks() {
+        const envChunks = parseInt(process.env.WEBINY_FILE_UPLOAD_PARALLEL_CHUNKS || "0");
+        if ("development" === process.env.NODE_ENV) {
+            const windowChunks = window["fmUploadParallelChunks"];
+            if (windowChunks) return windowChunks;
+        }
+        return envChunks || 5;
+    }
+}
+export { MultiPartUploadStrategy };
+
+//# sourceMappingURL=MultiPartUploadStrategy.js.map

package/MultiPartUploadStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiPartUploadStrategy.js","sources":["../src/MultiPartUploadStrategy.ts"],"sourcesContent":["import type { UploadedFile, UploadOptions } from \"@webiny/app/types.js\";\nimport type { FileUploadStrategy } from \"~/index.js\";\nimport { MultiPartUploader } from \"~/MultiPartUploader.js\";\nimport { MultiPartUploadGraphQLAPI } from \"~/MultiPartUploadGraphQLAPI.js\";\n\nexport class MultiPartUploadStrategy implements FileUploadStrategy {\n    async upload(file: File, options: UploadOptions): Promise<UploadedFile> {\n        const api = new MultiPartUploadGraphQLAPI(options.apolloClient);\n\n        const uploader = new MultiPartUploader(api, {\n            chunkSize: this.detectChunkSize(),\n            parallelUploads: this.detectParallelChunks()\n        });\n\n        if (options.onProgress) {\n            uploader.onProgress(options.onProgress);\n        }\n        return uploader.uploadFile(file);\n    }\n\n    private detectChunkSize(): number {\n        const envSize = parseInt(process.env.WEBINY_FILE_UPLOAD_CHUNK_SIZE || \"0\");\n\n        // For dev purposes, we take this global var into consideration.\n        if (process.env.NODE_ENV === \"development\") {\n            // @ts-expect-error\n            const windowSize = window[\"fmUploadChunkSize\"];\n            if (windowSize) {\n                return windowSize;\n            }\n        }\n\n        // As a last resort, we check the baked in value, or fall back to 50MB chunk size.\n        return envSize || 50;\n    }\n\n    private detectParallelChunks(): number {\n        const envChunks = parseInt(process.env.WEBINY_FILE_UPLOAD_PARALLEL_CHUNKS || \"0\");\n\n        // For dev purposes, we take this global var into consideration.\n        if (process.env.NODE_ENV === \"development\") {\n            // @ts-expect-error\n            const windowChunks = window[\"fmUploadParallelChunks\"];\n            if (windowChunks) {\n                return windowChunks;\n            }\n        }\n\n        // As a last resort, we check the baked in value, or fall back to 5 parallel chunks.\n        return envChunks || 5;\n    }\n}\n"],"names":["MultiPartUploadStrategy","file","options","api","MultiPartUploadGraphQLAPI","uploader","MultiPartUploader","envSize","parseInt","process","windowSize","window","envChunks","windowChunks"],"mappings":";;AAKO,MAAMA;IACT,MAAM,OAAOC,IAAU,EAAEC,OAAsB,EAAyB;QACpE,MAAMC,MAAM,IAAIC,0BAA0BF,QAAQ,YAAY;QAE9D,MAAMG,WAAW,IAAIC,kBAAkBH,KAAK;YACxC,WAAW,IAAI,CAAC,eAAe;YAC/B,iBAAiB,IAAI,CAAC,oBAAoB;QAC9C;QAEA,IAAID,QAAQ,UAAU,EAClBG,SAAS,UAAU,CAACH,QAAQ,UAAU;QAE1C,OAAOG,SAAS,UAAU,CAACJ;IAC/B;IAEQ,kBAA0B;QAC9B,MAAMM,UAAUC,SAASC,QAAQ,GAAG,CAAC,6BAA6B,IAAI;QAGtE,IAAIA,AAAyB,kBAAzBA,QAAQ,GAAG,CAAC,QAAQ,EAAoB;YAExC,MAAMC,aAAaC,MAAM,CAAC,oBAAoB;YAC9C,IAAID,YACA,OAAOA;QAEf;QAGA,OAAOH,WAAW;IACtB;IAEQ,uBAA+B;QACnC,MAAMK,YAAYJ,SAASC,QAAQ,GAAG,CAAC,kCAAkC,IAAI;QAG7E,IAAIA,AAAyB,kBAAzBA,QAAQ,GAAG,CAAC,QAAQ,EAAoB;YAExC,MAAMI,eAAeF,MAAM,CAAC,yBAAyB;YACrD,IAAIE,cACA,OAAOA;QAEf;QAGA,OAAOD,aAAa;IACxB;AACJ"}

package/MultiPartUploader.d.ts

@@ -0,0 +1,43 @@
+import type { MultiPartUploadAPI } from "./MultiPartUploadAPI.js";
+interface MultiPartUploaderOptions {
+    /**
+     * Chunk size in MB. Must be >=5MB (enforced by AWS).
+     */
+    chunkSize?: number;
+    /**
+     * Number of parallel uploads. Must be >=5 && <=15.
+     */
+    parallelUploads?: number;
+}
+interface OnProgressCallback {
+    (params: {
+        sent: number;
+        total: number;
+        percentage: number;
+    }): void;
+}
+interface OnErrorCallback {
+    (error: Error): void;
+}
+export declare class MultiPartUploader {
+    private readonly api;
+    private readonly chunkSize;
+    private readonly parallelUploads;
+    private readonly activeConnections;
+    private readonly progressTracker;
+    private upload;
+    private file;
+    private onErrorFn;
+    private onProgressFn;
+    constructor(api: MultiPartUploadAPI, options?: MultiPartUploaderOptions);
+    uploadFile(file: File): Promise<import("@webiny/app/types.js").UploadedFile>;
+    onProgress(onProgress: OnProgressCallback): this;
+    onError(onError: OnErrorCallback): this;
+    private complete;
+    private sendCompleteRequest;
+    private progressListener;
+    private uploadNextPart;
+    private uploadPart;
+    private assertIsDefined;
+}
+export {};

package/MultiPartUploader.js

@@ -0,0 +1,139 @@
+import p_retry from "p-retry";
+class MultiPartUploader {
+    constructor(api, options = {}){
+        this.activeConnections = new Map();
+        this.progressTracker = new Map();
+        this.onErrorFn = (error)=>console.error(error);
+        this.api = api;
+        const chunkSize = options.chunkSize || 50;
+        const parallelUploads = options.parallelUploads || 5;
+        this.chunkSize = Math.max(1048576 * chunkSize, 5242880);
+        this.parallelUploads = Math.min(parallelUploads, 15);
+    }
+    async uploadFile(file) {
+        this.file = file;
+        const numberOfParts = Math.ceil(file.size / this.chunkSize);
+        try {
+            this.upload = await this.api.createUpload({
+                data: {
+                    name: file.name,
+                    size: file.size,
+                    type: file.type
+                },
+                numberOfParts
+            });
+            const threads = Math.min(numberOfParts, this.parallelUploads);
+            await Promise.all(Array.from({
+                length: threads
+            }).map(()=>this.uploadNextPart()));
+            await this.complete();
+            return this.upload.file;
+        } catch (error) {
+            await this.complete(error);
+            throw error;
+        }
+    }
+    onProgress(onProgress) {
+        this.onProgressFn = onProgress;
+        return this;
+    }
+    onError(onError) {
+        this.onErrorFn = onError;
+        return this;
+    }
+    async complete(error) {
+        if (error) return void this.onErrorFn(error);
+        try {
+            await this.sendCompleteRequest();
+        } catch (error) {
+            this.onErrorFn(error);
+        }
+    }
+    async sendCompleteRequest() {
+        this.assertIsDefined(this.upload, 'Upload must be created before calling "sendCompleteRequest"!');
+        return this.api.completeUpload({
+            fileKey: this.upload.file.key,
+            uploadId: this.upload.uploadId
+        });
+    }
+    progressListener(part, event) {
+        if (!this.file) return;
+        this.progressTracker.set(part.partNumber, event.loaded);
+        const uploaded = Array.from(this.progressTracker.values()).reduce((sum = 0, value)=>sum + value);
+        const uploadedSize = Math.min(uploaded, this.file.size);
+        if (this.onProgressFn) try {
+            this.onProgressFn({
+                sent: uploadedSize,
+                total: this.file.size,
+                percentage: Math.round(uploadedSize / this.file.size * 100)
+            });
+        } catch (err) {
+            console.error('Error executing the "onProgress" callback', err);
+        }
+    }
+    async uploadNextPart() {
+        if (!this.upload) return;
+        const part = this.upload.parts.shift();
+        if (!part) return;
+        return executeWithRetry(()=>this.uploadPart(part)).then(()=>this.uploadNextPart());
+    }
+    uploadPart(part) {
+        this.assertIsDefined(this.upload, 'Upload must be created before calling "sendCompleteRequest"!');
+        this.assertIsDefined(this.file, 'File must be set before calling "uploadPart"!');
+        const sentSize = (part.partNumber - 1) * this.chunkSize;
+        const nextChunkSize = Math.min(sentSize + this.chunkSize, this.file.size);
+        const chunk = this.file.slice(sentSize, nextChunkSize, this.upload.file.type);
+        console.log(`Chunk for part #${part.partNumber}`, chunk.size);
+        return new Promise((resolve, reject)=>{
+            const throwXHRError = (error)=>{
+                this.activeConnections.delete(part.partNumber);
+                reject(error);
+            };
+            if (!window.navigator.onLine) return reject(new Error("Browser is offline!"));
+            const xhr = new XMLHttpRequest();
+            this.activeConnections.set(part.partNumber, xhr);
+            const abortXHR = ()=>xhr.abort();
+            xhr.upload.addEventListener("progress", (event)=>this.progressListener(part, event));
+            window.addEventListener("offline", abortXHR);
+            const removeListeners = ()=>{
+                window.removeEventListener("offline", abortXHR);
+            };
+            xhr.open("PUT", part.url);
+            xhr.onreadystatechange = ()=>{
+                if (4 === xhr.readyState && 200 === xhr.status) try {
+                    this.activeConnections.delete(part.partNumber);
+                    window.removeEventListener("offline", abortXHR);
+                    resolve(xhr.status);
+                } catch (err) {
+                    console.error('Error in "onreadystatechange"', err);
+                }
+            };
+            xhr.onerror = ()=>{
+                removeListeners();
+                throwXHRError(new Error(`Failed to upload file part #${part.partNumber}`));
+            };
+            xhr.ontimeout = ()=>{
+                removeListeners();
+                throwXHRError(new Error(`Request timed out for file part #${part.partNumber}!`));
+            };
+            xhr.onabort = ()=>{
+                removeListeners();
+                throwXHRError(new Error(`Upload was cancelled for part #${part.partNumber}!`));
+            };
+            xhr.send(chunk);
+        });
+    }
+    assertIsDefined(upload, message) {
+        if (!upload) throw new Error(message);
+    }
+}
+const executeWithRetry = (execute, options)=>p_retry(execute, {
+        maxRetryTime: 300000,
+        retries: 5,
+        minTimeout: 1500,
+        maxTimeout: 30000,
+        ...options
+    });
+export { MultiPartUploader };
+
+//# sourceMappingURL=MultiPartUploader.js.map

package/MultiPartUploader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiPartUploader.js","sources":["../src/MultiPartUploader.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport type { MultiPartUpload, MultiPartUploadAPI, FilePart } from \"./MultiPartUploadAPI.js\";\n\ninterface MultiPartUploaderOptions {\n    /**\n     * Chunk size in MB. Must be >=5MB (enforced by AWS).\n     */\n    chunkSize?: number;\n    /**\n     * Number of parallel uploads. Must be >=5 && <=15.\n     */\n    parallelUploads?: number;\n}\n\ninterface OnProgressCallback {\n    (params: { sent: number; total: number; percentage: number }): void;\n}\n\ninterface OnErrorCallback {\n    (error: Error): void;\n}\n\nexport class MultiPartUploader {\n    private readonly api: MultiPartUploadAPI;\n    private readonly chunkSize: number;\n    private readonly parallelUploads: number;\n    private readonly activeConnections: Map<number, XMLHttpRequest> = new Map();\n    private readonly progressTracker: Map<number, number> = new Map();\n    private upload: MultiPartUpload | undefined;\n    private file: File | undefined;\n    private onErrorFn: OnErrorCallback = error => console.error(error);\n    private onProgressFn: OnProgressCallback | undefined;\n\n    constructor(api: MultiPartUploadAPI, options: MultiPartUploaderOptions = {}) {\n        this.api = api;\n        const chunkSize = options.chunkSize || 50;\n        const parallelUploads = options.parallelUploads || 5;\n\n        this.chunkSize = Math.max(1024 * 1024 * chunkSize, 1024 * 1024 * 5);\n        this.parallelUploads = Math.min(parallelUploads, 15);\n    }\n\n    async uploadFile(file: File) {\n        this.file = file;\n        const numberOfParts = Math.ceil(file.size / this.chunkSize);\n\n        try {\n            /**\n             * Initialize the file upload on AWS S3.\n             */\n            this.upload = await this.api.createUpload({\n                data: { name: file.name, size: file.size, type: file.type },\n                numberOfParts\n            });\n\n            /**\n             * Run the defined number of parallel uploads. Each thread will continue to process parts\n             * for as long as there are parts to upload. The promise will resolve once there's no more parts to upload.\n             */\n            const threads = Math.min(numberOfParts, this.parallelUploads);\n            await Promise.all(Array.from({ length: threads }).map(() => this.uploadNextPart()));\n\n            await this.complete();\n\n            return this.upload.file;\n        } catch (error) {\n            await this.complete(error);\n            throw error;\n        }\n    }\n\n    onProgress(onProgress: OnProgressCallback) {\n        this.onProgressFn = onProgress;\n        return this;\n    }\n\n    onError(onError: OnErrorCallback) {\n        this.onErrorFn = onError;\n        return this;\n    }\n\n    private async complete(error?: Error) {\n        if (error) {\n            this.onErrorFn(error);\n            return;\n        }\n\n        try {\n            await this.sendCompleteRequest();\n        } catch (error) {\n            this.onErrorFn(error);\n        }\n    }\n\n    private async sendCompleteRequest() {\n        this.assertIsDefined(\n            this.upload,\n            `Upload must be created before calling \"sendCompleteRequest\"!`\n        );\n\n        return this.api.completeUpload({\n            fileKey: this.upload.file.key,\n            uploadId: this.upload.uploadId\n        });\n    }\n\n    private progressListener(part: FilePart, event: ProgressEvent<XMLHttpRequestEventTarget>) {\n        if (!this.file) {\n            return;\n        }\n\n        this.progressTracker.set(part.partNumber, event.loaded);\n\n        const uploaded = Array.from(this.progressTracker.values()).reduce(\n            (sum = 0, value) => sum + value\n        );\n\n        const uploadedSize = Math.min(uploaded, this.file.size);\n\n        if (this.onProgressFn) {\n            try {\n                this.onProgressFn({\n                    sent: uploadedSize,\n                    total: this.file.size,\n                    percentage: Math.round((uploadedSize / this.file.size) * 100)\n                });\n            } catch (err) {\n                console.error(`Error executing the \"onProgress\" callback`, err);\n            }\n        }\n    }\n\n    private async uploadNextPart(): Promise<void> {\n        if (!this.upload) {\n            return;\n        }\n\n        const part = this.upload.parts.shift();\n\n        if (!part) {\n            return;\n        }\n\n        return executeWithRetry(() => this.uploadPart(part)).then(() => this.uploadNextPart());\n    }\n\n    private uploadPart(part: FilePart) {\n        this.assertIsDefined(\n            this.upload,\n            `Upload must be created before calling \"sendCompleteRequest\"!`\n        );\n\n        this.assertIsDefined(this.file, `File must be set before calling \"uploadPart\"!`);\n\n        const sentSize = (part.partNumber - 1) * this.chunkSize;\n        const nextChunkSize = Math.min(sentSize + this.chunkSize, this.file.size);\n        const chunk = this.file.slice(sentSize, nextChunkSize, this.upload.file.type);\n        console.log(`Chunk for part #${part.partNumber}`, chunk.size);\n\n        return new Promise((resolve, reject) => {\n            const throwXHRError = (error: Error) => {\n                this.activeConnections.delete(part.partNumber);\n                reject(error);\n            };\n\n            if (!window.navigator.onLine) {\n                return reject(new Error(\"Browser is offline!\"));\n            }\n\n            const xhr = new XMLHttpRequest();\n            this.activeConnections.set(part.partNumber, xhr);\n            const abortXHR = () => xhr.abort();\n\n            xhr.upload.addEventListener(\"progress\", event => this.progressListener(part, event));\n\n            window.addEventListener(\"offline\", abortXHR);\n            const removeListeners = () => {\n                window.removeEventListener(\"offline\", abortXHR);\n            };\n\n            xhr.open(\"PUT\", part.url);\n\n            xhr.onreadystatechange = () => {\n                if (xhr.readyState === 4 && xhr.status === 200) {\n                    try {\n                        this.activeConnections.delete(part.partNumber);\n                        window.removeEventListener(\"offline\", abortXHR);\n                        resolve(xhr.status);\n                    } catch (err) {\n                        console.error(`Error in \"onreadystatechange\"`, err);\n                    }\n                }\n            };\n\n            xhr.onerror = () => {\n                removeListeners();\n                throwXHRError(new Error(`Failed to upload file part #${part.partNumber}`));\n            };\n            xhr.ontimeout = () => {\n                removeListeners();\n                throwXHRError(new Error(`Request timed out for file part #${part.partNumber}!`));\n            };\n            xhr.onabort = () => {\n                removeListeners();\n                throwXHRError(new Error(`Upload was cancelled for part #${part.partNumber}!`));\n            };\n            xhr.send(chunk);\n        });\n    }\n\n    private assertIsDefined<T>(upload: T, message: string): asserts upload is NonNullable<T> {\n        if (!upload) {\n            throw new Error(message);\n        }\n    }\n}\n\nconst executeWithRetry = (execute: () => void, options?: Parameters<typeof pRetry>[1]) => {\n    return pRetry(execute, {\n        maxRetryTime: 300000,\n        retries: 5,\n        minTimeout: 1500,\n        maxTimeout: 30000,\n        ...options\n    });\n};\n"],"names":["MultiPartUploader","api","options","Map","error","console","chunkSize","parallelUploads","Math","file","numberOfParts","threads","Promise","Array","onProgress","onError","part","event","uploaded","sum","value","uploadedSize","err","executeWithRetry","sentSize","nextChunkSize","chunk","resolve","reject","throwXHRError","window","Error","xhr","XMLHttpRequest","abortXHR","removeListeners","upload","message","execute","pRetry"],"mappings":"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"}

package/README.md

@@ -1 +1,11 @@
-# @webiny/app-file-manager-s3
+# @webiny/app-file-manager-s3
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/SimpleUploadStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { UploadedFile, UploadOptions } from "@webiny/app/types.js";
+import type { FileUploadStrategy } from "./index.js";
+declare global {
+    interface File {
+        key?: string;
+        keyPrefix?: string;
+    }
+}
+export declare class SimpleUploadStrategy implements FileUploadStrategy {
+    upload(file: File, { apolloClient, onProgress }: UploadOptions): Promise<UploadedFile>;
+}

package/SimpleUploadStrategy.js

@@ -0,0 +1,47 @@
+import { GET_PRE_SIGNED_POST_PAYLOAD } from "./graphql.js";
+class SimpleUploadStrategy {
+    async upload(file, { apolloClient, onProgress }) {
+        const response = await apolloClient.query({
+            query: GET_PRE_SIGNED_POST_PAYLOAD,
+            fetchPolicy: "no-cache",
+            variables: {
+                data: {
+                    size: file.size,
+                    name: file.name,
+                    type: file.type,
+                    key: file.key,
+                    keyPrefix: file.keyPrefix
+                }
+            }
+        });
+        const { getPreSignedPostPayload } = response.data.fileManager;
+        if (getPreSignedPostPayload.error) {
+            console.error(getPreSignedPostPayload);
+            throw Error(getPreSignedPostPayload.error);
+        }
+        return new Promise((resolve, reject)=>{
+            const formData = new window.FormData();
+            Object.keys(getPreSignedPostPayload.data.data.fields).forEach((key)=>{
+                formData.append(key, getPreSignedPostPayload.data.data.fields[key]);
+            });
+            formData.append("file", file);
+            const xhr = new window.XMLHttpRequest();
+            xhr.upload.addEventListener("progress", (event)=>{
+                if (onProgress) onProgress({
+                    sent: event.loaded,
+                    total: file.size,
+                    percentage: event.loaded / file.size * 100
+                });
+            }, false);
+            xhr.open("POST", getPreSignedPostPayload.data.data.url, true);
+            xhr.send(formData);
+            xhr.onload = function() {
+                if (204 === this.status) return void resolve(getPreSignedPostPayload.data.file);
+                reject(this.responseText);
+            };
+        });
+    }
+}
+export { SimpleUploadStrategy };
+
+//# sourceMappingURL=SimpleUploadStrategy.js.map

package/SimpleUploadStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleUploadStrategy.js","sources":["../src/SimpleUploadStrategy.ts"],"sourcesContent":["import type { UploadedFile, UploadOptions } from \"@webiny/app/types.js\";\nimport { GET_PRE_SIGNED_POST_PAYLOAD } from \"./graphql.js\";\nimport type { FileUploadStrategy } from \"~/index.js\";\n\ndeclare global {\n    interface File {\n        key?: string;\n        keyPrefix?: string;\n    }\n}\n\nexport class SimpleUploadStrategy implements FileUploadStrategy {\n    async upload(file: File, { apolloClient, onProgress }: UploadOptions): Promise<UploadedFile> {\n        // 1. GET PreSignedPostPayload\n        const response = await apolloClient.query({\n            query: GET_PRE_SIGNED_POST_PAYLOAD,\n            fetchPolicy: \"no-cache\",\n            variables: {\n                data: {\n                    size: file.size,\n                    name: file.name,\n                    type: file.type,\n                    key: file.key,\n                    keyPrefix: file.keyPrefix\n                }\n            }\n        });\n\n        const { getPreSignedPostPayload } = response.data.fileManager;\n        if (getPreSignedPostPayload.error) {\n            console.error(getPreSignedPostPayload);\n            throw Error(getPreSignedPostPayload.error);\n        }\n\n        // 2. upload file to S3\n        return new Promise((resolve, reject) => {\n            const formData = new window.FormData();\n            Object.keys(getPreSignedPostPayload.data.data.fields).forEach(key => {\n                formData.append(key, getPreSignedPostPayload.data.data.fields[key]);\n            });\n\n            formData.append(\"file\", file);\n\n            const xhr = new window.XMLHttpRequest();\n            xhr.upload.addEventListener(\n                \"progress\",\n                event => {\n                    if (onProgress) {\n                        onProgress({\n                            sent: event.loaded,\n                            total: file.size,\n                            percentage: (event.loaded / file.size) * 100\n                        });\n                    }\n                },\n                false\n            );\n            xhr.open(\"POST\", getPreSignedPostPayload.data.data.url, true);\n            xhr.send(formData);\n            xhr.onload = function () {\n                if (this.status === 204) {\n                    resolve(getPreSignedPostPayload.data.file);\n                    return;\n                }\n\n                reject(this.responseText);\n            };\n        });\n    }\n}\n"],"names":["SimpleUploadStrategy","file","apolloClient","onProgress","response","GET_PRE_SIGNED_POST_PAYLOAD","getPreSignedPostPayload","console","Error","Promise","resolve","reject","formData","window","Object","key","xhr","event"],"mappings":";AAWO,MAAMA;IACT,MAAM,OAAOC,IAAU,EAAE,EAAEC,YAAY,EAAEC,UAAU,EAAiB,EAAyB;QAEzF,MAAMC,WAAW,MAAMF,aAAa,KAAK,CAAC;YACtC,OAAOG;YACP,aAAa;YACb,WAAW;gBACP,MAAM;oBACF,MAAMJ,KAAK,IAAI;oBACf,MAAMA,KAAK,IAAI;oBACf,MAAMA,KAAK,IAAI;oBACf,KAAKA,KAAK,GAAG;oBACb,WAAWA,KAAK,SAAS;gBAC7B;YACJ;QACJ;QAEA,MAAM,EAAEK,uBAAuB,EAAE,GAAGF,SAAS,IAAI,CAAC,WAAW;QAC7D,IAAIE,wBAAwB,KAAK,EAAE;YAC/BC,QAAQ,KAAK,CAACD;YACd,MAAME,MAAMF,wBAAwB,KAAK;QAC7C;QAGA,OAAO,IAAIG,QAAQ,CAACC,SAASC;YACzB,MAAMC,WAAW,IAAIC,OAAO,QAAQ;YACpCC,OAAO,IAAI,CAACR,wBAAwB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAACS,CAAAA;gBAC1DH,SAAS,MAAM,CAACG,KAAKT,wBAAwB,IAAI,CAAC,IAAI,CAAC,MAAM,CAACS,IAAI;YACtE;YAEAH,SAAS,MAAM,CAAC,QAAQX;YAExB,MAAMe,MAAM,IAAIH,OAAO,cAAc;YACrCG,IAAI,MAAM,CAAC,gBAAgB,CACvB,YACAC,CAAAA;gBACI,IAAId,YACAA,WAAW;oBACP,MAAMc,MAAM,MAAM;oBAClB,OAAOhB,KAAK,IAAI;oBAChB,YAAagB,MAAM,MAAM,GAAGhB,KAAK,IAAI,GAAI;gBAC7C;YAER,GACA;YAEJe,IAAI,IAAI,CAAC,QAAQV,wBAAwB,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;YACxDU,IAAI,IAAI,CAACJ;YACTI,IAAI,MAAM,GAAG;gBACT,IAAI,AAAgB,QAAhB,IAAI,CAAC,MAAM,EAAU,YACrBN,QAAQJ,wBAAwB,IAAI,CAAC,IAAI;gBAI7CK,OAAO,IAAI,CAAC,YAAY;YAC5B;QACJ;IACJ;AACJ"}

package/graphql.d.ts

@@ -0,0 +1 @@
+export declare const GET_PRE_SIGNED_POST_PAYLOAD: import("graphql").DocumentNode;

package/graphql.js

@@ -0,0 +1,25 @@
+import graphql_tag from "graphql-tag";
+const GET_PRE_SIGNED_POST_PAYLOAD = graphql_tag`
+    query getPreSignedPostPayload($data: PreSignedPostPayloadInput!) {
+        fileManager {
+            getPreSignedPostPayload(data: $data) {
+                data {
+                    data
+                    file {
+                        id
+                        type
+                        name
+                        size
+                        key
+                    }
+                }
+                error {
+                    message
+                }
+            }
+        }
+    }
+`;
+export { GET_PRE_SIGNED_POST_PAYLOAD };
+
+//# sourceMappingURL=graphql.js.map

package/graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.js","sources":["../src/graphql.ts"],"sourcesContent":["import gql from \"graphql-tag\";\n\nexport const GET_PRE_SIGNED_POST_PAYLOAD = gql`\n    query getPreSignedPostPayload($data: PreSignedPostPayloadInput!) {\n        fileManager {\n            getPreSignedPostPayload(data: $data) {\n                data {\n                    data\n                    file {\n                        id\n                        type\n                        name\n                        size\n                        key\n                    }\n                }\n                error {\n                    message\n                }\n            }\n        }\n    }\n`;\n"],"names":["GET_PRE_SIGNED_POST_PAYLOAD","gql"],"mappings":";AAEO,MAAMA,8BAA8BC,WAAG,CAAC;;;;;;;;;;;;;;;;;;;;AAoB/C,CAAC"}

package/index.d.ts

@@ -1,3 +1,6 @@
-import { AppFileManagerStorageS3 } from "./types";
-declare const _default: () => AppFileManagerStorageS3;
+import type { FileUploaderPlugin } from "@webiny/app/types.js";
+export interface FileUploadStrategy {
+    upload: FileUploaderPlugin["upload"];
+}
+declare const _default: () => FileUploaderPlugin;
 export default _default;

package/index.js

@@ -1,103 +1,20 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
-
-var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
-
-var _templateObject;
-
-var GET_PRE_SIGNED_POST_PAYLOAD = (0, _graphqlTag.default)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2.default)(["\n    query getPreSignedPostPayload($data: PreSignedPostPayloadInput!) {\n        fileManager {\n            getPreSignedPostPayload(data: $data) {\n                data {\n                    data\n                    file {\n                        type\n                        name\n                        size\n                        key\n                    }\n                }\n                error {\n                    message\n                }\n            }\n        }\n    }\n"])));
-
-var _default = function _default() {
-  return {
-    type: "app-file-manager-storage",
-    name: "app-file-manager-storage",
-    upload: function () {
-      var _upload = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee(file, _ref) {
-        var apolloClient, response, getPreSignedPostPayload;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                apolloClient = _ref.apolloClient;
-                _context.next = 3;
-                return apolloClient.query({
-                  query: GET_PRE_SIGNED_POST_PAYLOAD,
-                  fetchPolicy: "no-cache",
-                  variables: {
-                    data: {
-                      size: file.size,
-                      name: file.name,
-                      type: file.type
-                    }
-                  }
-                });
-
-              case 3:
-                response = _context.sent;
-                getPreSignedPostPayload = response.data.fileManager.getPreSignedPostPayload;
-
-                if (!getPreSignedPostPayload.error) {
-                  _context.next = 8;
-                  break;
-                }
-
-                console.log(getPreSignedPostPayload); // eslint-disable-line
-
-                return _context.abrupt("return");
-
-              case 8:
-                _context.next = 10;
-                return new Promise(function (resolve, reject) {
-                  var formData = new window.FormData();
-                  Object.keys(getPreSignedPostPayload.data.data.fields).forEach(function (key) {
-                    formData.append(key, getPreSignedPostPayload.data.data.fields[key]);
-                  });
-                  formData.append("file", file);
-                  var xhr = new window.XMLHttpRequest(); // eslint-disable-line
-
-                  xhr.open("POST", getPreSignedPostPayload.data.data.url, true);
-                  xhr.send(formData);
-
-                  xhr.onload = function () {
-                    if (this.status === 204) {
-                      resolve(getPreSignedPostPayload.data.file);
-                      return;
-                    }
-
-                    reject(this.responseText);
-                  };
-                });
-
-              case 10:
-                return _context.abrupt("return", _context.sent);
-
-              case 11:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }));
-
-      function upload(_x, _x2) {
-        return _upload.apply(this, arguments);
-      }
-
-      return upload;
-    }()
-  };
+import { SimpleUploadStrategy } from "./SimpleUploadStrategy.js";
+import { MultiPartUploadStrategy } from "./MultiPartUploadStrategy.js";
+const src = ()=>{
+    class S3FileUploader {
+        upload(file, options) {
+            const multiPartThreshold = window["fmUploadMultiPartThreshold"] ?? 100;
+            const simple = file.size < 1024 * multiPartThreshold * 1024;
+            const strategy = simple ? new SimpleUploadStrategy() : new MultiPartUploadStrategy();
+            return strategy.upload(file, options);
+        }
+        constructor(){
+            this.type = "file-uploader";
+            this.name = "file-uploader";
+        }
+    }
+    return new S3FileUploader();
 };
+export default src;
 
-exports.default = _default;
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["GET_PRE_SIGNED_POST_PAYLOAD","gql","type","name","upload","file","apolloClient","query","fetchPolicy","variables","data","size","response","getPreSignedPostPayload","fileManager","error","console","log","Promise","resolve","reject","formData","window","FormData","Object","keys","fields","forEach","key","append","xhr","XMLHttpRequest","open","url","send","onload","status","responseText"],"sources":["index.ts"],"sourcesContent":["import gql from \"graphql-tag\";\nimport { AppFileManagerStorageS3 } from \"./types\";\n\nconst GET_PRE_SIGNED_POST_PAYLOAD = gql`\n    query getPreSignedPostPayload($data: PreSignedPostPayloadInput!) {\n        fileManager {\n            getPreSignedPostPayload(data: $data) {\n                data {\n                    data\n                    file {\n                        type\n                        name\n                        size\n                        key\n                    }\n                }\n                error {\n                    message\n                }\n            }\n        }\n    }\n`;\n\nexport default () =>\n    ({\n        type: \"app-file-manager-storage\",\n        name: \"app-file-manager-storage\",\n        upload: async (file: File, { apolloClient }) => {\n            // 1. GET PreSignedPostPayload\n            const response = await apolloClient.query({\n                query: GET_PRE_SIGNED_POST_PAYLOAD,\n                fetchPolicy: \"no-cache\",\n                variables: {\n                    data: { size: file.size, name: file.name, type: file.type }\n                }\n            });\n\n            const { getPreSignedPostPayload } = response.data.fileManager;\n            if (getPreSignedPostPayload.error) {\n                console.log(getPreSignedPostPayload); // eslint-disable-line\n                return;\n            }\n            // 2. upload file to S3\n            return await new Promise((resolve, reject) => {\n                const formData = new window.FormData();\n                Object.keys(getPreSignedPostPayload.data.data.fields).forEach(key => {\n                    formData.append(key, getPreSignedPostPayload.data.data.fields[key]);\n                });\n\n                formData.append(\"file\", file);\n\n                const xhr = new window.XMLHttpRequest(); // eslint-disable-line\n                xhr.open(\"POST\", getPreSignedPostPayload.data.data.url, true);\n                xhr.send(formData);\n                xhr.onload = function () {\n                    if (this.status === 204) {\n                        resolve(getPreSignedPostPayload.data.file);\n                        return;\n                    }\n\n                    reject(this.responseText);\n                };\n            });\n        }\n    } as AppFileManagerStorageS3);\n"],"mappings":";;;;;;;;;;;;;;;AAAA;;;;AAGA,IAAMA,2BAA2B,OAAGC,mBAAH,kkBAAjC;;eAqBe;EAAA,OACV;IACGC,IAAI,EAAE,0BADT;IAEGC,IAAI,EAAE,0BAFT;IAGGC,MAAM;MAAA,qGAAE,iBAAOC,IAAP;QAAA;QAAA;UAAA;YAAA;cAAA;gBAAqBC,YAArB,QAAqBA,YAArB;gBAAA;gBAAA,OAEmBA,YAAY,CAACC,KAAb,CAAmB;kBACtCA,KAAK,EAAEP,2BAD+B;kBAEtCQ,WAAW,EAAE,UAFyB;kBAGtCC,SAAS,EAAE;oBACPC,IAAI,EAAE;sBAAEC,IAAI,EAAEN,IAAI,CAACM,IAAb;sBAAmBR,IAAI,EAAEE,IAAI,CAACF,IAA9B;sBAAoCD,IAAI,EAAEG,IAAI,CAACH;oBAA/C;kBADC;gBAH2B,CAAnB,CAFnB;;cAAA;gBAEEU,QAFF;gBAUIC,uBAVJ,GAUgCD,QAAQ,CAACF,IAAT,CAAcI,WAV9C,CAUID,uBAVJ;;gBAAA,KAWAA,uBAAuB,CAACE,KAXxB;kBAAA;kBAAA;gBAAA;;gBAYAC,OAAO,CAACC,GAAR,CAAYJ,uBAAZ,EAZA,CAYsC;;gBAZtC;;cAAA;gBAAA;gBAAA,OAgBS,IAAIK,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;kBAC1C,IAAMC,QAAQ,GAAG,IAAIC,MAAM,CAACC,QAAX,EAAjB;kBACAC,MAAM,CAACC,IAAP,CAAYZ,uBAAuB,CAACH,IAAxB,CAA6BA,IAA7B,CAAkCgB,MAA9C,EAAsDC,OAAtD,CAA8D,UAAAC,GAAG,EAAI;oBACjEP,QAAQ,CAACQ,MAAT,CAAgBD,GAAhB,EAAqBf,uBAAuB,CAACH,IAAxB,CAA6BA,IAA7B,CAAkCgB,MAAlC,CAAyCE,GAAzC,CAArB;kBACH,CAFD;kBAIAP,QAAQ,CAACQ,MAAT,CAAgB,MAAhB,EAAwBxB,IAAxB;kBAEA,IAAMyB,GAAG,GAAG,IAAIR,MAAM,CAACS,cAAX,EAAZ,CAR0C,CAQD;;kBACzCD,GAAG,CAACE,IAAJ,CAAS,MAAT,EAAiBnB,uBAAuB,CAACH,IAAxB,CAA6BA,IAA7B,CAAkCuB,GAAnD,EAAwD,IAAxD;kBACAH,GAAG,CAACI,IAAJ,CAASb,QAAT;;kBACAS,GAAG,CAACK,MAAJ,GAAa,YAAY;oBACrB,IAAI,KAAKC,MAAL,KAAgB,GAApB,EAAyB;sBACrBjB,OAAO,CAACN,uBAAuB,CAACH,IAAxB,CAA6BL,IAA9B,CAAP;sBACA;oBACH;;oBAEDe,MAAM,CAAC,KAAKiB,YAAN,CAAN;kBACH,CAPD;gBAQH,CAnBY,CAhBT;;cAAA;gBAAA;;cAAA;cAAA;gBAAA;YAAA;UAAA;QAAA;MAAA,CAAF;;MAAA;QAAA;MAAA;;MAAA;IAAA;EAHT,CADU;AAAA,C"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import type { FileUploaderPlugin, UploadOptions } from \"@webiny/app/types.js\";\nimport { SimpleUploadStrategy } from \"~/SimpleUploadStrategy.js\";\nimport { MultiPartUploadStrategy } from \"~/MultiPartUploadStrategy.js\";\n\nexport interface FileUploadStrategy {\n    upload: FileUploaderPlugin[\"upload\"];\n}\n\nexport default (): FileUploaderPlugin => {\n    class S3FileUploader implements FileUploaderPlugin {\n        public readonly type = \"file-uploader\";\n        public readonly name = \"file-uploader\";\n\n        upload(file: File, options: UploadOptions) {\n            // Use \"simple\" strategy for files smaller than ~100MB\n            // @ts-expect-error\n            const multiPartThreshold = window[\"fmUploadMultiPartThreshold\"] ?? 100;\n            const simple = file.size < multiPartThreshold * 1024 * 1024;\n\n            const strategy: FileUploadStrategy = simple\n                ? new SimpleUploadStrategy()\n                : new MultiPartUploadStrategy();\n\n            return strategy.upload(file, options);\n        }\n    }\n\n    return new S3FileUploader();\n};\n"],"names":["S3FileUploader","file","options","multiPartThreshold","window","simple","strategy","SimpleUploadStrategy","MultiPartUploadStrategy"],"mappings":";;AAQA,YAAgB;IACZ,MAAMA;QAIF,OAAOC,IAAU,EAAEC,OAAsB,EAAE;YAGvC,MAAMC,qBAAqBC,MAAM,CAAC,6BAA6B,IAAI;YACnE,MAAMC,SAASJ,KAAK,IAAI,GAAGE,AAAqB,OAArBA,qBAA4B;YAEvD,MAAMG,WAA+BD,SAC/B,IAAIE,yBACJ,IAAIC;YAEV,OAAOF,SAAS,MAAM,CAACL,MAAMC;QACjC;;iBAdgB,IAAI,GAAG;iBACP,IAAI,GAAG;;IAc3B;IAEA,OAAO,IAAIF;AACf"}

package/package.json

@@ -1,7 +1,11 @@
 {
 	"name": "@webiny/app-file-manager-s3",
-	"version": "0.0.0-unstable.78f581c1d2",
-	"main": "index.js",
+	"version": "0.0.0-unstable.7be00a75a9",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/webiny/webiny-js.git"
@@ -10,26 +14,20 @@
 	"author": "Webiny Ltd",
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/plugins": "0.0.0-unstable.78f581c1d2",
-		"apollo-client": "2.6.10",
-		"graphql": "15.8.0",
-		"graphql-tag": "2.12.6"
+		"@webiny/app": "0.0.0-unstable.7be00a75a9",
+		"graphql-tag": "2.12.6",
+		"p-retry": "8.0.0"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.19.3",
-		"@babel/core": "^7.19.3",
-		"@webiny/cli": "^0.0.0-unstable.78f581c1d2",
-		"@webiny/project-utils": "^0.0.0-unstable.78f581c1d2",
-		"rimraf": "^3.0.2",
-		"typescript": "4.7.4"
+		"@webiny/build-tools": "0.0.0-unstable.7be00a75a9",
+		"rimraf": "6.1.3",
+		"typescript": "6.0.3"
 	},
 	"publishConfig": {
-		"access": "public",
-		"directory": "dist"
-	},
-	"scripts": {
-		"build": "yarn webiny run build",
-		"watch": "yarn webiny run watch"
+		"access": "public"
 	},
-	"gitHead": "78f581c1d2e5e6936aa11b9452a66d2a3652a1b2"
+	"gitHead": "b8aec8a1be3f25c3b428b357fe1e352c7cbff9ae",
+	"webiny": {
+		"publishFrom": "dist"
+	}
 }

package/types.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="web" />
-import { Plugin } from "@webiny/plugins/types";
-import { ApolloClient } from "apollo-client";
-export declare type AppFileManagerStorageS3 = Plugin & {
-    type: "app-file-manager-storage";
-    name: "app-file-manager-storage";
-    upload(file: File, options: {
-        apolloClient: ApolloClient<Record<string, any>>;
-    }): Promise<any>;
-};

package/types.js

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

package/types.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins/types\";\nimport { ApolloClient } from \"apollo-client\";\n\nexport type AppFileManagerStorageS3 = Plugin & {\n    type: \"app-file-manager-storage\";\n    name: \"app-file-manager-storage\";\n    upload(file: File, options: { apolloClient: ApolloClient<Record<string, any>> }): Promise<any>;\n};\n"],"mappings":""}