@difizen/libro-common 0.3.4 → 1.0.0

package/es/app/file-tree/files.js

@@ -0,0 +1,478 @@
+var _BinarySize;
+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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/platform/files/common/files.ts
+
+import { URI } from "../../common/index.js";
+export var FileOperation = /*#__PURE__*/function (FileOperation) {
+  FileOperation[FileOperation["CREATE"] = 0] = "CREATE";
+  FileOperation[FileOperation["DELETE"] = 1] = "DELETE";
+  FileOperation[FileOperation["MOVE"] = 2] = "MOVE";
+  FileOperation[FileOperation["COPY"] = 3] = "COPY";
+  return FileOperation;
+}({});
+export var FileOperationEvent = /*#__PURE__*/function () {
+  function FileOperationEvent(resource, operation, target) {
+    _classCallCheck(this, FileOperationEvent);
+    this.resource = resource;
+    this.operation = operation;
+    this.target = target;
+  }
+  _createClass(FileOperationEvent, [{
+    key: "isOperation",
+    value: function isOperation(operation) {
+      return this.operation === operation;
+    }
+  }]);
+  return FileOperationEvent;
+}();
+
+/**
+ * Possible changes that can occur to a file.
+ */
+export var FileChangeType = /*#__PURE__*/function (FileChangeType) {
+  FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
+  FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
+  FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
+  return FileChangeType;
+}({});
+
+/**
+ * Identifies a single change in a file.
+ */
+
+export var FileChangesEvent = /*#__PURE__*/function () {
+  function FileChangesEvent(changes) {
+    _classCallCheck(this, FileChangesEvent);
+    this.changes = changes;
+  }
+
+  /**
+   * Returns true if this change event contains the provided file with the given change type (if provided). In case of
+   * type DELETED, this method will also return true if a folder got deleted that is the parent of the
+   * provided file path.
+   */
+  _createClass(FileChangesEvent, [{
+    key: "contains",
+    value: function contains(resource, type) {
+      if (!resource) {
+        return false;
+      }
+      var checkForChangeType = typeof type === 'number';
+      return this.changes.some(function (change) {
+        if (checkForChangeType && change.type !== type) {
+          return false;
+        }
+
+        // For deleted also return true when deleted folder is parent of target path
+        if (change.type === FileChangeType.DELETED) {
+          return resource.includes(change.resource);
+        }
+        return resource.toString() === change.resource.toString();
+      });
+    }
+
+    /**
+     * Returns the changes that describe added files.
+     */
+  }, {
+    key: "getAdded",
+    value: function getAdded() {
+      return this.getOfType(FileChangeType.ADDED);
+    }
+
+    /**
+     * Returns if this event contains added files.
+     */
+  }, {
+    key: "gotAdded",
+    value: function gotAdded() {
+      return this.hasType(FileChangeType.ADDED);
+    }
+
+    /**
+     * Returns the changes that describe deleted files.
+     */
+  }, {
+    key: "getDeleted",
+    value: function getDeleted() {
+      return this.getOfType(FileChangeType.DELETED);
+    }
+
+    /**
+     * Returns if this event contains deleted files.
+     */
+  }, {
+    key: "gotDeleted",
+    value: function gotDeleted() {
+      return this.hasType(FileChangeType.DELETED);
+    }
+
+    /**
+     * Returns the changes that describe updated files.
+     */
+  }, {
+    key: "getUpdated",
+    value: function getUpdated() {
+      return this.getOfType(FileChangeType.UPDATED);
+    }
+
+    /**
+     * Returns if this event contains updated files.
+     */
+  }, {
+    key: "gotUpdated",
+    value: function gotUpdated() {
+      return this.hasType(FileChangeType.UPDATED);
+    }
+  }, {
+    key: "getOfType",
+    value: function getOfType(type) {
+      return this.changes.filter(function (change) {
+        return change.type === type;
+      });
+    }
+  }, {
+    key: "hasType",
+    value: function hasType(type) {
+      return this.changes.some(function (change) {
+        return change.type === type;
+      });
+    }
+  }]);
+  return FileChangesEvent;
+}();
+export var BaseStat;
+(function (_BaseStat) {
+  function is(arg) {
+    return !!arg && _typeof(arg) === 'object' &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    'resource' in arg && arg.resource instanceof URI && 'name' in arg && typeof arg.name === 'string';
+  }
+  _BaseStat.is = is;
+})(BaseStat || (BaseStat = {}));
+/**
+ * A file resource with meta information.
+ */
+export var FileStat;
+(function (_FileStat) {
+  function is(arg) {
+    if (BaseStat.is(arg) && 'isFile' in arg) {
+      return 'isFile' in arg && typeof arg.isFile === 'boolean' && 'isDirectory' in arg && typeof arg.isDirectory === 'boolean' && 'isSymbolicLink' in arg && typeof arg.isSymbolicLink === 'boolean';
+    }
+    return false;
+  }
+  _FileStat.is = is;
+  function asFileType(stat) {
+    var res = 0;
+    if (stat.isFile) {
+      res += FileType.File;
+    } else if (stat.isDirectory) {
+      res += FileType.Directory;
+    }
+    if (stat.isSymbolicLink) {
+      res += FileType.SymbolicLink;
+    }
+    return res;
+  }
+  _FileStat.asFileType = asFileType;
+  function toStat(stat) {
+    return {
+      type: asFileType(stat),
+      ctime: stat.ctime,
+      mtime: stat.mtime,
+      size: stat.size
+    };
+  }
+  _FileStat.toStat = toStat;
+  function fromStat(resource, stat) {
+    return {
+      resource: resource,
+      name: resource.path.base || resource.path.toString(),
+      isFile: (stat.type & FileType.File) !== 0,
+      isDirectory: (stat.type & FileType.Directory) !== 0,
+      isSymbolicLink: (stat.type & FileType.SymbolicLink) !== 0,
+      mtime: stat.mtime,
+      ctime: stat.ctime,
+      size: stat.size,
+      etag: etag({
+        mtime: stat.mtime,
+        size: stat.size
+      })
+    };
+  }
+  _FileStat.fromStat = fromStat;
+  function dir(resource, stat) {
+    return fromStat(resource instanceof URI ? resource : new URI(resource), _objectSpread({
+      type: FileType.Directory
+    }, stat));
+  }
+  _FileStat.dir = dir;
+  function file(resource, stat) {
+    return fromStat(resource instanceof URI ? resource : new URI(resource), _objectSpread({
+      type: FileType.File
+    }, stat));
+  }
+  _FileStat.file = file;
+})(FileStat || (FileStat = {}));
+export var FileOperationError = /*#__PURE__*/function (_Error) {
+  _inherits(FileOperationError, _Error);
+  var _super = _createSuper(FileOperationError);
+  function FileOperationError(message, fileOperationResult, options) {
+    var _this;
+    _classCallCheck(this, FileOperationError);
+    _this = _super.call(this, message);
+    _this.fileOperationResult = fileOperationResult;
+    _this.options = options;
+    Object.setPrototypeOf(_assertThisInitialized(_this), FileOperationError.prototype);
+    return _this;
+  }
+  return _createClass(FileOperationError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var FileOperationResult = /*#__PURE__*/function (FileOperationResult) {
+  FileOperationResult[FileOperationResult["FILE_IS_DIRECTORY"] = 0] = "FILE_IS_DIRECTORY";
+  FileOperationResult[FileOperationResult["FILE_NOT_FOUND"] = 1] = "FILE_NOT_FOUND";
+  FileOperationResult[FileOperationResult["FILE_NOT_MODIFIED_SINCE"] = 2] = "FILE_NOT_MODIFIED_SINCE";
+  FileOperationResult[FileOperationResult["FILE_MODIFIED_SINCE"] = 3] = "FILE_MODIFIED_SINCE";
+  FileOperationResult[FileOperationResult["FILE_MOVE_CONFLICT"] = 4] = "FILE_MOVE_CONFLICT";
+  FileOperationResult[FileOperationResult["FILE_READ_ONLY"] = 5] = "FILE_READ_ONLY";
+  FileOperationResult[FileOperationResult["FILE_PERMISSION_DENIED"] = 6] = "FILE_PERMISSION_DENIED";
+  FileOperationResult[FileOperationResult["FILE_TOO_LARGE"] = 7] = "FILE_TOO_LARGE";
+  FileOperationResult[FileOperationResult["FILE_INVALID_PATH"] = 8] = "FILE_INVALID_PATH";
+  FileOperationResult[FileOperationResult["FILE_EXCEEDS_MEMORY_LIMIT"] = 9] = "FILE_EXCEEDS_MEMORY_LIMIT";
+  FileOperationResult[FileOperationResult["FILE_NOT_DIRECTORY"] = 10] = "FILE_NOT_DIRECTORY";
+  FileOperationResult[FileOperationResult["FILE_OTHER_ERROR"] = 11] = "FILE_OTHER_ERROR";
+  return FileOperationResult;
+}({});
+export var FileType = /*#__PURE__*/function (FileType) {
+  FileType[FileType["Unknown"] = 0] = "Unknown";
+  FileType[FileType["File"] = 1] = "File";
+  FileType[FileType["Directory"] = 2] = "Directory";
+  FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+  return FileType;
+}({});
+export var FileSystemProviderCapabilities = /*#__PURE__*/function (FileSystemProviderCapabilities) {
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["Access"] = 16777216] = "Access";
+  FileSystemProviderCapabilities[FileSystemProviderCapabilities["Update"] = 33554432] = "Update";
+  return FileSystemProviderCapabilities;
+}({});
+export var FileSystemProviderErrorCode = /*#__PURE__*/function (FileSystemProviderErrorCode) {
+  FileSystemProviderErrorCode["FileExists"] = "EntryExists";
+  FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
+  FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
+  FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
+  FileSystemProviderErrorCode["FileExceedsMemoryLimit"] = "EntryExceedsMemoryLimit";
+  FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
+  FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
+  FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
+  FileSystemProviderErrorCode["Unknown"] = "Unknown";
+  return FileSystemProviderErrorCode;
+}({});
+export var FileSystemProviderError = /*#__PURE__*/function (_Error2) {
+  _inherits(FileSystemProviderError, _Error2);
+  var _super2 = _createSuper(FileSystemProviderError);
+  function FileSystemProviderError(message, code) {
+    var _this2;
+    _classCallCheck(this, FileSystemProviderError);
+    _this2 = _super2.call(this, message);
+    _this2.code = code;
+    Object.setPrototypeOf(_assertThisInitialized(_this2), FileSystemProviderError.prototype);
+    return _this2;
+  }
+  return _createClass(FileSystemProviderError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export function createFileSystemProviderError(error, code) {
+  var providerError = new FileSystemProviderError(error.toString(), code);
+  markAsFileSystemProviderError(providerError, code);
+  return providerError;
+}
+export function ensureFileSystemProviderError(error) {
+  if (!error) {
+    return createFileSystemProviderError('Unknown Error', FileSystemProviderErrorCode.Unknown); // https://github.com/Microsoft/vscode/issues/72798
+  }
+  return error;
+}
+export var FileSystemProvider = Symbol('FileSystemProvider');
+/**
+ * A {@link FileSystemProvider} provides the capabilities to read, write, discover, and to manage files and folders
+ * of the underlying (potentially virtual) file system. {@link FileSystemProvider}s can be used to serve files from both the
+ * local disk as well as remote locations like ftp-servers, REST-services etc. A {@link FileSystemProvider} is registered for a certain
+ * scheme and can handle all resources whose uri does conform to that scheme.
+ */
+
+/**
+ * Subtype of {@link FileSystemProvider} that ensures that the optional functions needed for providers, that should be
+ * able access files, are implemented.
+ */
+
+export function hasAccessCapability(provider) {
+  return !!(provider.capabilities & FileSystemProviderCapabilities.Access);
+}
+
+/**
+ * Subtype of {@link FileSystemProvider} that ensures that the optional functions, needed for providers
+ * that should be able to read & write files, are implemented.
+ */
+
+export function hasReadWriteCapability(provider) {
+  return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite);
+}
+
+/**
+ * Subtype of {@link FileSystemProvider} that ensures that the optional functions, needed for providers that should be able to copy
+ * file folders, are implemented.
+ */
+
+export function hasFileFolderCopyCapability(provider) {
+  return !!(provider.capabilities & FileSystemProviderCapabilities.FileFolderCopy);
+}
+
+/**
+ * Subtype of {@link FileSystemProvider} that ensures that the optional functions, needed for providers that should be able to open,read, write
+ * or close files, are implemented.
+ */
+
+export function hasOpenReadWriteCloseCapability(provider) {
+  return !!(provider.capabilities & FileSystemProviderCapabilities.FileOpenReadWriteClose);
+}
+export function markAsFileSystemProviderError(error, code) {
+  error.name = code ? "".concat(code, " (FileSystemError)") : 'FileSystemError';
+  return error;
+}
+export function toFileSystemProviderErrorCode(error) {
+  // Guard against abuse
+  if (!error) {
+    return FileSystemProviderErrorCode.Unknown;
+  }
+
+  // FileSystemProviderError comes with the code
+  if (error instanceof FileSystemProviderError) {
+    return error.code;
+  }
+
+  // Any other error, check for name match by assuming that the error
+  // went through the markAsFileSystemProviderError() method
+  var match = /^(.+) \(FileSystemError\)$/.exec(error.name);
+  if (!match) {
+    return FileSystemProviderErrorCode.Unknown;
+  }
+
+  // eslint-disable-next-line default-case
+  switch (match[1]) {
+    case FileSystemProviderErrorCode.FileExists:
+      return FileSystemProviderErrorCode.FileExists;
+    case FileSystemProviderErrorCode.FileIsADirectory:
+      return FileSystemProviderErrorCode.FileIsADirectory;
+    case FileSystemProviderErrorCode.FileNotADirectory:
+      return FileSystemProviderErrorCode.FileNotADirectory;
+    case FileSystemProviderErrorCode.FileNotFound:
+      return FileSystemProviderErrorCode.FileNotFound;
+    case FileSystemProviderErrorCode.FileExceedsMemoryLimit:
+      return FileSystemProviderErrorCode.FileExceedsMemoryLimit;
+    case FileSystemProviderErrorCode.FileTooLarge:
+      return FileSystemProviderErrorCode.FileTooLarge;
+    case FileSystemProviderErrorCode.NoPermissions:
+      return FileSystemProviderErrorCode.NoPermissions;
+    case FileSystemProviderErrorCode.Unavailable:
+      return FileSystemProviderErrorCode.Unavailable;
+  }
+  return FileSystemProviderErrorCode.Unknown;
+}
+export function toFileOperationResult(error) {
+  // FileSystemProviderError comes with the result already
+  if (error instanceof FileOperationError) {
+    return error.fileOperationResult;
+  }
+
+  // Otherwise try to find from code
+  switch (toFileSystemProviderErrorCode(error)) {
+    case FileSystemProviderErrorCode.FileNotFound:
+      return FileOperationResult.FILE_NOT_FOUND;
+    case FileSystemProviderErrorCode.FileIsADirectory:
+      return FileOperationResult.FILE_IS_DIRECTORY;
+    case FileSystemProviderErrorCode.FileNotADirectory:
+      return FileOperationResult.FILE_NOT_DIRECTORY;
+    case FileSystemProviderErrorCode.NoPermissions:
+      return FileOperationResult.FILE_PERMISSION_DENIED;
+    case FileSystemProviderErrorCode.FileExists:
+      return FileOperationResult.FILE_MOVE_CONFLICT;
+    case FileSystemProviderErrorCode.FileExceedsMemoryLimit:
+      return FileOperationResult.FILE_EXCEEDS_MEMORY_LIMIT;
+    case FileSystemProviderErrorCode.FileTooLarge:
+      return FileOperationResult.FILE_TOO_LARGE;
+    default:
+      return FileOperationResult.FILE_OTHER_ERROR;
+  }
+}
+
+/**
+ * A hint to disable etag checking for reading/writing.
+ */
+export var ETAG_DISABLED = '';
+export function etag(stat) {
+  if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {
+    return undefined;
+  }
+  return stat.mtime.toString(29) + stat.size.toString(31);
+}
+/**
+ * Helper to format a raw byte size into a human readable label.
+ */
+export var BinarySize = /*#__PURE__*/function () {
+  function BinarySize() {
+    _classCallCheck(this, BinarySize);
+  }
+  _createClass(BinarySize, null, [{
+    key: "formatSize",
+    value: function formatSize(size) {
+      if (size < BinarySize.KB) {
+        return "".concat(size, "B");
+      }
+      if (size < BinarySize.MB) {
+        return "".concat((size / BinarySize.KB).toFixed(2), "KB");
+      }
+      if (size < BinarySize.GB) {
+        return "".concat((size / BinarySize.MB).toFixed(2), "MB");
+      }
+      if (size < BinarySize.TB) {
+        return "".concat((size / BinarySize.GB).toFixed(2), "GB");
+      }
+      return "".concat((size / BinarySize.TB).toFixed(2), "TB");
+    }
+  }]);
+  return BinarySize;
+}();
+_BinarySize = BinarySize;
+BinarySize.KB = 1024;
+BinarySize.MB = _BinarySize.KB * _BinarySize.KB;
+BinarySize.GB = _BinarySize.MB * _BinarySize.KB;
+BinarySize.TB = _BinarySize.GB * _BinarySize.KB;

package/es/app/file-tree/filesystem-utils.d.ts

@@ -0,0 +1,14 @@
+import { URI } from '../../common/index.js';
+import type { FileStat } from './files.js';
+export declare namespace FileSystemUtils {
+    /**
+     * Generate unique URI for a given parent which does not collide
+     *
+     * @param parentUri the `URI` of the parent
+     * @param parent the `FileStat` of the parent
+     * @param name the resource name
+     * @param ext the resource extension
+     */
+    function generateUniqueResourceURI(parentUri: URI, parent: FileStat, name: string, ext?: string): URI;
+}
+//# sourceMappingURL=filesystem-utils.d.ts.map

package/es/app/file-tree/filesystem-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-utils.d.ts","sourceRoot":"","sources":["../../../src/app/file-tree/filesystem-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,yBAAiB,eAAe,CAAC;IAC/B;;;;;;;OAOG;IACH,SAAgB,yBAAyB,CACvC,SAAS,EAAE,GAAG,EACd,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,GAAG,SAAK,GACP,GAAG,CAYL;CACF"}

package/es/app/file-tree/filesystem-utils.js

@@ -0,0 +1,20 @@
+import { URI } from "../../common/index.js";
+export var FileSystemUtils;
+(function (_FileSystemUtils) {
+  function generateUniqueResourceURI(parentUri, parent, name) {
+    var ext = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+    var children = !parent.children ? [] : parent.children.map(function (child) {
+      return child.resource;
+    });
+    var index = 1;
+    var base = name + ext;
+    while (children.some(function (child) {
+      return child.path.base === base;
+    })) {
+      index += 1;
+      base = "".concat(name, "_").concat(index).concat(ext);
+    }
+    return URI.resolve(parentUri, base);
+  }
+  _FileSystemUtils.generateUniqueResourceURI = generateUniqueResourceURI;
+})(FileSystemUtils || (FileSystemUtils = {}));

package/es/app/file-tree/index.d.ts

@@ -0,0 +1,7 @@
+export * from './files';
+export * from './file-tree';
+export * from './file-service';
+export * from './file-tree-model';
+export * from './file-tree-view';
+export * from './module';
+//# sourceMappingURL=index.d.ts.map

package/es/app/file-tree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/app/file-tree/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC"}

package/es/app/file-tree/index.js

@@ -0,0 +1,6 @@
+export * from "./files";
+export * from "./file-tree";
+export * from "./file-service";
+export * from "./file-tree-model";
+export * from "./file-tree-view";
+export * from "./module";

package/es/app/file-tree/module.d.ts

@@ -0,0 +1,3 @@
+import { ManaModule } from '../../core/index.js';
+export declare const FileTreeModule: ManaModule;
+//# sourceMappingURL=module.d.ts.map

package/es/app/file-tree/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/app/file-tree/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAajD,eAAO,MAAM,cAAc,YAOJ,CAAC"}

package/es/app/file-tree/module.js

@@ -0,0 +1,18 @@
+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); }
+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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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); }
+import { ManaModule } from "../../core/index.js";
+import { DefaultTreeNodeComponents, TreeModule, TreeNodeComponents } from "../tree/index.js";
+import { FileService } from "./file-service.js";
+import { TreeNodeIcon } from "./file-tree-icon.js";
+import { FileTreeLabelProvider } from "./file-tree-label-provider.js";
+import { FileTreeView } from "./file-tree-view.js";
+export var FileTreeModule = ManaModule.create().register(FileTreeView).register(FileService, FileTreeLabelProvider).register({
+  token: TreeNodeComponents,
+  useValue: _objectSpread(_objectSpread({}, DefaultTreeNodeComponents), {}, {
+    TreeNodeIcon: TreeNodeIcon
+  })
+}).dependOn(TreeModule);

package/es/app/file-tree/selection-command-handler.d.ts

@@ -0,0 +1,25 @@
+import type { CommandHandler } from '../../core/index.js';
+import type { SelectionService } from '../../core/index.js';
+export declare class SelectionCommandHandler<S> implements CommandHandler {
+    protected readonly selectionService: SelectionService;
+    protected readonly toSelection: (arg: any) => S | undefined;
+    protected readonly options: SelectionCommandHandler.Options<S>;
+    constructor(selectionService: SelectionService, toSelection: (arg: any) => S | undefined, options: SelectionCommandHandler.Options<S>);
+    execute(...args: any[]): Record<any, any> | undefined;
+    isVisible(...args: any[]): boolean;
+    isEnabled(...args: any[]): boolean;
+    protected isMulti(): boolean;
+    protected getSelection(...args: any[]): S | S[] | undefined;
+    protected getSingleSelection(arg: any | undefined): S | undefined;
+    protected getMultiSelection(arg: any | undefined): S[] | undefined;
+}
+export declare namespace SelectionCommandHandler {
+    type Options<S> = SelectionOptions<false, S> | SelectionOptions<true, S[]>;
+    type SelectionOptions<Multi extends boolean, T> = {
+        multi: Multi;
+        execute(selection: T, ...args: any[]): any;
+        isEnabled?(selection: T, ...args: any[]): boolean;
+        isVisible?(selection: T, ...args: any[]): boolean;
+    };
+}
+//# sourceMappingURL=selection-command-handler.d.ts.map

package/es/app/file-tree/selection-command-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-command-handler.d.ts","sourceRoot":"","sources":["../../../src/app/file-tree/selection-command-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,qBAAa,uBAAuB,CAAC,CAAC,CAAE,YAAW,cAAc;IAC/D,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAEtD,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,SAAS,CAAC;IAC5D,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAG7D,gBAAgB,EAAE,gBAAgB,EAClC,WAAW,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,SAAS,EACxC,OAAO,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC;IAO7C,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS;IAKrD,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO;IASlC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO;IASlC,SAAS,CAAC,OAAO,IAAI,OAAO;IAI5B,SAAS,CAAC,YAAY,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS;IAY3D,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS;IAgBjE,SAAS,CAAC,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,GAAG,CAAC,EAAE,GAAG,SAAS;CAgBnE;AACD,yBAAiB,uBAAuB,CAAC;IACvC,KAAY,OAAO,CAAC,CAAC,IAAI,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAClF,KAAY,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,CAAC,IAAI;QACvD,KAAK,EAAE,KAAK,CAAC;QACb,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;QAC3C,SAAS,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;QAClD,SAAS,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;KACnD,CAAC;CACH"}