@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

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

@@ -13,12 +13,13 @@
 
    Authors:
      * John Spackman (john.spackman@zenesis.com, @johnspackman)
+     * Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
 
 ************************************************************************ */
 
-const process = require("process");
-const Gauge = require("gauge");
 const semver = require("semver");
+const process = require("process");
+const cliProgress = require("cli-progress");
 const path = require("upath");
 const consoleControl = require("console-control-strings");
 const fs = qx.tool.utils.Promisify.fs;
@@ -27,224 +28,292 @@ require("app-module-path").addPath(process.cwd() + "/node_modules");
 
 /**
  * Handles compilation of the project
- * @ignore(setImmediate)
  */
-qx.Class.define("qx.tool.cli.commands.Compile", {
-  extend: qx.tool.cli.commands.Command,
+qx.Class.define("qx.tool.compiler.cli.commands.Compile", {
+  extend: qx.tool.compiler.cli.Command,
 
   statics: {
-    YARGS_BUILDER: {
-      target: {
-        alias: "t",
-        describe:
-          "Set the target type: source or build or class name. Default is first target in config file",
-        requiresArg: true,
-        type: "string"
-      },
+    /**
+     * 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({
+        name: "compile",
+        description: "compiles the current application, using compile.json"
+      });
 
-      "output-path-prefix": {
-        describe:
-          "Sets a prefix for the output path of the target - used to compile a version into a non-standard directory",
-        type: "string"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("download").set({
+          shortCode: "d",
+          description: "Whether to automatically download missing libraries",
+          type: "boolean",
+          value: true
+        })
+      );
 
-      download: {
-        alias: "d",
-        describe: "Whether to automatically download missing libraries",
-        type: "boolean",
-        default: true
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("update-po-files").set({
+          shortCode: "u",
+          description:
+            "enables detection of translations and writing them out into .po files",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      locale: {
-        alias: "l",
-        describe: "Compile for a given locale",
-        nargs: 1,
-        requiresArg: true,
-        type: "string",
-        array: true
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("library-po").set({
+          description: "The policy for updating translations in libraries",
+          type: ["ignore", "untranslated", "all"],
+          value: "ignore"
+        })
+      );
 
-      "update-po-files": {
-        alias: "u",
-        describe:
-          "enables detection of translations and writing them out into .po files",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("write-all-translations").set({
+          description:
+            "enables output of all translations, not just those that are explicitly referenced",
+          type: "boolean"
+        })
+      );
 
-      "library-po": {
-        describe: "The policy for updating translations in libraries",
-        type: ["ignore", "untranslated", "all"],
-        default: "ignore"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("target").set({
+          shortCode: "t",
+          description:
+            "Set the target type: source or build or class name. Default is first target in config file",
+          required: true,
+          type: "string",
+          value: "source"
+        })
+      );
 
-      "write-all-translations": {
-        describe:
-          "enables output of all translations, not just those that are explicitly referenced",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("output-path-prefix").set({
+          description:
+            "Sets a prefix for the output path of the target - used to compile a version into a non-standard directory",
+          type: "string"
+        })
+      );
 
-      "app-class": {
-        describe: "sets the application class",
-        nargs: 1,
-        requiresArg: true,
-        type: "string"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("locale").set({
+          shortCode: "l",
+          description: "Compile for a given locale",
+          array: true,
+          type: "string",
+          value: ["en"]
+        })
+      );
 
-      "app-theme": {
-        describe: "sets the theme class for the current application",
-        nargs: 1,
-        requiresArg: true,
-        type: "string"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("app-class").set({
+          description: "sets the application class",
+          array: true,
+          type: "string"
+        })
+      );
 
-      "app-name": {
-        describe: "sets the name of the current application",
-        nargs: 1,
-        requiresArg: true,
-        type: "string"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("app-theme").set({
+          description: "sets the theme class for the current application",
+          array: true,
+          type: "string"
+        })
+      );
 
-      "app-group": {
-        describe: "which application groups to compile (defaults to all)",
-        nargs: 1,
-        requiresArg: true,
-        type: "string"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("app-name").set({
+          description: "sets the name of the current application",
+          array: true,
+          type: "string"
+        })
+      );
 
-      "local-fonts": {
-        describe: "whether to prefer local font files over CDN",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("app-group").set({
+          description: "which application groups to compile (defaults to all)",
+          type: "string"
+        })
+      );
 
-      watch: {
-        describe: "enables watching for changes and continuous compilation",
-        type: "boolean",
-        alias: "w"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("watch").set({
+          description:
+            "enables watching for changes and continuous compilation",
+          type: "boolean",
+          shortCode: "w",
+          value: false
+        })
+      );
 
-      "watch-debug": {
-        describe: "enables debug messages for watching",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("watch-debug").set({
+          description: "enables debug messages for watching",
+          type: "boolean",
+          value: false
+        })
+      );
+      
+      cmd.addFlag(
+        new qx.tool.cli.Flag("machine-readable").set({
+          shortCode: "M",
+          description: "output compiler messages in machine-readable format",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      "machine-readable": {
-        alias: "M",
-        describe: "output compiler messages in machine-readable format",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("minify").set({
+          shortCode: "m",
+          description: "disables minification (build targets only)",
+          type: ["off", "minify", "mangle", "beautify"],
+          value: "mangle"
+        })
+      );
 
-      minify: {
-        alias: "m",
-        describe: "disables minification (build targets only)",
-        choices: ["off", "minify", "mangle", "beautify"],
-        default: "mangle"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("mangle-privates").set({
+          description: "Whether to mangle private variables",
+          type: "boolean"
+        })
+      );
 
-      "mangle-privates": {
-        describe: "Whether to mangle private variables",
-        default: true,
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("save-source-in-map").set({
+          description:
+            "Saves the source code in the map file (build target only)",
+          type: "boolean"
+        })
+      );
 
-      "save-source-in-map": {
-        describe: "Saves the source code in the map file (build target only)",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("source-map-relative-paths").set({
+          description:
+            "If true, the source file will be saved in the map file if the target supports it. Can be overridden on a per application basis.",
+          type: "boolean"
+        })
+      );
 
-      "source-map-relative-paths": {
-        describe:
-          "If true, the source file will be saved in the map file if the target supports it. Can be overridden on a per application basis.",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("save-unminified").set({
+          shortCode: "u",
+          description:
+            "Saves a copy of the unminified version of output files (build target only)",
+          type: "boolean"
+        })
+      );
 
-      "save-unminified": {
-        alias: "u",
-        describe:
-          "Saves a copy of the unminified version of output files (build target only)",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("inline-external-scripts").set({
+          description: "Inlines external Javascript",
+          type: "boolean"
+        })
+      );
 
-      "inline-external-scripts": {
-        describe: "Inlines external Javascript",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("erase").set({
+          shortCode: "e",
+          description:
+            "Enabled automatic deletion of the output directory when compiler version or environment variables change",
+          type: "boolean",
+          value: true
+        })
+      );
 
-      erase: {
-        alias: "e",
-        describe:
-          "Enabled automatic deletion of the output directory when compiler version or environment variables change",
-        type: "boolean",
-        default: true
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("feedback").set({
+          description: "Shows progress bar feedback",
+          type: "boolean",
+          shortCode: "f",
+          value: false
+        })
+      );
 
-      feedback: {
-        describe: "Shows gas-gauge feedback",
-        type: "boolean",
-        alias: "f"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("typescript").set({
+          shortCode: "T",
+          description: "Outputs typescript definitions in qooxdoo.d.ts",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      typescript: {
-        alias: "T",
-        describe: "Outputs typescript definitions in qooxdoo.d.ts",
-        type: "boolean",
-        default: null
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("add-created-at").set({
+          description: "Adds code to populate object's $$createdAt",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      "add-created-at": {
-        describe: "Adds code to populate object's $$createdAt",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("clean").set({
+          shortCode: "D",
+          description: "Deletes the target dir before compile",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      "verbose-created-at": {
-        describe: "Adds additional detail to $$createdAt",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("warn-as-error").set({
+          shortCode: "w",
+          description: "Handle compiler warnings as error",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      clean: {
-        alias: "D",
-        describe: "Deletes the target dir before compile",
-        type: "boolean"
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("write-library-info").set({
+          shortCode: "I",
+          description:
+            "Write library information to the script, for reflection",
+          type: "boolean",
+          value: true
+        })
+      );
 
-      "warn-as-error": {
-        alias: "E",
-        describe: "Handle compiler warnings as error",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("write-compile-info").set({
+          description:
+            "Write application summary information to the script, used mostly for unit tests",
+          type: "boolean",
+          value: false
+        })
+      );
 
-      "write-library-info": {
-        alias: "I",
-        describe: "Write library information to the script, for reflection",
-        type: "boolean",
-        default: true
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("bundling").set({
+          shortCode: "b",
+          description: "Whether bundling is enabled",
+          type: "boolean",
+          value: true
+        })
+      );
 
-      "write-compile-info": {
-        describe:
-          "Write application summary information to the script, used mostly for unit tests",
-        type: "boolean",
-        default: false
-      },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("set").set({
+          description: "sets an environment value for the compiler",
+          type: "string",
+          array: true
+        })
+      );
 
-      bundling: {
-        alias: "b",
-        describe: "Whether bundling is enabled",
-        type: "boolean",
-        default: true
-      }
-    },
+      cmd.addFlag(
+        new qx.tool.cli.Flag("set-env").set({
+          description: "sets an environment value for the application",
+          type: "string",
+          array: true
+        })
+      );
 
-    getYargsCommand() {
-      return {
-        command: "compile",
-        describe: "compiles the current application, using compile.json",
-        builder: qx.tool.cli.commands.Compile.YARGS_BUILDER
-      };
+      return cmd;
     }
   },
 
@@ -281,13 +350,8 @@ qx.Class.define("qx.tool.cli.commands.Compile", {
      *
      * Note that target.getAppMeta() will return null after this event has been fired
      */
-    writtenApplications: "qx.event.type.Data",
 
-    /**
-     * Fired after writing of all meta data; data is an object containing:
-     *   maker {qx.tool.compiler.makers.Maker}
-     */
-    writtenMetaData: "qx.event.type.Data",
+    writtenApplications: "qx.event.type.Data",
 
     /**
      * Fired when a class is about to be compiled.
@@ -358,11 +422,19 @@ qx.Class.define("qx.tool.cli.commands.Compile", {
     minifiedApplication: "qx.event.type.Data"
   },
 
+  properties: {},
+
   members: {
-    __gauge: null,
+    /** @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,
@@ -370,16 +442,32 @@ qx.Class.define("qx.tool.cli.commands.Compile", {
     /** @type{Boolean} whether the typescript output is enabled */
     __typescriptEnabled: false,
 
-    /** @type{String} the name of the typescript file to generate */
+    /** @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() {
-      await super.process();
+      let configDb = await qx.tool.compiler.cli.ConfigDb.getInstance();
+      if (this.argv.set) {
+        this.argv.set.forEach(function (kv) {
+          var m = kv.match(/^([^=\s]+)(=(.+))?$/);
+          if (m) {
+            var key = m[1];
+            var value = m[3];
+            configDb.setOverride(key, value);
+          } else {
+            throw new qx.tool.utils.Utils.UserError(
+              `Failed to parse environment setting commandline option '--set ${kv}'`
+            );
+          }
+        });
+      }
 
-      let configDb = await qx.tool.cli.ConfigDb.getInstance();
       if (this.argv["feedback"] === null) {
         this.argv["feedback"] = configDb.db("qx.default.feedback", true);
       }
@@ -393,7 +481,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       if (this.argv["machine-readable"]) {
         qx.tool.compiler.Console.getInstance().setMachineReadable(true);
       } else {
-        let configDb = await qx.tool.cli.ConfigDb.getInstance();
         let color = configDb.db("qx.default.color", null);
         if (color) {
           let colorOn = consoleControl.color(color.split(" "));
@@ -408,20 +495,15 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         }
 
         if (this.argv["feedback"]) {
-          var themes = require("gauge/themes");
-          var ourTheme = themes.newTheme(
-            themes({ hasUnicode: true, hasColor: true })
-          );
-
           let colorOn = qx.tool.compiler.Console.getInstance().getColorOn();
-          ourTheme.preProgressbar = colorOn + ourTheme.preProgressbar;
-          ourTheme.preSubsection = colorOn + ourTheme.preSubsection;
-          ourTheme.progressbarTheme.postComplete += colorOn;
-          ourTheme.progressbarTheme.postRemaining += colorOn;
-
-          this.__gauge = new Gauge();
-          this.__gauge.setTheme(ourTheme);
-          this.__gauge.show("Compiling", 0);
+          
+          this.__progressBar = new cliProgress.SingleBar({
+            format: colorOn + 'Progress |{bar}| {percentage}% | {status}',
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+            hideCursor: true
+          });
+          this.__progressBar.start(100, 0, { status: 'Compiling' });
           const TYPES = {
             error: "ERROR",
             warning: "Warning"
@@ -430,60 +512,122 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           qx.tool.compiler.Console.getInstance().setWriter((str, msgId) => {
             msgId = qx.tool.compiler.Console.MESSAGE_IDS[msgId];
             if (!msgId || msgId.type !== "message") {
-              this.__gauge.hide();
+              this.__progressBar.stop();
               qx.tool.compiler.Console.log(
                 colorOn + TYPES[(msgId || {}).type || "error"] + ": " + str
               );
-
-              this.__gauge.show();
+              this.__progressBar.start(100, this.__progressBar.value || 0, { 
+                status: this.__progressBar.payload?.status || 'Compiling' 
+              });
             } else {
-              this.__gauge.show(colorOn + str);
+              this.__progressBar.update(this.__progressBar.value || 0, { status: colorOn + str });
             }
           });
         }
       }
+      let parsedArgs = {
+        target: this.argv.target,
+        outputPath: null,
+        locales: null,
+        writeAllTranslations: this.argv.writeAllTranslations,
+        environment: {},
+        verbose: this.argv.verbose
+      };
+
+      if (this.argv.locale && this.argv.locale.length) {
+        parsedArgs.locales = this.argv.locale;
+      }
+
+      if (this.argv["set-env"]) {
+        this.argv["set-env"].forEach(function (kv) {
+          var m = kv.match(/^([^=\s]+)(=(.+))?$/);
+          var key = m[1];
+          var value = m[3];
+          parsedArgs.environment[key] = value;
+        });
+      }
+
+      let targetType = this.getCompilerApi().getCommand().getTargetType();
+      let config = this.getCompilerApi().getConfiguration();
+
+      if (!config.locales) {
+        config.locales = [];
+      }
+      if (typeof parsedArgs.writeAllTranslations == "boolean") {
+        config.writeAllTranslations = parsedArgs.writeAllTranslations;
+      }
+
+      if (!config.environment) {
+        config.environment = {};
+      }
 
-      if (this.__gauge) {
+      // Set the environment variables coming from command line arguments
+      // in target's environment object. If that object doesn't exist create
+      // one and assign it to the target.
+      if (config.targets) {
+        const target = config.targets.find(
+          target => target.type === targetType
+        );
+
+        target.environment = target.environment || {};
+        qx.lang.Object.mergeWith(
+          target.environment,
+          parsedArgs.environment,
+          true
+        );
+      }
+
+      if (config.sass && config.sass.compiler !== undefined) {
+        qx.tool.compiler.resources.ScssConverter.USE_V6_COMPILER =
+          config.sass.compiler == "latest";
+      } else {
+        qx.tool.compiler.resources.ScssConverter.USE_V6_COMPILER = null;
+      }
+      if (config.sass && config.sass.copyOriginal) {
+        qx.tool.compiler.resources.ScssConverter.COPY_ORIGINAL_FILES = true;
+      }
+
+      if (this.__progressBar) {
         this.addListener("writingApplications", () =>
-          this.__gauge.show("Writing Applications", 0)
+          this.__progressBar.update(0, { status: "Writing Applications" })
         );
 
         this.addListener("writtenApplications", () =>
-          this.__gauge.show("Writing Applications", 1)
+          this.__progressBar.update(100, { status: "Writing Applications" })
         );
 
         this.addListener("writingApplication", evt =>
-          this.__gauge.pulse(
-            "Writing Application " +
+          this.__progressBar.increment({
+            status: "Writing Application " +
               evt.getData().appMeta.getApplication().getName()
-          )
+          })
         );
 
         this.addListener("compilingClass", evt =>
-          this.__gauge.pulse(
-            "Compiling " + evt.getData().classFile.getClassName()
-          )
+          this.__progressBar.increment({
+            status: "Compiling " + evt.getData().classFile.getClassName()
+          })
         );
 
         this.addListener("minifyingApplication", evt =>
-          this.__gauge.pulse(
-            "Minifying " +
+          this.__progressBar.increment({
+            status: "Minifying " +
               evt.getData().application.getName() +
               " " +
               evt.getData().filename
-          )
+          })
         );
       } else {
         this.addListener("writingApplication", evt => {
           let appInfo = evt.getData();
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.writingApplication",
+            "qx.tool.compiler.cli.compile.writingApplication",
             appInfo.appMeta.getApplication().getName()
           );
         });
         this.addListener("minifyingApplication", evt =>
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.minifyingApplication",
+            "qx.tool.compiler.cli.compile.minifyingApplication",
             evt.getData().application.getName(),
             evt.getData().filename
           )
@@ -491,18 +635,18 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       }
 
       this.addListener("making", evt => {
-        if (this.__gauge) {
-          this.__gauge.show("Compiling", 1);
+        if (this.__progressBar) {
+          this.__progressBar.update(100, { status: "Compiling" });
         } else {
-          qx.tool.compiler.Console.print("qx.tool.cli.compile.makeBegins");
+          qx.tool.compiler.Console.print("qx.tool.compiler.cli.compile.makeBegins");
         }
       });
 
       this.addListener("made", evt => {
-        if (this.__gauge) {
-          this.__gauge.show("Compiling", 1);
+        if (this.__progressBar) {
+          this.__progressBar.update(100, { status: "Compiling" });
         } else {
-          qx.tool.compiler.Console.print("qx.tool.cli.compile.makeEnds");
+          qx.tool.compiler.Console.print("qx.tool.compiler.cli.compile.makeEnds");
         }
       });
 
@@ -537,17 +681,17 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         ) {
           qx.tool.compiler.Console.warn(
             "   *******************************************************************************************\n" +
-              "   **                                                                                       **\n" +
-              "   **  Your compilation will include temporary files that are only necessary during         **\n" +
-              "   **  development; these files speed up the compilation, but take up space that you would  **\n" +
-              "   **  probably not want to put on a production server.                                     **\n" +
-              "   **                                                                                       **\n" +
-              "   **  When you are ready to deploy, try running `qx deploy` to get a minimised version     **\n" +
-              "   **                                                                                       **\n" +
-              "   *******************************************************************************************"
+            "   **                                                                                       **\n" +
+            "   **  Your compilation will include temporary files that are only necessary during         **\n" +
+            "   **  development; these files speed up the compilation, but take up space that you would  **\n" +
+            "   **  probably not want to put on a production server.                                     **\n" +
+            "   **                                                                                       **\n" +
+            "   **  When you are ready to deploy, try running `qx deploy` to get a minimised version     **\n" +
+            "   **                                                                                       **\n" +
+            "   *******************************************************************************************"
           );
         }
-        process.exitCode = success ? 0 : 1;
+        return success ? 0 : 1;
       }
     },
 
@@ -557,16 +701,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
      * @return {Boolean} true if all makers succeeded
      */
     async _loadConfigAndStartMaking() {
-      if (
-        !this.getCompilerApi().compileJsonExists() &&
-        !qx.tool.cli.Cli.getInstance().compileJsExists()
-      ) {
-        qx.tool.compiler.Console.error(
-          "Cannot find either compile.json nor compile.js"
-        );
-
-        process.exit(1);
-      }
       var config = this.getCompilerApi().getConfiguration();
       var makers = (this.__makers = await this.createMakersFromConfig(config));
       if (!makers || !makers.length) {
@@ -581,120 +715,115 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           this.dispatchEvent(evt.clone());
         }
       };
+      let waiters = [];
+      for await (const maker of makers) {
+        var analyser = maker.getAnalyser();
+        let cfg = await qx.tool.compiler.cli.ConfigDb.getInstance();
+        analyser.setWritePoLineNumbers(
+          cfg.db("qx.translation.strictPoCompatibility", false)
+        );
 
-      let isFirstWatcher = true;
+        if (!(await fs.existsAsync(maker.getOutputDir()))) {
+          this.__outputDirWasCreated = true;
+        }
+        if (this.argv["clean"]) {
+          await maker.eraseOutputDir();
+          await qx.tool.utils.files.Utils.safeUnlink(analyser.getDbFilename());
 
-      await qx.Promise.all(
-        makers.map(async maker => {
-          var analyser = maker.getAnalyser();
-          let cfg = await qx.tool.cli.ConfigDb.getInstance();
-          analyser.setWritePoLineNumbers(
-            cfg.db("qx.translation.strictPoCompatibility", false)
+          await qx.tool.utils.files.Utils.safeUnlink(
+            analyser.getResDbFilename()
           );
+        }
+        if (config.ignores) {
+          analyser.setIgnores(config.ignores);
+        }
 
-          if (!(await fs.existsAsync(maker.getOutputDir()))) {
-            this.__outputDirWasCreated = true;
-          }
-          if (this.argv["clean"]) {
-            await maker.eraseOutputDir();
-            await qx.tool.utils.files.Utils.safeUnlink(
-              analyser.getDbFilename()
-            );
+        var target = maker.getTarget();
+        analyser.addListener("compilingClass", e =>
+          this.dispatchEvent(e.clone())
+        );
 
-            await qx.tool.utils.files.Utils.safeUnlink(
-              analyser.getResDbFilename()
-            );
-          }
-          if (config.ignores) {
-            analyser.setIgnores(config.ignores);
-          }
+        analyser.addListener("compiledClass", e =>
+          this.dispatchEvent(e.clone())
+        );
 
-          var target = maker.getTarget();
-          analyser.addListener("compilingClass", e =>
-            this.dispatchEvent(e.clone())
-          );
+        analyser.addListener("saveDatabase", e =>
+          this.dispatchEvent(e.clone())
+        );
 
-          analyser.addListener("compiledClass", e =>
-            this.dispatchEvent(e.clone())
-          );
+        target.addListener("checkEnvironment", e =>
+          this.dispatchEvent(e.clone())
+        );
 
-          analyser.addListener("saveDatabase", e =>
+        let appInfos = [];
+        target.addListener("writingApplication", async () => {
+          let appInfo = {
+            maker,
+            target,
+            appMeta: target.getAppMeta()
+          };
+
+          appInfos.push(appInfo);
+          await this.fireDataEventAsync("writingApplication", appInfo);
+        });
+        target.addListener("writtenApplication", async () => {
+          await this.fireDataEventAsync("writtenApplication", {
+            maker,
+            target,
+            appMeta: target.getAppMeta()
+          });
+        });
+        maker.addListener("writingApplications", collateDispatchEvent);
+        maker.addListener("writtenApplications", async () => {
+          await this.fireDataEventAsync("writtenApplications", appInfos);
+        });
+
+        if (target instanceof qx.tool.compiler.targets.BuildTarget) {
+          target.addListener("minifyingApplication", e =>
             this.dispatchEvent(e.clone())
           );
 
-          target.addListener("checkEnvironment", e =>
+          target.addListener("minifiedApplication", e =>
             this.dispatchEvent(e.clone())
           );
+        }
+
+        let stat = await qx.tool.utils.files.Utils.safeStat(
+          "source/index.html"
+        );
 
-          let appInfos = [];
-          target.addListener("writingApplication", async () => {
-            let appInfo = {
-              maker,
-              target,
-              appMeta: target.getAppMeta()
-            };
+        if (stat) {
+          qx.tool.compiler.Console.print(
+            "qx.tool.compiler.cli.compile.legacyFiles",
+            "source/index.html"
+          );
+        }
 
-            appInfos.push(appInfo);
-            await this.fireDataEventAsync("writingApplication", appInfo);
-          });
-          target.addListener("writtenApplication", async () => {
-            await this.fireDataEventAsync("writtenApplication", {
-              maker,
-              target,
-              appMeta: target.getAppMeta()
-            });
+        // Setup event listeners for non-watch mode
+        if (!this.argv.watch) {
+          maker.addListener("making", () => {
+            countMaking++;
+            if (countMaking == 1) {
+              this.fireEvent("making");
+            }
           });
-          maker.addListener("writingApplications", collateDispatchEvent);
-          maker.addListener("writtenApplications", async () => {
-            await this.fireDataEventAsync("writtenApplications", appInfos);
+          maker.addListener("made", () => {
+            countMaking--;
+            if (countMaking == 0) {
+              this.fireEvent("made");
+            }
           });
+        }
 
-          if (target instanceof qx.tool.compiler.targets.BuildTarget) {
-            target.addListener("minifyingApplication", e =>
-              this.dispatchEvent(e.clone())
-            );
-
-            target.addListener("minifiedApplication", e =>
-              this.dispatchEvent(e.clone())
-            );
-          }
-
-          let stat =
-            await qx.tool.utils.files.Utils.safeStat("source/index.html");
-
-          if (stat) {
-            qx.tool.compiler.Console.print(
-              "qx.tool.cli.compile.legacyFiles",
-              "source/index.html"
-            );
-          }
-
-          // Simple one of make
-          if (!this.argv.watch) {
-            maker.addListener("making", () => {
-              countMaking++;
-              if (countMaking == 1) {
-                this.fireEvent("making");
-              }
-            });
-            maker.addListener("made", () => {
-              countMaking--;
-              if (countMaking == 0) {
-                this.fireEvent("made");
-              }
-            });
-
-            return await maker.make();
-          }
+        // Always make first
+        await maker.make();
 
-          // Continuous make
-          let watch = new qx.tool.cli.Watch(maker);
+        // Watch mode setup
+        if (this.argv.watch) {
+          let watch = new qx.tool.compiler.cli.Watch(maker);
           config.applications.forEach(appConfig => {
             if (appConfig.runWhenWatching) {
-              watch.setRunWhenWatching(
-                appConfig.name,
-                appConfig.runWhenWatching
-              );
+              watch.setRunWhenWatching(appConfig.name, appConfig.runWhenWatching);
             }
           });
           if (this.argv["watch-debug"]) {
@@ -723,11 +852,8 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
 
           watch.setConfigFilenames(arr);
 
-          if (
-            target instanceof qx.tool.compiler.targets.SourceTarget &&
-            isFirstWatcher
-          ) {
-            isFirstWatcher = false;
+          if (this.__typescriptEnabled && target instanceof qx.tool.compiler.targets.SourceTarget && !this.__typescriptWatcherAttached) {
+            this.__typescriptWatcherAttached = true;
             try {
               await this.__attachTypescriptWatcher(watch);
             } catch (ex) {
@@ -735,132 +861,26 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             }
           }
 
-          return watch.start();
-        })
-      );
+          waiters.push(watch.start());
+        }
+      }
 
-      if (!this.argv.watch) {
+      if (!this.argv.watch && this.__typescriptEnabled) {
         try {
           await this.__attachTypescriptWatcher(null);
         } catch (ex) {
           qx.tool.compiler.Console.error(ex);
         }
       }
-    },
-
-    async __attachTypescriptWatcher(watch) {
-      let classFiles = [];
-
-      // Scans a directory recursively to find all .js files
-      const scanImpl = async filename => {
-        let basename = path.basename(filename);
-        let stat = await fs.promises.stat(filename);
-        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);
-          }
-        }
-      };
-
-      // Do the initial scan
-      qx.tool.compiler.Console.info(`Loading meta data ...`);
-      let metaDb = new qx.tool.compiler.MetaDatabase().set({
-        rootDir: this.__metaDir
-      });
-
-      await metaDb.load();
-
-      // Scan all library directories
-      metaDb.getDatabase().libraries = {};
-      for (let lib of Object.values(this.__libraries)) {
-        let dir = path.join(lib.getRootDir(), lib.getSourcePath());
-        metaDb.getDatabase().libraries[lib.getNamespace()] = {
-          sourceDir: dir
-        };
-
-        await scanImpl(dir);
-      }
-
-      for (let filename of classFiles) {
-        await metaDb.addFile(filename, !!this.argv.clean);
-      }
-      await metaDb.reparseAll();
-      await metaDb.save();
-      await this.fireDataEventAsync("writtenMetaData", metaDb);
 
-      // Do the inital write
-      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;
-      }
-
-      // Redo the files that change, as they change
-      classFiles = {};
-      let debounce = new qx.tool.utils.Debounce(async () => {
-        let filesParsed = false;
-        qx.tool.compiler.Console.info(`Loading meta data ...`);
-        let addFilePromises = [];
-        while (true) {
-          let arr = Object.keys(classFiles);
-          if (arr.length == 0) {
-            break;
-          }
-          filesParsed = true;
-          classFiles = {};
-          arr.forEach(filename => {
-            if (this.argv.verbose) {
-              qx.tool.compiler.Console.info(
-                `Processing meta for ${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 for changes
-      watch.addListener("fileChanged", evt => {
-        let data = evt.getData();
-        if (data.fileType == "source") {
-          let filename = data.library.getFilename(data.filename);
-          classFiles[filename] = true;
-          debounce.run();
-        }
-      });
+      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 {qx.tool.compiler.makers.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();
@@ -870,11 +890,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           data.babel = data.babel || {};
           data.babel.options = data.babelOptions;
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.deprecatedBabelOptions"
+            "qx.tool.compiler.cli.compile.deprecatedBabelOptions"
           );
         } else {
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.deprecatedBabelOptionsConflicting"
+            "qx.tool.compiler.cli.compile.deprecatedBabelOptionsConflicting"
           );
         }
         delete data.babelOptions;
@@ -884,26 +904,25 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         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)
-        );
+        this.__typescriptFile = path.relative(process.cwd(), path.resolve(data.meta.typescript));
       }
-      if (qx.lang.Type.isBoolean(this.argv.typescript)) {
-        this.__typescriptEnabled = this.argv.typescript;
+      if (this.argv.typescript === true) {
+        this.__typescriptEnabled = true;
       }
 
       var argvAppNames = null;
       if (t.argv["app-name"]) {
         argvAppNames = {};
-        t.argv["app-name"]
+        let appNameStr = String(t.argv["app-name"]);
+        appNameStr
           .split(",")
           .forEach(name => (argvAppNames[name] = true));
       }
       var argvAppGroups = null;
       if (t.argv["app-group"]) {
         argvAppGroups = {};
-        t.argv["app-group"]
+        let appGroupStr = String(t.argv["app-group"]);
+        appGroupStr
           .split(",")
           .forEach(name => (argvAppGroups[name] = true));
       }
@@ -929,7 +948,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           ) {
             if (defaultTargetConfig) {
               qx.tool.compiler.Console.print(
-                "qx.tool.cli.compile.multipleDefaultTargets"
+                "qx.tool.compiler.cli.compile.multipleDefaultTargets"
               );
             } else {
               defaultTargetConfig = targetConfig;
@@ -979,8 +998,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             appTargetConfigs = [defaultTargetConfig];
           } else {
             throw new qx.tool.utils.Utils.UserError(
-              `Cannot find any suitable targets for application #${index} (named ${
-                appConfig.name || "unnamed"
+              `Cannot find any suitable targets for application #${index} (named ${appConfig.name || "unnamed"
               })`
             );
           }
@@ -1002,12 +1020,13 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       }
 
       let libraries = (this.__libraries = {});
-      let librariesArray = [];
-      for (let libPath of data.libraries) {
-        let library = await qx.tool.compiler.app.Library.createLibrary(libPath);
+      let libs = this.getCompilerApi().getLibraryApis();
+      for await (const lib of libs) {
+        var library = await qx.tool.compiler.app.Library.createLibrary(
+          lib.getRootDir()
+        );
 
         libraries[library.getNamespace()] = library;
-        librariesArray.push(library);
       }
 
       // Search for Qooxdoo library if not already provided
@@ -1016,7 +1035,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         let qxPath = await qx.tool.config.Utils.getQxPath();
         var library = await qx.tool.compiler.app.Library.createLibrary(qxPath);
         libraries[library.getNamespace()] = library;
-        librariesArray.push(library);
         qxLib = libraries["qx"];
       }
       if (this.argv.verbose) {
@@ -1051,7 +1069,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             let setDefault;
             if (appConfig.writeIndexHtmlToRoot !== undefined) {
               qx.tool.compiler.Console.print(
-                "qx.tool.cli.compile.deprecatedCompileSeeOther",
+                "qx.tool.compiler.cli.compile.deprecatedCompileSeeOther",
                 "application.writeIndexHtmlToRoot",
                 "application.default"
               );
@@ -1081,24 +1099,24 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         }
       });
 
-      /*
-       * There is still only one target per maker, so convert our list of targetConfigs into an array of makers
-       */
-      let targetOutputPaths = {};
-      let makers = [];
-
       this.__metaDir = data.meta?.output;
-      if (!this.__metaDir) {
+      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
+       */
+      let targetOutputPaths = {};
+      let makers = [];
+
       targetConfigs.forEach(targetConfig => {
         if (!targetConfig.appConfigs) {
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.unusedTarget",
+            "qx.tool.compiler.cli.compile.unusedTarget",
             targetConfig.type,
             targetConfig.index
           );
@@ -1146,15 +1164,15 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         }
 
         var targetClass = targetConfig.targetClass
-          ? this.resolveTargetClass(targetConfig.targetClass)
+          ? this.__resolveTargetClass(targetConfig.targetClass)
           : null;
         if (!targetClass && targetConfig.type) {
-          targetClass = this.resolveTargetClass(targetConfig.type);
+          targetClass = this.__resolveTargetClass(targetConfig.type);
         }
         if (!targetClass) {
           throw new qx.tool.utils.Utils.UserError(
             "Cannot find target class: " +
-              (targetConfig.targetClass || targetConfig.type)
+            (targetConfig.targetClass || targetConfig.type)
           );
         }
         /* eslint-disable new-cap */
@@ -1162,7 +1180,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         /* eslint-enable new-cap */
         if (targetConfig.uri) {
           qx.tool.compiler.Console.print(
-            "qx.tool.cli.compile.deprecatedUri",
+            "qx.tool.compiler.cli.compile.deprecatedUri",
             "target.uri",
             targetConfig.uri
           );
@@ -1184,18 +1202,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         target.setUpdatePoFiles(this.argv.updatePoFiles);
         target.setLibraryPoPolicy(this.argv.libraryPo);
 
-        let fontsConfig = targetConfig.fonts || {};
-        let preferLocalFonts = true;
-
-        if (this.argv.localFonts !== undefined) {
-          preferLocalFonts = this.argv.localFonts;
-        } else if (fontsConfig.local !== undefined) {
-          preferLocalFonts = fontsConfig.local;
-        }
-        target.setPreferLocalFonts(preferLocalFonts);
-        if (fontsConfig.fontTypes !== undefined) {
-          target.setFontTypes(fontsConfig.fontTypes);
-        }
         // Take the command line for `minify` as most precedent only if provided
         var minify;
         if (process.argv.indexOf("--minify") > -1) {
@@ -1321,26 +1327,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           maker.setWriteAllTranslations(data.writeAllTranslations);
         }
 
-        if (typeof targetConfig.typescript == "string") {
-          Console.warn(
-            "The 'typescript' property inside a target definition is deprecated - please see top level 'meta.typescript' property"
-          );
-
-          if (this.__typescriptFile) {
-            Console.warn(
-              "Multiple conflicting locations for the Typescript output - choosing to write to " +
-                this.__typescriptFile +
-                " and NOT " +
-                targetConfig.typescript
-            );
-          } else {
-            this.__typescriptEnabled = true;
-            this.__typescriptFile = path.relative(
-              process.cwd(),
-              path.resolve(targetConfig.typescript)
-            );
-          }
-        }
 
         if (data.environment) {
           maker.setEnvironment(data.environment);
@@ -1350,8 +1336,8 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         Libraries have to be added first because there is qx library
         which includes a framework version
         */
-        for (let library of librariesArray) {
-          maker.getAnalyser().addLibrary(library);
+        for (let ns in libraries) {
+          maker.getAnalyser().addLibrary(libraries[ns]);
         }
 
         let targetEnvironment = {
@@ -1412,16 +1398,12 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         );
         maker.getAnalyser().setBrowserifyConfig(browserifyConfig);
 
+
         var addCreatedAt =
           targetConfig["addCreatedAt"] || t.argv["addCreatedAt"];
         if (addCreatedAt) {
           maker.getAnalyser().setAddCreatedAt(true);
         }
-        const verboseCreatedAt =
-          targetConfig["verboseCreatedAt"] || t.argv["verboseCreatedAt"];
-        if (verboseCreatedAt) {
-          maker.getAnalyser().setVerboseCreatedAt(true);
-        }
 
         let allApplicationTypes = {};
         appConfigs.forEach(appConfig => {
@@ -1452,7 +1434,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           allApplicationTypes[app.getType()] = true;
           if (appConfig.uri) {
             qx.tool.compiler.Console.print(
-              "qx.tool.cli.compile.deprecatedUri",
+              "qx.tool.compiler.cli.compile.deprecatedUri",
               "application.uri",
               appConfig.uri
             );
@@ -1479,9 +1461,9 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             if (!parts.boot) {
               throw new qx.tool.utils.Utils.UserError(
                 "Cannot determine a boot part for application " +
-                  (appConfig.index + 1) +
-                  " " +
-                  (appConfig.name || "")
+                (appConfig.index + 1) +
+                " " +
+                (appConfig.name || "")
               );
             }
             for (var partName in parts) {
@@ -1592,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
@@ -1643,11 +1699,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             if (!fs.existsSync(qx.tool.config.Manifest.config.fileName)) {
               Console.error(
                 "Libraries are missing and there is no Manifest.json in the current directory so we cannot attempt to install them; the missing libraries are: \n     " +
-                  urisToInstall.join("\n     ") +
-                  "\nThe library which refers to the missing libraries is " +
-                  lib.getNamespace() +
-                  " in " +
-                  lib.getRootDir()
+                urisToInstall.join("\n     ") +
+                "\nThe library which refers to the missing libraries is " +
+                lib.getNamespace() +
+                " in " +
+                lib.getRootDir()
               );
 
               process.exit(1);
@@ -1660,11 +1716,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
                 )}...`
               );
             }
-            const installer = new qx.tool.cli.commands.package.Install({
+            const installer = new qx.tool.compiler.cli.commands.package.Install();
+            await installer.process({
               verbose: this.argv.verbose,
               save: false // save to lockfile only, not to manifest
             });
-            await installer.process();
             throw new qx.tool.utils.Utils.UserError(
               `Library ${lib.getNamespace()} requires ${urisToInstall.join(
                 ","
@@ -1739,12 +1795,11 @@ 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 {qx.tool.compiler.makers.Maker}
+     * @returns {Function|null}
      */
-    resolveTargetClass(type) {
+    __resolveTargetClass(type) {
       if (!type) {
         return null;
       }
@@ -1757,6 +1812,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       if (type == "source") {
         return qx.tool.compiler.targets.SourceTarget;
       }
+      if (type == "typescript") {
+        throw new qx.tool.utils.Utils.UserError(
+          "Typescript targets are no longer supported - please use `typescript: true` in source target instead"
+        );
+      }
       if (type) {
         var targetClass;
         if (type.indexOf(".") < 0) {
@@ -1772,37 +1832,17 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
     /**
      * Returns the list of makers to make
      *
-     * @return  {qx.tool.compiler.makers.Maker[]}
+     * @return  {Maker[]}
      */
     getMakers() {
       return this.__makers;
     },
 
-    /**
-     * Returns the one maker; this is for backwards compatibility with the compiler API, because it is
-     * possible to define multiple targets and therefore have multiple makers.  This method will return
-     * the one maker, when there is only one maker defined (ie one target), which is fine for any existing
-     * configurations.
-     *
-     * @deprected
-     * @return {qx.tool.compiler.makers.Maker}
-     */
-    getMaker() {
-      if (this.__makers.length == 1) {
-        return this.__makers[0];
-      }
-      throw new Error(
-        "Cannot get a single maker - there are " +
-          this.__makers.length +
-          " available"
-      );
-    },
-
     /**
      * Returns the makers for a given application name
      *
      * @param appName {String} the name of the application
-     * @return {qx.tool.compiler.makers.Maker}
+     * @return {qx.tool.compiler.makers.Maker[]}
      */
     getMakersForApp(appName) {
       return this.__makers.filter(maker => {
@@ -1814,7 +1854,7 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
     /**
      * Returns a list of libraries which are used
      *
-     * @return {qx.tool.compiler.app.Library[]}
+     * @return {Library[]}
      */
     getLibraries() {
       return this.__libraries;
@@ -1823,35 +1863,35 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
 
   defer(statics) {
     qx.tool.compiler.Console.addMessageIds({
-      "qx.tool.cli.compile.writingApplication": "Writing application %1",
-      "qx.tool.cli.compile.minifyingApplication": "Minifying %1 %2",
-      "qx.tool.cli.compile.compilingClass": "Compiling class %1",
-      "qx.tool.cli.compile.compiledClass": "Compiled class %1 in %2s",
-      "qx.tool.cli.compile.makeBegins": "Making applications...",
-      "qx.tool.cli.compile.makeEnds": "Applications are made"
+      "qx.tool.compiler.cli.compile.writingApplication": "Writing application %1",
+      "qx.tool.compiler.cli.compile.minifyingApplication": "Minifying %1 %2",
+      "qx.tool.compiler.cli.compile.compilingClass": "Compiling class %1",
+      "qx.tool.compiler.cli.compile.compiledClass": "Compiled class %1 in %2s",
+      "qx.tool.compiler.cli.compile.makeBegins": "Making applications...",
+      "qx.tool.compiler.cli.compile.makeEnds": "Applications are made"
     });
 
     qx.tool.compiler.Console.addMessageIds(
       {
-        "qx.tool.cli.compile.multipleDefaultTargets":
+        "qx.tool.compiler.cli.compile.multipleDefaultTargets":
           "Multiple default targets found!",
-        "qx.tool.cli.compile.unusedTarget":
+        "qx.tool.compiler.cli.compile.unusedTarget":
           "Target type %1, index %2 is unused",
-        "qx.tool.cli.compile.selectingDefaultApp":
+        "qx.tool.compiler.cli.compile.selectingDefaultApp":
           "You have multiple applications, none of which are marked as 'default'; the first application named %1 has been chosen as the default application",
-        "qx.tool.cli.compile.legacyFiles":
+        "qx.tool.compiler.cli.compile.legacyFiles":
           "File %1 exists but is no longer used",
-        "qx.tool.cli.compile.deprecatedCompile":
+        "qx.tool.compiler.cli.compile.deprecatedCompile":
           "The configuration setting %1 in compile.json is deprecated",
-        "qx.tool.cli.compile.deprecatedCompileSeeOther":
+        "qx.tool.compiler.cli.compile.deprecatedCompileSeeOther":
           "The configuration setting %1 in compile.json is deprecated (see %2)",
-        "qx.tool.cli.compile.deprecatedUri":
+        "qx.tool.compiler.cli.compile.deprecatedUri":
           "URIs are no longer set in compile.json, the configuration setting %1=%2 in compile.json is ignored (it's auto detected)",
-        "qx.tool.cli.compile.deprecatedProvidesBoot":
+        "qx.tool.compiler.cli.compile.deprecatedProvidesBoot":
           "Manifest.Json no longer supports provides.boot - only Applications can have boot; specified in %1",
-        "qx.tool.cli.compile.deprecatedBabelOptions":
+        "qx.tool.compiler.cli.compile.deprecatedBabelOptions":
           "Deprecated use of `babelOptions` - these should be moved to `babel.options`",
-        "qx.tool.cli.compile.deprecatedBabelOptionsConflicting":
+        "qx.tool.compiler.cli.compile.deprecatedBabelOptionsConflicting":
           "Conflicting use of `babel.options` and the deprecated `babelOptions` (ignored)"
       },