@capacitor/filesystem 7.0.2-nightly-20250526T150552.0 → 7.1.0-dev.1

package/ios/Sources/FilesystemPlugin/FilesystemOperationExecutor.swift

@@ -0,0 +1,116 @@
+import Capacitor
+import Foundation
+import IONFilesystemLib
+import Combine
+
+class FilesystemOperationExecutor {
+    let service: FileService
+    private var cancellables = Set<AnyCancellable>()
+
+    init(service: FileService) {
+        self.service = service
+    }
+
+    func execute(_ operation: FilesystemOperation, _ call: CAPPluginCall) {
+        do {
+            var resultData: PluginCallResultData?
+
+            switch operation {
+            case .readFile(let url, let encoding):
+                let data = try service.readEntireFile(atURL: url, withEncoding: encoding).textValue
+                resultData = [Constants.ResultDataKey.data: data]
+            case .readFileInChunks(let url, let encoding, let chunkSize):
+                try processFileInChunks(at: url, withEncoding: encoding, chunkSize: chunkSize, for: operation, call)
+                return
+            case .write(let url, let encodingMapper, let recursive):
+                try service.saveFile(atURL: url, withEncodingAndData: encodingMapper, includeIntermediateDirectories: recursive)
+                resultData = [Constants.ResultDataKey.uri: url.absoluteString]
+            case .append(let url, let encodingMapper, let recursive):
+                try service.appendData(encodingMapper, atURL: url, includeIntermediateDirectories: recursive)
+            case .delete(let url):
+                try service.deleteFile(atURL: url)
+            case .mkdir(let url, let recursive):
+                try service.createDirectory(atURL: url, includeIntermediateDirectories: recursive)
+            case .rmdir(let url, let recursive):
+                try service.removeDirectory(atURL: url, includeIntermediateDirectories: recursive)
+            case .readdir(let url):
+                let directoryAttributes = try service.listDirectory(atURL: url)
+                    .map { try fetchItemAttributesJSObject(using: service, atURL: $0) }
+                resultData = [Constants.ResultDataKey.files: directoryAttributes]
+            case .stat(let url):
+                resultData = try fetchItemAttributesJSObject(using: service, atURL: url)
+            case .getUri(let url):
+                resultData = [Constants.ResultDataKey.uri: url.absoluteString]
+            case .rename(let source, let destination):
+                try service.renameItem(fromURL: source, toURL: destination)
+            case .copy(let source, let destination):
+                try service.copyItem(fromURL: source, toURL: destination)
+                resultData = [Constants.ResultDataKey.uri: destination.absoluteString]
+            }
+
+            call.handleSuccess(resultData)
+        } catch {
+            call.handleError(mapError(error, for: operation))
+        }
+    }
+}
+
+private extension FilesystemOperationExecutor {
+    func processFileInChunks(at url: URL, withEncoding encoding: IONFILEEncoding, chunkSize: Int, for operation: FilesystemOperation, _ call: CAPPluginCall) throws {
+        let chunkSizeToUse = chunkSizeToUse(basedOn: chunkSize, and: encoding)
+        try service.readFileInChunks(atURL: url, withEncoding: encoding, andChunkSize: chunkSizeToUse)
+            .sink(receiveCompletion: { completion in
+                switch completion {
+                case .finished:
+                    call.handleSuccess([Constants.ResultDataKey.data: Constants.ConfigurationValue.endOfFile])
+                case .failure(let error):
+                    call.handleError(self.mapError(error, for: operation))
+                }
+            }, receiveValue: {
+                call.handleSuccess([Constants.ResultDataKey.data: $0.textValue], true)
+            })
+            .store(in: &cancellables)
+    }
+
+    private func chunkSizeToUse(basedOn chunkSize: Int, and encoding: IONFILEEncoding) -> Int {
+        // When dealing with byte buffers, we need chunk size that are multiples of 3
+        // We're treating byte buffers as base64 data, and size multiple of 3 makes it so that chunks can be concatenated
+        encoding == .byteBuffer ? chunkSize - chunkSize % 3 + 3 : chunkSize
+    }
+
+    func mapError(_ error: Error, for operation: FilesystemOperation) -> FilesystemError {
+        var path = ""
+        var method: IONFileMethod = IONFileMethod.getUri
+        switch operation {
+        case .readFile(let url, _): path = url.absoluteString; method = .readFile
+        case .readFileInChunks(let url, _, _): path = url.absoluteString; method = .readFileInChunks
+        case .write(let url, _, _): path = url.absoluteString; method = .writeFile
+        case .append(let url, _, _): path = url.absoluteString; method = .appendFile
+        case .delete(let url): path = url.absoluteString; method = .deleteFile
+        case .mkdir(let url, _): path = url.absoluteString; method = .mkdir
+        case .rmdir(let url, _): path = url.absoluteString; method = .rmdir
+        case .readdir(let url): path = url.absoluteString; method = .readdir
+        case .stat(let url): path = url.absoluteString; method = .stat
+        case .getUri(let url): return FilesystemError.invalidPath(url.absoluteString)
+        case .rename(let sourceUrl, _): path = sourceUrl.absoluteString; method = .rename
+        case .copy(let sourceUrl, _): path = sourceUrl.absoluteString; method = .copy
+        }
+
+        return mapError(error, withPath: path, andMethod: method)
+    }
+
+    private func mapError(_ error: Error, withPath path: String, andMethod method: IONFileMethod) -> FilesystemError {
+        return switch error {
+        case IONFILEDirectoryManagerError.notEmpty: .cannotDeleteChildren
+        case IONFILEDirectoryManagerError.alreadyExists: .directoryAlreadyExists(path)
+        case IONFILEFileManagerError.missingParentFolder: .parentDirectoryMissing
+        case IONFILEFileManagerError.fileNotFound: .fileNotFound(method: method, path)
+        default: .operationFailed(method: method, error)
+        }
+    }
+
+    func fetchItemAttributesJSObject(using service: FileService, atURL url: URL) throws -> IONFILEItemAttributeModel.JSResult {
+        let attributes = try service.getItemAttributes(atURL: url)
+        return attributes.toJSResult(with: url)
+    }
+}

package/ios/Sources/FilesystemPlugin/FilesystemPlugin.swift

@@ -1,5 +1,8 @@
 import Foundation
 import Capacitor
+import IONFilesystemLib
+
+typealias FileService = any IONFILEDirectoryManager & IONFILEFileManager
 
 /**
  * Please read the Capacitor iOS Plugin Development Guide
@@ -11,6 +14,7 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
     public let jsName = "Filesystem"
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "readFile", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "readFileInChunks", returnType: CAPPluginReturnCallback),
         CAPPluginMethod(name: "writeFile", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "appendFile", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "deleteFile", returnType: CAPPluginReturnPromise),
@@ -25,31 +29,48 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "downloadFile", returnType: CAPPluginReturnPromise)
     ]
-    private let implementation = Filesystem()
 
+    private let legacyImplementation = LegacyFilesystemImplementation()
+
+    private var fileService: FileService?
+
+    override public func load() {
+        self.fileService = IONFILEManager()
+    }
+
+    func getService() -> Result<FileService, FilesystemError> {
+        if fileService == nil { load() }
+        return fileService.map(Result.success) ?? .failure(.bridgeNotInitialised)
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        call.handlePermissionSuccess()
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        call.handlePermissionSuccess()
+    }
+}
+
+// MARK: - Public API Methods
+private extension FilesystemPlugin {
     /**
      * Read a file from the filesystem.
      */
     @objc func readFile(_ call: CAPPluginCall) {
-        let encoding = call.getString("encoding")
-
-        guard let file = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
+        let encoding = call.getEncoding(Constants.MethodParameter.encoding)
+        performSinglePathOperation(call) {
+            .readFile(url: $0, encoding: encoding)
         }
-        let directory = call.getString("directory")
+    }
 
-        guard let fileUrl = implementation.getFileUrl(at: file, in: directory) else {
-            handleError(call, "Invalid path")
-            return
+    @objc func readFileInChunks(_ call: CAPPluginCall) {
+        let encoding = call.getEncoding(Constants.MethodParameter.encoding)
+        guard let chunkSize = call.getInt(Constants.MethodParameter.chunkSize) else {
+            return call.handleError(.invalidInput(method: call.getIONFileMethod()))
         }
-        do {
-            let data = try implementation.readFile(at: fileUrl, with: encoding)
-            call.resolve([
-                "data": data
-            ])
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .readFileInChunks(url: $0, encoding: encoding, chunkSize: chunkSize)
         }
     }
 
@@ -57,33 +78,13 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Write a file to the filesystem.
      */
     @objc func writeFile(_ call: CAPPluginCall) {
-        let encoding = call.getString("encoding")
-        let recursive = call.getBool("recursive") ?? false
-
-        guard let file = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
+        guard let encodingMapper = call.getEncodingMapper() else {
+            return call.handleError(.invalidInput(method: call.getIONFileMethod()))
         }
+        let recursive = call.getBool(Constants.MethodParameter.recursive, false)
 
-        guard let data = call.getString("data") else {
-            handleError(call, "Data must be provided and must be a string.")
-            return
-        }
-
-        let directory = call.getString("directory")
-
-        guard let fileUrl = implementation.getFileUrl(at: file, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        do {
-            let path = try implementation.writeFile(at: fileUrl, with: data, recursive: recursive, with: encoding)
-            call.resolve([
-                "uri": path
-            ])
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .write(url: $0, encodingMapper: encodingMapper, recursive: recursive)
         }
     }
 
@@ -91,29 +92,13 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Append to a file.
      */
     @objc func appendFile(_ call: CAPPluginCall) {
-        let encoding = call.getString("encoding")
-
-        guard let file = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        guard let data = call.getString("data") else {
-            handleError(call, "Data must be provided and must be a string.")
-            return
+        guard let encodingMapper = call.getEncodingMapper() else {
+            return call.handleError(.invalidInput(method: call.getIONFileMethod()))
         }
+        let recursive = call.getBool(Constants.MethodParameter.recursive, false)
 
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: file, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        do {
-            try implementation.appendFile(at: fileUrl, with: data, recursive: false, with: encoding)
-            call.resolve()
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .append(url: $0, encodingMapper: encodingMapper, recursive: recursive)
         }
     }
 
@@ -121,22 +106,8 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Delete a file.
      */
     @objc func deleteFile(_ call: CAPPluginCall) {
-        guard let file = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: file, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        do {
-            try implementation.deleteFile(at: fileUrl)
-            call.resolve()
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .delete(url: $0)
         }
     }
 
@@ -144,23 +115,10 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Make a new directory, optionally creating parent folders first.
      */
     @objc func mkdir(_ call: CAPPluginCall) {
-        guard let path = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        let recursive = call.getBool("recursive") ?? false
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: path, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
+        let recursive = call.getBool(Constants.MethodParameter.recursive, false)
 
-        do {
-            try implementation.mkdir(at: fileUrl, recursive: recursive)
-            call.resolve()
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .mkdir(url: $0, recursive: recursive)
         }
     }
 
@@ -168,24 +126,10 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Remove a directory.
      */
     @objc func rmdir(_ call: CAPPluginCall) {
-        guard let path = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
+        let recursive = call.getBool(Constants.MethodParameter.recursive, false)
 
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: path, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        let recursive = call.getBool("recursive") ?? false
-
-        do {
-            try implementation.rmdir(at: fileUrl, recursive: recursive)
-            call.resolve()
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .rmdir(url: $0, recursive: recursive)
         }
     }
 
@@ -193,130 +137,29 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Read the contents of a directory.
      */
     @objc func readdir(_ call: CAPPluginCall) {
-        guard let path = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: path, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        do {
-            let directoryContents = try implementation.readdir(at: fileUrl)
-            let directoryContent = try directoryContents.map {(url: URL) -> [String: Any] in
-                let attr = try implementation.stat(at: url)
-                var ctime: UInt64 = 0
-                var mtime: UInt64 = 0
-
-                if let ctimeSeconds = (attr[.creationDate] as? Date)?.timeIntervalSince1970 {
-                    ctime = UInt64((ctimeSeconds * 1000).rounded())
-                }
-
-                if let mtimeSeconds = (attr[.modificationDate] as? Date)?.timeIntervalSince1970 {
-                    mtime = UInt64((mtimeSeconds * 1000).rounded())
-                }
-                return [
-                    "name": url.lastPathComponent,
-                    "type": implementation.getType(from: attr),
-                    "size": attr[.size] as? UInt64 ?? 0,
-                    "ctime": ctime,
-                    "mtime": mtime,
-                    "uri": url.absoluteString
-                ]
-            }
-            call.resolve([
-                "files": directoryContent
-            ])
-        } catch {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .readdir(url: $0)
         }
     }
 
     @objc func stat(_ call: CAPPluginCall) {
-        guard let path = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: path, in: directory) else {
-            handleError(call, "Invalid path")
-            return
-        }
-
-        do {
-            let attr = try implementation.stat(at: fileUrl)
-
-            var ctime: UInt64 = 0
-            var mtime: UInt64 = 0
-
-            if let ctimeSeconds = (attr[.creationDate] as? Date)?.timeIntervalSince1970 {
-                ctime = UInt64((ctimeSeconds * 1000).rounded())
-            }
-
-            if let mtimeSeconds = (attr[.modificationDate] as? Date)?.timeIntervalSince1970 {
-                mtime = UInt64((mtimeSeconds * 1000).rounded())
-            }
-
-            call.resolve([
-                "type": implementation.getType(from: attr),
-                "size": attr[.size] as? UInt64 ?? 0,
-                "ctime": ctime,
-                "mtime": mtime,
-                "uri": fileUrl.absoluteString
-            ])
-        } catch {
-            handleError(call, error.localizedDescription, error)
+        performSinglePathOperation(call) {
+            .stat(url: $0)
         }
     }
 
     @objc func getUri(_ call: CAPPluginCall) {
-        guard let path = call.getString("path") else {
-            handleError(call, "path must be provided and must be a string.")
-            return
-        }
-
-        let directory = call.getString("directory")
-        guard let fileUrl = implementation.getFileUrl(at: path, in: directory) else {
-            handleError(call, "Invalid path")
-            return
+        performSinglePathOperation(call) {
+            .getUri(url: $0)
         }
-
-        call.resolve([
-            "uri": fileUrl.absoluteString
-        ])
-
     }
 
     /**
      * Rename a file or directory.
      */
     @objc func rename(_ call: CAPPluginCall) {
-        guard let from = call.getString("from"), let to = call.getString("to") else {
-            handleError(call, "Both to and from must be provided")
-            return
-        }
-
-        let directory = call.getString("directory")
-        let toDirectory = call.getString("toDirectory") ?? directory
-
-        guard let fromUrl = implementation.getFileUrl(at: from, in: directory) else {
-            handleError(call, "Invalid from path")
-            return
-        }
-
-        guard let toUrl = implementation.getFileUrl(at: to, in: toDirectory) else {
-            handleError(call, "Invalid to path")
-            return
-        }
-        do {
-            try implementation.rename(at: fromUrl, to: toUrl)
-            call.resolve()
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
+        performDualPathOperation(call) {
+            .rename(source: $0, destination: $1)
         }
     }
 
@@ -324,48 +167,18 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
      * Copy a file or directory.
      */
     @objc func copy(_ call: CAPPluginCall) {
-        guard let from = call.getString("from"), let to = call.getString("to") else {
-            handleError(call, "Both to and from must be provided")
-            return
+        performDualPathOperation(call) {
+            .copy(source: $0, destination: $1)
         }
-
-        let directory = call.getString("directory")
-        let toDirectory = call.getString("toDirectory") ?? directory
-
-        guard let fromUrl = implementation.getFileUrl(at: from, in: directory) else {
-            handleError(call, "Invalid from path")
-            return
-        }
-
-        guard let toUrl = implementation.getFileUrl(at: to, in: toDirectory) else {
-            handleError(call, "Invalid to path")
-            return
-        }
-        do {
-            try implementation.copy(at: fromUrl, to: toUrl)
-            call.resolve([
-                "uri": toUrl.absoluteString
-            ])
-        } catch let error as NSError {
-            handleError(call, error.localizedDescription, error)
-        }
-    }
-
-    @objc override public func checkPermissions(_ call: CAPPluginCall) {
-        call.resolve([
-            "publicStorage": "granted"
-        ])
-    }
-
-    @objc override public func requestPermissions(_ call: CAPPluginCall) {
-        call.resolve([
-            "publicStorage": "granted"
-        ])
     }
 
+    /**
+     * [DEPRECATED] Download a file
+     */
+    @available(*, deprecated, message: "Use @capacitor/file-transfer plugin instead.")
     @objc func downloadFile(_ call: CAPPluginCall) {
         guard let url = call.getString("url") else { return call.reject("Must provide a URL") }
-        let progressEmitter: Filesystem.ProgressEmitter = { bytes, contentLength in
+        let progressEmitter: LegacyFilesystemImplementation.ProgressEmitter = { bytes, contentLength in
             self.notifyListeners("progress", data: [
                 "url": url,
                 "bytes": bytes,
@@ -374,17 +187,43 @@ public class FilesystemPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         do {
-            try implementation.downloadFile(call: call, emitter: progressEmitter, config: bridge?.config)
+            try legacyImplementation.downloadFile(call: call, emitter: progressEmitter, config: bridge?.config)
         } catch let error {
             call.reject(error.localizedDescription)
         }
     }
+}
 
-    /**
-     * Helper for handling errors
-     */
-    private func handleError(_ call: CAPPluginCall, _ message: String, _ error: Error? = nil) {
-        call.reject(message, nil, error)
+// MARK: - Operation Execution
+private extension FilesystemPlugin {
+    func performSinglePathOperation(_ call: CAPPluginCall, operationBuilder: (URL) -> FilesystemOperation) {
+        executeOperation(call) { service in
+            FilesystemLocationResolver(service: service)
+                .resolveSinglePath(from: call)
+                .map { operationBuilder($0) }
+        }
     }
 
+    func performDualPathOperation(_ call: CAPPluginCall, operationBuilder: (URL, URL) -> FilesystemOperation) {
+        executeOperation(call) { service in
+            FilesystemLocationResolver(service: service)
+                .resolveDualPaths(from: call)
+                .map { operationBuilder($0.source, $0.destination) }
+        }
+    }
+
+    func executeOperation(_ call: CAPPluginCall, operationProvider: (FileService) -> Result<FilesystemOperation, FilesystemError>) {
+        switch getService() {
+        case .success(let service):
+            switch operationProvider(service) {
+            case .success(let operation):
+                let executor = FilesystemOperationExecutor(service: service)
+                executor.execute(operation, call)
+            case .failure(let error):
+                call.handleError(error)
+            }
+        case .failure(let error):
+            call.handleError(error)
+        }
+    }
 }

package/ios/Sources/FilesystemPlugin/IONFileStructures+Converters.swift

@@ -0,0 +1,60 @@
+import Foundation
+import IONFilesystemLib
+
+extension IONFILEStringEncoding {
+    static func create(from text: String) -> Self {
+        switch text {
+        case Constants.StringEncodingValue.ascii: .ascii
+        case Constants.StringEncodingValue.utf16: .utf16
+        case Constants.StringEncodingValue.utf8: .utf8
+        default: .utf8
+        }
+    }
+}
+
+extension IONFILEDirectoryType {
+    static func create(from text: String) -> Self? {
+        switch text {
+        case Constants.DirectoryTypeValue.cache: .cache
+        case Constants.DirectoryTypeValue.data, Constants.DirectoryTypeValue.documents, Constants.DirectoryTypeValue.external, Constants.DirectoryTypeValue.externalCache, Constants.DirectoryTypeValue.externalStorage: .document
+        case Constants.DirectoryTypeValue.library: .library
+        case Constants.DirectoryTypeValue.libraryNoCloud: .notSyncedLibrary
+        case Constants.DirectoryTypeValue.temporary: .temporary
+        default: nil
+        }
+    }
+}
+
+extension IONFILEEncodingValueMapper {
+    var textValue: String {
+        switch self {
+        case .byteBuffer(let data): data.base64EncodedString()
+        case .string(_, let text): text
+        @unknown default: ""
+        }
+    }
+}
+
+extension IONFILEItemAttributeModel {
+    typealias JSResult = [String: Any]
+    func toJSResult(with url: URL) -> JSResult {
+        [
+            Constants.ItemAttributeJSONKey.name: url.lastPathComponent,
+            Constants.ItemAttributeJSONKey.type: type.description,
+            Constants.ItemAttributeJSONKey.size: size,
+            Constants.ItemAttributeJSONKey.ctime: UInt64(creationDateTimestamp.rounded()),
+            Constants.ItemAttributeJSONKey.mtime: UInt64(modificationDateTimestamp.rounded()),
+            Constants.ItemAttributeJSONKey.uri: url.absoluteString
+        ]
+    }
+}
+
+extension IONFILEItemType {
+    var description: String {
+        switch self {
+        case .directory: Constants.FileItemTypeValue.directory
+        case .file: Constants.FileItemTypeValue.file
+        @unknown default: Constants.FileItemTypeValue.fallback
+        }
+    }
+}