gdcore-tools 1.0.2 → 1.0.5

package/src/JsExtensionsLoader/LocalJsExtensionsFinder.js

@@ -18,9 +18,6 @@ const checkIfPathHasJsExtensionModule = (extensionFolderPath) => {
 };
 
 const findJsExtensionModules = (extensionsRoot) => {
-  console.info(
-    `Searching for JS extensions (file called JsExtension.js) in ${extensionsRoot}...`
-  );
   return new Promise(async (resolve, reject) => {
     const extensionFolders = await fs.readdirAsync(extensionsRoot);
 

package/src/LocalFileSystem.js

@@ -1,28 +1,28 @@
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
+const fs = require("fs-extra");
+const path = require("path");
+const os = require("os");
 
-exports.fs = {
-  mkDir: function(path) {
+module.exports.makeFS = (gd) => ({
+  mkDir: function (path) {
     try {
       fs.mkdirsSync(path);
     } catch (e) {
-      console.error('mkDir(' + path + ') failed: ' + e);
+      console.error("mkDir(" + path + ") failed: " + e);
       return false;
     }
     return true;
   },
-  dirExists: function(path) {
+  dirExists: function (path) {
     return fs.existsSync(path);
   },
-  clearDir: function(path) {
+  clearDir: function (path) {
     var files = [];
     var that = this;
     try {
       if (fs.existsSync(path)) {
         files = fs.readdirSync(path);
-        files.forEach(function(file) {
-          var curPath = path + '/' + file;
+        files.forEach(function (file) {
+          var curPath = path + "/" + file;
           if (fs.lstatSync(curPath).isDirectory()) {
             // recurse
             that.clearDir(curPath);
@@ -31,31 +31,31 @@ exports.fs = {
             try {
               fs.unlinkSync(curPath);
             } catch (e) {
-              console.error('fs.unlinkSync(' + curPath + ') failed: ' + e);
+              console.error("fs.unlinkSync(" + curPath + ") failed: " + e);
             }
           }
         });
       }
     } catch (e) {
-      console.error('clearDir(' + path + ') failed: ' + e);
+      console.error("clearDir(" + path + ") failed: " + e);
     }
   },
-  getTempDir: function() {
+  getTempDir: function () {
     return os.tmpdir();
   },
-  fileNameFrom: function(fullpath) {
+  fileNameFrom: function (fullpath) {
     if (this._isExternalURL(fullpath)) return fullpath;
 
     fullpath = this._translateURL(fullpath);
     return path.basename(fullpath);
   },
-  dirNameFrom: function(fullpath) {
-    if (this._isExternalURL(fullpath)) return '';
+  dirNameFrom: function (fullpath) {
+    if (this._isExternalURL(fullpath)) return "";
 
     fullpath = this._translateURL(fullpath);
     return path.dirname(fullpath);
   },
-  makeAbsolute: function(filename, baseDirectory) {
+  makeAbsolute: function (filename, baseDirectory) {
     if (this._isExternalURL(filename)) return filename;
 
     filename = this._translateURL(filename);
@@ -64,23 +64,23 @@ exports.fs = {
 
     return path.resolve(baseDirectory, path.normalize(filename));
   },
-  makeRelative: function(filename, baseDirectory) {
+  makeRelative: function (filename, baseDirectory) {
     if (this._isExternalURL(filename)) return filename;
 
     filename = this._translateURL(filename);
     return path.relative(baseDirectory, path.normalize(filename));
   },
-  isAbsolute: function(fullpath) {
+  isAbsolute: function (fullpath) {
     if (this._isExternalURL(fullpath)) return true;
 
     if (fullpath.length === 0) return true;
     fullpath = this._translateURL(fullpath);
     return (
-      (fullpath.length > 0 && fullpath.charAt(0) === '/') ||
-      (fullpath.length > 1 && fullpath.charAt(1) === ':')
+      (fullpath.length > 0 && fullpath.charAt(0) === "/") ||
+      (fullpath.length > 1 && fullpath.charAt(1) === ":")
     );
   },
-  copyFile: function(source, dest) {
+  copyFile: function (source, dest) {
     //URL are not copied.
     if (this._isExternalURL(source)) return true;
 
@@ -88,52 +88,52 @@ exports.fs = {
     try {
       if (source !== dest) fs.copySync(source, dest);
     } catch (e) {
-      console.error('copyFile(' + source + ', ' + dest + ') failed: ' + e);
+      console.error("copyFile(" + source + ", " + dest + ") failed: " + e);
       return false;
     }
     return true;
   },
-  writeToFile: function(file, contents) {
+  writeToFile: function (file, contents) {
     try {
       fs.outputFileSync(file, contents);
     } catch (e) {
-      console.error('writeToFile(' + file + ', ...) failed: ' + e);
+      console.error("writeToFile(" + file + ", ...) failed: " + e);
       return false;
     }
     return true;
   },
-  readFile: function(file) {
+  readFile: function (file) {
     try {
       var contents = fs.readFileSync(file);
       return contents.toString();
     } catch (e) {
-      console.error('readFile(' + file + ') failed: ' + e);
-      return '';
+      console.error("readFile(" + file + ") failed: " + e);
+      return "";
     }
   },
-  readDir: function(path, ext) {
+  readDir: function (path, ext) {
     ext = ext.toUpperCase();
-    var output = new _GD.VectorString();
+    var output = new gd.VectorString();
     try {
       var files = [];
       if (fs.existsSync(path)) {
         files = fs.readdirSync(path);
-        files.forEach(function(file) {
+        files.forEach(function (file) {
           if (
             ext.length === 0 ||
             file.toUpperCase().indexOf(ext, file.length - ext.length) !== -1
           ) {
-            output.push_back(path + '/' + file);
+            output.push_back(path + "/" + file);
           }
         });
       }
     } catch (e) {
-      console.error('readDir(' + path + ',' + ext + ') failed: ' + e);
+      console.error("readDir(" + path + "," + ext + ") failed: " + e);
     }
 
     return output;
   },
-  fileExists: function(filename) {
+  fileExists: function (filename) {
     filename = this._translateURL(filename);
     try {
       const stat = fs.statSync(filename);
@@ -142,17 +142,17 @@ exports.fs = {
       return false;
     }
   },
-  _isExternalURL: function(filename) {
-    return filename.substr(0, 4) === 'http' || filename.substr(0, 4) === 'ftp';
+  _isExternalURL: function (filename) {
+    return filename.substr(0, 4) === "http" || filename.substr(0, 4) === "ftp";
   },
   /**
    * Return the filename associated to the URL on the server, relative to the games directory.
    * (i.e: Transform g/mydirectory/myfile.png to mydirectory/myfile.png).
    */
-  _translateURL: function(filename) {
-    if (filename.substr(0, 2) === 'g/' || filename.substr(0, 2) === 'g\\')
+  _translateURL: function (filename) {
+    if (filename.substr(0, 2) === "g/" || filename.substr(0, 2) === "g\\")
       filename = filename.substr(2);
 
     return filename;
   },
-};
+});

package/src/WrappedGD.js

@@ -0,0 +1,138 @@
+const EventEmitter = require("events");
+const loadExtensions = require("./JsExtensionsLoader/LocalJsExtensionsLoader");
+const projectLoader = require("./LocalProjectOpener");
+const { makeLoader } = require("./EventsFunctionsExtensionsLoader/index");
+const {
+  makeLocalEventsFunctionCodeWriter,
+} = require("./EventsFunctionsExtensionsLoader/LocalEventsFunctionCodeWriter");
+const saveProject = require("./LocalProjectWriter");
+const assignIn = require("lodash/assignIn");
+const { getGD, getRuntimePath } = require("./downloadGD");
+const { join, resolve } = require("path");
+const { makeFS } = require("./LocalFileSystem");
+
+class WrappedGD extends EventEmitter {
+  constructor(version) {
+    super();
+
+    /**
+     * The raw gd namespace.
+     */
+    this.gd = null;
+
+    /**
+     * The GDevelop abstract file system.
+     * @private
+     */
+    this.fs = null;
+
+    /**
+     * The Events Functions loader
+     * @private
+     */
+    this.eventsFunctionsLoader = null;
+
+    /**
+     * The Events Functions loader.
+     * @private
+     */
+    this.eventsFunctionsWriter = makeLocalEventsFunctionCodeWriter();
+
+    /**
+     * The path to the current version.
+     * @private
+     */
+    this.versionPath = getRuntimePath(version);
+
+    // Begin async loading of GDCore and extensions
+    getGD(version, {
+      print: (message) => this.emit("print", message),
+      printErr: (e) => this.emit("error", e),
+      onAbort: (e) => this.emit("error", e),
+    })
+      .then((gd) => {
+        this.gd = gd;
+        return loadExtensions(
+          gd,
+          join(this.versionPath, "Runtime", "Extensions")
+        );
+      })
+      .then(() => {
+        this.fs = assignIn(new this.gd.AbstractFileSystemJS(), makeFS(this.gd));
+        this.eventsFunctionsLoader = makeLoader(
+          this.gd
+        ).loadProjectEventsFunctionsExtensions;
+      })
+      .then(() => this.emit("ready"))
+      .catch((e) => this.emit("initError", e));
+  }
+
+  /**
+   * Loads a project json file.
+   * @param {string} projectLocation The path to the json file
+   */
+  loadProject(projectLocation) {
+    return projectLoader
+      .loadProjectFiles(projectLocation)
+      .then((projectFile) => {
+        projectFile.content.properties.projectFile = projectLocation;
+        return projectLoader.loadSerializedProject(
+          this.gd,
+          projectFile.content
+        );
+      })
+      .then(async (project) => {
+        await this.reloadEventsFunctions(project);
+        project.setProjectFile(resolve(projectLocation));
+        return project;
+      });
+  }
+
+  /**
+   * Saves a project to a json file.
+   * @param {*} project The loaded project
+   * @param {string} [fileName] The name of the file to save. Defaults to "game.json".
+   * @param {string} [pathName] The path to save to. Defaults to "./".
+   */
+  saveProject(project, fileName, pathName) {
+    pathName = pathName || "./";
+    fileName = join(pathName, fileName || "game.json");
+    return saveProject(this.gd, project, fileName, pathName);
+  }
+
+  /**
+   * Exports a project.
+   * @param {*} project The loaded project.
+   * @param {string} outputDir The output directory.
+   * @param {Object<string>} options Options to pass to the exporter.
+   */
+  exportProject(project, outputDir, options) {
+    const gd = this.gd;
+    const exporter = new gd.Exporter(this.fs, this.versionPath);
+    const exportOptions = new gd.MapStringBoolean();
+    for (let key in options) {
+      exportOptions.set(key, options[key]);
+    }
+    exporter.exportWholePixiProject(project, outputDir, exportOptions);
+    exportOptions.delete();
+    exporter.delete();
+  }
+
+  /**
+   * Reload and generate events based extensions in a project.
+   * @param {*} project
+   */
+  reloadEventsFunctions(project) {
+    return this.eventsFunctionsLoader(project, this.eventsFunctionsWriter);
+  }
+
+  /**
+   * Returns the path to the runtime files.
+   * @returns {string}
+   */
+  getRuntimePath() {
+    return join(this.versionPath, "Runtime");
+  }
+}
+
+module.exports = WrappedGD;

package/src/downloadGD.js

@@ -1,18 +1,20 @@
-const https = require("follow-redirects").https;
 const fs = require("fs-extra-promise");
 const path = require("path");
 const { request } = require("@octokit/request");
-const StreamZip = require("node-stream-zip");
+const { https } = require("follow-redirects");
 
 const getRuntimePath = (version) => path.join(__dirname, "Versions", version);
 
-const downloadFile = (file, savePath) =>
+const downloadFile = (file, savePath, required = true) =>
   new Promise((resolve) => {
     https.get(file, function (response) {
       if (response.statusCode !== 200) {
-        throw new Error(
-          `❌ Cannot download ${file}! Error ${response.statusCode}: ${response.statusMessage}`
-        );
+        if (required)
+          throw new Error(
+            `❌ Cannot download ${file}! Error ${response.statusCode}: ${response.statusMessage}`
+          );
+        // Silently fail if the file is not required
+        else return resolve(true);
       }
       response.pipe(fs.createWriteStream(savePath)).addListener("close", () => {
         resolve();
@@ -49,6 +51,7 @@ const findLatestVersion = () => {
  * @param {string} versionTag The GDevelop version tag
  */
 const downloadVersion = async function (versionTag) {
+  const StreamZip = require("node-stream-zip");
   const tasks = [];
   const gdPath = getRuntimePath(versionTag);
 
@@ -63,14 +66,28 @@ const downloadVersion = async function (versionTag) {
     .then(() => fs.removeAsync(gdPath))
     .finally(() => fs.mkdirAsync(gdPath));
 
-  const commitHash = (
-    await request("GET /repos/4ian/GDevelop/git/ref/tags/{tag}", {
-      tag: versionTag,
+  let commit = (
+    await request("GET /repos/4ian/GDevelop/commits/{ref}", {
+      ref: (
+        await request("GET /repos/4ian/GDevelop/git/ref/tags/{tag}", {
+          tag: versionTag,
+        })
+      ).data.object.sha,
     })
-  ).data.object.sha;
+  ).data;
+
+  // Go up to the latest commit for which libGD.js was built
+  while (commit.commit.message.indexOf("[skip ci]") !== -1) {
+    commit = (
+      await request("GET /repos/4ian/GDevelop/commits/{ref}", {
+        ref: commit.parents[0].sha,
+      })
+    ).data;
+    console.log(commit.commit.message, commit.parents);
+  }
 
   // Fetch the file with the GDJS Runtime and extensions
-  console.info(`🕗 Starting download of GDevelop '${versionTag}'...`);
+  console.info(`🕗 Starting download of GDevelop Runtime '${versionTag}'...`);
   const zipPath = path.join(gdPath, "gd.zip");
   tasks.push(
     downloadFile(
@@ -78,15 +95,15 @@ const downloadVersion = async function (versionTag) {
       zipPath
     )
       .then(async () => {
-        console.info(`✅ Done downloading GDevelop '${versionTag}'`);
-        console.info(`🕗 Extracting GDevelop '${versionTag}'...`);
+        console.info(`✅ Done downloading GDevelop Runtime '${versionTag}'`);
+        console.info(`🕗 Extracting GDevelop Runtime '${versionTag}'...`);
         await fs.mkdirAsync(path.join(gdPath, "Runtime"));
         await fs.mkdirAsync(path.join(gdPath, "Runtime", "Extensions"));
         const zip = new StreamZip({
           file: zipPath,
           storeEntries: true,
         });
-        const prefix = `4ian-GDevelop-${commitHash.slice(0, 7)}/`;
+        const prefix = `4ian-GDevelop-${commit.sha.slice(0, 7)}/`;
         return Promise.all([
           new Promise((resolve) => {
             zip.on("ready", () => {
@@ -95,7 +112,10 @@ const downloadVersion = async function (versionTag) {
                 path.join(gdPath, "Runtime", "Extensions"),
                 (e) => {
                   if (e)
-                    console.error("❌ Error while extracting extensions! ", e);
+                    console.error(
+                      "❌ Error while extracting the GDevelop Runtime extensions! ",
+                      e
+                    );
                   else resolve();
                 }
               );
@@ -108,7 +128,10 @@ const downloadVersion = async function (versionTag) {
                 path.join(gdPath, "Runtime"),
                 (e) => {
                   if (e)
-                    console.error("❌ Error while extracting the runtime! ", e);
+                    console.error(
+                      "❌ Error while extracting the GDevelop Runtime! ",
+                      e
+                    );
                   else resolve();
                 }
               );
@@ -134,20 +157,31 @@ const downloadVersion = async function (versionTag) {
   // Download the fitting libGD version
   const libGDPath =
     "https://s3.amazonaws.com/gdevelop-gdevelop.js/master/commit/" +
-    commitHash +
+    commit.sha +
     "/";
-  console.info(`🕗 Starting download of libGD.js and libGD.js.mem...`);
+  console.info(`🕗 Starting download of GDevelop Core...`);
   tasks.push(
-    downloadFile(
-      libGDPath + "libGD.js",
-      path.join(gdPath, "libGD.js")
-    ).then(() => console.info(`✅ Done downloading libGD.js`))
+    downloadFile(libGDPath + "libGD.js", path.join(gdPath, "libGD.js")).then(
+      () => console.info(`✅ Done downloading libGD.js`)
+    )
   );
   tasks.push(
     downloadFile(
       libGDPath + "libGD.js.mem",
-      path.join(gdPath, "libGD.js.mem")
-    ).then(() => console.info(`✅ Done downloading libGD.js.mem`))
+      path.join(gdPath, "libGD.js.mem"),
+      false
+    ).then(
+      (errored) => !errored && console.info(`✅ Done downloading libGD.js.mem`)
+    )
+  );
+  tasks.push(
+    downloadFile(
+      libGDPath + "libGD.wasm",
+      path.join(gdPath, "libGD.wasm"),
+      false
+    ).then(
+      (errored) => !errored && console.info(`✅ Done downloading libGD.wasm`)
+    )
   );
 
   return Promise.all(tasks).then(() =>
@@ -161,7 +195,7 @@ const downloadVersion = async function (versionTag) {
  * Returning `gd` doesn't work, so a hacky workaround with global is used.
  * @param {string} [versionTag] The GDevelop version to use. If not precised, the latest is used.
  */
-const getGD = async function (versionTag) {
+const getGD = async function (versionTag, gdOptions) {
   const runtimePath = getRuntimePath(versionTag);
   // Download the version if it isn't present
   try {
@@ -171,10 +205,12 @@ const getGD = async function (versionTag) {
     await downloadVersion(versionTag).catch(console.error);
   }
 
-  await new Promise((resolve) => {
-    require(path.join(runtimePath, "libGD.js"))().then((GD) => {
-      global._GD = GD;
-      resolve();
+  const gd = require(path.join(runtimePath, "libGD.js"))(gdOptions);
+  return new Promise((resolve) => {
+    gd.then(() => {
+      // Make sure gd is not thenable as the promise would think it is one as well.
+      delete gd.then;
+      resolve(gd);
     });
   });
 };

package/src/index.js

@@ -1,116 +1,16 @@
-const loadExtensions = require("./JsExtensionsLoader/LocalJsExtensionsLoader");
-const projectLoader = require("./LocalProjectOpener");
-const eventsFunctionsLoader = require("./EventsFunctionsExtensionsLoader/index")
-  .loadProjectEventsFunctionsExtensions;
-const eventFunctionsWriter = require("./EventsFunctionsExtensionsLoader/LocalEventsFunctionCodeWriter")
-  .makeLocalEventsFunctionCodeWriter;
-const saveProject = require("./LocalProjectWriter");
-const localFileSystem = require("./LocalFileSystem").fs;
-const assignIn = require("lodash/assignIn");
-const { getGD, getRuntimePath, findLatestVersion } = require("./downloadGD");
-const { join, resolve } = require("path");
-
-class WrappedGD {
-  constructor(gd, versionPath) {
-    /**
-     * The raw gd namespace.
-     */
-    this.gd = gd;
-
-    /**
-     * The path to the current version.
-     * @private
-     */
-    this.versionPath = versionPath;
-  }
-
-  /**
-   * Loads a project json file.
-   * @param {string} projectLocation The path to the json file
-   */
-  loadProject(projectLocation) {
-    let project;
-    return projectLoader
-      .loadProjectFiles(projectLocation)
-      .then((projectFile) => {
-        projectFile.content.properties.projectFile = projectLocation;
-        return projectLoader.loadSerializedProject(
-          this.gd,
-          projectFile.content
-        );
-      })
-      .then((projectLoaded) => {
-        project = projectLoaded;
-        project.setProjectFile(resolve(projectLocation));
-        return eventsFunctionsLoader(project, eventFunctionsWriter());
-      })
-      .then(() => project);
-  }
-
-  /**
-   * Saves a project to a json file.
-   * @param {*} project The loaded project
-   * @param {string} [fileName] The name of the file to save. Defaults to "game.json".
-   * @param {string} [pathName] The path to save to. Defaults to "./".
-   */
-  saveProject(project, fileName, pathName) {
-    pathName = pathName || "./";
-    fileName = join(pathName, fileName || "game.json");
-    return saveProject(this.gd, project, fileName, pathName);
-  }
-
-  /**
-   * Exports a project.
-   * @param {*} project The loaded project.
-   * @param {string} outputDir The output directory.
-   * @param {Object<string>} options Options to pass to the exporter.
-   */
-  exportProject(project, outputDir, options) {
-    const gd = this.gd;
-    const fileSystem = assignIn(new gd.AbstractFileSystemJS(), localFileSystem);
-    const exporter = new gd.Exporter(fileSystem, this.versionPath);
-    const exportOptions = new gd.MapStringBoolean();
-    for (let key in options) {
-      exportOptions.set(key, options[key]);
-    }
-    exporter.exportWholePixiProject(project, outputDir, exportOptions);
-    exportOptions.delete();
-    exporter.delete();
-  }
-
-  /**
-   * Returns the path to the runtime files.
-   * @returns {string}
-   */
-  getRuntimePath() {
-    return join(this.path, "Runtime");
-  }
-}
+const { findLatestVersion } = require("./downloadGD");
+const WrappedGD = require("./WrappedGD");
 
 const loadGD = async (version) => {
-  let gd;
   if (version === undefined) version = await findLatestVersion();
-  return (
-    getGD(version)
-      .then(() => {
-        gd = global._GD;
-      })
-      .then(() => {
-        return loadExtensions(
-          gd,
-          join(getRuntimePath(version), "Runtime", "Extensions")
-        );
-      })
-      /*
-    .then(() => {
-      const exts = gd.JsPlatform.get().getAllPlatformExtensions();
-      for (let i = 0; i < exts.size(); i++) console.log(exts.at(i).getName());
-    })
-    */
-      .then(() => {
-        return new WrappedGD(gd, getRuntimePath(version));
-      })
-  );
+  return new Promise((resolve, reject) => {
+    const wgd = new WrappedGD(version);
+    wgd.once("ready", () => {
+      wgd.removeAllListeners();
+      resolve(wgd);
+    });
+    wgd.once("initError", reject);
+  });
 };
 
 module.exports = loadGD;