[HTML5] Run eslint --fix.

Should I write a poem about this whole new world? ;)

1 files changed, 44 insertions, 45 deletions

diff --git a/platform/javascript/js/libs/library_godot_os.js b/platform/javascript/js/libs/library_godot_os.js
index 582f04cb1b..488753d704 100644
--- a/platform/javascript/js/libs/library_godot_os.js
+++ b/platform/javascript/js/libs/library_godot_os.js
@@ -33,23 +33,23 @@ const IDHandler = {
 		_last_id: 0,
 		_references: {},
 
-		get: function(p_id) {
+		get: function (p_id) {
 			return IDHandler._references[p_id];
 		},
 
-		add: function(p_data) {
+		add: function (p_data) {
 			const id = ++IDHandler._last_id;
 			IDHandler._references[id] = p_data;
 			return id;
 		},
 
-		remove: function(p_id) {
+		remove: function (p_id) {
 			delete IDHandler._references[p_id];
 		},
 	},
 };
 
-autoAddDeps(IDHandler, "$IDHandler");
+autoAddDeps(IDHandler, '$IDHandler');
 mergeInto(LibraryManager.library, IDHandler);
 
 const GodotConfig = {
@@ -57,12 +57,12 @@ const GodotConfig = {
 	$GodotConfig__deps: ['$GodotRuntime'],
 	$GodotConfig: {
 		canvas: null,
-		locale: "en",
+		locale: 'en',
 		resize_on_start: false,
 		on_execute: null,
 
-		init_config: function(p_opts) {
-			GodotConfig.resize_on_start = p_opts['resizeCanvasOnStart'] ? true : false;
+		init_config: function (p_opts) {
+			GodotConfig.resize_on_start = !!p_opts['resizeCanvasOnStart'];
 			GodotConfig.canvas = p_opts['canvas'];
 			GodotConfig.locale = p_opts['locale'] || GodotConfig.locale;
 			GodotConfig.on_execute = p_opts['onExecute'];
@@ -70,20 +70,20 @@ const GodotConfig = {
 			Module['onExit'] = p_opts['onExit']; // eslint-disable-line no-undef
 		},
 
-		locate_file: function(file) {
-			return Module["locateFile"](file); // eslint-disable-line no-undef
+		locate_file: function (file) {
+			return Module['locateFile'](file); // eslint-disable-line no-undef
 		},
 	},
 
-	godot_js_config_canvas_id_get: function(p_ptr, p_ptr_max) {
-		GodotRuntime.stringToHeap('#' + GodotConfig.canvas.id, p_ptr, p_ptr_max);
+	godot_js_config_canvas_id_get: function (p_ptr, p_ptr_max) {
+		GodotRuntime.stringToHeap(`#${GodotConfig.canvas.id}`, p_ptr, p_ptr_max);
 	},
 
-	godot_js_config_locale_get: function(p_ptr, p_ptr_max) {
+	godot_js_config_locale_get: function (p_ptr, p_ptr_max) {
 		GodotRuntime.stringToHeap(GodotConfig.locale, p_ptr, p_ptr_max);
 	},
 
-	godot_js_config_is_resize_on_start: function() {
+	godot_js_config_is_resize_on_start: function () {
 		return GodotConfig.resize_on_start ? 1 : 0;
 	},
 };
@@ -91,7 +91,6 @@ const GodotConfig = {
 autoAddDeps(GodotConfig, '$GodotConfig');
 mergeInto(LibraryManager.library, GodotConfig);
 
-
 const GodotFS = {
 	$GodotFS__deps: ['$FS', '$IDBFS', '$GodotRuntime'],
 	$GodotFS__postset: [
@@ -104,7 +103,7 @@ const GodotFS = {
 		_syncing: false,
 		_mount_points: [],
 
-		is_persistent: function() {
+		is_persistent: function () {
 			return GodotFS._idbfs ? 1 : 0;
 		},
 
@@ -112,7 +111,7 @@ const GodotFS = {
 		// Returns a promise that resolves when the FS is ready.
 		// We keep track of mount_points, so that we can properly close the IDBFS
 		// since emscripten is not doing it by itself. (emscripten GH#12516).
-		init: function(persistentPaths) {
+		init: function (persistentPaths) {
 			GodotFS._idbfs = false;
 			if (!Array.isArray(persistentPaths)) {
 				return Promise.reject(new Error('Persistent paths must be an array'));
@@ -133,16 +132,16 @@ const GodotFS = {
 				}
 			}
 
-			GodotFS._mount_points.forEach(function(path) {
+			GodotFS._mount_points.forEach(function (path) {
 				createRecursive(path);
 				FS.mount(IDBFS, {}, path);
 			});
-			return new Promise(function(resolve, reject) {
-				FS.syncfs(true, function(err) {
+			return new Promise(function (resolve, reject) {
+				FS.syncfs(true, function (err) {
 					if (err) {
 						GodotFS._mount_points = [];
 						GodotFS._idbfs = false;
-						GodotRuntime.print("IndexedDB not available: " + err.message);
+						GodotRuntime.print(`IndexedDB not available: ${err.message}`);
 					} else {
 						GodotFS._idbfs = true;
 					}
@@ -152,12 +151,12 @@ const GodotFS = {
 		},
 
 		// Deinit godot file system, making sure to unmount file systems, and close IDBFS(s).
-		deinit: function() {
-			GodotFS._mount_points.forEach(function(path) {
+		deinit: function () {
+			GodotFS._mount_points.forEach(function (path) {
 				try {
 					FS.unmount(path);
 				} catch (e) {
-					GodotRuntime.print("Already unmounted", e);
+					GodotRuntime.print('Already unmounted', e);
 				}
 				if (GodotFS._idbfs && IDBFS.dbs[path]) {
 					IDBFS.dbs[path].close();
@@ -169,16 +168,16 @@ const GodotFS = {
 			GodotFS._syncing = false;
 		},
 
-		sync: function() {
+		sync: function () {
 			if (GodotFS._syncing) {
 				GodotRuntime.error('Already syncing!');
 				return Promise.resolve();
 			}
 			GodotFS._syncing = true;
 			return new Promise(function (resolve, reject) {
-				FS.syncfs(false, function(error) {
+				FS.syncfs(false, function (error) {
 					if (error) {
-						GodotRuntime.error('Failed to save IDB file system: ' + error.message);
+						GodotRuntime.error(`Failed to save IDB file system: ${error.message}`);
 					}
 					GodotFS._syncing = false;
 					resolve(error);
@@ -187,9 +186,9 @@ const GodotFS = {
 		},
 
 		// Copies a buffer to the internal file system. Creating directories recursively.
-		copy_to_fs: function(path, buffer) {
-			const idx = path.lastIndexOf("/");
-			let dir = "/";
+		copy_to_fs: function (path, buffer) {
+			const idx = path.lastIndexOf('/');
+			let dir = '/';
 			if (idx > 0) {
 				dir = path.slice(0, idx);
 			}
@@ -201,7 +200,7 @@ const GodotFS = {
 				}
 				FS.mkdirTree(dir);
 			}
-			FS.writeFile(path, new Uint8Array(buffer), {'flags': 'wx+'});
+			FS.writeFile(path, new Uint8Array(buffer), { 'flags': 'wx+' });
 		},
 	},
 };
@@ -214,54 +213,54 @@ const GodotOS = {
 		'GodotOS._fs_sync_promise = Promise.resolve();',
 	].join(''),
 	$GodotOS: {
-		request_quit: function() {},
+		request_quit: function () {},
 		_async_cbs: [],
 		_fs_sync_promise: null,
 
-		atexit: function(p_promise_cb) {
+		atexit: function (p_promise_cb) {
 			GodotOS._async_cbs.push(p_promise_cb);
 		},
 
-		finish_async: function(callback) {
-			GodotOS._fs_sync_promise.then(function(err) {
+		finish_async: function (callback) {
+			GodotOS._fs_sync_promise.then(function (err) {
 				const promises = [];
-				GodotOS._async_cbs.forEach(function(cb) {
+				GodotOS._async_cbs.forEach(function (cb) {
 					promises.push(new Promise(cb));
 				});
 				return Promise.all(promises);
-			}).then(function() {
+			}).then(function () {
 				return GodotFS.sync(); // Final FS sync.
-			}).then(function(err) {
+			}).then(function (err) {
 				// Always deferred.
-				setTimeout(function() {
+				setTimeout(function () {
 					callback();
 				}, 0);
 			});
 		},
 	},
 
-	godot_js_os_finish_async: function(p_callback) {
+	godot_js_os_finish_async: function (p_callback) {
 		const func = GodotRuntime.get_func(p_callback);
 		GodotOS.finish_async(func);
 	},
 
-	godot_js_os_request_quit_cb: function(p_callback) {
+	godot_js_os_request_quit_cb: function (p_callback) {
 		GodotOS.request_quit = GodotRuntime.get_func(p_callback);
 	},
 
-	godot_js_os_fs_is_persistent: function() {
+	godot_js_os_fs_is_persistent: function () {
 		return GodotFS.is_persistent();
 	},
 
-	godot_js_os_fs_sync: function(callback) {
+	godot_js_os_fs_sync: function (callback) {
 		const func = GodotRuntime.get_func(callback);
 		GodotOS._fs_sync_promise = GodotFS.sync();
-		GodotOS._fs_sync_promise.then(function(err) {
+		GodotOS._fs_sync_promise.then(function (err) {
 			func();
 		});
 	},
 
-	godot_js_os_execute: function(p_json) {
+	godot_js_os_execute: function (p_json) {
 		const json_args = GodotRuntime.parseString(p_json);
 		const args = JSON.parse(json_args);
 		if (GodotConfig.on_execute) {
@@ -271,7 +270,7 @@ const GodotOS = {
 		return 1;
 	},
 
-	godot_js_os_shell_open: function(p_uri) {
+	godot_js_os_shell_open: function (p_uri) {
 		window.open(GodotRuntime.parseString(p_uri), '_blank');
 	},
 };