@scaleflex/widget-provider-views 4.8.6 → 4.8.7

package/lib/index.js

@@ -0,0 +1,1139 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _excluded = ["children"];
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+import { useEffect } from 'react';
+import { LoaderView } from '@scaleflex/widget-common';
+import generateFileId from '@scaleflex/widget-utils/lib/generateFileId';
+import isFolder from '@scaleflex/widget-utils/lib/isFolder';
+import { LIST_VIEW_COLS_IDS, LAYOUTS_IDS, LIST_VIEW_FOLDERS_COLS_IDS, PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import { CheckBoxGroup } from '@scaleflex/ui/core';
+import AuthView from './components/AuthView';
+import Browser from './components/Browser';
+import FolderImportProgress from './components/FolderImportProgress';
+// TODO: find a way to show version of the current plugin
+// why solution below isn't good?
+// first import doesn't work with webpack 5 as it was deprecated
+// second import fixes webpack 5 issue as it was mentioned in their docs
+// but it exposes our package.json to the client and it is mentioned as security rist in mutiple places
+// https://github.com/axelpale/genversion
+// https://stackoverflow.com/questions/64993118/error-should-not-import-the-named-export-version-imported-as-version
+// https://stackoverflow.com/questions/9153571/is-there-a-way-to-get-version-from-package-json-in-nodejs-code/10855054#10855054
+// import { version } from '../package.json'
+// import packageInfo from '../package.json'
+
+/**
+ * Array.prototype.findIndex ponyfill for old browsers.
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function findIndex(array, predicate) {
+  for (var i = 0; i < array.length; i++) {
+    if (predicate(array[i])) return i;
+  }
+  return -1;
+}
+
+// location.origin does not exist in IE
+function getOrigin() {
+  if ('origin' in location) {
+    return location.origin; // eslint-disable-line compat/compat
+  }
+  return "".concat(location.protocol, "//").concat(location.hostname).concat(location.port ? ":".concat(location.port) : '');
+}
+var CloseWrapper = function CloseWrapper(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  useEffect(function () {
+    return props.onUnmount;
+  }, []);
+  return children;
+};
+
+/**
+ * Class to easily generate generic views for Provider plugins
+ */
+var ProviderView = /*#__PURE__*/function () {
+  // static VERSION = packageInfo.version
+
+  /**
+   * @param {object} plugin instance of the plugin
+   * @param {object} opts
+   */
+  function ProviderView(plugin, opts) {
+    var _this = this;
+    _classCallCheck(this, ProviderView);
+    /**
+     * Toggles file/folder checkbox to on/off state while updating files list.
+     *
+     * Note that some extra complexity comes from supporting shift+click to
+     * toggle multiple checkboxes at once, which is done by getting all files
+     * in between last checked file and current one.
+     */
+    _defineProperty(this, "toggleCheckbox", function (e, item) {
+      var isMultiple = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      e.stopPropagation();
+      e.preventDefault();
+      e.currentTarget.focus();
+      var _this$plugin$getPlugi = _this.plugin.getPluginCommonState(),
+        folders = _this$plugin$getPlugi.folders,
+        files = _this$plugin$getPlugi.files;
+      var items = _this.filterItems(folders.concat(files));
+      var isFolderItem = isFolder(item);
+
+      // Shift-clicking selects a single consecutive list of items
+      // starting at the previous click and deselects everything else.
+      if (_this.lastCheckbox && e.shiftKey) {
+        var currentSelection;
+        var prevIndex = findIndex(items, function (i) {
+          return i.id === _this.lastCheckbox;
+        });
+        var currentIndex = findIndex(items, function (i) {
+          return i.id === item.id;
+        });
+        if (prevIndex < currentIndex) {
+          currentSelection = items.slice(prevIndex, currentIndex + 1);
+        } else {
+          currentSelection = items.slice(currentIndex, prevIndex + 1);
+        }
+        var _currentSelection$red = currentSelection.reduce(function (selections, currentItem) {
+            var key = isFolder(currentItem) ? 'selectedFolders' : 'selectedFiles';
+            return _objectSpread(_objectSpread({}, selections), {}, _defineProperty({}, key, [].concat(_toConsumableArray(selections[key]), [currentItem])));
+          }, {
+            selectedFolders: [],
+            selectedFiles: []
+          }),
+          selectedFolders = _currentSelection$red.selectedFolders,
+          selectedFiles = _currentSelection$red.selectedFiles;
+        // We need the current files & the file to be added, so that we are subtracting file of the bulk selected ones and reusing it as separate file.
+        if (_this.plugin.filerobot.isFileRestrictedToGetAdded(selectedFiles.slice(1), selectedFiles[0], false)) {
+          return;
+        }
+        var _isAllFoldersSelected = _this.checkIfAllSelected(selectedFolders, folders);
+        var _isAllFilesSelected = _this.checkIfAllSelected(selectedFiles, files);
+        _this.plugin.setPluginCommonState({
+          currentSelection: currentSelection,
+          isAllFoldersSelected: _isAllFoldersSelected,
+          isAllFilesSelected: _isAllFilesSelected
+        });
+        return currentSelection;
+      } else if (isMultiple || e.ctrlKey || e.metaKey) {
+        _this.lastCheckbox = item.id;
+        var _this$plugin$getPlugi2 = _this.plugin.getPluginCommonState(),
+          _currentSelection = _this$plugin$getPlugi2.currentSelection;
+        var updatedSelection = _this.isChecked(item) ? _currentSelection.filter(function (i) {
+          return item.id !== i.id;
+        }) : _currentSelection.concat([item]);
+        var updates = {
+          currentSelection: updatedSelection
+        };
+        if (isFolderItem) {
+          updates.isAllFoldersSelected = _this.checkIfAllSelected(updatedSelection.filter(function (item) {
+            return isFolder(item);
+          }), folders);
+        } else {
+          if (_this.plugin.filerobot.isFileRestrictedToGetAdded(_currentSelection, item, false)) {
+            return;
+          }
+          updates.isAllFilesSelected = _this.checkIfAllSelected(updatedSelection.filter(function (item) {
+            return !isFolder(item);
+          }), files);
+        }
+        _this.plugin.setPluginCommonState(updates);
+        return updatedSelection;
+      }
+
+      // If only 1 file/folder is available and it's selected means we have selected all the files/folders.
+      var isAllFoldersSelected = false;
+      var isAllFilesSelected = false;
+      if (isFolderItem && folders.length === 1) {
+        isAllFoldersSelected = true;
+      } else if (!isFolderItem && files.length === 1) {
+        isAllFilesSelected = true;
+      }
+      if (!isFolderItem && _this.plugin.filerobot.isFileRestrictedToGetAdded([], item, false)) {
+        return;
+      }
+      _this.lastCheckbox = item.id;
+      _this.plugin.setPluginCommonState({
+        currentSelection: [item],
+        disableDownloadButton: !!isFolderItem,
+        isAllFoldersSelected: isAllFoldersSelected,
+        isAllFilesSelected: isAllFilesSelected
+      });
+      return [item];
+    });
+    _defineProperty(this, "toggleAllFilesSelection", function () {
+      var _this$plugin$getPlugi3 = _this.plugin.getPluginCommonState(),
+        _this$plugin$getPlugi4 = _this$plugin$getPlugi3.currentSelection,
+        currentSelection = _this$plugin$getPlugi4 === void 0 ? [] : _this$plugin$getPlugi4,
+        files = _this$plugin$getPlugi3.files,
+        _this$plugin$getPlugi5 = _this$plugin$getPlugi3.isAllFilesSelected,
+        isAllFilesSelected = _this$plugin$getPlugi5 === void 0 ? false : _this$plugin$getPlugi5;
+      var selectedFolders = currentSelection.filter(function (item) {
+        return isFolder(item);
+      });
+      var newSelections = isAllFilesSelected ? selectedFolders : selectedFolders.concat(files);
+      _this.plugin.setPluginCommonState({
+        currentSelection: newSelections,
+        isAllFilesSelected: !isAllFilesSelected
+      });
+    });
+    _defineProperty(this, "toggleAllFoldersSelection", function () {
+      var _this$plugin$getPlugi6 = _this.plugin.getPluginCommonState(),
+        _this$plugin$getPlugi7 = _this$plugin$getPlugi6.currentSelection,
+        currentSelection = _this$plugin$getPlugi7 === void 0 ? [] : _this$plugin$getPlugi7,
+        folders = _this$plugin$getPlugi6.folders,
+        _this$plugin$getPlugi8 = _this$plugin$getPlugi6.isAllFoldersSelected,
+        isAllFoldersSelected = _this$plugin$getPlugi8 === void 0 ? false : _this$plugin$getPlugi8;
+      var selectedFiles = currentSelection.filter(function (item) {
+        return !isFolder(item);
+      });
+      var newSelections = isAllFoldersSelected ? selectedFiles : selectedFiles.concat(folders);
+      _this.plugin.setPluginCommonState({
+        currentSelection: newSelections,
+        isAllFoldersSelected: !isAllFoldersSelected
+      });
+    });
+    _defineProperty(this, "checkIfAllSelected", function (currentSelection, items) {
+      return currentSelection.length === items.length;
+    });
+    /**
+     * Validates restrictions during import that require backend requests
+     */
+    _defineProperty(this, "validateDuringImport", function (fileCount, totalSize, depth) {
+      var folderCount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+      if (_this.importState.shouldStop) {
+        return false; // Already stopped due to previous restriction
+      }
+      var _this$plugin$filerobo = _this.plugin.filerobot.opts.restrictions,
+        remoteMaxFolderImportCount = _this$plugin$filerobo.remoteMaxFolderImportCount,
+        remoteMaxFolderImportSize = _this$plugin$filerobo.remoteMaxFolderImportSize,
+        remoteMaxFolderDepth = _this$plugin$filerobo.remoteMaxFolderDepth,
+        remoteMaxFolderCount = _this$plugin$filerobo.remoteMaxFolderCount;
+      var _this$plugin$getPlugi9 = _this.plugin.getPluginCommonState(),
+        shouldIncludeSubFolders = _this$plugin$getPlugi9.shouldIncludeSubFolders;
+
+      // Update tracking state
+      _this.importState.totalFilesImported += fileCount;
+      _this.importState.totalFoldersImported += folderCount;
+      _this.importState.totalSizeImported += totalSize;
+      _this.importState.currentDepth = Math.max(_this.importState.currentDepth, depth);
+
+      // Check file count restriction
+      if (remoteMaxFolderImportCount && _this.importState.totalFilesImported > remoteMaxFolderImportCount) {
+        _this.importState.shouldStop = true;
+        throw new Error(_this.plugin.filerobot.i18n('remoteUploadTooManyFilesSelectedError', {
+          limit: remoteMaxFolderImportCount
+        }));
+      }
+
+      // Check total file size restriction
+      if (remoteMaxFolderImportSize && _this.importState.totalSizeImported > remoteMaxFolderImportSize) {
+        _this.importState.shouldStop = true;
+        var maxSizeGB = Math.round(remoteMaxFolderImportSize / (1024 * 1024 * 1024));
+        throw new Error(_this.plugin.filerobot.i18n('remoteUploadTotalFileSizeTooBigError', {
+          limit: "".concat(maxSizeGB, " GB")
+        }));
+      }
+
+      // Check total folder count restriction during import (only for recursive imports)
+      if (shouldIncludeSubFolders && remoteMaxFolderCount && _this.importState.totalFoldersImported > remoteMaxFolderCount) {
+        _this.importState.shouldStop = true;
+        throw new Error(_this.plugin.filerobot.i18n('remoteUploadTooManyFoldersSelectedError', {
+          limit: remoteMaxFolderCount
+        }));
+      }
+
+      // Check folder depth restriction (only for recursive imports)
+      if (shouldIncludeSubFolders && remoteMaxFolderDepth && _this.importState.currentDepth > remoteMaxFolderDepth) {
+        _this.importState.shouldStop = true;
+        throw new Error(_this.plugin.filerobot.i18n('remoteUploadPathTooLongError', {
+          limit: remoteMaxFolderDepth
+        }));
+      }
+      return true; // Continue importing
+    });
+    this.id = PLUGINS_IDS.PROVIDER_VIEWS;
+    this.plugin = plugin;
+    this.provider = opts.provider;
+
+    // set default options
+    var defaultOptions = {
+      layoutType: LAYOUTS_IDS.LIST,
+      showTitles: true,
+      showFilter: false,
+      showBreadcrumbs: true,
+      showSort: false,
+      is3rdPartyData: true,
+      showLogout: true,
+      showUsername: true,
+      selectedListViewCols: [LIST_VIEW_COLS_IDS.TYPE, LIST_VIEW_COLS_IDS.VISIBILITY,
+      // LIST_VIEW_COLS_IDS.STATUS,
+      LIST_VIEW_COLS_IDS.TAGS, LIST_VIEW_COLS_IDS.LABELS, LIST_VIEW_COLS_IDS.LAST_MODIFY],
+      selectedListViewFoldersCols: [LIST_VIEW_FOLDERS_COLS_IDS.VISIBILITY, LIST_VIEW_FOLDERS_COLS_IDS.AMOUNT, LIST_VIEW_FOLDERS_COLS_IDS.LAST_MODIFY]
+    };
+
+    // merge default options with the ones set by user
+    this.opts = _objectSpread(_objectSpread({}, defaultOptions), opts);
+
+    // Logic
+    this.addFile = this.addFile.bind(this);
+    this.enqueueFile = this.enqueueFile.bind(this);
+    this.addFolder = this.addFolder.bind(this);
+    this.filterItems = this.filterItems.bind(this);
+    this.filterQuery = this.filterQuery.bind(this);
+    this.toggleSearch = this.toggleSearch.bind(this);
+    this.getFolder = this.getFolder.bind(this);
+    this.getNextFolder = this.getNextFolder.bind(this);
+    this.logout = this.logout.bind(this);
+    this.preFirstRender = this.preFirstRender.bind(this);
+    this.handleAuth = this.handleAuth.bind(this);
+    this.sortByTitle = this.sortByTitle.bind(this);
+    this.sortByDate = this.sortByDate.bind(this);
+    this.isActiveRow = this.isActiveRow.bind(this);
+    this.isChecked = this.isChecked.bind(this);
+    this.toggleCheckbox = this.toggleCheckbox.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.handleScroll = this.handleScroll.bind(this);
+    this.list = this.list.bind(this);
+    this.cancelPicking = this.cancelPicking.bind(this);
+    this.clearSelection = this.clearSelection.bind(this);
+    this.addSelectedItems = this.addSelectedItems.bind(this);
+    this.renderPanelUploadActionButtons = this.renderPanelUploadActionButtons.bind(this);
+
+    // Visual
+    this.render = this.render.bind(this);
+    this.clearSelection();
+
+    // Set default state for the plugin
+    this.plugin.setPluginCommonState({
+      authenticated: false,
+      files: [],
+      folders: [],
+      openedFolders: [],
+      selectedFolders: {},
+      activeRow: -1,
+      filterInput: '',
+      isSearchVisible: false
+    });
+  }
+  return _createClass(ProviderView, [{
+    key: "_updateFilesAndFolders",
+    value: function _updateFilesAndFolders(res, files, folders) {
+      this.nextPagePath = res.nextPagePath;
+      res.items.forEach(function (item) {
+        if (item.isFolder) {
+          folders.push(item);
+        } else {
+          files.push(item);
+        }
+      });
+      this.plugin.setPluginCommonState({
+        folders: folders,
+        files: files
+      });
+    }
+
+    /**
+     * Called only the first time the provider view is rendered.
+     * Kind of like an init function.
+     */
+  }, {
+    key: "preFirstRender",
+    value: function preFirstRender() {
+      this.plugin.setPluginCommonState({
+        didFirstRender: true
+      });
+      this.plugin.onFirstRender();
+    }
+
+    /**
+     * Based on folder ID, fetch a new folder and update it to state
+     * used from the companion-client
+     *
+     * @param  {string} id Folder id
+     * @returns {Promise}   Folders/files in folder
+     */
+  }, {
+    key: "getFolder",
+    value: function getFolder(id, name) {
+      var _this2 = this;
+      return this._loaderWrapper(this.provider.list(id), function (res) {
+        var folders = [];
+        var files = [];
+        var openedFolders;
+        var state = _this2.plugin.getPluginCommonState();
+        var index = findIndex(state.openedFolders, function (folder) {
+          return id === folder.id;
+        });
+        if (index !== -1) {
+          openedFolders = state.openedFolders.slice(0, index + 1);
+        } else {
+          openedFolders = state.openedFolders.concat([{
+            id: id,
+            title: name
+          }]);
+        }
+        _this2.username = _this2.username ? _this2.username : res.username;
+        _this2._updateFilesAndFolders(res, files, folders);
+        _this2.plugin.setPluginCommonState({
+          openedFolders: openedFolders
+        });
+      }, this.handleError);
+    }
+
+    /**
+     * Fetches new folder
+     *
+     * @param  {object} folder
+     */
+  }, {
+    key: "getNextFolder",
+    value: function getNextFolder(folder) {
+      if (folder) {
+        this.getFolder(folder.requestPath || folder.id, folder.name || folder.title);
+        this.lastCheckbox = undefined;
+        if (this.opts.is3rdPartyData) {
+          this.plugin.setPluginCommonState({
+            currentSelection: []
+          });
+        }
+      }
+    }
+  }, {
+    key: "enqueueFile",
+    value: function enqueueFile(file) {
+      var _this$importState;
+      // Check if we should stop due to previous restriction hits
+      if ((_this$importState = this.importState) !== null && _this$importState !== void 0 && _this$importState.shouldStop) {
+        return; // Stop processing
+      }
+
+      // For individual files (not from folders), validate restrictions during import
+      if (this.importState && !file.relativePath) {
+        try {
+          this.validateDuringImport(1, file.size || 0, 0);
+        } catch (error) {
+          this.importState.shouldStop = true;
+          throw error;
+        }
+      }
+      this.importState.filesQueue.push(file);
+    }
+  }, {
+    key: "addFile",
+    value: function addFile(file) {
+      var tagFile = _objectSpread(_objectSpread({
+        id: this.providerFileToId(file),
+        source: this.plugin.id,
+        data: file,
+        name: file.name || file.id,
+        type: file.mimeType,
+        isRemote: true,
+        body: {
+          fileId: file.id
+        }
+      }, file.relativePath && {
+        info: {
+          relativePath: "".concat(file.relativePath).concat(file.name)
+        }
+      }), {}, {
+        remote: {
+          companionUrl: this.plugin.provider.companionUrl,
+          url: "".concat(this.provider.fileUrl(file.requestPath)),
+          body: {
+            fileId: file.id
+          },
+          providerOptions: this.provider.opts
+        }
+      });
+      if (file.thumbnail || file.preview) {
+        tagFile.preview = file.thumbnail || file.preview;
+      }
+      this.plugin.filerobot.log('Adding remote file');
+      try {
+        this.plugin.filerobot.addFile(tagFile);
+      } catch (err) {
+        if (!err.isRestriction) {
+          this.plugin.filerobot.log(err);
+        }
+      }
+    }
+  }, {
+    key: "removeFile",
+    value: function removeFile(id) {
+      var _this$plugin$getPlugi10 = this.plugin.getPluginCommonState(),
+        currentSelection = _this$plugin$getPlugi10.currentSelection;
+      this.plugin.setPluginCommonState({
+        currentSelection: currentSelection.filter(function (file) {
+          return file.id !== id;
+        })
+      });
+    }
+
+    /**
+     * Removes session token on client side.
+     */
+  }, {
+    key: "logout",
+    value: function logout() {
+      var _this3 = this;
+      this.provider.logout().then(function (res) {
+        if (res.ok) {
+          if (!res.revoked) {
+            var message = _this3.plugin.filerobot.i18n('providerViewCompanionUnauthorizeMessage', {
+              provider: _this3.plugin.title,
+              url: res.manual_revoke_url
+            });
+            _this3.plugin.filerobot.info(message, 'info', 7000);
+          }
+          var newState = {
+            authenticated: false,
+            files: [],
+            folders: [],
+            openedFolders: []
+          };
+          _this3.plugin.setPluginCommonState(newState);
+        }
+      })["catch"](this.handleError);
+    }
+  }, {
+    key: "filterQuery",
+    value: function filterQuery(e) {
+      var state = this.plugin.getPluginCommonState();
+      this.plugin.setPluginCommonState(_extends({}, state, {
+        filterInput: e ? e.target.value : ''
+      }));
+    }
+  }, {
+    key: "toggleSearch",
+    value: function toggleSearch(inputEl) {
+      var state = this.plugin.getPluginCommonState();
+      this.plugin.setPluginCommonState({
+        isSearchVisible: !state.isSearchVisible,
+        filterInput: ''
+      });
+    }
+  }, {
+    key: "filterItems",
+    value: function filterItems(items) {
+      var state = this.plugin.getPluginCommonState();
+      if (!state.filterInput || state.filterInput === '') {
+        return items;
+      }
+      return items.filter(function (folder) {
+        return folder.name.toLowerCase().indexOf(state.filterInput.toLowerCase()) !== -1;
+      });
+    }
+  }, {
+    key: "sortByTitle",
+    value: function sortByTitle() {
+      var state = _extends({}, this.plugin.getPluginCommonState());
+      var files = state.files,
+        folders = state.folders,
+        sorting = state.sorting;
+      var sortedFiles = files.sort(function (fileA, fileB) {
+        if (sorting === 'titleDescending') {
+          return fileB.name.localeCompare(fileA.name);
+        }
+        return fileA.name.localeCompare(fileB.name);
+      });
+      var sortedFolders = folders.sort(function (folderA, folderB) {
+        if (sorting === 'titleDescending') {
+          return folderB.name.localeCompare(folderA.name);
+        }
+        return folderA.name.localeCompare(folderB.name);
+      });
+      this.plugin.setPluginCommonState(_extends({}, state, {
+        files: sortedFiles,
+        folders: sortedFolders,
+        sorting: sorting === 'titleDescending' ? 'titleAscending' : 'titleDescending'
+      }));
+    }
+  }, {
+    key: "sortByDate",
+    value: function sortByDate() {
+      var state = _extends({}, this.plugin.getPluginCommonState());
+      var files = state.files,
+        folders = state.folders,
+        sorting = state.sorting;
+      var sortedFiles = files.sort(function (fileA, fileB) {
+        var a = new Date(fileA.modifiedDate);
+        var b = new Date(fileB.modifiedDate);
+        if (sorting === 'dateDescending') {
+          return a > b ? -1 : a < b ? 1 : 0;
+        }
+        return a > b ? 1 : a < b ? -1 : 0;
+      });
+      var sortedFolders = folders.sort(function (folderA, folderB) {
+        var a = new Date(folderA.modifiedDate);
+        var b = new Date(folderB.modifiedDate);
+        if (sorting === 'dateDescending') {
+          return a > b ? -1 : a < b ? 1 : 0;
+        }
+        return a > b ? 1 : a < b ? -1 : 0;
+      });
+      this.plugin.setPluginCommonState(_extends({}, state, {
+        files: sortedFiles,
+        folders: sortedFolders,
+        sorting: sorting === 'dateDescending' ? 'dateAscending' : 'dateDescending'
+      }));
+    }
+  }, {
+    key: "sortBySize",
+    value: function sortBySize() {
+      var state = _extends({}, this.plugin.getPluginCommonState());
+      var files = state.files,
+        sorting = state.sorting;
+
+      // check that plugin supports file sizes
+      if (!files.length || !this.plugin.getItemData(files[0]).size) {
+        return;
+      }
+      var sortedFiles = files.sort(function (fileA, fileB) {
+        var a = fileA.size;
+        var b = fileB.size;
+        if (sorting === 'sizeDescending') {
+          return a > b ? -1 : a < b ? 1 : 0;
+        }
+        return a > b ? 1 : a < b ? -1 : 0;
+      });
+      this.plugin.setPluginCommonState(_extends({}, state, {
+        files: sortedFiles,
+        sorting: sorting === 'sizeDescending' ? 'sizeAscending' : 'sizeDescending'
+      }));
+    }
+  }, {
+    key: "isActiveRow",
+    value: function isActiveRow(file) {
+      return this.plugin.getPluginCommonState().activeRow === this.plugin.getItemId(file);
+    }
+  }, {
+    key: "isChecked",
+    value: function isChecked(file) {
+      var _this$plugin$getPlugi11 = this.plugin.getPluginCommonState(),
+        currentSelection = _this$plugin$getPlugi11.currentSelection;
+      // comparing id instead of the file object, because the reference to the object
+      // changes when we switch folders, and the file list is updated
+      return currentSelection.some(function (item) {
+        return item.id === file.id;
+      });
+    }
+
+    /**
+     * Adds all files found inside of specified folder.
+     *
+     * Uses separated state while folder contents are being fetched and
+     * mantains list of selected folders, which are separated from files.
+     */
+  }, {
+    key: "addFolder",
+    value: function addFolder(folder) {
+      var _this$importState2,
+        _this4 = this;
+      var parentRelativePath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      var currentDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      // Check if we should stop due to previous restriction hits
+      if ((_this$importState2 = this.importState) !== null && _this$importState2 !== void 0 && _this$importState2.shouldStop) {
+        return Promise.resolve();
+      }
+      var folderId = this.providerFileToId(folder);
+      var folders = _objectSpread({}, this.plugin.getPluginCommonState().selectedFolders);
+      if (folderId in folders && folders[folderId].loading) {
+        return;
+      }
+      folders[folderId] = {
+        loading: true,
+        files: []
+      };
+      this.plugin.setPluginCommonState({
+        selectedFolders: folders
+      });
+      var _this$plugin$getPlugi12 = this.plugin.getPluginCommonState(),
+        shouldIncludeSubFolders = _this$plugin$getPlugi12.shouldIncludeSubFolders;
+      var relativePath = "".concat(parentRelativePath || folder.relativePath || '').concat(folder.name, "/");
+      return this.list(folder.requestPath).then(function (_ref2) {
+        var _this4$importState, _this4$importState2;
+        var _ref3 = _slicedToArray(_ref2, 2),
+          files = _ref3[0],
+          _ref3$ = _ref3[1],
+          subFolders = _ref3$ === void 0 ? [] : _ref3$;
+        // Check if we should stop due to restriction hit during list operation
+        if ((_this4$importState = _this4.importState) !== null && _this4$importState !== void 0 && _this4$importState.shouldStop) {
+          return Promise.resolve();
+        }
+
+        // Calculate total size of files in this folder
+        var totalSize = files.reduce(function (sum, file) {
+          return sum + (file.size || 0);
+        }, 0);
+
+        // Validate restrictions during import (this may throw and stop the process)
+        try {
+          _this4.validateDuringImport(files.length, totalSize, currentDepth, 1); // Count this folder as 1
+        } catch (error) {
+          // Stop the import process and propagate the error
+          _this4.importState.shouldStop = true;
+          return Promise.reject(error);
+        }
+
+        // Update progress during import
+        _this4.updateImportProgress(1, files.length);
+        files.forEach(function (file) {
+          // Add relativePath for recursive folder structure replication
+          _this4.enqueueFile(_objectSpread(_objectSpread({}, file), {}, {
+            relativePath: relativePath
+          }));
+        });
+        var ids = files.map(_this4.providerFileToId);
+        folders = _objectSpread(_objectSpread({}, _this4.plugin.getPluginCommonState().selectedFolders), {}, _defineProperty({}, folderId, {
+          loading: false,
+          files: ids
+        }));
+        _this4.plugin.setPluginCommonState({
+          selectedFolders: folders
+        });
+        var message;
+        if (files.length) {
+          message = _this4.plugin.filerobot.i18n('filerobotFolderAddedMessage', {
+            smart_count: files.length,
+            folder: folder.name
+          });
+        } else {
+          message = _this4.plugin.filerobot.i18n('filerobotEmptyFolderAddedMessage');
+        }
+        _this4.plugin.filerobot.info(message);
+
+        // Process subfolders if recursion is enabled and we haven't hit any restrictions
+        if (shouldIncludeSubFolders && !((_this4$importState2 = _this4.importState) !== null && _this4$importState2 !== void 0 && _this4$importState2.shouldStop)) {
+          return Promise.all(subFolders.map(function (subFolder) {
+            return _this4.addFolder(_objectSpread(_objectSpread({}, subFolder), {}, {
+              relativePath: relativePath
+            }), relativePath, currentDepth + 1);
+          }));
+        }
+      })["catch"](function (e) {
+        folders = _objectSpread({}, _this4.plugin.getPluginCommonState().selectedFolders);
+        delete folders[folderId];
+        _this4.plugin.setPluginCommonState({
+          selectedFolders: folders
+        });
+        _this4.handleError(e);
+      });
+    }
+
+    /**
+     * Updates the progressive loading UI with current import progress
+     */
+  }, {
+    key: "updateImportProgress",
+    value: function updateImportProgress(foldersCount, filesCount) {
+      var _state$folderImportPr;
+      var state = this.plugin.getPluginCommonState();
+      if ((_state$folderImportPr = state.folderImportProgress) !== null && _state$folderImportPr !== void 0 && _state$folderImportPr.isVisible) {
+        var currentProgress = state.folderImportProgress;
+        this.plugin.setPluginCommonState({
+          folderImportProgress: _objectSpread(_objectSpread({}, currentProgress), {}, {
+            foldersCount: (currentProgress.foldersCount || 0) + foldersCount,
+            filesCount: (currentProgress.filesCount || 0) + filesCount
+          })
+        });
+      }
+    }
+  }, {
+    key: "providerFileToId",
+    value: function providerFileToId(file) {
+      return generateFileId({
+        data: file,
+        name: file.name || file.id,
+        type: file.mimeType
+      });
+    }
+  }, {
+    key: "handleAuth",
+    value: function handleAuth() {
+      var _this5 = this;
+      var authState = btoa(JSON.stringify({
+        origin: getOrigin()
+      }));
+      var clientVersion = encodeURIComponent("@scaleflex/widget-provider-views=".concat(ProviderView.VERSION));
+      var link = "".concat(this.provider.authUrl(), "?state=").concat(authState, "&filerobotVersions=").concat(clientVersion);
+      var authWindow = window.open(link, '_blank');
+      var _handleToken = function handleToken(e) {
+        if (e.source !== authWindow) {
+          _this5.plugin.filerobot.log("rejecting event from ".concat(e.origin));
+          return;
+        }
+
+        // Check if it's a string before doing the JSON.parse to maintain support
+        // for older Companion versions that used object references
+        var data = typeof e.data === 'string' ? JSON.parse(e.data) : e.data;
+        if (!data.token) {
+          _this5.plugin.filerobot.log('did not receive token from auth window');
+          return;
+        }
+        authWindow.close();
+        window.removeEventListener('message', _handleToken);
+        _this5.provider.setAuthToken(data.token);
+        _this5.preFirstRender();
+      };
+      window.addEventListener('message', _handleToken);
+    }
+  }, {
+    key: "handleError",
+    value: function handleError(error) {
+      var filerobot = this.plugin.filerobot;
+      filerobot.log(error.toString());
+      if (error.isAuthError) {
+        return;
+      }
+      var message = error.message || error.toString() || filerobot.i18n('providerViewCompanionError');
+      filerobot.info({
+        message: message
+      }, 'error', 5000);
+    }
+  }, {
+    key: "handleScroll",
+    value: function handleScroll(e) {
+      var _this6 = this;
+      var scrollPos = e.target.scrollHeight - (e.target.scrollTop + e.target.offsetHeight);
+      var path = this.nextPagePath || null;
+      if (scrollPos < 50 && path && !this._isHandlingScroll) {
+        this.provider.list(path).then(function (res) {
+          var _this6$plugin$getPlug = _this6.plugin.getPluginCommonState(),
+            files = _this6$plugin$getPlug.files,
+            folders = _this6$plugin$getPlug.folders;
+          _this6._updateFilesAndFolders(res, files, folders);
+        })["catch"](this.handleError).then(function () {
+          _this6._isHandlingScroll = false;
+        }); // always called
+
+        this._isHandlingScroll = true;
+      }
+    }
+  }, {
+    key: "list",
+    value: function list(path) {
+      var _this7 = this;
+      var files = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var folders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      files = files || [];
+      folders = folders || [];
+      return new Promise(function (resolve, reject) {
+        _this7.provider.list(path).then(function (res) {
+          res.items.forEach(function (item) {
+            if (item.isFolder) {
+              folders.push(item);
+            } else {
+              files.push(item);
+            }
+          });
+          var nextPagePath = res.nextPagePath || null;
+          if (nextPagePath) {
+            return _this7.list(nextPagePath, files, folders).then(function (_ref4) {
+              var _ref5 = _slicedToArray(_ref4, 2),
+                files = _ref5[0],
+                folders = _ref5[1];
+              return resolve([files, folders]);
+            })["catch"](function (e) {
+              return reject(e);
+            });
+          } else {
+            return resolve([files, folders]);
+          }
+        })["catch"](function (e) {
+          return reject(e);
+        });
+      });
+    }
+
+    /**
+     * gets all the current selection items adds them to the uploading panel
+     * if folder it would retrieve its files
+     * if files they would be added directly
+     *
+     */
+  }, {
+    key: "addSelectedItems",
+    value: async function addSelectedItems() {
+      var _this8 = this;
+      try {
+        var _this$plugin$getPlugi13 = this.plugin.getPluginCommonState(),
+          currentSelection = _this$plugin$getPlugi13.currentSelection;
+        var remoteMaxFolderCount = this.plugin.filerobot.opts.restrictions.remoteMaxFolderCount;
+
+        // Pre-validate only restrictions that don't need backend requests
+        this.validatePreImportRestrictions(currentSelection, {
+          remoteMaxFolderCount: remoteMaxFolderCount
+        });
+
+        // Initialize import tracking state
+        this.importState = {
+          totalFilesImported: 0,
+          totalFoldersImported: 0,
+          totalSizeImported: 0,
+          filesQueue: [],
+          currentDepth: 0,
+          shouldStop: false
+        };
+
+        // Set up progressive loading state
+        this.plugin.setPluginCommonState({
+          folderImportProgress: {
+            isVisible: true,
+            foldersCount: 0,
+            filesCount: 0
+          }
+        });
+        var promises = currentSelection.map(function (file) {
+          if (file.isFolder) {
+            return _this8.addFolder(file, '', 1); // Start at depth 1
+          } else {
+            return _this8.enqueueFile(file);
+          }
+        });
+        Promise.all(promises).then(function () {
+          var _this8$importState, _this8$importState2;
+          _this8.plugin.setPluginCommonState({
+            folderImportProgress: {
+              isVisible: false
+            }
+          });
+          if (!((_this8$importState = _this8.importState) !== null && _this8$importState !== void 0 && _this8$importState.shouldStop) && ((_this8$importState2 = _this8.importState) === null || _this8$importState2 === void 0 ? void 0 : _this8$importState2.filesQueue.length) > 0) {
+            _this8.importState.filesQueue.forEach(function (file) {
+              return _this8.addFile(file);
+            });
+          }
+          _this8.importState = null;
+        })["catch"](function (error) {
+          _this8.plugin.setPluginCommonState({
+            folderImportProgress: {
+              isVisible: false
+            }
+          });
+          _this8.handleImportError(error);
+          _this8.importState = null;
+        });
+      } catch (error) {
+        // Hide any loading state and maintain selection
+        this.plugin.setPluginCommonState({
+          folderImportProgress: {
+            isVisible: false
+          }
+        });
+
+        // Show error message without clearing selection
+        this.plugin.filerobot.info(error.message, 'error', 5000);
+      }
+    }
+
+    /**
+     * Validates restrictions that don't require backend requests
+     */
+  }, {
+    key: "validatePreImportRestrictions",
+    value: function validatePreImportRestrictions(currentSelection, restrictions) {
+      var _this$plugin$getPlugi14 = this.plugin.getPluginCommonState(),
+        shouldIncludeSubFolders = _this$plugin$getPlugi14.shouldIncludeSubFolders;
+      var remoteMaxFolderCount = restrictions.remoteMaxFolderCount;
+      var folders = currentSelection.filter(function (item) {
+        return item.isFolder;
+      });
+
+      // Check folder count restriction (no backend request needed)
+      if (shouldIncludeSubFolders && remoteMaxFolderCount && folders.length > remoteMaxFolderCount) {
+        throw new Error(this.plugin.filerobot.i18n('remoteUploadTooManyFoldersSelectedError', {
+          limit: remoteMaxFolderCount
+        }));
+      }
+    }
+  }, {
+    key: "handleImportError",
+    value:
+    /**
+     * Handles import errors by cleaning up state
+     */
+    function handleImportError(error) {
+      var _this9 = this;
+      // Remove any partially imported files from this session
+      var files = this.plugin.filerobot.getUploads();
+      Object.keys(files).forEach(function (fileId) {
+        if (files[fileId].source === _this9.plugin.id) {
+          _this9.plugin.filerobot.removeFile(fileId);
+        }
+      });
+
+      // Clear any folder loading states
+      this.plugin.setPluginCommonState({
+        selectedFolders: {}
+      });
+
+      // Show error message without clearing selection (so user can adjust and try again)
+      this.plugin.filerobot.info(error.message, 'error', 5000);
+    }
+  }, {
+    key: "cancelPicking",
+    value: function cancelPicking() {
+      var clearSelection = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (clearSelection) {
+        this.clearSelection();
+      }
+      this.plugin.setPluginCommonState({
+        folderImportProgress: {
+          isVisible: false
+        },
+        selectedFolders: {}
+      });
+      this.importState = null;
+      this.provider.cancel();
+    }
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      this.plugin.setPluginCommonState({
+        isAllFoldersSelected: false,
+        isAllFilesSelected: false,
+        currentSelection: []
+      });
+    }
+
+    // displays loader view while asynchronous request is being made.
+  }, {
+    key: "_loaderWrapper",
+    value: function _loaderWrapper(promise, then, catch_) {
+      var _this10 = this;
+      this.plugin.setPluginCommonState({
+        loading: true
+      });
+      return promise.then(function (result) {
+        _this10.plugin.setPluginCommonState({
+          loading: false
+        });
+        then(result);
+      })["catch"](function (err) {
+        _this10.plugin.setPluginCommonState({
+          loading: false
+        });
+        catch_(err);
+      });
+    }
+  }, {
+    key: "renderPanelUploadActionButtons",
+    value: function renderPanelUploadActionButtons() {
+      var _this11 = this;
+      if (!this.plugin.filerobot.opts.enableRemoteRecursiveUpload) {
+        return null;
+      }
+      var _this$plugin$getPlugi15 = this.plugin.getPluginCommonState(),
+        shouldIncludeSubFolders = _this$plugin$getPlugi15.shouldIncludeSubFolders;
+      var handleToggleIncludeSubfoldersOption = function handleToggleIncludeSubfoldersOption() {
+        return _this11.plugin.setPluginCommonState({
+          shouldIncludeSubFolders: !shouldIncludeSubFolders
+        });
+      };
+      return /*#__PURE__*/_jsx(CheckBoxGroup, {
+        checked: shouldIncludeSubFolders,
+        label: this.plugin.filerobot.i18n('remoteUploadIncludeSubFoldersCheckbox'),
+        labelPosition: "after",
+        onChange: handleToggleIncludeSubfoldersOption,
+        size: "sm",
+        type: "checkbox"
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(state) {
+      var _this12 = this;
+      var viewOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var _this$plugin$getPlugi16 = this.plugin.getPluginCommonState(),
+        authenticated = _this$plugin$getPlugi16.authenticated,
+        didFirstRender = _this$plugin$getPlugi16.didFirstRender,
+        folderImportProgress = _this$plugin$getPlugi16.folderImportProgress;
+      if (!didFirstRender) {
+        this.preFirstRender();
+      }
+
+      // reload pluginState for "loading" attribute because it might
+      // have changed above.
+      if (this.plugin.getPluginCommonState().loading) {
+        return /*#__PURE__*/_jsx(CloseWrapper, {
+          onUnmount: this.cancelPicking,
+          children: /*#__PURE__*/_jsx(LoaderView, {
+            loaderLabel: this.plugin.filerobot.i18n('loaderLoadingLabel')
+          })
+        });
+      }
+      if (!authenticated) {
+        return /*#__PURE__*/_jsx(CloseWrapper, {
+          onUnmount: this.cancelPicking,
+          children: /*#__PURE__*/_jsx(AuthView, {
+            pluginName: this.plugin.title,
+            pluginIcon: this.plugin.icon,
+            handleAuth: this.handleAuth,
+            i18n: this.plugin.filerobot.i18n,
+            i18nArray: this.plugin.filerobot.i18nArray
+          })
+        });
+      }
+      var targetViewOptions = _objectSpread(_objectSpread({}, this.opts), viewOptions);
+      var browserProps = _extends({}, this.plugin.getPluginCommonState(), _objectSpread(_objectSpread({}, targetViewOptions), {}, {
+        username: this.username,
+        getNextFolder: this.getNextFolder,
+        getFolder: this.getFolder,
+        filterItems: this.filterItems,
+        filterQuery: this.filterQuery,
+        toggleSearch: this.toggleSearch,
+        sortByTitle: this.sortByTitle,
+        sortByDate: this.sortByDate,
+        logout: this.logout,
+        isActiveRow: this.isActiveRow,
+        isChecked: this.isChecked,
+        toggleCheckbox: this.toggleCheckbox,
+        handleScroll: this.handleScroll,
+        list: this.list,
+        done: this.addSelectedItems,
+        cancel: this.cancelPicking,
+        title: this.plugin.title,
+        pluginIcon: this.plugin.icon,
+        i18n: this.plugin.filerobot.i18n,
+        updateFilesAndFolders: function updateFilesAndFolders() {
+          return _this12._updateFilesAndFolders.apply(_this12, arguments);
+        },
+        toggleAllFilesSelection: this.toggleAllFilesSelection,
+        toggleAllFoldersSelection: this.toggleAllFoldersSelection
+      }));
+      return /*#__PURE__*/_jsxs(CloseWrapper, {
+        onUnmount: this.cancelPicking,
+        children: [/*#__PURE__*/_jsx(Browser, _objectSpread({}, browserProps)), (folderImportProgress === null || folderImportProgress === void 0 ? void 0 : folderImportProgress.isVisible) && /*#__PURE__*/_jsx(FolderImportProgress, {
+          i18n: this.plugin.filerobot.i18n,
+          foldersCount: folderImportProgress.foldersCount || 0,
+          filesCount: folderImportProgress.filesCount || 0,
+          message: this.plugin.filerobot.i18n('remoteUploadFolderImportProgressMessage'),
+          cancel: function cancel() {
+            return _this12.cancelPicking(false);
+          }
+        })]
+      });
+    }
+  }]);
+}();
+export { ProviderView as default };