@amazon-devices/expo-file-system 2.0.1758683737

package/kepler/test/FileSystem.cpp

@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/utils/KeplerUIManager.h>
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+#include "../ExponentFileSystem.h"
+#include "JSObjectsConversion.h"
+#include "catch.hpp"
+
+namespace {
+void handlePromiseRejection(volta::react::NativeJSObject payload) {
+    std::string rejectionMessage = std::get<std::string>(payload["message"]);
+    FAIL(rejectionMessage);
+}
+}  // namespace
+
+SCENARIO("Testing Expo FileSystem module") {
+    ExponentFileSystem fileSystemModule;
+
+    WHEN("documentDirectory method is called") {
+        auto documentDirectory = fileSystemModule.documentDirectory();
+
+        THEN("Proper value is returned") {
+            REQUIRE(documentDirectory == "/data");
+        }
+    }
+
+    WHEN("cacheDirectory method is called") {
+        auto cacheDirectory = fileSystemModule.cacheDirectory();
+
+        THEN("Proper value is returned") {
+            REQUIRE(cacheDirectory == "/cache");
+        }
+    }
+
+    WHEN("bundleDirectory method is called") {
+        auto bundleDirectory = fileSystemModule.bundleDirectory();
+
+        THEN("Proper value is returned") {
+            REQUIRE(bundleDirectory == "");
+        }
+    }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("getInfoAsync is called for a nonexisting file") {
+    //         auto promise = fileSystemModule.getInfoAsync("/data/nonExistingFile.txt", {});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains appropriate file info for non existing file") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<volta::react::NativeJSObject>(args[0]));
+
+    //                         volta::react::NativeJSObject fileInfo = std::get<volta::react::NativeJSObject>(args[0]);
+
+    //                         REQUIRE(std::holds_alternative<bool>(fileInfo["exists"]));
+    //                         REQUIRE(std::holds_alternative<bool>(fileInfo["isDirectory"]));
+
+    //                         REQUIRE_FALSE(std::get<bool>(fileInfo["exists"]));
+    //                         REQUIRE_FALSE(std::get<bool>(fileInfo["isDirectory"]));
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("getInfoAsync is called for an existing file") {
+    //         auto promise =
+    //                 fileSystemModule.getInfoAsync("/data/expo-unit-tests", volta::react::NativeJSObject{{"size",
+    //                 true}});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains appropriate file info for existing file") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<volta::react::NativeJSObject>(args[0]));
+
+    //                         volta::react::NativeJSObject fileInfo = std::get<volta::react::NativeJSObject>(args[0]);
+
+    //                         REQUIRE(std::holds_alternative<bool>(fileInfo["exists"]));
+    //                         REQUIRE(std::holds_alternative<bool>(fileInfo["isDirectory"]));
+    //                         REQUIRE(std::holds_alternative<std::string>(fileInfo["size"]));
+    //                         REQUIRE(std::holds_alternative<std::string>(fileInfo["modification"]));
+
+    //                         REQUIRE(std::get<bool>(fileInfo["exists"]));
+    //                         REQUIRE_FALSE(std::get<bool>(fileInfo["isDirectory"]));
+    //                         REQUIRE(std::get<std::string>(fileInfo["size"]) > "1024");
+    //                         REQUIRE(std::get<std::string>(fileInfo["modification"]) > "1718788070");
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("getContentUriAsync is called") {
+    //         auto promise = fileSystemModule.getContentUriAsync("expo-unit-tests");
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains formatted URI") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<std::string>(args[0]));
+
+    //                         REQUIRE(std::get<std::string>(args[0]) == "/data/expo-unit-tests");
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    //     Unable to test due to lack of 'Promise' support
+    //         WHEN("writeAsStringAsync is called") {
+    //             auto promise = fileSystemModule.writeAsStringAsync("/data/hello-world.txt", "Hello world!", {});
+
+    //             promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                     volta::react::Callback([](auto args) {
+    //                         THEN("Promise is resolved on success") {
+    //                             REQUIRE(args.size() == 0);
+    //                         }
+    //                     }),
+    //                     volta::react::Callback([](auto args) {
+    //                         volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                                 std::get<utils::json::JsonContainer>(args[0]));
+    //                         handlePromiseRejection(payload);
+    //                     })));
+    //         }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("readAsStringAsync is called") {
+    //         auto promise = fileSystemModule.readAsStringAsync("/data/hello-world.txt", {});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains file content") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<std::string>(args[0]));
+
+    //                         REQUIRE(std::get<std::string>(args[0]) == "Hello world!");
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("makeDirectoryAsync is called") {
+    //         auto promise = fileSystemModule.makeDirectoryAsync("/data/hello", {});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Promise is resolved on success") {
+    //                         REQUIRE(args.size() == 0);
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     std::string rejectionMessage = std::get<std::string>(payload["message"]);
+    //                     if (rejectionMessage.find("already exists") != std::string::npos) {
+    //                         THEN("Promise is rejected with appropriate error message when the test is run more than
+    //                         once") {
+    //                             REQUIRE(rejectionMessage == "Directory already exists!");
+    //                         }
+    //                     } else {
+    //                         handlePromiseRejection(payload);
+    //                     }
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("copyAsync is called") {
+    //         auto promise = fileSystemModule.copyAsync(
+    //                 volta::react::NativeJSObject{{"from", "data/hello-world.txt"}, {"to", "data/hello/world.txt"}});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Promise is resolved on success") {
+    //                         REQUIRE(args.size() == 0);
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     std::string rejectionMessage = std::get<std::string>(payload["message"]);
+    //                     if (rejectionMessage.find("cannot copy: File exists") != std::string::npos) {
+    //                         THEN("Promise is rejected with appropriate error message when the test is run more than
+    //                         once") {
+    //                         }
+    //                     } else {
+    //                         handlePromiseRejection(payload);
+    //                     }
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("moveAsync is called") {
+    //         auto promise = fileSystemModule.moveAsync(
+    //                 volta::react::NativeJSObject{{"from", "data/hello-world.txt"}, {"to",
+    //                 "data/hello/hello-world.txt"}});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Promise is resolved on success") {
+    //                         REQUIRE(args.size() == 0);
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("deleteAsync is called") {
+    //         auto promise = fileSystemModule.deleteAsync("data/hello/hello-world.txt", {});
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Promise is resolved on success") {
+    //                         REQUIRE(args.size() == 0);
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("readDirectoryAsync is called") {
+    //         auto promise = fileSystemModule.readDirectoryAsync("/data/hello");
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains directory content") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<volta::react::NativeJSArray>(args[0]));
+
+    //                         volta::react::NativeJSArray directoryContent =
+    //                         std::get<volta::react::NativeJSArray>(args[0]);
+
+    //                         REQUIRE(directoryContent.size() > 0);
+
+    //                         for (volta::react::NativeJSValue entry : directoryContent)
+    //                             REQUIRE(std::holds_alternative<std::string>(entry));
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("getFreeDiskStorageAsync is called") {
+    //         auto promise = fileSystemModule.getFreeDiskStorageAsync();
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains free disk capacity in bytes") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<std::string>(args[0]));
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    //     WHEN("getTotalDiskCapacityAsync is called") {
+    //         auto promise = fileSystemModule.getTotalDiskCapacityAsync();
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise does not contain free disk capacity information") {
+    //                         REQUIRE(args.size() == 0);
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    // Sidenote: wifi connection is required to perform below testcase
+    //     WHEN("downloadAsync is called") {
+    //         std::vector<utils::json::JsonContainer> headers;
+    //         auto headerAccept = utils::json::JsonContainer::createJsonObject();
+    //         headerAccept.insert("Accept", 'application/json');
+    //         headers.push_back(headerAccept);
+
+    //         auto promise =
+    //                 fileSystemModule
+    //                         .downloadAsync("https://httpbin.org/get", "/data/hello/downloadResponse.json", {}, 1,
+    //                         headers);
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains download response") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<volta::react::NativeJSObject>(args[0]));
+
+    //                         volta::react::NativeJSObject fileInfo = std::get<volta::react::NativeJSObject>(args[0]);
+
+    //                         REQUIRE(std::holds_alternative<std::string>(fileInfo["uri"]));
+
+    //                         REQUIRE(std::get<std::string>(fileInfo["uri"]) == "/data/hello/downloadResponse.json");
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    // Unable to test due to lack of 'Promise' support
+    // Sidenote: wifi connection is required to perform below testcase
+    //     WHEN("uploadAsync is called") {
+    //         std::vector<utils::json::JsonContainer> headers;
+    //         auto headerAccept = utils::json::JsonContainer::createJsonObject();
+    //         headerAccept.insert("Accept", 'application/json');
+    //         headers.push_back(headerAccept);
+
+    //         auto promise =
+    //                 fileSystemModule
+    //                         .uploadAsync("https://httpbin.org/post", "/data/hello/uploadResponse.json", {}, 2,
+    //                         headers);
+
+    //         promise.promiseOperation_(std::make_shared<volta::react::Promise>(
+    //                 volta::react::Callback([](auto args) {
+    //                     THEN("Resolved promise contains upload response") {
+    //                         REQUIRE(args.size() == 1);
+    //                         REQUIRE(std::holds_alternative<volta::react::NativeJSObject>(args[0]));
+
+    //                         volta::react::NativeJSObject fileInfo = std::get<volta::react::NativeJSObject>(args[0]);
+
+    //                         REQUIRE(std::holds_alternative<std::string>(fileInfo["uri"]));
+
+    //                         REQUIRE(std::get<std::string>(fileInfo["uri"]) == "/data/hello/uploadResponse.json");
+    //                     }
+    //                 }),
+    //                 volta::react::Callback([](auto args) {
+    //                     volta::react::NativeJSObject payload = ExpoUtils::convertJsonContainerToNativeJSObject(
+    //                             std::get<utils::json::JsonContainer>(args[0]));
+    //                     handlePromiseRejection(payload);
+    //                 })));
+    //     }
+
+    WHEN("aggregateMethods is called") {
+        std::weak_ptr<facebook::react::Instance> instance;
+        fileSystemModule.triggerMethodAggregation(*fileSystemModule.jsQueue_, instance);
+
+        THEN("methodContainerMap contains expected methods") {
+            REQUIRE(fileSystemModule.methodContainerMap_.find("documentDirectory") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("cacheDirectory") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("bundleDirectory") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("getInfoAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("readAsStringAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("getContentUriAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("writeAsStringAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("deleteAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("moveAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("copyAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("makeDirectoryAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("readDirectoryAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("getFreeDiskStorageAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("getTotalDiskCapacityAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("downloadAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+            REQUIRE(fileSystemModule.methodContainerMap_.find("uploadAsync") !=
+                    fileSystemModule.methodContainerMap_.end());
+        }
+
+        THEN("size of methodContainerMap is increased by addListener and removeListeners") {
+            REQUIRE(fileSystemModule.methodContainerMap_.size() == 19);
+        }
+    }
+}

package/package.json

@@ -0,0 +1 @@
+{"name": "@amazon-devices/expo-file-system", "version": "2.0.1758683737+15.8.0", "description": "Provides access to the local file system on the device.", "main": "build/index.js", "types": "build/index.d.ts", "sideEffects": false, "scripts": {"build": "expo-module build", "clean": "expo-module clean", "lint": "expo-module lint", "test": "expo-module test", "expo-module": "expo-module"}, "kepler": {"temporary-alias-for-package": {"name": "expo-file-system", "version": "15.8.0"}}, "keywords": ["react-native", "expo", "file-system", "file"], "repository": {"type": "git", "url": "https://github.com/expo/expo.git", "directory": "packages/expo-file-system"}, "bugs": {"url": "https://github.com/expo/expo/issues"}, "author": "650 Industries, Inc.", "license": "See license in LICENSE", "homepage": "https://docs.expo.dev/versions/latest/sdk/filesystem/", "dependencies": {"uuid": "^3.4.0", "@amazon-devices/keplerscript-turbomodule-api": "^1.0.0"}, "devDependencies": {"expo-module-scripts": "^3.0.0", "jest-expo": "~50.0.0-alpha.0"}, "peerDependencies": {"expo": "*"}}

package/plugin/build/withFileSystem.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from 'expo/config-plugins';
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/withFileSystem.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+const pkg = require('expo-file-system/package.json');
+const withFileSystem = (config) => {
+    return config_plugins_1.AndroidConfig.Permissions.withPermissions(config, [
+        'android.permission.READ_EXTERNAL_STORAGE',
+        'android.permission.WRITE_EXTERNAL_STORAGE',
+        'android.permission.INTERNET',
+    ]);
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withFileSystem, pkg.name, pkg.version);

package/plugin/src/withFileSystem.ts

@@ -0,0 +1,13 @@
+import { AndroidConfig, ConfigPlugin, createRunOncePlugin } from 'expo/config-plugins';
+
+const pkg = require('expo-file-system/package.json');
+
+const withFileSystem: ConfigPlugin = (config) => {
+  return AndroidConfig.Permissions.withPermissions(config, [
+    'android.permission.READ_EXTERNAL_STORAGE',
+    'android.permission.WRITE_EXTERNAL_STORAGE',
+    'android.permission.INTERNET',
+  ]);
+};
+
+export default createRunOncePlugin(withFileSystem, pkg.name, pkg.version);

package/plugin/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "expo-module-scripts/tsconfig.plugin",
+  "compilerOptions": {
+    "outDir": "build",
+    "rootDir": "src"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}

package/plugin/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/withFileSystem.ts"],"version":"5.7.2"}

package/react-native.config.js

@@ -0,0 +1,21 @@
+module.exports = {
+    dependencies: {
+        '@amazon-devices/react-native-kepler': {
+            platforms: {
+                kepler: null,  // do not use platform definition from @react-native-kepler
+            },
+        },
+    },
+    dependency: {
+        platforms: {
+            kepler: {
+                autolink: {
+                    ExponentFileSystemLib: {
+                        provider: 'system',
+                        turbomodules: ['ExponentFileSystem'],
+                    },
+                },
+            },
+        },
+    },
+};

package/src/ExponentFileSystem.kepler.ts

@@ -0,0 +1,167 @@
+import { KeplerTurboModule, TurboModuleRegistry } from '@amazon-devices/keplerscript-turbomodule-api';
+
+import {
+  DeletingOptions,
+  DownloadOptions,
+  FileInfo,
+  FileSystemDownloadResult,
+  FileSystemUploadOptions,
+  FileSystemUploadResult,
+  InfoOptions,
+  MakeDirectoryOptions,
+  ReadingOptions,
+  RelocatingOptions,
+  WritingOptions,
+  FileSystemHttpResult,
+} from './FileSystem.types';
+import { ExponentFileSystemModule } from './types';
+
+interface Spec extends KeplerTurboModule {
+    readonly documentDirectory: () => string;
+    readonly cacheDirectory: () => string;
+    /**
+     * @deprecated this property was removed from expo
+     */
+    readonly bundledAssets: () => string;
+    readonly bundleDirectory: () => string;
+    readonly getInfoAsync: (fileUri: string, options: InfoOptions) => Promise<FileInfo>;
+    readonly readAsStringAsync: (fileUri: string, options: ReadingOptions) => Promise<string>;
+    readonly getContentUriAsync: (fileUri: string) => Promise<string>;
+    readonly writeAsStringAsync: (fileUri: string, contents: string, options: WritingOptions) => Promise<void>;
+    readonly writeArrayBufferAsync: (fileUri: string, contents: ArrayBuffer) => Promise<void>;
+    readonly deleteAsync: (fileUri: string, options: DeletingOptions) => Promise<void>;
+    readonly moveAsync: (options: RelocatingOptions) => Promise<void>;
+    readonly copyAsync: (options: RelocatingOptions) => Promise<void>;
+    readonly makeDirectoryAsync: (fileUri: string, options: MakeDirectoryOptions) => Promise<void>;
+    readonly readDirectoryAsync: (fileUri: string) => Promise<string[]>;
+    readonly getFreeDiskStorageAsync: () => Promise<string>;
+    readonly getTotalDiskCapacityAsync: () => Promise<string | undefined>;
+}
+
+const nativeModule = TurboModuleRegistry.getEnforcing<Spec>('ExponentFileSystem') as Spec;
+const expoCryptoNativeModule = TurboModuleRegistry.getEnforcing<any>('ExpoCrypto');
+
+function getHeadersFromResponse(response: Response): FileSystemHttpResult['headers'] {
+  const responseHeaders: FileSystemDownloadResult['headers'] = {};
+  response.headers.forEach((value: string, key: string) => {
+    responseHeaders[key] = value;
+  })
+  return responseHeaders;
+}
+
+function getMimeTypeFromHeaders(responseHeaders: FileSystemHttpResult['headers']): FileSystemHttpResult['mimeType'] {
+  const contentTypeKey = Object.keys(responseHeaders).find((key) => key.toLowerCase() === "content-type");
+  return contentTypeKey ? responseHeaders[contentTypeKey].split(';')[0] : null;
+}
+
+const module: ExponentFileSystemModule = {
+    get name(): 'ExponentFileSystem' {
+        return 'ExponentFileSystem';
+    },
+    get documentDirectory() {
+        return nativeModule.documentDirectory();
+    },
+    get cacheDirectory() {
+        return nativeModule.cacheDirectory();
+    },
+    /**
+     * @deprecated this property was removed from expo
+     */
+    get bundledAssets() {
+        return null;
+    },
+    get bundleDirectory() {
+        return nativeModule.bundleDirectory();
+    },
+    async getInfoAsync(fileUri: string, options: InfoOptions) {
+        return nativeModule.getInfoAsync(fileUri, options);
+    },
+    async readAsStringAsync(fileUri: string, options: ReadingOptions) {
+        return nativeModule.readAsStringAsync(fileUri, options);
+    },
+    async getContentUriAsync(fileUri: string) {
+        return nativeModule.getContentUriAsync(fileUri);
+    },
+    async writeAsStringAsync(fileUri: string, contents: string, options: WritingOptions) {
+        return nativeModule.writeAsStringAsync(fileUri, contents, options);
+    },
+    async deleteAsync(fileUri: string, options: DeletingOptions) {
+        return nativeModule.deleteAsync(fileUri, options);
+    },
+    async moveAsync(options: RelocatingOptions) {
+        return nativeModule.moveAsync(options);
+    },
+    async copyAsync(options: RelocatingOptions) {
+        return nativeModule.copyAsync(options);
+    },
+    async makeDirectoryAsync(fileUri: string, options: MakeDirectoryOptions) {
+        return nativeModule.makeDirectoryAsync(fileUri, options);
+    },
+    async readDirectoryAsync(fileUri: string) {
+        return nativeModule.readDirectoryAsync(fileUri);
+    },
+    async getFreeDiskStorageAsync() {
+        return nativeModule.getFreeDiskStorageAsync().then(parseInt);
+    },
+    async getTotalDiskCapacityAsync() {
+        const result = await nativeModule.getTotalDiskCapacityAsync();
+        return result ? parseInt(result) : 0;
+    },
+    async downloadAsync(url: string, fileUri: string, options: DownloadOptions): Promise<FileSystemDownloadResult> {
+      const { headers, md5 } = options;
+      const response = await fetch(url, { headers });
+
+      if (!response.ok) {
+        throw new Error('Failed to download the file!');
+      }
+
+      const data = await response.arrayBuffer();
+
+      await nativeModule.writeArrayBufferAsync(fileUri, data);
+
+      const responseHeaders = getHeadersFromResponse(response);
+
+      let downloadResult: FileSystemDownloadResult = {
+        uri: fileUri,
+        headers: responseHeaders,
+        status: response.status,
+        mimeType: getMimeTypeFromHeaders(responseHeaders)
+      };
+
+      if (md5) {
+        const md5ArrayBuffer = await expoCryptoNativeModule.digestAsync("MD5", data);
+        downloadResult.md5 = [...new Uint8Array(md5ArrayBuffer)]
+          .map(x => x.toString(16).padStart(2, '0'))
+          .join('');
+      }
+
+      return downloadResult;
+    },
+    async uploadAsync(url: string, fileUri: string, options: FileSystemUploadOptions): Promise<FileSystemUploadResult> {
+      const { headers, httpMethod } = options;
+      const method = httpMethod ?? "POST";
+
+      const data = await nativeModule.readAsStringAsync(fileUri, {});
+
+      const response = await fetch(url, { method, headers, body: data });
+
+      if (!response.ok) {
+        throw new Error('Failed to upload the file!');
+      }
+
+      const uploadResult = await response.text();
+
+      const responseHeaders = getHeadersFromResponse(response);
+
+      return {
+        body: uploadResult,
+        headers: responseHeaders,
+        status: response.status,
+        mimeType: getMimeTypeFromHeaders(responseHeaders)
+      };
+    },
+    addListener(eventName: string): void{},
+    removeListeners(count: number): void{},
+};
+
+export default module;