gdcore-tools 1.0.6 → 1.0.7

package/src/LocalFileSystem.js

@@ -1,158 +0,0 @@
-const fs = require("fs-extra");
-const path = require("path");
-const os = require("os");
-
-module.exports.makeFS = (gd) => ({
-  mkDir: function (path) {
-    try {
-      fs.mkdirsSync(path);
-    } catch (e) {
-      console.error("mkDir(" + path + ") failed: " + e);
-      return false;
-    }
-    return true;
-  },
-  dirExists: function (path) {
-    return fs.existsSync(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;
-          if (fs.lstatSync(curPath).isDirectory()) {
-            // recurse
-            that.clearDir(curPath);
-          } else {
-            // delete file
-            try {
-              fs.unlinkSync(curPath);
-            } catch (e) {
-              console.error("fs.unlinkSync(" + curPath + ") failed: " + e);
-            }
-          }
-        });
-      }
-    } catch (e) {
-      console.error("clearDir(" + path + ") failed: " + e);
-    }
-  },
-  getTempDir: function () {
-    return os.tmpdir();
-  },
-  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 "";
-
-    fullpath = this._translateURL(fullpath);
-    return path.dirname(fullpath);
-  },
-  makeAbsolute: function (filename, baseDirectory) {
-    if (this._isExternalURL(filename)) return filename;
-
-    filename = this._translateURL(filename);
-    if (!this.isAbsolute(baseDirectory))
-      baseDirectory = path.resolve(baseDirectory);
-
-    return path.resolve(baseDirectory, path.normalize(filename));
-  },
-  makeRelative: function (filename, baseDirectory) {
-    if (this._isExternalURL(filename)) return filename;
-
-    filename = this._translateURL(filename);
-    return path.relative(baseDirectory, path.normalize(filename));
-  },
-  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) === ":")
-    );
-  },
-  copyFile: function (source, dest) {
-    //URL are not copied.
-    if (this._isExternalURL(source)) return true;
-
-    source = this._translateURL(source);
-    try {
-      if (source !== dest) fs.copySync(source, dest);
-    } catch (e) {
-      console.error("copyFile(" + source + ", " + dest + ") failed: " + e);
-      return false;
-    }
-    return true;
-  },
-  writeToFile: function (file, contents) {
-    try {
-      fs.outputFileSync(file, contents);
-    } catch (e) {
-      console.error("writeToFile(" + file + ", ...) failed: " + e);
-      return false;
-    }
-    return true;
-  },
-  readFile: function (file) {
-    try {
-      var contents = fs.readFileSync(file);
-      return contents.toString();
-    } catch (e) {
-      console.error("readFile(" + file + ") failed: " + e);
-      return "";
-    }
-  },
-  readDir: function (path, ext) {
-    ext = ext.toUpperCase();
-    var output = new gd.VectorString();
-    try {
-      var files = [];
-      if (fs.existsSync(path)) {
-        files = fs.readdirSync(path);
-        files.forEach(function (file) {
-          if (
-            ext.length === 0 ||
-            file.toUpperCase().indexOf(ext, file.length - ext.length) !== -1
-          ) {
-            output.push_back(path + "/" + file);
-          }
-        });
-      }
-    } catch (e) {
-      console.error("readDir(" + path + "," + ext + ") failed: " + e);
-    }
-
-    return output;
-  },
-  fileExists: function (filename) {
-    filename = this._translateURL(filename);
-    try {
-      const stat = fs.statSync(filename);
-      return stat.isFile();
-    } catch (e) {
-      return false;
-    }
-  },
-  _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\\")
-      filename = filename.substr(2);
-
-    return filename;
-  },
-});

package/src/LocalProjectOpener.js

@@ -1,46 +0,0 @@
-const fs = require('fs');
-const path = require("path");
-const { unsplit } = require("./ObjectSplitter");
-
-module.exports = {
-  readProjectFile: (filepath) => {
-    return new Promise((resolve, reject) => {
-      if (!fs) return reject('Not supported');
-
-      fs.readFile(filepath, { encoding: 'utf8' }, (err, data) => {
-        if (err) return reject(err);
-
-        try {
-          const dataObject = JSON.parse(data);
-          return resolve(dataObject);
-        } catch (ex) {
-          return reject('Malformed file');
-        }
-      });
-    });
-  },
-  loadProjectFiles: (filePath) => {
-    const projectPath = path.dirname(filePath);
-    return module.exports.readProjectFile(filePath).then(object => {
-      return unsplit(object, {
-        getReferencePartialObject: referencePath => {
-          return module.exports.readProjectFile(path.join(projectPath, referencePath) + '.json');
-        },
-        isReferenceMagicPropertyName: '__REFERENCE_TO_SPLIT_OBJECT',
-        // Limit unsplitting to depth 3 (which would allow properties of layouts/external layouts/external events
-        // to be un-splitted, but not the content of these properties), to avoid very slow processing
-        // of large game files.
-        maxUnsplitDepth: 3,
-      }).then(() => {
-        return { content: object };
-      });
-    });
-  },
-  loadSerializedProject: (gd, projectObject) => {
-    const serializedProject = gd.Serializer.fromJSObject(projectObject);
-    const newProject = gd.ProjectHelper.createNewGDJSProject();
-    newProject.unserializeFrom(serializedProject);
-  
-    return newProject;
-  },
-};

package/src/LocalProjectWriter.js

@@ -1,96 +0,0 @@
-const { serializeToJSObject } = require("./Serializer");
-const {
-  split,
-  splitPaths,
-  getSlugifiedUniqueNameFromProperty,
-} = require("./ObjectSplitter");
-const fs = require("fs-extra-promise");
-const path = require("path");
-
-const checkFileContent = (filePath, expectedContent) => {
-  return new Promise((resolve, reject) => {
-    fs.readFile(filePath, { encoding: "utf8" }, (err, content) => {
-      if (err) return reject(err);
-
-      if (content === "") {
-        reject(new Error(`Written file is empty, did the write fail?`));
-      }
-      if (content !== expectedContent) {
-        reject(
-          new Error(
-            `Written file is not containing the expected content, did the write fail?`
-          )
-        );
-      }
-      resolve();
-    });
-  });
-};
-
-const writeJSONFile = (object, filePath) => {
-  try {
-    const content = JSON.stringify(object, null, 2);
-    if (content === "") {
-      return Promise.reject(
-        new Error("The content to save on disk is empty. Aborting.")
-      );
-    }
-
-    return fs
-      .ensureDirAsync(path.dirname(filePath))
-      .then(() => fs.writeFileAsync(filePath, content))
-      .then(() => checkFileContent(filePath, content));
-  } catch (stringifyException) {
-    return Promise.reject(stringifyException);
-  }
-};
-
-/**
- * Serializes and writes a json file for project
- * @param {*} gd
- * @param {*} project
- * @param {string} filePath
- * @param {string} projectPath
- */
-module.exports = (gd, project, filePath, projectPath) => {
-  const serializedProjectObject = serializeToJSObject(gd, project);
-
-  if (project.isFolderProject()) {
-    const partialObjects = split(serializedProjectObject, {
-      pathSeparator: "/",
-      getArrayItemReferenceName: getSlugifiedUniqueNameFromProperty("name"),
-      shouldSplit: splitPaths(
-        new Set([
-          "/layouts/*",
-          "/externalLayouts/*",
-          "/externalEvents/*",
-          "/layouts/*",
-          "/eventsFunctionsExtensions/*",
-        ])
-      ),
-      isReferenceMagicPropertyName: "__REFERENCE_TO_SPLIT_OBJECT",
-    });
-
-    return Promise.all(
-      partialObjects.map((partialObject) => {
-        return writeJSONFile(
-          partialObject.object,
-          path.join(projectPath, partialObject.reference) + ".json"
-        ).catch((err) => {
-          console.error("Unable to write a partial file:", err);
-          throw err;
-        });
-      })
-    ).then(() => {
-      return writeJSONFile(serializedProjectObject, filePath).catch((err) => {
-        console.error("Unable to write the split project:", err);
-        throw err;
-      });
-    });
-  } else {
-    return writeJSONFile(serializedProjectObject, filePath).catch((err) => {
-      console.error("Unable to write the project:", err);
-      throw err;
-    });
-  }
-};

package/src/MapFor.js

@@ -1,46 +0,0 @@
-// @flow
-// Note: this file does not use export/imports and use Flow comments to allow its usage from Node.js
-
-const mapFor = /*:: <T>*/ (
-  start /*: number */,
-  end /*: number */,
-  func /*: (number) => T */
-) /*:Array<T> */ => {
-  const result = [];
-  for (let i = start; i < end; i++) {
-    result.push(func(i));
-  }
-  return result;
-};
-
-const mapReverseFor = /*:: <T>*/ (
-  start /*: number */,
-  end /*: number */,
-  func /*: (number) => T */
-) /*:Array<T> */ => {
-  const result = [];
-  for (let i = end - 1; i >= start; i--) {
-    result.push(func(i));
-  }
-  return result;
-};
-
-/*flow-include
-type CppVector<T> = {
-  +size: () => number,
-  +at: (number) => T,
-}
-*/
-
-const mapVector = /*:: <T, U>*/ (
-  cppVector /*: CppVector<T> */,
-  func /*: (T, number) => U */
-) /*:Array<U> */ => {
-  return mapFor(0, cppVector.size(), i => func(cppVector.at(i), i));
-};
-
-module.exports = {
-  mapFor,
-  mapReverseFor,
-  mapVector,
-};

package/src/ObjectSplitter.js

@@ -1,187 +0,0 @@
-/**
- * Mutate the given object to split it into multiple partial objects.
- * Partial objects will be replaced by references.
- *
- * @param object The object to be split.
- * @param configuration Configuration to be used to split the object.
- */
-const split = (
-  object,
-  {
-    pathSeparator,
-    getArrayItemReferenceName,
-    shouldSplit,
-    isReferenceMagicPropertyName,
-  }
-) => {
-  const partialObjects = [];
-  const createReference = (reference, object) => {
-    partialObjects.push({
-      reference,
-      object,
-    });
-
-    return {
-      [isReferenceMagicPropertyName]: true,
-      referenceTo: reference,
-    };
-  };
-
-  const splitObject = (currentObject, currentPath, currentReference) => {
-    if (currentObject !== null && typeof currentObject === "object") {
-      if (Array.isArray(currentObject)) {
-        for (let index in currentObject) {
-          const itemPath = currentPath + pathSeparator + "*";
-          if (shouldSplit(itemPath)) {
-            const partialObject = currentObject[index];
-            const name = getArrayItemReferenceName(
-              partialObject,
-              currentReference
-            );
-            const itemReference = currentReference + pathSeparator + name;
-
-            currentObject[index] = createReference(
-              itemReference,
-              partialObject
-            );
-
-            splitObject(partialObject, itemPath, itemReference);
-          } else {
-            const itemReference = currentReference + pathSeparator + index;
-
-            splitObject(currentObject[index], itemPath, itemReference);
-          }
-        }
-      } else {
-        for (let propertyName in currentObject) {
-          const propertyPath = currentPath + pathSeparator + propertyName;
-          const propertyReference =
-            currentReference + pathSeparator + propertyName;
-          if (shouldSplit(propertyPath)) {
-            const partialObject = currentObject[propertyName];
-
-            currentObject[propertyName] = createReference(
-              propertyReference,
-              partialObject
-            );
-
-            splitObject(partialObject, propertyPath, propertyReference);
-          } else {
-            splitObject(
-              currentObject[propertyName],
-              propertyPath,
-              propertyReference
-            );
-          }
-        }
-      }
-    }
-  };
-
-  splitObject(object, "", "");
-  return partialObjects;
-};
-
-/**
- * Mutate the given object to recompose it from partial objects.
- * References to partial objects will be fetched as needed.
- *
- * @param object The object to be unsplit.
- * @param configuration Configuration to be used to unsplit the object.
- */
-const unsplit = (
-  object,
-  { isReferenceMagicPropertyName, getReferencePartialObject, maxUnsplitDepth }
-) => {
-  const isReference = (object) => {
-    if (object[isReferenceMagicPropertyName] === true) {
-      return object;
-    }
-
-    return null;
-  };
-
-  const unsplitObject = (currentObject, depth) => {
-    if (maxUnsplitDepth !== undefined && depth >= maxUnsplitDepth) {
-      return Promise.resolve();
-    }
-
-    if (currentObject !== null && typeof currentObject === "object") {
-      const keys = Object.keys(currentObject);
-      if (keys) {
-        return Promise.all(
-          keys.map((indexOrPropertyName) => {
-            const reference = isReference(currentObject[indexOrPropertyName]);
-            if (reference) {
-              return getReferencePartialObject(reference.referenceTo).then(
-                (partialObject) => {
-                  currentObject[indexOrPropertyName] = partialObject;
-
-                  return unsplitObject(
-                    currentObject[indexOrPropertyName],
-                    depth + 1
-                  );
-                }
-              );
-            }
-
-            return unsplitObject(currentObject[indexOrPropertyName], depth + 1);
-          })
-        ).then(() => {});
-      }
-    }
-
-    return Promise.resolve();
-  };
-
-  return unsplitObject(object, 0);
-};
-
-/**
- * A helper that can be used to split according to a list of hardcoded paths
- */
-const splitPaths = (paths) => {
-  return (path) => paths.has(path);
-};
-
-/**
- * A helper that can be used to get the name of items in array using an hardcoded property name.
- */
-const getNameFromProperty = (propertyName) => {
-  return (object) => {
-    const property = object[propertyName];
-    if (typeof property !== "string") {
-      throw new Error(`Property ${propertyName} is not a string`);
-    }
-
-    return property;
-  };
-};
-
-/**
- * A helper that can be used to get the name of items in array using an hardcoded property name.
- */
-const getSlugifiedUniqueNameFromProperty = (propertyName) => {
-  const existingNamesForReference = {};
-
-  return (object, currentReference) => {
-    const property = object[propertyName];
-    if (typeof property !== "string") {
-      throw new Error(`Property ${propertyName} is not a string`);
-    }
-
-    existingNamesForReference[currentReference] =
-      existingNamesForReference[currentReference] || {};
-    const newName = newNameGenerator(
-      slugs(property),
-      (name) => !!existingNamesForReference[currentReference][name]
-    );
-    existingNamesForReference[currentReference][newName] = true;
-    return newName;
-  };
-};
-
-module.exports.getSlugifiedUniqueNameFromProperty = getSlugifiedUniqueNameFromProperty;
-module.exports.splitPaths = splitPaths;
-module.exports.split = split;
-module.exports.unsplit = unsplit;

package/src/Serializer.js

@@ -1,35 +0,0 @@
-/**
- * Tool function to save a serializable object to a JS object.
- * Most gd.* objects are "serializable", meaning they have a serializeTo
- * and unserializeFrom method.
- *
- * @param {*} serializable
- * @param {*} methodName The name of the serialization method. "unserializeFrom" by default
- */
-module.exports.serializeToJSObject = function(gd, serializable, methodName) {
-  methodName = methodName || "serializeTo";
-  const serializedElement = new gd.SerializerElement();
-  serializable[methodName](serializedElement);
-  const object = JSON.parse(gd.Serializer.toJSON(serializedElement));
-  serializedElement.delete();
-
-  return object;
-}
-
-/**
- * Tool function to save a serializable object to a JSON.
- * Most gd.* objects are "serializable", meaning they have a serializeTo
- * and unserializeFrom method.
- *
- * @param {*} serializable
- * @param {*} methodName The name of the serialization method. "unserializeFrom" by default
- */
-module.exports.serializeToJSON = function(gd, serializable, methodName) {
-  methodName = methodName || "serializeTo";
-  const serializedElement = new gd.SerializerElement();
-  serializable[methodName](serializedElement);
-  const json = gd.Serializer.toJSON(serializedElement);
-  serializedElement.delete();
-
-  return json;
-}

package/src/build.js

@@ -1,51 +0,0 @@
-const esbuild = require("esbuild");
-
-/** @param {string} outPath */
-const renameBuiltFile = (outPath) => {
-  return outPath.replace(/\.ts$/, ".js");
-};
-
-/**
- * Builds the GDJS Runtime
- */
-module.exports = async (gdPath) => {
-  const {
-    getAllInOutFilePaths,
-    isUntransformedFile,
-  } = require("./runtime-files-list")(gdPath);
-  const esbuildService = await esbuild.startService();
-
-  // Generate the output file paths
-  const {
-    allGDJSInOutFilePaths,
-    allExtensionsInOutFilePaths,
-  } = await getAllInOutFilePaths();
-
-  // Build (or copy) all the files
-  let errored = false;
-  const startTime = Date.now();
-  await Promise.all(
-    [...allGDJSInOutFilePaths, ...allExtensionsInOutFilePaths].map(
-      async ({ inPath, outPath }) => {
-        const outfile = renameBuiltFile(outPath);
-        if (isUntransformedFile(inPath) || inPath === outfile) return;
-        return esbuildService
-          .build({
-            sourcemap: true,
-            entryPoints: [inPath],
-            outfile,
-            minify: true,
-          })
-          .catch(() => {
-            // Error is already logged by esbuild.
-            errored = true;
-          });
-      }
-    )
-  );
-
-  esbuildService.stop();
-  const buildDuration = Date.now() - startTime;
-  if (!errored) console.info(`✅ Runtime built in ${buildDuration}ms`);
-  else console.info(`❌ Error while building gdjs`);
-};