@qooxdoo/framework 8.0.0-beta.1 → 8.0.0-beta.2

package/source/class/qx/tool/compiler/cli/commands/Compile.js

@@ -33,6 +33,11 @@ qx.Class.define("qx.tool.compiler.cli.commands.Compile", {
   extend: qx.tool.compiler.cli.Command,
 
   statics: {
+    /**
+     * Creates and configures the CLI command for the compile subcommand
+     * @param clazz {Function} the class to instantiate as the command handler
+     * @return {Promise<qx.tool.cli.Command>} the configured command
+     */
     async createCliCommand(clazz = this) {
       let cmd = await qx.tool.compiler.cli.Command.createCliCommand(clazz);
       cmd.set({
@@ -420,14 +425,30 @@ qx.Class.define("qx.tool.compiler.cli.commands.Compile", {
   properties: {},
 
   members: {
+    /** @type{cliProgress.SingleBar|null} progress bar instance */
     __progressBar: null,
+    /** @type{qx.tool.compiler.makers.Maker[]|null} list of makers created from config */
     __makers: null,
+    /** @type{Object} map of namespace to Library instance */
     __libraries: null,
+    /** @type{Boolean} true if the output directory was created during this run */
     __outputDirWasCreated: false,
     /** @type {Boolean} Whether libraries have had their `.load()` method called yet */
     __librariesNotified: false,
 
-    /*
+    /** @type{String} the path to the root of the meta files by classname */
+    __metaDir: null,
+
+    /** @type{Boolean} whether the typescript output is enabled */
+    __typescriptEnabled: false,
+
+    /** @type{String} the name of the typescript file to generate, null = use default */
+    __typescriptFile: null,
+
+    /** @type{Boolean} whether the typescript watcher has already been attached (watch mode) */
+    __typescriptWatcherAttached: false,
+
+    /**
      * @Override
      */
     async process() {
@@ -830,17 +851,36 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           );
 
           watch.setConfigFilenames(arr);
+
+          if (this.__typescriptEnabled && target instanceof qx.tool.compiler.targets.SourceTarget && !this.__typescriptWatcherAttached) {
+            this.__typescriptWatcherAttached = true;
+            try {
+              await this.__attachTypescriptWatcher(watch);
+            } catch (ex) {
+              qx.tool.compiler.Console.error(ex);
+            }
+          }
+
           waiters.push(watch.start());
         }
       }
+
+      if (!this.argv.watch && this.__typescriptEnabled) {
+        try {
+          await this.__attachTypescriptWatcher(null);
+        } catch (ex) {
+          qx.tool.compiler.Console.error(ex);
+        }
+      }
+
       return qx.Promise.all(waiters);
     },
 
     /**
-     * Processes the configuration from a JSON data structure and creates a Maker
+     * Processes the configuration from a JSON data structure and creates Makers
      *
-     * @param data {Map}
-     * @return {Maker}
+     * @param data {Object} the compile.json configuration data
+     * @return {Promise<qx.tool.compiler.makers.Maker[]>}
      */
     async createMakersFromConfig(data) {
       const Console = qx.tool.compiler.Console.getInstance();
@@ -860,6 +900,16 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         delete data.babelOptions;
       }
 
+      if (qx.lang.Type.isBoolean(data?.meta?.typescript)) {
+        this.__typescriptEnabled = data.meta.typescript;
+      } else if (qx.lang.Type.isString(data?.meta?.typescript)) {
+        this.__typescriptEnabled = true;
+        this.__typescriptFile = path.relative(process.cwd(), path.resolve(data.meta.typescript));
+      }
+      if (this.argv.typescript === true) {
+        this.__typescriptEnabled = true;
+      }
+
       var argvAppNames = null;
       if (t.argv["app-name"]) {
         argvAppNames = {};
@@ -1049,6 +1099,14 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         }
       });
 
+      this.__metaDir = data.meta?.output;
+      if (!this.__metaDir && targetConfigs.length > 0) {
+        this.__metaDir = path.relative(
+          process.cwd(),
+          path.resolve(targetConfigs[0].outputPath, "../meta")
+        );
+      }
+
       /*
        * There is still only one target per maker, so convert our list of targetConfigs into an array of makers
        */
@@ -1516,6 +1574,80 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       return makers;
     },
 
+    /**
+     * Loads class metadata, generates TypeScript definitions, and (in watch mode) sets up a
+     * debounced file watcher that re-runs metadata parsing and TypeScript generation whenever
+     * a source file changes.  When `watch` is null the method performs a single one-shot run
+     * and returns immediately after writing the output.
+     *
+     * @param watch {qx.tool.compiler.cli.Watch|null} watcher instance in watch mode, or null for a one-shot compile
+     */
+    async __attachTypescriptWatcher(watch) {
+      qx.tool.compiler.Console.info(`Loading meta data ...`);
+      let metaDb = new qx.tool.compiler.MetaDatabase().set({ rootDir: this.__metaDir });
+      await metaDb.load(); // hydrates existing class metadata from disk; library map is rebuilt fresh below
+
+      metaDb.getDatabase().libraries = {};
+      const dirs = [];
+      for (let lib of Object.values(this.__libraries)) {
+        let dir = path.join(lib.getRootDir(), lib.getSourcePath());
+        metaDb.getDatabase().libraries[lib.getNamespace()] = { sourceDir: dir };
+        dirs.push(dir);
+      }
+      await metaDb.loadFromDirectories(dirs, { force: !!this.argv.clean });
+      await metaDb.save();
+
+      let tsWriter = null;
+      if (this.__typescriptEnabled) {
+        qx.tool.compiler.Console.info(`Generating typescript output ...`);
+        tsWriter = new qx.tool.compiler.targets.TypeScriptWriter(metaDb);
+        if (this.__typescriptFile) {
+          tsWriter.setOutputTo(this.__typescriptFile);
+        } else {
+          tsWriter.setOutputTo(path.join(this.__metaDir, "..", "qooxdoo.d.ts"));
+        }
+        await tsWriter.process();
+      }
+
+      if (!watch) {
+        return;
+      }
+
+      // Watch mode: re-run metadata and typescript on file changes
+      let classFiles = {};
+      let debounce = new qx.tool.utils.Debounce(async () => {
+        let filesParsed = false;
+        qx.tool.compiler.Console.info(`Loading meta data ...`);
+        let addFilePromises = [];
+        let arr = Object.keys(classFiles);
+        if (arr.length > 0) {
+          filesParsed = true;
+          classFiles = {};
+          arr.forEach(filename => {
+            addFilePromises.push(metaDb.addFile(filename));
+          });
+        }
+        if (filesParsed) {
+          qx.tool.compiler.Console.info(`Generating typescript output ...`);
+          await Promise.all(addFilePromises);
+          await metaDb.reparseAll();
+          await metaDb.save();
+          if (this.__typescriptEnabled) {
+            await tsWriter.process();
+          }
+        }
+      });
+
+      watch.addListener("fileChanged", evt => {
+        let data = evt.getData();
+        if (data.fileType == "source") {
+          let filename = data.library.getFilename(data.filename);
+          classFiles[filename] = true;
+          debounce.run();
+        }
+      });
+    },
+
     /**
      * Checks the dependencies of the current library
      * @param  {qx.tool.compiler.app.Library[]} libs
@@ -1663,10 +1795,9 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
     },
 
     /**
-     * Resolves the target class instance from the type name; accepts "source" or "build" or
-     * a class name
+     * Resolves the target class from the type name; accepts "source", "build", or a class
      * @param type {String}
-     * @returns {Maker}
+     * @returns {Function|null}
      */
     __resolveTargetClass(type) {
       if (!type) {
@@ -1711,7 +1842,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
      * Returns the makers for a given application name
      *
      * @param appName {String} the name of the application
-     * @return {Maker}
+     * @return {qx.tool.compiler.makers.Maker[]}
      */
     getMakersForApp(appName) {
       return this.__makers.filter(maker => {

package/source/class/qx/tool/compiler/cli/commands/Create.js

@@ -18,7 +18,6 @@
 ************************************************************************ */
 const fs = require("fs");
 const path = require("upath");
-const inquirer = require("inquirer");
 
 /**
  * Create a new qooxdoo project. This will assemble the information needed to create the
@@ -210,6 +209,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.Create", {
       // ask user for missing values
       let answers;
       try {
+        const { default: inquirer } = await import("inquirer");
         answers = await inquirer.prompt(questions);
       } catch (e) {
         throw new qx.tool.utils.Utils.UserError(e.message);

package/source/class/qx/tool/compiler/cli/commands/Serve.js

@@ -209,7 +209,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.Serve", {
         });
       }
       let config = this.getCompilerApi().getConfiguration();
-      let listenPort = config?.serve?.listenPort ?? this.argv.listenPort;
+      let listenPort = this.argv.listenPort ?? config?.serve?.listenPort;
       let server = http.createServer(app);
       this.fireDataEvent("beforeStart", {
         server: server,

package/source/class/qx/tool/compiler/cli/commands/Typescript.js

@@ -91,32 +91,6 @@ qx.Class.define("qx.tool.compiler.cli.commands.Typescript", {
         ig.add(exclude);
       }
 
-      const classFiles = [];
-
-      const scanImpl = async filename => {
-        let basename = path.basename(filename);
-        let stat = await fs.promises.stat(filename);
-        
-        // Check if this file/directory should be ignored
-        let relativePath = path.relative(process.cwd(), filename);
-        if (ig.ignores(relativePath)) {
-          return;
-        }
-        
-        if (stat.isFile() && basename.match(/\.js$/)) {
-          classFiles.push(filename);
-        } else if (
-          stat.isDirectory() &&
-          (basename == "." || basename[0] != ".")
-        ) {
-          let files = await fs.promises.readdir(filename);
-          for (let i = 0; i < files.length; i++) {
-            let subname = path.join(filename, files[i]);
-            await scanImpl(subname);
-          }
-        }
-      };
-
       let files = this.argv.files || [];
       if (files.length === 0) {
         if (fs.existsSync("Manifest.json")) {
@@ -137,18 +111,37 @@ qx.Class.define("qx.tool.compiler.cli.commands.Typescript", {
         qx.tool.compiler.Console.error("No files to process");
         process.exit(1);
       }
-      for (let file of files) {
-        await scanImpl(file);
-      }
 
       if (qx.core.Environment.get("qx.debug")) {
         if (this.argv.metaDebug) {
           this.argv.verbose = true;
-          if (classFiles.length > 1) {
-            console.log("Only one file can be processed in meta debug mode");
+          let target = files[0];
+          let stat = await fs.promises.stat(target);
+          if (stat.isDirectory()) {
+            const findFirst = async dir => {
+              for (let entry of await fs.promises.readdir(dir)) {
+                let full = path.join(dir, entry);
+                let s = await fs.promises.stat(full);
+                if (s.isFile() && entry.endsWith(".js")) {
+                  return full;
+                }
+                if (s.isDirectory() && entry[0] !== ".") {
+                  let found = await findFirst(full);
+                  if (found) {
+                    return found;
+                  }
+                }
+              }
+              return null;
+            };
+            target = await findFirst(target);
+            if (!target) {
+              qx.tool.compiler.Console.error("No .js file found for meta debug");
+              process.exit(1);
+            }
           }
           let meta = new qx.tool.compiler.MetaExtraction();
-          await meta.parse(classFiles[0]);
+          await meta.parse(target);
           meta.fixupJsDoc({ resolveType: type => type });
           console.log(JSON.stringify(meta.getMetaData(), null, 2));
           process.exit(0);
@@ -157,13 +150,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.Typescript", {
 
       let metaDb = new qx.tool.compiler.MetaDatabase();
       await metaDb.load();
-      for (let filename of classFiles) {
-        if (this.argv.verbose) {
-          qx.tool.compiler.Console.info(`Processing ${filename} ...`);
-        }
-        await metaDb.addFile(filename);
-      }
-      await metaDb.reparseAll();
+      await metaDb.loadFromDirectories(files, { ignore: ig, verbose: this.argv.verbose });
 
       let tsWriter = new qx.tool.compiler.targets.TypeScriptWriter(metaDb);
       if (this.argv.outputFilename) {

package/source/class/qx/tool/compiler/cli/commands/add/Script.js

@@ -20,7 +20,6 @@
 const fs = require("fs");
 const process = require("process");
 const path = require("upath");
-const inquirer = require("inquirer");
 /**
  * Add a new script file to the current project, to be loaded by the qooxdoo boot loader
  *
@@ -125,6 +124,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.add.Script", {
       }
       if ((await fs.existsAsync(resource_file_path)) && !this.argv.undo) {
         if (!this.argv.noninteractive) {
+          const { default: inquirer } = await import("inquirer");
           let question = {
             type: "confirm",
             name: "doOverwrite",

package/source/class/qx/tool/compiler/cli/commands/package/Publish.js

@@ -20,7 +20,6 @@ const path = require("upath");
 const process = require("process");
 const { Octokit } = require("@octokit/rest");
 const semver = require("semver");
-const inquirer = require("inquirer");
 const { glob } = require("glob");
 
 /**
@@ -148,6 +147,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.package.Publish", {
     async process() {
       // init
       const argv = this.argv;
+      const { default: inquirer } = await import("inquirer");
 
       // qooxdoo version
       let qxVersion = await this.getQxVersion();
@@ -521,6 +521,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.package.Publish", {
      * @private
      */
     async __createIndexFile(argv) {
+      const { default: inquirer } = await import("inquirer");
       if (argv.verbose && !argv.quiet) {
         qx.tool.compiler.Console.info("Creating index file...");
       }
@@ -552,7 +553,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.package.Publish", {
         let answer = await inquirer.prompt({
           name: "mainpath",
           message: "Please choose the main library",
-          type: "list",
+          type: "select",
           choices
         });
 

package/source/class/qx/tool/compiler/cli/commands/package/Update.js

@@ -18,13 +18,13 @@
 const process = require("process");
 const { Octokit } = require("@octokit/rest");
 const semver = require("semver");
-const inquirer = require("inquirer");
 const path = require("upath");
 
 /**
  * Updates the local cache with information of available library packages
  *
  * @ignore(Buffer.from)
+ * @ignore(fetch)
  */
 qx.Class.define("qx.tool.compiler.cli.commands.package.Update", {
   extend: qx.tool.compiler.cli.commands.Package,
@@ -120,6 +120,7 @@ qx.Class.define("qx.tool.compiler.cli.commands.package.Update", {
         await this.updateFromRepository();
       } else {
         if (!github.token) {
+          const { default: inquirer } = await import("inquirer");
           let response = await inquirer.prompt([
             {
               type: "input",
@@ -173,7 +174,6 @@ qx.Class.define("qx.tool.compiler.cli.commands.package.Update", {
       }
       let url = this.getRepositoryCacheUrl();
       try {
-        let fetch = (await import("node-fetch")).default;
         let res = await fetch(url);
         let data = await res.json();
         this.setCache(data);

package/source/class/qx/tool/compiler/targets/TypeScriptWriter.js

@@ -440,6 +440,9 @@ qx.Class.define("qx.tool.compiler.targets.TypeScriptWriter", {
 
       if (typeof typename == "object") {
         if ("type" in typename) {
+          if (!typename.type) {
+            return defaultType;
+          }
           const dimensions = typename.dimensions ?? 1;
           typename = typename.type + "[]".repeat(dimensions - 1);
         } else {

package/source/class/qx/tool/compiler/targets/meta/Browserify.js

@@ -80,7 +80,27 @@ qx.Class.define("qx.tool.compiler.targets.meta.Browserify", {
     async writeToDisk() {
       const localModules = this.getAppMeta().getApplication().getLocalModules();
       let db = this.getAppMeta().getAnalyser().getDatabase();
-      const { commonjsModules } = this.__getCommonjsModules();
+      const { commonjsModules, references } = this.__getCommonjsModules();
+
+      // Warn about missing npm modules on every compile, not just when the bundle is rebuilt
+      if (this.getAppMeta().getEnvironmentValue("qx.compiler.applicationType") == "browser") {
+        for (const moduleName of commonjsModules) {
+          try {
+            require.resolve(moduleName, { paths: [process.cwd()] });
+          } catch (_) {
+            const msg = [`WARNING: could not locate require()d module: "${moduleName}"`, "  required from:"];
+            const modRefs = references[moduleName];
+            if (modRefs) {
+              for (const mr of modRefs) {
+                for (const ref of mr) {
+                  msg.push("    " + ref);
+                }
+              }
+            }
+            qx.tool.compiler.Console.error(msg.join("\n"));
+          }
+        }
+      }
 
       let modules = [];
       let modulesInfo = {};
@@ -147,91 +167,133 @@ qx.Class.define("qx.tool.compiler.targets.meta.Browserify", {
       });
     },
 
-    __browserify(commonjsModules, references, localModules, ws) {
-      const babelify = require("babelify");
-      const preset = require("@babel/preset-env");
-      const browserify = require("browserify");
-      const builtins = require("browserify/lib/builtins.js");
-
-      // For some reason, `process` is not require()able, but `_process` is.
-      // Make them equivalent.
-      builtins.process = builtins._process;
-
-      return new Promise((resolve, reject) => {
-        const options = {
-          builtins: builtins,
-          ignoreMissing: true,
-          insertGlobals: true,
-          detectGlobals: true
-        };
-        qx.lang.Object.mergeWith(
-          options,
-          this.getAppMeta().getAnalyser().getBrowserifyConfig()?.options || {},
-          false
-        );
-        let b = browserify([], options);
+    async __browserify(commonjsModules, references, localModules, ws) {
+      const esbuild = require("esbuild");
+      const { polyfillNode } = require("esbuild-plugin-polyfill-node");
 
-        b._mdeps.on("missing", (id, parent) => {
-          let message = [];
-          message.push(`ERROR: could not locate require()d module: "${id}"`);
-          message.push("  required from:");
-          try {
-            [...references[id]].forEach(refs => {
-              refs.forEach(ref => {
-                message.push(`    ${ref}`);
-              });
-            });
-          } catch (e) {
-            message.push(`    <compile.json:application.localModules'>`);
-          }
-          qx.tool.compiler.Console.error(message.join("\n"));
-        });
+      // Convert a module name to a valid JS identifier
+      const safeName = name => "_m_" + name.replace(/[^a-zA-Z0-9_$]/g, "_");
 
-        // Include any dynamically determined `require()`d modules
-        if (commonjsModules.length > 0) {
-          b.require(commonjsModules);
+      // esbuild equivalent of browserify's ignoreMissing:true — logs a warning and
+      // returns an empty module stub so the bundle is still produced
+      const missingModulePlugin = {
+        name: "qx-missing-module",
+        setup(build) {
+          const onResolveHandler = async args => {
+            if (args.namespace === "qx-missing") { return null; }
+            const searchPaths = [args.resolveDir, process.cwd()].filter(Boolean);
+            for (const dir of searchPaths) {
+              try {
+                require.resolve(args.path, { paths: [dir] });
+                return null;
+              } catch (_) {}
+            }
+            return { path: args.path, namespace: "qx-missing" };
+          };
+          build.onResolve({ filter: /^[^./]/ }, onResolveHandler);
+          build.onLoad({ filter: /.*/, namespace: "qx-missing" }, args => ({
+            contents: `// Missing module: ${args.path}\nmodule.exports = {};`,
+            loader: "js"
+          }));
         }
+      };
 
-        // Include any local modules specified for the application
-        // in compile.json
-        if (localModules) {
-          for (let requireName in localModules) {
-            b.require(localModules[requireName], { expose: requireName });
-          }
+      const allModules = [
+        ...commonjsModules.map(m => ({ require: m, file: m })),
+        ...Object.entries(localModules || {}).map(([name, file]) => ({ require: name, file }))
+      ];
+
+      // Build a virtual entry that imports all required modules and exposes
+      // them via a global require() function compatible with Qooxdoo's runtime require() calls
+      const entryContent = [
+        ...allModules.map(m => `import * as ${safeName(m.require)} from ${JSON.stringify(m.file)};`),
+        `const __qx_mods = {`,
+        ...allModules.map(m => `  ${JSON.stringify(m.require)}: ${safeName(m.require)},`),
+        `};`,
+        `const __prev = typeof globalThis.require === "function" ? globalThis.require : null;`,
+        `globalThis.require = function(name) {`,
+        `  if (name in __qx_mods) return __qx_mods[name];`,
+        `  if (__prev) return __prev(name);`,
+        `  throw new Error("Module not found: " + name);`,
+        `};`
+      ].join("\n");
+
+      // Merge in any user-provided esbuild options from compile.json's "browserify" key
+      const browserifyConfig = this.getAppMeta().getAnalyser().getBrowserifyConfig() || {};
+      const userOptions = { ...(browserifyConfig.options || {}) };
+
+      // Filter out browserify-only options that esbuild doesn't understand
+      const BROWSERIFY_ONLY_OPTS = ["noParse", "ignoreMissing", "insertGlobals", "detectGlobals", "builtins"];
+      for (const opt of BROWSERIFY_ONLY_OPTS) {
+        if (opt in userOptions) {
+          qx.tool.compiler.Console.warn(
+            `WARNING: compile.json browserify.options.${opt} is a browserify-only option and is not supported by esbuild — it will be ignored.` +
+              (opt === "noParse" ? ' Use esbuild\'s "external" option instead if needed.' : "")
+          );
+          delete userOptions[opt];
         }
-        // Ensure ES6 local modules are converted to CommonJS format
-        b.transform(babelify, {
-          presets: [preset],
-          sourceMaps: false,
-          global: true
-        });
-
-        b.bundle(function (e, output) {
-          if (e) {
-            // THIS IS A HACK!
-            // In case of error dependency walker never returns from
-            // ```if (self.inputPending > 0) return setTimeout(resolve);```
-            // because inputPending is not decremented anymore.
-            // so set it to 0 here.
-            let d = b.pipeline.get("deps");
-            d.get(0).inputPending = 0;
-            qx.tool.compiler.Console.error(
-              `Unable to browserify - this is probably because a module is being require()'d which is not compatible with Browserify:\n${e.message}`
-            );
-
-            setTimeout(() => {
-              this.emit("end");
-            });
-            return;
+      }
+
+      // polyfillNode is enabled by default; set browserify.polyfillNode: false in compile.json to disable
+      const usePolyfillNode = browserifyConfig.polyfillNode !== false;
+
+      // Extract define and plugins manually (object rest destructuring is not supported by the qx parser)
+      const userDefine = userOptions.define || {};
+      const userPlugins = Array.isArray(userOptions.plugins) ? userOptions.plugins : [];
+      delete userOptions.define;
+      delete userOptions.plugins;
+      const basePlugins = usePolyfillNode ? [polyfillNode()] : [];
+
+      let result;
+      try {
+        result = await esbuild.build(
+          Object.assign(
+            {
+              stdin: {
+                contents: entryContent,
+                resolveDir: process.cwd()
+              },
+              bundle: true,
+              platform: "browser",
+              format: "iife",
+              write: false,
+              sourcemap: false,
+              logLevel: "silent",
+              // Preserve .name property of classes/functions even when esbuild renames bindings to
+              // avoid scope conflicts inside already-bundled packages (e.g. browserified bundles that
+              // have duplicate identifier names across inlined modules).
+              keepNames: true,
+              // Replace global with globalThis so Node.js packages using `global.<x>` work in browsers
+              define: Object.assign({ global: "globalThis" }, userDefine),
+              plugins: basePlugins.concat([missingModulePlugin], userPlugins)
+            },
+            userOptions
+          )
+        );
+      } catch (e) {
+        // Report missing/unresolvable modules with context from the analyser database
+        for (const err of e.errors || []) {
+          const id = err.text?.match(/Cannot resolve "([^"]+)"/)?.[1] || err.text;
+          let message = [`ERROR: could not bundle module: "${id || err.text}"`];
+          if (id && references[id]) {
+            message.push("  required from:");
+            try {
+              for (const refs of references[id]) {
+                for (const ref of refs) {
+                  message.push("    " + ref);
+                }
+              }
+            } catch (_) {}
           }
-          // in case of end event output can not be writen.
-          // so catch the error and ignore it
-          try {
-            ws.write(output);
-          } catch (err) {}
-          resolve(null);
-        });
-      });
+          qx.tool.compiler.Console.error(message.join("\n"));
+        }
+        qx.tool.compiler.Console.error(`Unable to bundle CommonJS modules: ${e.message}`);
+        return;
+      }
+
+      try {
+        ws.write(Buffer.from(result.outputFiles[0].contents));
+      } catch (_) {}
     },
 
     /**