gdcore-tools 1.0.5 → 1.0.7

package/src/EventsFunctionsExtensionsLoader/index.js

@@ -1,451 +0,0 @@
-const { mapVector, mapFor } = require("../MapFor");
-const { caseSensitiveSlug } = require("../CaseSensitiveSlug");
-
-const mangleName = (name) => {
-  return caseSensitiveSlug(name, "_", []);
-};
-
-/** Generate the namespace for a free function. */
-const getFreeFunctionCodeNamespace = (eventsFunction, codeNamespacePrefix) => {
-  return codeNamespacePrefix + "__" + mangleName(eventsFunction.getName());
-};
-
-/** Generate the namespace for a behavior function. */
-const getBehaviorFunctionCodeNamespace = (
-  eventsBasedBehavior,
-  codeNamespacePrefix
-) => {
-  return codeNamespacePrefix + "__" + mangleName(eventsBasedBehavior.getName());
-};
-
-module.exports.makeLoader = (gd) => {
-  const {
-    declareInstructionOrExpressionMetadata,
-    declareBehaviorInstructionOrExpressionMetadata,
-    declareEventsFunctionParameters,
-    declareBehaviorMetadata,
-    declareExtension,
-    isBehaviorLifecycleEventsFunction,
-    isExtensionLifecycleEventsFunction,
-    declareBehaviorPropertiesInstructionAndExpressions,
-  } = require("./MetadataDeclarationHelpers")(gd);
-
-  const loader = {};
-
-  /**
-   * Load all events functions of a project in extensions
-   */
-  const loadProjectEventsFunctionsExtensions = (
-    project,
-    eventsFunctionCodeWriter
-  ) => {
-    return Promise.all(
-      // First pass: generate extensions from the events functions extensions,
-      // without writing code for the functions. This is useful as events in functions
-      // could be using other functions, which would not yet be available as
-      // extensions.
-      mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
-        return loadProjectEventsFunctionsExtension(
-          project,
-          project.getEventsFunctionsExtensionAt(i),
-          { skipCodeGeneration: true, eventsFunctionCodeWriter }
-        );
-      })
-    ).then(() =>
-      Promise.all(
-        // Second pass: generate extensions, including code.
-        mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
-          return loadProjectEventsFunctionsExtension(
-            project,
-            project.getEventsFunctionsExtensionAt(i),
-            {
-              skipCodeGeneration: false,
-              eventsFunctionCodeWriter,
-            }
-          );
-        })
-      )
-    );
-  };
-  loader.loadProjectEventsFunctionsExtensions =
-    loadProjectEventsFunctionsExtensions;
-
-  const loadProjectEventsFunctionsExtension = (
-    project,
-    eventsFunctionsExtension,
-    options
-  ) => {
-    return generateEventsFunctionExtension(
-      project,
-      eventsFunctionsExtension,
-      options
-    ).then((extension) => {
-      gd.JsPlatform.get().addNewExtension(extension);
-      extension.delete();
-    });
-  };
-
-  /**
-   * Get the list of mandatory include files when using the
-   * extension.
-   */
-  const getExtensionIncludeFiles = (
-    project,
-    eventsFunctionsExtension,
-    options,
-    codeNamespacePrefix
-  ) => {
-    return mapFor(
-      0,
-      eventsFunctionsExtension.getEventsFunctionsCount(),
-      (i) => {
-        const eventsFunction = eventsFunctionsExtension.getEventsFunctionAt(i);
-
-        if (isExtensionLifecycleEventsFunction(eventsFunction.getName())) {
-          const codeNamespace = getFreeFunctionCodeNamespace(
-            eventsFunction,
-            codeNamespacePrefix
-          );
-          const functionName = codeNamespace + ".func"; // TODO
-
-          return options.eventsFunctionCodeWriter.getIncludeFileFor(
-            functionName
-          );
-        }
-
-        return null;
-      }
-    ).filter(Boolean);
-  };
-
-  /**
-   * Generate the code for the events based extension
-   */
-  const generateEventsFunctionExtension = (
-    project,
-    eventsFunctionsExtension,
-    options
-  ) => {
-    const extension = new gd.PlatformExtension();
-    declareExtension(extension, eventsFunctionsExtension);
-
-    const codeNamespacePrefix =
-      "gdjs.evtsExt__" + mangleName(eventsFunctionsExtension.getName());
-
-    const extensionIncludeFiles = getExtensionIncludeFiles(
-      project,
-      eventsFunctionsExtension,
-      options,
-      codeNamespacePrefix
-    );
-    const codeGenerationContext = {
-      codeNamespacePrefix,
-      extensionIncludeFiles,
-    };
-
-    return Promise.all(
-      // Generate all behaviors and their functions
-      mapVector(
-        eventsFunctionsExtension.getEventsBasedBehaviors(),
-        (eventsBasedBehavior) => {
-          return generateBehavior(
-            project,
-            extension,
-            eventsFunctionsExtension,
-            eventsBasedBehavior,
-            options,
-            codeGenerationContext
-          );
-        }
-      )
-    )
-      .then(() =>
-        // Generate all free functions
-        Promise.all(
-          mapFor(0, eventsFunctionsExtension.getEventsFunctionsCount(), (i) => {
-            const eventsFunction =
-              eventsFunctionsExtension.getEventsFunctionAt(i);
-            return generateFreeFunction(
-              project,
-              extension,
-              eventsFunctionsExtension,
-              eventsFunction,
-              options,
-              codeGenerationContext
-            );
-          })
-        )
-      )
-      .then(() => extension);
-  };
-
-  const generateFreeFunction = (
-    project,
-    extension,
-    eventsFunctionsExtension,
-    eventsFunction,
-    options,
-    codeGenerationContext
-  ) => {
-    const instructionOrExpression = declareInstructionOrExpressionMetadata(
-      extension,
-      eventsFunctionsExtension,
-      eventsFunction
-    );
-    // By convention, first parameter is always the Runtime Scene.
-    instructionOrExpression.addCodeOnlyParameter("currentScene", "");
-    declareEventsFunctionParameters(eventsFunction, instructionOrExpression);
-
-    // Hide "lifecycle" functions as they are called automatically by
-    // the game engine.
-    if (isExtensionLifecycleEventsFunction(eventsFunction.getName())) {
-      instructionOrExpression.setHidden();
-    }
-
-    const codeNamespace = getFreeFunctionCodeNamespace(
-      eventsFunction,
-      codeGenerationContext.codeNamespacePrefix
-    );
-    const functionName = codeNamespace + ".func";
-
-    const codeExtraInformation =
-      instructionOrExpression.getCodeExtraInformation();
-    codeExtraInformation
-      .setIncludeFile(
-        options.eventsFunctionCodeWriter.getIncludeFileFor(functionName)
-      )
-      .setFunctionName(functionName);
-
-    // Always include the extension include files when using a free function.
-    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
-      codeExtraInformation.addIncludeFile(includeFile);
-    });
-
-    if (!options.skipCodeGeneration) {
-      const includeFiles = new gd.SetString();
-      const eventsFunctionsExtensionCodeGenerator =
-        new gd.EventsFunctionsExtensionCodeGenerator(project);
-      const code =
-        eventsFunctionsExtensionCodeGenerator.generateFreeEventsFunctionCompleteCode(
-          eventsFunction,
-          codeNamespace,
-          includeFiles,
-          // For now, always generate functions for runtime (this disables
-          // generation of profiling for groups (see EventsCodeGenerator))
-          // as extensions generated can be used either for preview or export.
-          true
-        );
-
-      // Add any include file required by the function to the list
-      // of include files for this function (so that when used, the "dependencies"
-      // are transitively included).
-      includeFiles
-        .toNewVectorString()
-        .toJSArray()
-        .forEach((includeFile) => {
-          codeExtraInformation.addIncludeFile(includeFile);
-        });
-
-      includeFiles.delete();
-
-      return options.eventsFunctionCodeWriter.writeFunctionCode(
-        functionName,
-        code
-      );
-    } else {
-      // Skip code generation if no events function writer is provided.
-      // This is the case during the "first pass", where all events functions extensions
-      // are loaded as extensions but not code generated, as events in functions could
-      // themselves be using functions that are not yet available in extensions.
-      return Promise.resolve();
-    }
-  };
-
-  function generateBehavior(
-    project,
-    extension,
-    eventsFunctionsExtension,
-    eventsBasedBehavior,
-    options,
-    codeGenerationContext
-  ) {
-    const behaviorMetadata = declareBehaviorMetadata(
-      extension,
-      eventsBasedBehavior
-    );
-
-    const eventsFunctionsContainer = eventsBasedBehavior.getEventsFunctions();
-    const codeNamespace = getBehaviorFunctionCodeNamespace(
-      eventsBasedBehavior,
-      codeGenerationContext.codeNamespacePrefix
-    );
-    const includeFile =
-      options.eventsFunctionCodeWriter.getIncludeFileFor(codeNamespace);
-
-    behaviorMetadata.setIncludeFile(includeFile);
-
-    // Always include the extension include files when using a behavior.
-    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
-      behaviorMetadata.addIncludeFile(includeFile);
-    });
-
-    return Promise.resolve().then(() => {
-      const behaviorMethodMangledNames = new gd.MapStringString();
-
-      // Declare the instructions/expressions for properties
-      declareBehaviorPropertiesInstructionAndExpressions(
-        behaviorMetadata,
-        eventsBasedBehavior
-      );
-
-      // Declare all the behavior functions
-      mapFor(0, eventsFunctionsContainer.getEventsFunctionsCount(), (i) => {
-        const eventsFunction = eventsFunctionsContainer.getEventsFunctionAt(i);
-
-        const eventsFunctionMangledName = mangleName(eventsFunction.getName());
-        behaviorMethodMangledNames.set(
-          eventsFunction.getName(),
-          eventsFunctionMangledName
-        );
-
-        const instructionOrExpression =
-          declareBehaviorInstructionOrExpressionMetadata(
-            behaviorMetadata,
-            eventsBasedBehavior,
-            eventsFunction
-          );
-        declareEventsFunctionParameters(
-          eventsFunction,
-          instructionOrExpression
-        );
-
-        // Hide "lifecycle" methods as they are called automatically by
-        // the game engine.
-        if (isBehaviorLifecycleEventsFunction(eventsFunction.getName())) {
-          instructionOrExpression.setHidden();
-        }
-
-        const codeExtraInformation =
-          instructionOrExpression.getCodeExtraInformation();
-        codeExtraInformation
-          .setIncludeFile(includeFile)
-          .setFunctionName(eventsFunctionMangledName);
-      });
-
-      // Generate code for the behavior and its methods
-      if (!options.skipCodeGeneration) {
-        const includeFiles = new gd.SetString();
-        const behaviorCodeGenerator = new gd.BehaviorCodeGenerator(project);
-        const code = behaviorCodeGenerator.generateRuntimeBehaviorCompleteCode(
-          eventsFunctionsExtension.getName(),
-          eventsBasedBehavior,
-          codeNamespace,
-          behaviorMethodMangledNames,
-          includeFiles,
-
-          // For now, always generate functions for runtime (this disables
-          // generation of profiling for groups (see EventsCodeGenerator))
-          // as extensions generated can be used either for preview or export.
-          true
-        );
-        behaviorCodeGenerator.delete();
-        behaviorMethodMangledNames.delete();
-
-        // Add any include file required by the functions to the list
-        // of include files for this behavior (so that when used, the "dependencies"
-        // are transitively included).
-        includeFiles
-          .toNewVectorString()
-          .toJSArray()
-          .forEach((includeFile) => {
-            behaviorMetadata.addIncludeFile(includeFile);
-          });
-
-        includeFiles.delete();
-
-        return options.eventsFunctionCodeWriter.writeBehaviorCode(
-          codeNamespace,
-          code
-        );
-      } else {
-        // Skip code generation
-        behaviorMethodMangledNames.delete();
-        return Promise.resolve();
-      }
-    });
-  }
-
-  /**
-   * Unload all extensions providing events functions of a project
-   */
-  const unloadProjectEventsFunctionsExtensions = (project) => {
-    return Promise.all(
-      mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
-        gd.JsPlatform.get().removeExtension(
-          project.getEventsFunctionsExtensionAt(i).getName()
-        );
-      })
-    );
-  };
-  loader.unloadProjectEventsFunctionsExtensions =
-    unloadProjectEventsFunctionsExtensions;
-
-  /**
-   * Given metadata about an instruction or an expression, tells if this was created
-   * from an event function.
-   */
-  const isAnEventFunctionMetadata = (instructionOrExpression) => {
-    const parametersCount = instructionOrExpression.getParametersCount();
-    if (parametersCount <= 0) return false;
-
-    return (
-      instructionOrExpression.getParameter(parametersCount - 1).getType() ===
-      "eventsFunctionContext"
-    );
-  };
-  loader.isAnEventFunctionMetadata = isAnEventFunctionMetadata;
-
-  /**
-   * Get back the name a function from its type.
-   * See also getFreeEventsFunctionType for the reverse operation.
-   */
-  const getFunctionNameFromType = (type) => {
-    const parts = type.split("::");
-    if (!parts.length)
-      return {
-        name: "",
-        behaviorName: "",
-        extensionName: "",
-      };
-
-    return {
-      name: parts[parts.length - 1],
-      behaviorName: parts.length > 2 ? parts[1] : undefined,
-      extensionName: parts[0],
-    };
-  };
-  loader.getFunctionNameFromType = getFunctionNameFromType;
-
-  /**
-   * Get the type of a Events Function.
-   * See also getFunctionNameFromType for the reverse operation.
-   */
-  const getFreeEventsFunctionType = (extensionName, eventsFunction) => {
-    return extensionName + "::" + eventsFunction.getName();
-  };
-  loader.getFreeEventsFunctionType = getFreeEventsFunctionType;
-
-  /**
-   * Return the index of the first parameter to be shown to the user:
-   * * 0 for a behavior "method",
-   * * 1 for a free function (as the first parameter is by convention the runtimeScene).
-   */
-  const getParametersIndexOffset = (isEventsBasedBehaviorMethod) => {
-    return isEventsBasedBehaviorMethod
-      ? 0 /*In the case of a behavior events function, the first two parameters are by convention the "Object" and "Behavior" */
-      : 1; /*In the case of a free events function (i.e: not tied to a behavior), the first parameter is by convention the current scene and is not shown.*/
-  };
-  loader.getParametersIndexOffset = getParametersIndexOffset;
-
-  return loader;
-};

package/src/JsExtensionsLoader/LocalJsExtensionsFinder.js

@@ -1,42 +0,0 @@
-const path = require("path");
-const fs = require("fs-extra-promise");
-
-const checkIfPathHasJsExtensionModule = (extensionFolderPath) => {
-  return new Promise((resolve) => {
-    const jsExtensionModulePath = path.join(
-      extensionFolderPath,
-      "JsExtension.js"
-    );
-    fs.stat(jsExtensionModulePath, (err, stats) => {
-      if (err) {
-        return resolve(null);
-      }
-
-      return resolve(stats.isFile() ? jsExtensionModulePath : null);
-    });
-  });
-};
-
-const findJsExtensionModules = (extensionsRoot) => {
-  return new Promise(async (resolve, reject) => {
-    const extensionFolders = await fs.readdirAsync(extensionsRoot);
-
-    const filteredExtensionFolders = extensionFolders.filter((folder) => {
-      return folder.indexOf("Example") === -1;
-    });
-
-    Promise.all(
-      filteredExtensionFolders.map((extensionFolder) =>
-        checkIfPathHasJsExtensionModule(
-          path.join(extensionsRoot, extensionFolder)
-        )
-      )
-    ).then((modulePaths) => {
-      resolve(modulePaths.filter((modulePath) => !!modulePath));
-    }, reject);
-  });
-};
-
-module.exports = {
-  findJsExtensionModules,
-};

package/src/JsExtensionsLoader/LocalJsExtensionsLoader.js

@@ -1,57 +0,0 @@
-const loadExtension = require("./index.js").loadExtension;
-const { findJsExtensionModules } = require("./LocalJsExtensionsFinder");
-
-const _ = (arg) => arg; // No translations
-
-/**
- * Loader that will load all JS Extensions.
- */
-module.exports = function loadExtensions(gd, extensionsRoot) {
-  return findJsExtensionModules(extensionsRoot).then(
-    (extensionModulePaths) => {
-      return Promise.all(
-        extensionModulePaths.map((extensionModulePath) => {
-          let extensionModule = null;
-          try {
-            extensionModule = require(extensionModulePath);
-          } catch (ex) {
-            return {
-              extensionModulePath,
-              result: {
-                message:
-                  "Unable to import extension. Please check for any syntax error or error that would prevent it from being run.",
-                error: true,
-                rawError: ex,
-              },
-            };
-          }
-
-          if (extensionModule) {
-            return {
-              extensionModulePath,
-              result: loadExtension(
-                _,
-                gd,
-                gd.JsPlatform.get(),
-                extensionModule
-              ),
-            };
-          }
-
-          return {
-            extensionModulePath,
-            result: {
-              error: true,
-              message:
-                "Unknown error. Please check for any syntax error or error that would prevent it from being run.",
-            },
-          };
-        })
-      );
-    },
-    (err) => {
-      console.error(`Unable to find JS extensions modules`);
-      throw err;
-    }
-  );
-};

package/src/JsExtensionsLoader/index.js

@@ -1,101 +0,0 @@
-const some = require("lodash/some");
-
-/**
- * Run extensions tests and check for any non-empty results.
- */
-const runExtensionSanityTests = (
-  gd /*: any */,
-  extension /*: gdPlatformExtension*/,
-  jsExtensionModule /*: JsExtensionModule*/
-) /*: ExtensionLoadingResult*/ => {
-  if (!jsExtensionModule.runExtensionSanityTests) {
-    return {
-      error: true,
-      message:
-        'Missing runExtensionSanityTests in the extension module exports',
-    };
-  }
-
-  const testResults = jsExtensionModule.runExtensionSanityTests(gd, extension);
-  if (some(testResults)) {
-    return {
-      error: true,
-      message: 'One or more tests are failing for the extension (see rawError)',
-      rawError: testResults,
-    };
-  }
-
-  return {
-    error: false,
-    message: 'Tests passed successfully',
-  };
-};
-
-/**
- * Load an extension from the specified JavaScript module, which is supposed
- * to contain a "createExtension" function returning a gd.PlatformExtension.
- */
-const loadExtension = (
-  _,
-  gd,
-  platform,
-  jsExtensionModule
-) => {
-  if (!jsExtensionModule.createExtension) {
-    return {
-      message:
-        'Extension module found, but no createExtension method is exported',
-      error: true,
-    };
-  }
-
-  let extension = null;
-  try {
-    extension = jsExtensionModule.createExtension(_, gd);
-    if (!extension) {
-      return {
-        message: `createExtension did not return any extension. Did you forget to return the extension created?`,
-        error: true,
-      };
-    }
-  } catch (ex) {
-    return {
-      message: `🚨 Exception caught while running createExtension. 💣 Please fix this error as this will make GDevelop crash at some point.`,
-      error: true,
-      dangerous: true,
-      rawError: ex,
-    };
-  }
-
-  try {
-    const testsResult = runExtensionSanityTests(
-      gd,
-      extension,
-      jsExtensionModule
-    );
-    if (testsResult.error) {
-      extension.delete();
-      return testsResult;
-    }
-  } catch (ex) {
-    return {
-      message: `🚨 Exception caught while running runExtensionSanityTests. 💣 Please fix this error as this will make GDevelop crash at some point.`,
-      error: true,
-      dangerous: true,
-      rawError: ex,
-    };
-  }
-
-  platform.addNewExtension(extension);
-  extension.delete(); // Release the extension as it was copied inside gd.JsPlatform
-
-  return {
-    message: '✅ Successfully loaded the extension.',
-    error: false,
-  };
-};
-
-module.exports = {
-  runExtensionSanityTests,
-  loadExtension,
-};