@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/file-system/file-system-access.ios.js

@@ -2,8 +2,8 @@ import { encoding as textEncoding } from '../text';
 import { iOSNativeHelper } from '../utils';
 // TODO: Implement all the APIs receiving callback using async blocks
 // TODO: Check whether we need try/catch blocks for the iOS implementation
-export class FileSystemAccess {
-    constructor() {
+var FileSystemAccess = /** @class */ (function () {
+    function FileSystemAccess() {
         this.copy = this.copySync.bind(this);
         this.readText = this.readTextSync.bind(this);
         this.readBuffer = this.readBufferSync.bind(this);
@@ -15,35 +15,35 @@ export class FileSystemAccess {
         this.writeBuffer = this.writeBufferSync.bind(this);
         this.write = this.writeSync.bind(this);
     }
-    getLastModified(path) {
-        const fileManager = NSFileManager.defaultManager;
-        const attributes = fileManager.attributesOfItemAtPathError(path);
+    FileSystemAccess.prototype.getLastModified = function (path) {
+        var fileManager = NSFileManager.defaultManager;
+        var attributes = fileManager.attributesOfItemAtPathError(path);
         if (attributes) {
             return attributes.objectForKey('NSFileModificationDate');
         }
         else {
             return new Date();
         }
-    }
-    getFileSize(path) {
-        const fileManager = NSFileManager.defaultManager;
-        const attributes = fileManager.attributesOfItemAtPathError(path);
+    };
+    FileSystemAccess.prototype.getFileSize = function (path) {
+        var fileManager = NSFileManager.defaultManager;
+        var attributes = fileManager.attributesOfItemAtPathError(path);
         if (attributes) {
             return attributes.objectForKey('NSFileSize');
         }
         else {
             return 0;
         }
-    }
-    getParent(path, onError) {
+    };
+    FileSystemAccess.prototype.getParent = function (path, onError) {
         try {
-            const fileManager = NSFileManager.defaultManager;
-            const nsString = NSString.stringWithString(path);
-            const parentPath = nsString.stringByDeletingLastPathComponent;
-            const name = fileManager.displayNameAtPath(parentPath);
+            var fileManager = NSFileManager.defaultManager;
+            var nsString = NSString.stringWithString(path);
+            var parentPath = nsString.stringByDeletingLastPathComponent;
+            var name_1 = fileManager.displayNameAtPath(parentPath);
             return {
                 path: parentPath.toString(),
-                name: name,
+                name: name_1,
             };
         }
         catch (exception) {
@@ -52,13 +52,13 @@ export class FileSystemAccess {
             }
             return undefined;
         }
-    }
-    getFile(path, onError) {
+    };
+    FileSystemAccess.prototype.getFile = function (path, onError) {
         try {
-            const fileManager = NSFileManager.defaultManager;
-            const exists = fileManager.fileExistsAtPath(path);
+            var fileManager = NSFileManager.defaultManager;
+            var exists = fileManager.fileExistsAtPath(path);
             if (!exists) {
-                const parentPath = this.getParent(path, onError).path;
+                var parentPath = this.getParent(path, onError).path;
                 if (!fileManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(parentPath, true, null) || !fileManager.createFileAtPathContentsAttributes(path, null, null)) {
                     if (onError) {
                         onError(new Error("Failed to create file at path '" + path + "'"));
@@ -66,7 +66,7 @@ export class FileSystemAccess {
                     return undefined;
                 }
             }
-            const fileName = fileManager.displayNameAtPath(path);
+            var fileName = fileManager.displayNameAtPath(path);
             return {
                 path: path,
                 name: fileName,
@@ -79,11 +79,11 @@ export class FileSystemAccess {
             }
             return undefined;
         }
-    }
-    getFolder(path, onError) {
+    };
+    FileSystemAccess.prototype.getFolder = function (path, onError) {
         try {
-            const fileManager = NSFileManager.defaultManager;
-            const exists = this.folderExists(path);
+            var fileManager = NSFileManager.defaultManager;
+            var exists = this.folderExists(path);
             if (!exists) {
                 try {
                     fileManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, true, null);
@@ -95,7 +95,7 @@ export class FileSystemAccess {
                     return undefined;
                 }
             }
-            const dirName = fileManager.displayNameAtPath(path);
+            var dirName = fileManager.displayNameAtPath(path);
             return {
                 path: path,
                 name: dirName,
@@ -107,13 +107,13 @@ export class FileSystemAccess {
             }
             return undefined;
         }
-    }
-    getExistingFolder(path, onError) {
+    };
+    FileSystemAccess.prototype.getExistingFolder = function (path, onError) {
         try {
-            const fileManager = NSFileManager.defaultManager;
-            const exists = this.folderExists(path);
+            var fileManager = NSFileManager.defaultManager;
+            var exists = this.folderExists(path);
             if (exists) {
-                const dirName = fileManager.displayNameAtPath(path);
+                var dirName = fileManager.displayNameAtPath(path);
                 return {
                     path: path,
                     name: dirName,
@@ -127,21 +127,21 @@ export class FileSystemAccess {
             }
             return undefined;
         }
-    }
-    eachEntity(path, onEntity, onError) {
+    };
+    FileSystemAccess.prototype.eachEntity = function (path, onEntity, onError) {
         if (!onEntity) {
             return;
         }
         this.enumEntities(path, onEntity, onError);
-    }
-    getEntities(path, onError) {
-        const fileInfos = new Array();
-        const onEntity = function (entity) {
+    };
+    FileSystemAccess.prototype.getEntities = function (path, onError) {
+        var fileInfos = new Array();
+        var onEntity = function (entity) {
             fileInfos.push(entity);
             return true;
         };
-        let errorOccurred;
-        const localError = function (error) {
+        var errorOccurred;
+        var localError = function (error) {
             if (onError) {
                 onError(error);
             }
@@ -152,37 +152,37 @@ export class FileSystemAccess {
             return fileInfos;
         }
         return null;
-    }
-    fileExists(path) {
-        const result = this.exists(path);
+    };
+    FileSystemAccess.prototype.fileExists = function (path) {
+        var result = this.exists(path);
         return result.exists;
-    }
-    folderExists(path) {
-        const result = this.exists(path);
+    };
+    FileSystemAccess.prototype.folderExists = function (path) {
+        var result = this.exists(path);
         return result.exists && result.isDirectory;
-    }
-    exists(path) {
-        const fileManager = NSFileManager.defaultManager;
-        const isDirectory = new interop.Reference(interop.types.bool, false);
-        const exists = fileManager.fileExistsAtPathIsDirectory(path, isDirectory);
+    };
+    FileSystemAccess.prototype.exists = function (path) {
+        var fileManager = NSFileManager.defaultManager;
+        var isDirectory = new interop.Reference(interop.types.bool, false);
+        var exists = fileManager.fileExistsAtPathIsDirectory(path, isDirectory);
         return { exists: exists, isDirectory: isDirectory.value };
-    }
-    concatPath(left, right) {
+    };
+    FileSystemAccess.prototype.concatPath = function (left, right) {
         return NSString.pathWithComponents([left, right]).toString();
-    }
-    deleteFile(path, onError) {
+    };
+    FileSystemAccess.prototype.deleteFile = function (path, onError) {
         this.deleteEntity(path, onError);
-    }
-    deleteFolder(path, onError) {
+    };
+    FileSystemAccess.prototype.deleteFolder = function (path, onError) {
         this.deleteEntity(path, onError);
-    }
-    emptyFolder(path, onError) {
-        const fileManager = NSFileManager.defaultManager;
-        const entities = this.getEntities(path, onError);
+    };
+    FileSystemAccess.prototype.emptyFolder = function (path, onError) {
+        var fileManager = NSFileManager.defaultManager;
+        var entities = this.getEntities(path, onError);
         if (!entities) {
             return;
         }
-        for (let i = 0; i < entities.length; i++) {
+        for (var i = 0; i < entities.length; i++) {
             try {
                 fileManager.removeItemAtPathError(entities[i].path);
             }
@@ -193,9 +193,9 @@ export class FileSystemAccess {
                 return;
             }
         }
-    }
-    rename(path, newPath, onError) {
-        const fileManager = NSFileManager.defaultManager;
+    };
+    FileSystemAccess.prototype.rename = function (path, newPath, onError) {
+        var fileManager = NSFileManager.defaultManager;
         try {
             fileManager.moveItemAtPathToPathError(path, newPath);
         }
@@ -204,26 +204,26 @@ export class FileSystemAccess {
                 onError(new Error("Failed to rename '" + path + "' to '" + newPath + "': " + ex));
             }
         }
-    }
-    getLogicalRootPath() {
-        const mainBundlePath = NSBundle.mainBundle.bundlePath;
-        const resolvedPath = NSString.stringWithString(mainBundlePath).stringByResolvingSymlinksInPath;
+    };
+    FileSystemAccess.prototype.getLogicalRootPath = function () {
+        var mainBundlePath = NSBundle.mainBundle.bundlePath;
+        var resolvedPath = NSString.stringWithString(mainBundlePath).stringByResolvingSymlinksInPath;
         return resolvedPath;
-    }
-    getDocumentsFolderPath() {
+    };
+    FileSystemAccess.prototype.getDocumentsFolderPath = function () {
         return this.getKnownPath(9 /* NSSearchPathDirectory.DocumentDirectory */);
-    }
-    getExternalDocumentsFolderPath() {
+    };
+    FileSystemAccess.prototype.getExternalDocumentsFolderPath = function () {
         return this.getDocumentsFolderPath();
-    }
-    getTempFolderPath() {
+    };
+    FileSystemAccess.prototype.getTempFolderPath = function () {
         return this.getKnownPath(13 /* NSSearchPathDirectory.CachesDirectory */);
-    }
-    getCurrentAppPath() {
+    };
+    FileSystemAccess.prototype.getCurrentAppPath = function () {
         return iOSNativeHelper.getCurrentAppPath();
-    }
-    copySync(src, dest, onError) {
-        const fileManager = NSFileManager.defaultManager;
+    };
+    FileSystemAccess.prototype.copySync = function (src, dest, onError) {
+        var fileManager = NSFileManager.defaultManager;
         try {
             return fileManager.copyItemAtPathToPathError(src, dest);
         }
@@ -231,18 +231,18 @@ export class FileSystemAccess {
             if (error.message.indexOf('exists') > -1) {
                 // check the size of file if empty remove then try copying again
                 // this could be zero due to using File.fromPath passing in a new file
-                let didRemove = false;
+                var didRemove = false;
                 try {
                     didRemove = fileManager.removeItemAtPathError(dest);
                     return fileManager.copyItemAtPathToPathError(src, dest);
                 }
-                catch (error) {
+                catch (exception) {
                     if (onError) {
                         if (didRemove) {
                             onError(error);
                         }
                         else {
-                            onError(error);
+                            onError(exception);
                         }
                     }
                 }
@@ -252,18 +252,19 @@ export class FileSystemAccess {
             }
         }
         return false;
-    }
-    copyAsync(src, dest) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.copyAsync = function (src, dest) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
             try {
-                NSData.dataWithContentsOfFileCompletion(src, (data) => {
+                NSData.dataWithContentsOfFileCompletion(src, function (data) {
                     if (!data) {
                         reject(new Error("Failed to read file at path '" + src));
                     }
                     else {
-                        data.writeToFileAtomicallyCompletion(dest, true, () => {
-                            if (this.fileExists(dest)) {
-                                const size = this.getFileSize(dest);
+                        data.writeToFileAtomicallyCompletion(dest, true, function () {
+                            if (_this.fileExists(dest)) {
+                                var size = _this.getFileSize(dest);
                                 if (size === data.length) {
                                     resolve(true);
                                 }
@@ -282,12 +283,12 @@ export class FileSystemAccess {
                 reject(ex);
             }
         });
-    }
-    readTextAsync(path, encoding) {
-        const actualEncoding = encoding || textEncoding.UTF_8;
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.readTextAsync = function (path, encoding) {
+        var actualEncoding = encoding || textEncoding.UTF_8;
+        return new Promise(function (resolve, reject) {
             try {
-                NSString.stringWithContentsOfFileEncodingCompletion(path, actualEncoding, (result, error) => {
+                NSString.stringWithContentsOfFileEncodingCompletion(path, actualEncoding, function (result, error) {
                     if (error) {
                         reject(error);
                     }
@@ -300,11 +301,11 @@ export class FileSystemAccess {
                 reject(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         });
-    }
-    readTextSync(path, onError, encoding) {
-        const actualEncoding = encoding || textEncoding.UTF_8;
+    };
+    FileSystemAccess.prototype.readTextSync = function (path, onError, encoding) {
+        var actualEncoding = encoding || textEncoding.UTF_8;
         try {
-            const nsString = NSString.stringWithContentsOfFileEncodingError(path, actualEncoding);
+            var nsString = NSString.stringWithContentsOfFileEncodingError(path, actualEncoding);
             return nsString.toString();
         }
         catch (ex) {
@@ -312,11 +313,11 @@ export class FileSystemAccess {
                 onError(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         }
-    }
-    readBufferAsync(path) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.readBufferAsync = function (path) {
+        return new Promise(function (resolve, reject) {
             try {
-                NSData.dataWithContentsOfFileCompletion(path, (data) => {
+                NSData.dataWithContentsOfFileCompletion(path, function (data) {
                     resolve(interop.bufferFromData(data));
                 });
             }
@@ -324,8 +325,8 @@ export class FileSystemAccess {
                 reject(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         });
-    }
-    readBufferSync(path, onError) {
+    };
+    FileSystemAccess.prototype.readBufferSync = function (path, onError) {
         try {
             return interop.bufferFromData(NSData.dataWithContentsOfFile(path));
         }
@@ -334,9 +335,9 @@ export class FileSystemAccess {
                 onError(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         }
-    }
-    readAsync(path) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.readAsync = function (path) {
+        return new Promise(function (resolve, reject) {
             try {
                 NSData.dataWithContentsOfFileCompletion(path, resolve);
             }
@@ -344,8 +345,8 @@ export class FileSystemAccess {
                 reject(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         });
-    }
-    readSync(path, onError) {
+    };
+    FileSystemAccess.prototype.readSync = function (path, onError) {
         try {
             return NSData.dataWithContentsOfFile(path);
         }
@@ -354,13 +355,13 @@ export class FileSystemAccess {
                 onError(new Error("Failed to read file at path '" + path + "': " + ex));
             }
         }
-    }
-    writeTextAsync(path, content, encoding) {
-        const nsString = NSString.stringWithString(content);
-        const actualEncoding = encoding || textEncoding.UTF_8;
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.writeTextAsync = function (path, content, encoding) {
+        var nsString = NSString.stringWithString(content);
+        var actualEncoding = encoding || textEncoding.UTF_8;
+        return new Promise(function (resolve, reject) {
             try {
-                nsString.writeToFileAtomicallyEncodingCompletion(path, true, actualEncoding, (error) => {
+                nsString.writeToFileAtomicallyEncodingCompletion(path, true, actualEncoding, function (error) {
                     if (error) {
                         reject(error);
                     }
@@ -373,10 +374,10 @@ export class FileSystemAccess {
                 reject(new Error("Failed to write file at path '" + path + "': " + ex));
             }
         });
-    }
-    writeTextSync(path, content, onError, encoding) {
-        const nsString = NSString.stringWithString(content);
-        const actualEncoding = encoding || textEncoding.UTF_8;
+    };
+    FileSystemAccess.prototype.writeTextSync = function (path, content, onError, encoding) {
+        var nsString = NSString.stringWithString(content);
+        var actualEncoding = encoding || textEncoding.UTF_8;
         // TODO: verify the useAuxiliaryFile parameter should be false
         try {
             nsString.writeToFileAtomicallyEncodingError(path, false, actualEncoding);
@@ -386,39 +387,40 @@ export class FileSystemAccess {
                 onError(new Error("Failed to write to file '" + path + "': " + ex));
             }
         }
-    }
-    static getBuffer(buffer) {
+    };
+    FileSystemAccess.getBuffer = function (buffer) {
+        var _a;
         if (buffer instanceof ArrayBuffer) {
             return NSData.dataWithData(buffer);
         }
         else {
-            const buf = NSData.dataWithData(buffer?.buffer);
-            const len = buffer.byteLength;
-            return NSData.dataWithBytesNoCopyLength(buf.bytes.add(buffer?.byteOffset ?? 0), len);
+            var buf = NSData.dataWithData(buffer === null || buffer === void 0 ? void 0 : buffer.buffer);
+            var len = buffer.byteLength;
+            return NSData.dataWithBytesNoCopyLength(buf.bytes.add((_a = buffer === null || buffer === void 0 ? void 0 : buffer.byteOffset) !== null && _a !== void 0 ? _a : 0), len);
         }
-    }
-    appendBufferAsync(path, content) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.appendBufferAsync = function (path, content) {
+        return new Promise(function (resolve, reject) {
             try {
-                const handle = NSFileHandle.fileHandleForWritingAtPath(path);
-                handle.appendDataCompletion(FileSystemAccess.getBuffer(content), (error) => {
+                var handle_1 = NSFileHandle.fileHandleForWritingAtPath(path);
+                handle_1.appendDataCompletion(FileSystemAccess.getBuffer(content), function (error) {
                     if (error) {
                         reject(error);
                     }
                     else {
                         resolve();
                     }
-                    handle.closeFile();
+                    handle_1.closeFile();
                 });
             }
             catch (ex) {
                 reject(new Error("Failed to write file at path '" + path + "': " + ex));
             }
         });
-    }
-    appendBufferSync(path, content, onError) {
+    };
+    FileSystemAccess.prototype.appendBufferSync = function (path, content, onError) {
         try {
-            const handle = NSFileHandle.fileHandleForWritingAtPath(path);
+            var handle = NSFileHandle.fileHandleForWritingAtPath(path);
             handle.seekToEndOfFile();
             handle.writeData(FileSystemAccess.getBuffer(content));
             handle.closeFile();
@@ -428,29 +430,29 @@ export class FileSystemAccess {
                 onError(new Error("Failed to write to file '" + path + "': " + ex));
             }
         }
-    }
-    appendAsync(path, content) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.appendAsync = function (path, content) {
+        return new Promise(function (resolve, reject) {
             try {
-                const handle = NSFileHandle.fileHandleForWritingAtPath(path);
-                handle.appendDataCompletion(content, (error) => {
+                var handle_2 = NSFileHandle.fileHandleForWritingAtPath(path);
+                handle_2.appendDataCompletion(content, function (error) {
                     if (error) {
                         reject(error);
                     }
                     else {
                         resolve();
                     }
-                    handle.closeFile();
+                    handle_2.closeFile();
                 });
             }
             catch (ex) {
                 reject(new Error("Failed to write file at path '" + path + "': " + ex));
             }
         });
-    }
-    appendSync(path, content, onError) {
+    };
+    FileSystemAccess.prototype.appendSync = function (path, content, onError) {
         try {
-            const handle = NSFileHandle.fileHandleForWritingAtPath(path);
+            var handle = NSFileHandle.fileHandleForWritingAtPath(path);
             handle.seekToEndOfFile();
             handle.writeData(content);
             handle.closeFile();
@@ -460,36 +462,36 @@ export class FileSystemAccess {
                 onError(new Error("Failed to write to file '" + path + "': " + ex));
             }
         }
-    }
-    appendTextAsync(path, content, encoding) {
-        const nsString = NSString.stringWithString(content);
-        const actualEncoding = encoding || textEncoding.UTF_8;
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.appendTextAsync = function (path, content, encoding) {
+        var nsString = NSString.stringWithString(content);
+        var actualEncoding = encoding || textEncoding.UTF_8;
+        return new Promise(function (resolve, reject) {
             try {
-                const data = nsString.dataUsingEncoding(actualEncoding);
-                const handle = NSFileHandle.fileHandleForWritingAtPath(path);
-                handle.appendDataCompletion(data, (error) => {
+                var data = nsString.dataUsingEncoding(actualEncoding);
+                var handle_3 = NSFileHandle.fileHandleForWritingAtPath(path);
+                handle_3.appendDataCompletion(data, function (error) {
                     if (error) {
                         reject(error);
                     }
                     else {
                         resolve();
                     }
-                    handle.closeFile();
+                    handle_3.closeFile();
                 });
             }
             catch (ex) {
                 reject(new Error("Failed to append file at path '" + path + "': " + ex));
             }
         });
-    }
-    appendTextSync(path, content, onError, encoding) {
-        const nsString = NSString.stringWithString(content);
-        const actualEncoding = encoding || textEncoding.UTF_8;
+    };
+    FileSystemAccess.prototype.appendTextSync = function (path, content, onError, encoding) {
+        var nsString = NSString.stringWithString(content);
+        var actualEncoding = encoding || textEncoding.UTF_8;
         // TODO: verify the useAuxiliaryFile parameter should be false
         try {
-            const data = nsString.dataUsingEncoding(actualEncoding);
-            const handle = NSFileHandle.fileHandleForWritingAtPath(path);
+            var data = nsString.dataUsingEncoding(actualEncoding);
+            var handle = NSFileHandle.fileHandleForWritingAtPath(path);
             handle.seekToEndOfFile();
             handle.writeData(data);
             handle.closeFile();
@@ -499,11 +501,11 @@ export class FileSystemAccess {
                 onError(new Error("Failed to append to file '" + path + "': " + ex));
             }
         }
-    }
-    writeBufferAsync(path, content) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.writeBufferAsync = function (path, content) {
+        return new Promise(function (resolve, reject) {
             try {
-                FileSystemAccess.getBuffer(content).writeToFileAtomicallyCompletion(path, true, () => {
+                FileSystemAccess.getBuffer(content).writeToFileAtomicallyCompletion(path, true, function () {
                     resolve();
                 });
             }
@@ -511,8 +513,8 @@ export class FileSystemAccess {
                 reject(new Error("Failed to write file at path '" + path + "': " + ex));
             }
         });
-    }
-    writeBufferSync(path, content, onError) {
+    };
+    FileSystemAccess.prototype.writeBufferSync = function (path, content, onError) {
         try {
             FileSystemAccess.getBuffer(content).writeToFileAtomically(path, true);
         }
@@ -521,11 +523,11 @@ export class FileSystemAccess {
                 onError(new Error("Failed to write to file '" + path + "': " + ex));
             }
         }
-    }
-    writeAsync(path, content) {
-        return new Promise((resolve, reject) => {
+    };
+    FileSystemAccess.prototype.writeAsync = function (path, content) {
+        return new Promise(function (resolve, reject) {
             try {
-                content.writeToFileAtomicallyCompletion(path, true, () => {
+                content.writeToFileAtomicallyCompletion(path, true, function () {
                     resolve();
                 });
             }
@@ -533,8 +535,8 @@ export class FileSystemAccess {
                 reject(new Error("Failed to write file at path '" + path + "': " + ex));
             }
         });
-    }
-    writeSync(path, content, onError) {
+    };
+    FileSystemAccess.prototype.writeSync = function (path, content, onError) {
         try {
             content.writeToFileAtomically(path, true);
         }
@@ -543,16 +545,16 @@ export class FileSystemAccess {
                 onError(new Error("Failed to write to file '" + path + "': " + ex));
             }
         }
-    }
-    getKnownPath(folderType) {
-        const fileManager = NSFileManager.defaultManager;
-        const paths = fileManager.URLsForDirectoryInDomains(folderType, 1 /* NSSearchPathDomainMask.UserDomainMask */);
-        const url = paths.objectAtIndex(0);
+    };
+    FileSystemAccess.prototype.getKnownPath = function (folderType) {
+        var fileManager = NSFileManager.defaultManager;
+        var paths = fileManager.URLsForDirectoryInDomains(folderType, 1 /* NSSearchPathDomainMask.UserDomainMask */);
+        var url = paths.objectAtIndex(0);
         return url.path;
-    }
+    };
     // TODO: This method is the same as in the iOS implementation.
     // Make it in a separate file / module so it can be reused from both implementations.
-    getFileExtension(path) {
+    FileSystemAccess.prototype.getFileExtension = function (path) {
         // TODO [For Panata]: The definitions currently specify "any" as a return value of this method
         //const nsString = Foundation.NSString.stringWithString(path);
         //const extension = nsString.pathExtension();
@@ -560,14 +562,14 @@ export class FileSystemAccess {
         //    extension = extension.concat(".", extension);
         //}
         //return extension;
-        const dotIndex = path.lastIndexOf('.');
+        var dotIndex = path.lastIndexOf('.');
         if (dotIndex && dotIndex >= 0 && dotIndex < path.length) {
             return path.substring(dotIndex);
         }
         return '';
-    }
-    deleteEntity(path, onError) {
-        const fileManager = NSFileManager.defaultManager;
+    };
+    FileSystemAccess.prototype.deleteEntity = function (path, onError) {
+        var fileManager = NSFileManager.defaultManager;
         try {
             fileManager.removeItemAtPathError(path);
         }
@@ -576,11 +578,11 @@ export class FileSystemAccess {
                 onError(new Error("Failed to delete file at path '" + path + "': " + ex));
             }
         }
-    }
-    enumEntities(path, callback, onError) {
+    };
+    FileSystemAccess.prototype.enumEntities = function (path, callback, onError) {
         try {
-            const fileManager = NSFileManager.defaultManager;
-            let files;
+            var fileManager = NSFileManager.defaultManager;
+            var files = void 0;
             try {
                 files = fileManager.contentsOfDirectoryAtPathError(path);
             }
@@ -590,9 +592,9 @@ export class FileSystemAccess {
                 }
                 return;
             }
-            for (let i = 0; i < files.count; i++) {
-                const file = files.objectAtIndex(i);
-                const info = {
+            for (var i = 0; i < files.count; i++) {
+                var file = files.objectAtIndex(i);
+                var info = {
                     path: this.concatPath(path, file),
                     name: file,
                     extension: '',
@@ -600,7 +602,7 @@ export class FileSystemAccess {
                 if (!this.folderExists(this.joinPath(path, file))) {
                     info.extension = this.getFileExtension(info.path);
                 }
-                const retVal = callback(info);
+                var retVal = callback(info);
                 if (retVal === false) {
                     // the callback returned false meaning we should stop the iteration
                     break;
@@ -612,24 +614,32 @@ export class FileSystemAccess {
                 onError(ex);
             }
         }
-    }
-    getPathSeparator() {
+    };
+    FileSystemAccess.prototype.getPathSeparator = function () {
         return '/';
-    }
-    normalizePath(path) {
-        const nsString = NSString.stringWithString(path);
-        const normalized = nsString.stringByStandardizingPath;
+    };
+    FileSystemAccess.prototype.normalizePath = function (path) {
+        var nsString = NSString.stringWithString(path);
+        var normalized = nsString.stringByStandardizingPath;
         return normalized;
-    }
-    joinPath(left, right) {
-        const nsString = NSString.stringWithString(left);
+    };
+    FileSystemAccess.prototype.joinPath = function (left, right) {
+        var nsString = NSString.stringWithString(left);
         return nsString.stringByAppendingPathComponent(right);
-    }
-    joinPaths(paths) {
-        return iOSNativeHelper.joinPaths(...paths);
-    }
-}
+    };
+    FileSystemAccess.prototype.joinPaths = function (paths) {
+        return iOSNativeHelper.joinPaths.apply(iOSNativeHelper, paths);
+    };
+    return FileSystemAccess;
+}());
+export { FileSystemAccess };
 // stub to avoid cross platform warning
-export class FileSystemAccess29 extends FileSystemAccess {
-}
+var FileSystemAccess29 = /** @class */ (function (_super) {
+    __extends(FileSystemAccess29, _super);
+    function FileSystemAccess29() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return FileSystemAccess29;
+}(FileSystemAccess));
+export { FileSystemAccess29 };
 //# sourceMappingURL=file-system-access.ios.js.map