@driveflux/upload 1.4.4 → 1.4.5

package/dist/uppy.js

@@ -1,3 +1,179 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 import { config } from '@driveflux/config/frontend';
 import { enhancedFetch } from '@driveflux/fetch';
 import { useToastResult } from '@driveflux/ui/toast';
@@ -5,159 +181,202 @@ import AwsS3Multipart from '@uppy/aws-s3';
 import Uppy from '@uppy/core';
 import isEqual from 'lodash/isEqual.js';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
-const defaultOptions = {
+var defaultOptions = {
     autoProceed: true,
     restrictions: {
-        maxFileSize: 10000000, // 10MB
-        maxTotalFileSize: 100000000, // 100MB
+        maxFileSize: 10000000,
+        maxTotalFileSize: 100000000,
         maxNumberOfFiles: 20,
-        allowedFileTypes: ['image/*', 'application/pdf'],
+        allowedFileTypes: [
+            'image/*',
+            'application/pdf'
+        ],
         minFileSize: 1000,
         minNumberOfFiles: 1,
-        requiredMetaFields: [],
+        requiredMetaFields: []
     },
-    getUploadParameters: null, // required
-    realm: null, // required
+    getUploadParameters: null,
+    realm: null
 };
-const initUppy = (uppyOptions, s3PluginOptions) => {
-    const uppy = new Uppy(uppyOptions);
+var initUppy = function(uppyOptions, s3PluginOptions) {
+    var uppy = new Uppy(uppyOptions);
     // @ts-expect-error
     uppy.use(AwsS3Multipart, s3PluginOptions);
     return uppy;
 };
-export const useUppy = (options, isUnauthenticated) => {
-    const previousOptions = useRef({
-        ...defaultOptions,
-        ...options,
-        restrictions: defaultOptions.restrictions,
-    });
-    const finalOptions = useMemo(() => {
-        const newOptions = {
-            ...defaultOptions,
-            ...options,
-            restrictions: {
-                ...defaultOptions.restrictions,
-                ...options.restrictions,
-            },
-        };
+export var useUppy = function(options, isUnauthenticated) {
+    var previousOptions = useRef(_object_spread_props(_object_spread({}, defaultOptions, options), {
+        restrictions: defaultOptions.restrictions
+    }));
+    var finalOptions = useMemo(function() {
+        var newOptions = _object_spread_props(_object_spread({}, defaultOptions, options), {
+            restrictions: _object_spread({}, defaultOptions.restrictions, options.restrictions)
+        });
         if (isEqual(newOptions, previousOptions.current)) {
             return previousOptions.current;
         }
         previousOptions.current = newOptions;
         return newOptions;
-    }, [options]);
-    const { autoProceed = true, restrictions, getUploadParameters, onUploadSuccess, onComplete, prefixFile, onError, realm, } = finalOptions;
-    const uploadUrlsMap = useRef(new Map());
-    const publicAcl = typeof options.publicAcl === 'boolean'
-        ? options.publicAcl
-        : realm === 'site';
-    const { toastResult, toastError } = useToastResult();
-    const uppyOptions = useMemo(() => ({
+    }, [
+        options
+    ]);
+    var _finalOptions_autoProceed = finalOptions.autoProceed, autoProceed = _finalOptions_autoProceed === void 0 ? true : _finalOptions_autoProceed, restrictions = finalOptions.restrictions, getUploadParameters = finalOptions.getUploadParameters, onUploadSuccess = finalOptions.onUploadSuccess, onComplete = finalOptions.onComplete, prefixFile = finalOptions.prefixFile, onError = finalOptions.onError, realm = finalOptions.realm;
+    var uploadUrlsMap = useRef(new Map());
+    var publicAcl = typeof options.publicAcl === 'boolean' ? options.publicAcl : realm === 'site';
+    var _useToastResult = useToastResult(), toastResult = _useToastResult.toastResult, toastError = _useToastResult.toastError;
+    var uppyOptions = useMemo(function() {
+        return {
+            autoProceed: autoProceed,
+            restrictions: restrictions
+        };
+    }, [
         autoProceed,
-        restrictions: restrictions,
-    }), [autoProceed, restrictions]);
-    const s3PluginOptions = useMemo(() => ({
-        id: 'AwsS3',
-        async getUploadParameters(file) {
-            if (getUploadParameters) {
-                return getUploadParameters(file);
-            }
-            if (!realm) {
-                toastError({
-                    title: 'Error while uploading file',
-                    description: 'No realm provided',
-                });
-                throw new Error('No realm provided');
-            }
-            if (!file.type) {
-                toastError({
-                    title: 'Error while uploading file',
-                    description: 'No file type provided',
-                });
-                throw new Error('No file type provided');
-            }
-            const parts = [];
-            const prefix = file.meta.prefix;
-            if (typeof prefix === 'string' && !!prefix.length) {
-                parts.push(prefix.replace(/\/$/, ''));
-            }
-            parts.push(file.name || 'unknown');
-            const filename = parts.join('/');
-            const targetUrl = `${config.apiUrl}/files/${isUnauthenticated ? 'unauthenticated-sign-upload' : 'sign-upload'}`;
-            const body = {
-                filename,
-                contentType: file.type,
-                realm,
-                publicAcl,
-                isUnauthenticated,
-            };
-            const response = await enhancedFetch(targetUrl, {
-                method: 'POST',
-                body: JSON.stringify(body),
-            });
-            if (response.err) {
-                toastResult(response, {
-                    error: {
-                        title: 'Error while uploading file',
-                        description: response.val.message,
-                    },
-                });
-                throw new Error(response.val.message || 'Error while uploading file');
+        restrictions
+    ]);
+    var s3PluginOptions = useMemo(function() {
+        return {
+            id: 'AwsS3',
+            getUploadParameters: function getUploadParameters1(file) {
+                return _async_to_generator(function() {
+                    var parts, prefix, filename, targetUrl, body, response, url;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (getUploadParameters) {
+                                    return [
+                                        2,
+                                        getUploadParameters(file)
+                                    ];
+                                }
+                                if (!realm) {
+                                    toastError({
+                                        title: 'Error while uploading file',
+                                        description: 'No realm provided'
+                                    });
+                                    throw new Error('No realm provided');
+                                }
+                                if (!file.type) {
+                                    toastError({
+                                        title: 'Error while uploading file',
+                                        description: 'No file type provided'
+                                    });
+                                    throw new Error('No file type provided');
+                                }
+                                parts = [];
+                                prefix = file.meta.prefix;
+                                if (typeof prefix === 'string' && !!prefix.length) {
+                                    parts.push(prefix.replace(/\/$/, ''));
+                                }
+                                parts.push(file.name || 'unknown');
+                                filename = parts.join('/');
+                                targetUrl = "".concat(config.apiUrl, "/files/").concat(isUnauthenticated ? 'unauthenticated-sign-upload' : 'sign-upload');
+                                body = {
+                                    filename: filename,
+                                    contentType: file.type,
+                                    realm: realm,
+                                    publicAcl: publicAcl,
+                                    isUnauthenticated: isUnauthenticated
+                                };
+                                return [
+                                    4,
+                                    enhancedFetch(targetUrl, {
+                                        method: 'POST',
+                                        body: JSON.stringify(body)
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                if (response.err) {
+                                    toastResult(response, {
+                                        error: {
+                                            title: 'Error while uploading file',
+                                            description: response.val.message
+                                        }
+                                    });
+                                    throw new Error(response.val.message || 'Error while uploading file');
+                                }
+                                // We remove the query string from the url and store it in the uploadUrlsMap
+                                // this is because uppy may not return the url in the upload success callback
+                                url = response.val.url.split('?')[0];
+                                uploadUrlsMap.current.set(file.id, url);
+                                return [
+                                    2,
+                                    {
+                                        method: 'PUT',
+                                        url: response.val.url,
+                                        fields: {},
+                                        headers: {
+                                            'Content-Type': file.type
+                                        }
+                                    }
+                                ];
+                        }
+                    });
+                })();
             }
-            // We remove the query string from the url and store it in the uploadUrlsMap
-            // this is because uppy may not return the url in the upload success callback
-            const url = response.val.url.split('?')[0];
-            uploadUrlsMap.current.set(file.id, url);
-            return {
-                method: 'PUT',
-                url: response.val.url,
-                fields: {},
-                headers: {
-                    'Content-Type': file.type,
-                },
-            };
-        },
-    }), [
+        };
+    }, [
         getUploadParameters,
         realm,
         toastResult,
         toastError,
         publicAcl,
-        isUnauthenticated,
+        isUnauthenticated
     ]);
-    const uppyInstance = useRef(
-    // @ts-expect-error options partial
+    var uppyInstance = useRef(// @ts-expect-error options partial
     initUppy(uppyOptions, s3PluginOptions));
-    const uppy = uppyInstance.current;
+    var uppy = uppyInstance.current;
     // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    const resyncMap = useCallback(() => {
-        const newMap = new Map();
-        for (const file of uppy.getFiles()) {
-            const oldUploadUrl = uploadUrlsMap.current.get(file.id);
-            if (oldUploadUrl) {
-                newMap.set(file.id, oldUploadUrl);
+    var resyncMap = useCallback(function() {
+        var newMap = new Map();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = uppy.getFiles()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var file = _step.value;
+                var oldUploadUrl = uploadUrlsMap.current.get(file.id);
+                if (oldUploadUrl) {
+                    newMap.set(file.id, oldUploadUrl);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
             }
         }
         // Resync the map
         uploadUrlsMap.current = newMap;
     }, []);
     // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    useEffect(() => {
+    useEffect(function() {
+        var _uppy_getPlugin;
         uppy.setOptions(uppyOptions);
-        uppy.getPlugin('AwsS3')?.setOptions(s3PluginOptions);
-    }, [uppyOptions, s3PluginOptions]);
-    useEffect(() => {
-        const handleFileAdded = (file) => {
+        (_uppy_getPlugin = uppy.getPlugin('AwsS3')) === null || _uppy_getPlugin === void 0 ? void 0 : _uppy_getPlugin.setOptions(s3PluginOptions);
+    }, [
+        uppyOptions,
+        s3PluginOptions
+    ]);
+    useEffect(function() {
+        var handleFileAdded = function(file) {
             resyncMap();
             if (prefixFile) {
                 // @ts-expect-error
-                uppy.setMeta({ prefix: prefixFile(file) });
+                uppy.setMeta({
+                    prefix: prefixFile(file)
+                });
             }
         };
         uppy.on('file-added', handleFileAdded);
-        const handleUploadSuccess = (file, response) => {
-            const uploadURL = response.uploadURL ||
-                (file ? uploadUrlsMap.current.get(file.id) : undefined);
+        var handleUploadSuccess = function(file, response) {
+            var uploadURL = response.uploadURL || (file ? uploadUrlsMap.current.get(file.id) : undefined);
             if (!response.uploadURL) {
                 response.uploadURL = uploadURL;
             }
@@ -165,51 +384,67 @@ export const useUppy = (options, isUnauthenticated) => {
                 if (!uploadURL) {
                     toastError({
                         title: 'Error while uploading file',
-                        description: `The uploader didn\'t return a valid uploadURL for file ${file?.name}`,
+                        description: "The uploader didn't return a valid uploadURL for file ".concat(file === null || file === void 0 ? void 0 : file.name)
                     });
                     return;
                 }
-                onUploadSuccess(file, {
-                    ...response,
-                    uploadURL,
-                });
+                onUploadSuccess(file, _object_spread_props(_object_spread({}, response), {
+                    uploadURL: uploadURL
+                }));
             }
         };
         uppy.on('upload-success', handleUploadSuccess);
-        const handleComplete = (result) => {
-            const realUploaded = [];
+        var handleComplete = function(result) {
+            var realUploaded = [];
             if (!result.successful) {
                 return;
             }
-            // Populate upload URL if any
-            for (const uploaded of result.successful) {
-                const uploadURL = uploaded.response?.uploadURL || uploadUrlsMap.current.get(uploaded.id);
-                if (!uploadURL) {
-                    toastError({
-                        title: 'Error while uploading file',
-                        description: `The uploader didn\'t return a valid uploadURL for file ${uploaded.name}`,
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                // Populate upload URL if any
+                for(var _iterator = result.successful[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var uploaded = _step.value;
+                    var _uploaded_response;
+                    var uploadURL = ((_uploaded_response = uploaded.response) === null || _uploaded_response === void 0 ? void 0 : _uploaded_response.uploadURL) || uploadUrlsMap.current.get(uploaded.id);
+                    if (!uploadURL) {
+                        toastError({
+                            title: 'Error while uploading file',
+                            description: "The uploader didn't return a valid uploadURL for file ".concat(uploaded.name)
+                        });
+                        continue;
+                    }
+                    uploaded.response = _object_spread_props(_object_spread({}, uploaded.response), {
+                        uploadURL: uploadURL
                     });
-                    continue;
+                    uploaded.uploadURL = uploadURL;
+                    realUploaded.push(uploaded);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
                 }
-                uploaded.response = {
-                    ...uploaded.response,
-                    uploadURL,
-                };
-                uploaded.uploadURL = uploadURL;
-                realUploaded.push(uploaded);
             }
             if (onComplete) {
                 onComplete(realUploaded);
             }
         };
         uppy.on('complete', handleComplete);
-        const handleError = (file, error, response) => {
+        var handleError = function(file, error, response) {
             if (onError) {
                 onError(file, error, response);
             }
         };
         uppy.on('upload-error', handleError);
-        return () => {
+        return function() {
             uppy.off('file-added', handleFileAdded);
             uppy.off('upload-success', handleUploadSuccess);
             uppy.off('complete', handleComplete);
@@ -222,8 +457,7 @@ export const useUppy = (options, isUnauthenticated) => {
         onUploadSuccess,
         resyncMap,
         prefixFile,
-        toastError,
+        toastError
     ]);
     return uppy;
 };
-//# sourceMappingURL=uppy.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driveflux/upload",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "type": "module",
   "exports": {
     ".": {
@@ -12,7 +12,7 @@
     "dist"
   ],
   "dependencies": {
-    "@driveflux/config": "1.8.0",
+    "@driveflux/config": "1.8.1",
     "@driveflux/fetch": "6.4.0",
     "@driveflux/ui": "1.4.0",
     "@uppy/aws-s3": "4.1.0",