godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-06 12:20:30 +00:00
Code Releases Wiki Activity

[HTML5] Run eslint --fix.

Browse Source 
Should I write a poem about this whole new world? ;)
This commit is contained in:
Fabio Alessandrelli
2020-11-23 13:27:13 +01:00
parent 0813008b8a
commit f316a1719d
13 changed files with 518 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
platform/javascript/js/libs/library_godot_os.js
View File

@@ -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');
},
};