@ibm-aspera/sdk 0.19.0 → 0.20.0

package/dist/commonjs/http-gateway/v2/app/upload.js

@@ -0,0 +1,601 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDropzone = exports.createDropzone = exports.upload = exports.startWebSocketTransfer = exports.getFoldersForUploadPromise = exports.getFoldersForUpload = exports.getFilesForUploadPromise = exports.getFilesForUpload = exports.addFolderPickerToForm = exports.addFilePickerToForm = exports.startSendingData = exports.handleSoftwareModeSlicing = exports.handleBlobSlicing = exports.updateTransferActivity = void 0;
+var index_1 = require("../index");
+var helpers_1 = require("../helpers/helpers");
+var messages_1 = require("../constants/messages");
+var models_1 = require("../models/models");
+var constants_1 = require("../constants/constants");
+var core_1 = require("./core");
+/**
+ * Used to update the transfer in the activity monitor for a specific transfer. If transfer not found it is ignored
+ *
+ * @param id the id of the transfer to update
+ * @param status the status of the transfer
+ * @param total the total bytes of the transfer
+ * @param current the amount of bytes transferred thus far
+ * @param error error body
+ * @param currentFile the current file being transferred
+ */
+var updateTransferActivity = function (id, status, total, current, error, currentFile) {
+    var transfer = index_1.asperaHttpGateway.activityTracking.getTransferById(id);
+    if (!transfer || transfer.status === 'cancelled' || transfer.status === 'completed') {
+        return;
+    }
+    transfer.status = status;
+    transfer.bytes_expected = total ? total : transfer.bytes_expected;
+    transfer.bytes_written = current ? current : transfer.bytes_written;
+    if (currentFile) {
+        transfer.current_file = currentFile.name;
+    }
+    if (status === 'completed' || status === 'failed') {
+        if (index_1.asperaHttpGateway.activityTracking.queuedUploads.length) {
+            var transferToStart = index_1.asperaHttpGateway.activityTracking.queuedUploads.shift();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            (0, exports.startWebSocketTransfer)(transferToStart.id, transferToStart.transferSpec, transferToStart.files, undefined, { serverUrlOverride: transfer.serverUrlOverride || undefined });
+        }
+    }
+    if (status === 'completed') {
+        transfer.setEndTime();
+        index_1.asperaHttpGateway.globals.deleteFormFromContainer(id.split(constants_1.keySplit)[0]);
+    }
+    else if (status === 'failed') {
+        transfer.error_desc = error.reason;
+        transfer.error_code = error.code;
+        index_1.asperaHttpGateway.globals.deleteFormFromContainer(id.split(constants_1.keySplit)[0]);
+    }
+    index_1.asperaHttpGateway.activityTracking.triggerActivityCallbacks();
+};
+exports.updateTransferActivity = updateTransferActivity;
+/**
+ * Slice a file and read it in with FileReader.  This uses the callback to send the read event.
+ * This function supports falling back to vendor prefix versions
+ * of the slice function for older Firefox and Webkit browsers.
+ *
+ * @param file the file to slice
+ * @param filePosition the start position of the file to slice
+ * @param chunksize the end position of the file to slice
+ * @param callback the callback to use for FileReader
+ * @param fileReader the FileReader to use for reading in data
+ */
+var handleBlobSlicing = function (file, filePosition, chunksize, callback, fileReader) {
+    var chunk;
+    if (typeof file.slice === 'function') {
+        chunk = file.slice(filePosition, filePosition + chunksize);
+    }
+    else if (typeof file.mozSlice === 'function') {
+        chunk = file.mozSlice(filePosition, filePosition + chunksize);
+    }
+    else if (typeof file.webkitSlice === 'function') {
+        chunk = file.webkitSlice(filePosition, filePosition + chunksize);
+    }
+    fileReader.onload = callback;
+    fileReader[(0, helpers_1.getFeatureFlag)('noBase64Encoding') ? 'readAsArrayBuffer' : 'readAsDataURL'](chunk);
+};
+exports.handleBlobSlicing = handleBlobSlicing;
+/**
+ * Software mode version of `handleBlobSlicing` for dealing with Buffer instead of File API
+ *
+ * @param file the file to slice (data string is a FileSystem readFile in binary format)
+ * @param filePosition the start position of the file to slice
+ * @param chunksize the end position of the file to slice
+ * @param callback the callback to use for triggering event on slice
+ *
+ * @example
+ * ```javascript
+ * const fileInfo = fs.statSync(filePointer);
+ * const file = {
+ *    data: fs.readFileSync(filePointer, {encoding: 'binary'}),
+ *    size: fileInfo.size,
+ *    type: 'file',
+ *    lastModified: fileInfo.mtime.toISOString(),
+ *    name: filePointer,
+ *  }
+ * ```
+ */
+var handleSoftwareModeSlicing = function (file, filePosition, chunksize, callback) {
+    var chunk = file.data.slice(filePosition, filePosition + chunksize);
+    callback({
+        total: chunk.length,
+        target: {
+            result: (0, helpers_1.getFeatureFlag)('noBase64Encoding') ? chunk : Buffer.from(chunk).toString('base64'),
+        }
+    });
+};
+exports.handleSoftwareModeSlicing = handleSoftwareModeSlicing;
+/**
+ * Start sending chunked data through the opened websocket
+ *
+ * @param socket the WebSocket to use for data transfer
+ * @param transferSpec the transferSpec to send for the upload
+ * @param id the ID of the transfer for monitoring
+ * @param queue the array of functions to call for sending data
+ * @param fileReaderToUse the file reader to use for this transfer
+ */
+var startSendingData = function (socket, transferSpec, files, id, queue, fileReaderToUse) {
+    var totalFileSize = 0;
+    var totalSentSize = 0;
+    files.forEach(function (file) {
+        totalFileSize += file.size;
+    });
+    (0, exports.updateTransferActivity)(id, 'running', totalFileSize);
+    files.forEach(function (file, index) {
+        var filePiece = 0;
+        var totalSlices = Math.ceil(file.size / index_1.asperaHttpGateway.globals.chunkSize);
+        var _loop_1 = function (filePosition) {
+            queue.push(function () {
+                var sendChunkCallback = function (event) {
+                    var transfer = index_1.asperaHttpGateway.activityTracking.getTransferById(id);
+                    if (transfer && transfer.status === 'failed') {
+                        return;
+                    }
+                    if (transfer && transfer.status === 'cancelled') {
+                        socket.close();
+                        return;
+                    }
+                    var binaryString = event.target.result;
+                    try {
+                        if ((0, helpers_1.getFeatureFlag)('noBase64Encoding')) {
+                            if (filePiece === 0) {
+                                socket.send(JSON.stringify({
+                                    slice_upload: {
+                                        name: file.asperaDropPath || file.webkitRelativePath || file.name,
+                                        type: file.type,
+                                        size: file.size,
+                                        slice: filePiece,
+                                        total_slices: totalSlices,
+                                        fileIndex: index
+                                    }
+                                }));
+                            }
+                            socket.send(binaryString);
+                            if (filePiece === totalSlices - 1) {
+                                socket.send(JSON.stringify({
+                                    slice_upload: {
+                                        name: file.asperaDropPath || file.webkitRelativePath || file.name,
+                                        type: file.type,
+                                        size: file.size,
+                                        slice: filePiece,
+                                        total_slices: totalSlices,
+                                        fileIndex: index
+                                    }
+                                }));
+                            }
+                        }
+                        else {
+                            if (typeof event.target.result === 'string' && event.target.result.indexOf('base64,') > -1) {
+                                binaryString = event.target.result.split('base64,')[1];
+                            }
+                            socket.send(JSON.stringify({
+                                slice_upload: {
+                                    name: file.asperaDropPath || file.webkitRelativePath || file.name,
+                                    type: file.type,
+                                    size: file.size,
+                                    data: binaryString,
+                                    slice: filePiece,
+                                    total_slices: totalSlices,
+                                    fileIndex: index
+                                }
+                            }));
+                        }
+                    }
+                    catch (error) {
+                        (0, exports.updateTransferActivity)(id, 'failed');
+                        (0, helpers_1.errorLog)(messages_1.messages.unableToParseDataForUpload, error);
+                        throw Error();
+                    }
+                    filePiece++;
+                    if (event.total) {
+                        totalSentSize += event.total;
+                    }
+                    var foundTransfer = index_1.asperaHttpGateway.activityTracking.getTransferById(id);
+                    if (foundTransfer) {
+                        foundTransfer.recentPacketTransfer(event.total);
+                    }
+                    (0, exports.updateTransferActivity)(id, 'running', undefined, totalSentSize, undefined, file);
+                    queue.shift();
+                };
+                if (index_1.asperaHttpGateway.globals.softwareMode) {
+                    (0, exports.handleSoftwareModeSlicing)(file, filePosition, index_1.asperaHttpGateway.globals.chunkSize, sendChunkCallback);
+                }
+                else {
+                    (0, exports.handleBlobSlicing)(file, filePosition, index_1.asperaHttpGateway.globals.chunkSize, sendChunkCallback, fileReaderToUse);
+                }
+            });
+        };
+        for (var filePosition = 0; filePosition < file.size; filePosition += index_1.asperaHttpGateway.globals.chunkSize) {
+            _loop_1(filePosition);
+        }
+    });
+    try {
+        socket.send(JSON.stringify({
+            transfer_spec: transferSpec
+        }));
+    }
+    catch (error) {
+        (0, exports.updateTransferActivity)(id, 'failed');
+        (0, helpers_1.errorLog)(messages_1.messages.unableToParseDataForUpload, error);
+        throw Error();
+    }
+};
+exports.startSendingData = startSendingData;
+/**
+ * Add file input to a form for getting files from the local computer
+ *
+ * @param form form to add new file input to
+ */
+var addFilePickerToForm = function (form) {
+    var element = document.createElement('input');
+    element.type = 'file';
+    element.multiple = true;
+    element.name = 'file-' + form.children.length;
+    form.appendChild(element);
+    return element;
+};
+exports.addFilePickerToForm = addFilePickerToForm;
+/**
+ * Add file input to a form with folder support for getting folders from the local computer
+ *
+ * NOTE: this cannot stop files from being picked.
+ *
+ * @param form form to add new file input to
+ */
+var addFolderPickerToForm = function (form) {
+    var element = document.createElement('input');
+    element.type = 'file';
+    element.multiple = true;
+    element.webkitdirectory = true;
+    element.mozdirectory = true;
+    element.msdirectory = true;
+    element.odirectory = true;
+    element.directory = true;
+    element.name = 'file-' + form.children.length;
+    form.appendChild(element);
+    return element;
+};
+exports.addFolderPickerToForm = addFolderPickerToForm;
+/**
+ * Request file picker for choosing files
+ *
+ * @param id the ID of the form to use (must be unique to each transfer grouping)
+ * @param callback the function to call once the files are added
+ */
+var getFilesForUpload = function (callback, id) {
+    if (!index_1.asperaHttpGateway.isReady) {
+        (0, helpers_1.errorLog)(messages_1.messages.serverNotVerified);
+        return;
+    }
+    var formToUse = index_1.asperaHttpGateway.globals.createOrUseForm(id);
+    var inputFile = (0, exports.addFilePickerToForm)(formToUse);
+    inputFile.onchange = function () {
+        var files = [];
+        if (!inputFile.files) {
+            callback({ dataTransfer: { files: files } });
+            return;
+        }
+        for (var i = 0; i < inputFile.files.length; i++) {
+            files.push(new models_1.FileSelected(inputFile.files[i]));
+        }
+        callback({ dataTransfer: { files: files } });
+    };
+    inputFile.click();
+};
+exports.getFilesForUpload = getFilesForUpload;
+/**
+ * Request file picker for choosing files and use promise.
+ * Uses `getFilesForUpload` logic wrapped in a Promise
+ *
+ * @param id the ID of the form to use (must be unique to each transfer grouping)
+ *
+ * @returns promise that resolves with the files (error state is never used)
+ */
+var getFilesForUploadPromise = function (id) {
+    var promiseToUse = (0, helpers_1.generatePromiseObjects)();
+    var promiseCallback = function (data) {
+        promiseToUse.resolver(data);
+    };
+    (0, exports.getFilesForUpload)(promiseCallback, id);
+    return promiseToUse.promise;
+};
+exports.getFilesForUploadPromise = getFilesForUploadPromise;
+/**
+ * Request folder picker for choosing folders
+ * @remarks Feature not supported. Will be introduced in future release.
+ *
+ * @param id the ID of the form to use (must be unique to each transfer grouping)
+ * @param callback the function to call once the folders are added
+ */
+var getFoldersForUpload = function (callback, id) {
+    if (!index_1.asperaHttpGateway.isReady) {
+        (0, helpers_1.errorLog)(messages_1.messages.serverNotVerified);
+        return;
+    }
+    var formToUse = index_1.asperaHttpGateway.globals.createOrUseForm(id);
+    var inputFile = (0, exports.addFolderPickerToForm)(formToUse);
+    inputFile.onchange = function () {
+        var files = [];
+        var folders = new Map();
+        if (!inputFile.files) {
+            callback({ dataTransfer: { files: files } });
+            return;
+        }
+        for (var i = 0; i < inputFile.files.length; i++) {
+            var file = inputFile.files[i];
+            if (file.webkitRelativePath) {
+                // TODO: Does Windows return using forward slash?
+                var rootFolder = file.webkitRelativePath.split('/')[0];
+                if (!folders.get(rootFolder)) {
+                    folders.set(rootFolder, { path: rootFolder, files: [] });
+                }
+                folders.get(rootFolder).files.push(file);
+            }
+            else {
+                files.push(new models_1.FileSelected(inputFile.files[i]));
+            }
+        }
+        var formFolderData = index_1.asperaHttpGateway.globals.getOrCreateFolderDataList(id);
+        (0, helpers_1.iterableToArray)(folders.values()).forEach(function (folder) {
+            formFolderData.set(folder.path, folder);
+            files.push(new models_1.FileSelected({ name: folder.path, size: 0, type: 'inode/directory' }));
+        });
+        callback({ dataTransfer: { files: files } });
+    };
+    inputFile.click();
+};
+exports.getFoldersForUpload = getFoldersForUpload;
+/**
+ * Request folder picker for choosing folders and use promise.
+ * Uses `getFoldersForUpload` logic wrapped in a Promise
+ * @remarks Feature not supported. Will be introduced in future release.
+ *
+ * @param id the ID of the form to use (must be unique to each transfer grouping)
+ *
+ * @returns promise that resolves with the folders/file list (error state is never used)
+ */
+var getFoldersForUploadPromise = function (id) {
+    var promiseToUse = (0, helpers_1.generatePromiseObjects)();
+    var promiseCallback = function (data) {
+        promiseToUse.resolver(data);
+    };
+    (0, exports.getFoldersForUpload)(promiseCallback, id);
+    return promiseToUse.promise;
+};
+exports.getFoldersForUploadPromise = getFoldersForUploadPromise;
+/**
+ * Start the Websockets and transfer
+ *
+ * @param id the ID to use for the transfer
+ * @param transferSpec the transferSpec of the transfer
+ * @param files the files to transfer
+ * @param promiseInfo the promise data to resolve for the transfer if needed
+ */
+var startWebSocketTransfer = function (id, transferSpec, files, promiseInfo, options) {
+    if (options === void 0) { options = {}; }
+    var queue = [];
+    var fileReaderToUse = typeof FileReader === 'function' ? new FileReader() : null;
+    var finalServerUrl = options.serverUrlOverride ? (0, core_1.cleanupServerUrl)(options.serverUrlOverride) : index_1.asperaHttpGateway.globals.serverUrl;
+    var socket = new WebSocket((0, helpers_1.getWebsocketUrl)(finalServerUrl, location.protocol));
+    socket.onopen = function (data) {
+        if (promiseInfo) {
+            promiseInfo.resolver(data);
+        }
+        index_1.asperaHttpGateway.activityTracking.setTransfer(id, new models_1.HttpTransfer(id, transferSpec, files, undefined, { serverUrlOverride: options.serverUrlOverride }));
+        (0, exports.startSendingData)(socket, transferSpec, files, id, queue, fileReaderToUse);
+    };
+    socket.onclose = function (data) {
+        var transfer = index_1.asperaHttpGateway.activityTracking.getTransferById(id);
+        if (transfer && transfer.status !== 'completed') {
+            (0, exports.updateTransferActivity)(id, 'failed', undefined, undefined, data);
+            (0, helpers_1.errorLog)(messages_1.messages.websocketClosedUnexpect, { error: data });
+        }
+    };
+    socket.onmessage = function (data) {
+        if (data.data === 'end upload') {
+            // TODO: check if fileReader is available due to dupe `end upload` events
+            if (queue.length) {
+                queue[0]();
+            }
+            else {
+                setTimeout(function () {
+                    socket.close(1000);
+                }, 5000);
+                (0, exports.updateTransferActivity)(id, 'completed');
+            }
+        }
+    };
+    socket.onerror = function (error) {
+        (0, helpers_1.errorLog)(messages_1.messages.websocketClosedUnexpect, error);
+        (0, exports.updateTransferActivity)(id, 'failed', undefined, undefined, error);
+        if (promiseInfo) {
+            promiseInfo.rejecter(error);
+        }
+    };
+};
+exports.startWebSocketTransfer = startWebSocketTransfer;
+/**
+ * Start a HTTP Gateway upload.
+ *
+ * @param transferSpec standard Connect transferSpec for uploading
+ * @param id the ID of the form group to use for files
+ * @param memoryFilesToLoad array of files from memory to use.  These will be used all the time and if transferSpec does not contain them an error will raise.
+ * @param options options for customizing the upload
+ *
+ * @returns a promise that resolves if upload is successful and rejects if upload cannot be started
+ */
+var upload = function (transferSpec, id, memoryFilesToLoad, options) {
+    if (options === void 0) { options = {}; }
+    if (!index_1.asperaHttpGateway.isReady) {
+        (0, helpers_1.errorLog)(messages_1.messages.serverNotVerified);
+        return new Promise(function (resolve, reject) {
+            reject((0, helpers_1.generateErrorBody)(messages_1.messages.serverNotVerified));
+        });
+    }
+    if (!(0, helpers_1.isValidTransferSpec)(transferSpec)) {
+        (0, helpers_1.errorLog)(messages_1.messages.notValidTransferSpec);
+        return new Promise(function (resolve, reject) {
+            reject((0, helpers_1.generateErrorBody)(messages_1.messages.notValidTransferSpec, { transferSpec: transferSpec }));
+        });
+    }
+    var files = (0, helpers_1.getFilesForTransfer)(id, transferSpec);
+    if (memoryFilesToLoad) {
+        memoryFilesToLoad.forEach(function (file) {
+            files.push(file);
+        });
+    }
+    var folderExplodeData = (0, helpers_1.folderTransferSpecExplode)(id, transferSpec);
+    if (folderExplodeData.files.length) {
+        folderExplodeData.files.forEach(function (file) {
+            files.push(file);
+        });
+        transferSpec.paths = folderExplodeData.newPath;
+    }
+    if (!files.length) {
+        (0, helpers_1.errorLog)(messages_1.messages.unableToGetFilesForUpload);
+        return new Promise(function (resolve, reject) {
+            reject((0, helpers_1.generateErrorBody)(messages_1.messages.unableToGetFilesForUpload, { transferSpec: transferSpec, files: files }));
+        });
+    }
+    else if (files.length !== transferSpec.paths.length) {
+        (0, helpers_1.errorLog)(messages_1.messages.unauthorizedFilesForUpload);
+        return new Promise(function (resolve, reject) {
+            reject((0, helpers_1.generateErrorBody)(messages_1.messages.unauthorizedFilesForUpload, { transferSpec: transferSpec, files: files }));
+        });
+    }
+    var promiseInfo = (0, helpers_1.generatePromiseObjects)();
+    id = "".concat(id).concat(constants_1.keySplit).concat((Math.random() * 10000000).toFixed());
+    var currentRunningTransfers = index_1.asperaHttpGateway.activityTracking.getActiveTransfers();
+    if (currentRunningTransfers.length >= index_1.asperaHttpGateway.globals.concurrentUploads) {
+        index_1.asperaHttpGateway.activityTracking.queuedUploads.push({ id: id, transferSpec: transferSpec, files: files });
+        index_1.asperaHttpGateway.activityTracking.setTransfer(id, new models_1.HttpTransfer(id, transferSpec, files, 'queued', { serverUrlOverride: options.serverUrlOverride }));
+        setTimeout(function () {
+            promiseInfo.resolver({});
+        }, 100);
+    }
+    else {
+        (0, exports.startWebSocketTransfer)(id, transferSpec, files, promiseInfo, options);
+    }
+    return promiseInfo.promise;
+};
+exports.upload = upload;
+/**
+ * Create a dropzone linked to a form grouping.
+ * All drops are stored in same place to allow body drops.
+ *
+ * @param callback the function to call once the files are dropped
+ * @param elementSelector the selector of the element on the page that should watch for drop events
+ */
+var createDropzone = function (callback, elementSelector) {
+    var elements = document.querySelectorAll(elementSelector);
+    if (!elements || !elements.length) {
+        (0, helpers_1.errorLog)(messages_1.messages.unableToFindElementOnPage);
+        return;
+    }
+    index_1.asperaHttpGateway.globals.createOrUseForm(constants_1.dropContainerName);
+    var currentFiles = index_1.asperaHttpGateway.globals.getOrCreateFormFileListFromDrop(constants_1.dropContainerName);
+    var formFolderData = index_1.asperaHttpGateway.globals.getOrCreateFolderDataList(constants_1.dropContainerName);
+    var dragEvent = function (event) {
+        event.preventDefault();
+    };
+    var dropEvent = function (event) {
+        event.preventDefault();
+        var files = [];
+        if (event.dataTransfer && event.dataTransfer.items && event.dataTransfer.items.length && event.dataTransfer.items[0] && event.dataTransfer.items[0].kind !== 'string') {
+            try {
+                var _loop_2 = function (i) {
+                    var fileEntry = event.dataTransfer.items[i].webkitGetAsEntry();
+                    if (fileEntry.isFile) {
+                        var file = event.dataTransfer.items[i].getAsFile();
+                        currentFiles.push(file);
+                        files.push({
+                            lastModified: file.lastModified,
+                            name: file.name,
+                            size: file.size,
+                            type: file.type
+                        });
+                    }
+                    else if (fileEntry.isDirectory) {
+                        var folder_1 = {
+                            path: fileEntry.name,
+                            files: [],
+                        };
+                        files.push({
+                            lastModified: 0,
+                            name: fileEntry.name,
+                            size: 0,
+                            type: 'inode/directory'
+                        });
+                        var recursiveReader_1 = function (entry) {
+                            var reader = entry.createReader();
+                            reader.readEntries(function (entries) {
+                                entries.forEach(function (entryItem) {
+                                    if (entryItem.isFile) {
+                                        entryItem.file(function (file) {
+                                            file.asperaDropPath = entryItem.fullPath;
+                                            folder_1.files.push(file);
+                                        });
+                                    }
+                                    else if (entryItem.isDirectory) {
+                                        recursiveReader_1(entryItem);
+                                    }
+                                });
+                                formFolderData.set(folder_1.path, folder_1);
+                            });
+                        };
+                        recursiveReader_1(fileEntry);
+                    }
+                };
+                for (var i = 0; i < event.dataTransfer.items.length; i++) {
+                    _loop_2(i);
+                }
+            }
+            catch (error) {
+                (0, helpers_1.errorLog)(messages_1.messages.unableToReadFolder, { event: event, error: error });
+                alert(messages_1.messages.unableToReadFolder);
+            }
+        }
+        else if (event.dataTransfer.files) {
+            for (var i = 0; i < event.dataTransfer.files.length; i++) {
+                currentFiles.push(event.dataTransfer.files[i]);
+                files.push(event.dataTransfer.files[i]);
+            }
+        }
+        callback({ event: event, files: { dataTransfer: { files: files } } });
+    };
+    elements.forEach(function (element) {
+        element.addEventListener('dragover', dragEvent);
+        element.addEventListener('drop', dropEvent);
+        index_1.asperaHttpGateway.globals.dropzonesCreated.set(elementSelector, [{ event: 'dragover', callback: dragEvent }, { event: 'drop', callback: dropEvent }]);
+    });
+};
+exports.createDropzone = createDropzone;
+/**
+ * Remove dropzone added by gateway.
+ *
+ * @param elementSelector the selector of the element on the page that should remove
+ */
+var removeDropzone = function (elementSelector) {
+    var foundDropzone = index_1.asperaHttpGateway.globals.dropzonesCreated.get(elementSelector);
+    if (foundDropzone) {
+        foundDropzone.forEach(function (data) {
+            var elements = document.querySelectorAll(elementSelector);
+            if (elements && elements.length) {
+                elements.forEach(function (element) {
+                    element.removeEventListener(data.event, data.callback);
+                });
+            }
+        });
+    }
+};
+exports.removeDropzone = removeDropzone;
+exports.default = {
+    upload: exports.upload,
+    updateTransferActivity: exports.updateTransferActivity,
+    startSendingData: exports.startSendingData,
+    addFilePickerToForm: exports.addFilePickerToForm,
+    createDropzone: exports.createDropzone,
+    removeDropzone: exports.removeDropzone,
+    getFilesForUploadPromise: exports.getFilesForUploadPromise,
+    getFilesForUpload: exports.getFilesForUpload,
+    getFoldersForUploadPromise: exports.getFoldersForUploadPromise,
+    getFoldersForUpload: exports.getFoldersForUpload,
+};

package/dist/commonjs/http-gateway/v2/constants/constants.d.ts

@@ -0,0 +1,6 @@
+/** @ignore */
+export declare const hiddenStyleList = "\n  display: none !important;\n  width: 1px !important;\n  height: 1px !important;\n  position: fixed !important;\n  z-index: -99 !important;\n  bottom: 0px !important;\n  right: 0px !important;\n";
+/** @ignore */
+export declare const keySplit = "-*ASPGTW*-";
+/** @ignore */
+export declare const dropContainerName = "http-dropzone-container";

package/dist/commonjs/http-gateway/v2/constants/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropContainerName = exports.keySplit = exports.hiddenStyleList = void 0;
+/** @ignore */
+exports.hiddenStyleList = "\n  display: none !important;\n  width: 1px !important;\n  height: 1px !important;\n  position: fixed !important;\n  z-index: -99 !important;\n  bottom: 0px !important;\n  right: 0px !important;\n";
+/** @ignore */
+exports.keySplit = '-*ASPGTW*-';
+/** @ignore */
+exports.dropContainerName = 'http-dropzone-container';

package/dist/commonjs/http-gateway/v2/constants/messages.d.ts

@@ -0,0 +1,35 @@
+/** @ignore */
+export declare const messages: {
+    serverUrlNotSet: string;
+    serverError: string;
+    serverNotVerified: string;
+    downloadFailed: string;
+    streamFailed: string;
+    notValidTransferSpec: string;
+    invalidServerUrl: string;
+    unableToGetFilesForUpload: string;
+    unableToUpload: string;
+    failedToGetDownloadUrl: string;
+    failedToGetStreamUrl: string;
+    streamInjectDomInvalid: string;
+    failedToGenerateIframe: string;
+    callbackIsNotFunction: string;
+    websocketClosedUnexpect: string;
+    invalidChunkSize: string;
+    invalidConcurrentUploads: string;
+    unableToParseDataForUpload: string;
+    unableToDeepCopyObject: string;
+    unableToFindElementOnPage: string;
+    unauthorizedFilesForUpload: string;
+    startDownload: string;
+    dropFoldersNotAllowed: string;
+    yes: string;
+    no: string;
+    close: string;
+    leavingWhileUploading: string;
+    unableToReadFolder: string;
+    streamingTooManyFiles: string;
+    loadingDownload: string;
+    versionNotsupported: string;
+    deprecationWarning: string;
+};