@qooxdoo/framework 7.2.1 → 7.3.1

package/source/class/qx/test/core/Property.js

@@ -1060,6 +1060,110 @@ qx.Class.define("qx.test.core.Property", {
       object.setPropTwo(arr2);
       this.assertIdentical(savePropTwo, object.getPropTwo());
       this.assertArrayEquals(["2", "3"], savePropTwo.toArray());
+    },
+
+    testPromises() {
+      const promiseDelay = (delay, fn) => new qx.Promise(resolve => {
+        setTimeout(async () => {
+          await fn();
+          resolve();
+        }, delay);
+      });
+
+      qx.Class.define("qxl.TestPromises", {
+        extend: qx.core.Object,
+
+        construct() {
+          super();
+          this.state = [];
+        },
+
+        properties: {
+          propOne: {
+            init: null,
+            nullable: true,
+            apply: "_applyPropOne",
+            event: "changePropOne"
+          },
+
+          propTwo: {
+            init: null,
+            nullable: true,
+            async: true,
+            apply: "_applyPropTwo",
+            event: "changePropTwo"
+          }
+        },
+
+        members: {
+          state: null,
+
+          async _applyPropOne(value) {
+            await promiseDelay(10, () => {
+              this.state.push("apply-one");
+            });
+            return "apply-one";
+          },
+          async _applyPropTwo(value) {
+            await promiseDelay(10, () => {
+              this.state.push("apply-two");
+            });
+            return "apply-two";
+          }
+        }
+      });
+
+      const createTestPromise = () => {
+        let tp = new qxl.TestPromises();
+        tp.addListener("changePropOne", async evt => {
+          await promiseDelay(1, () => {
+            evt.getTarget().state.push("event-one");
+          });
+          return "event-one";
+        });
+        tp.addListener("changePropTwo", async evt => {
+          await promiseDelay(1, () => {
+            evt.getTarget().state.push("event-two");
+          });
+          return "event-two";
+        });
+        return tp;
+      };
+
+      const testImpl = async () => {
+        let tmp;
+        let tp;
+        let result;
+        ("");
+
+        tp = createTestPromise();
+        tmp = tp.setPropOne(12);
+        this.assertTrue(tmp === 12);
+        this.assertArrayEquals(tp.state, []);
+
+        tp = createTestPromise();
+        tmp = tp.setPropOne(qx.Promise.resolve(14));
+        this.assertTrue(qx.lang.Type.isPromise(tmp));
+        this.assertArrayEquals(tp.state, []);
+
+        tp = createTestPromise();
+        tmp = tp.setPropTwoAsync(16);
+        this.assertTrue(qx.lang.Type.isPromise(tmp));
+        this.assertArrayEquals(tp.state, []);
+        result = await tmp;
+        this.assertTrue(result === 16);
+        this.assertArrayEquals(tp.state, ["apply-two", "event-two"]);
+
+        tp = createTestPromise();
+        tmp = tp.setPropTwoAsync(qx.Promise.resolve(18));
+        this.assertTrue(qx.lang.Type.isPromise(tmp));
+        this.assertArrayEquals(tp.state, []);
+        result = await tmp;
+        this.assertTrue(result === 18);
+        this.assertArrayEquals(tp.state, ["apply-two", "event-two"]);
+      };
+      testImpl().then(() => this.resume());
+      this.wait(1000);
     }
   }
 });

package/source/class/qx/theme/simple/Appearance.js

@@ -785,6 +785,41 @@ qx.Theme.define("qx.theme.simple.Appearance", {
     "row-layer": "widget",
     "column-layer": "widget",
 
+    "virtual-background-span": {
+      alias: "widget",
+
+      style(states) {
+        var style = {
+          decorator: "virtual-background-span"
+        };
+
+        if (states.header) {
+          style.decorator = "virtual-background-header";
+          style.backgroundColor = "table-header-cell";
+        } else if (states.selected) {
+          style.backgroundColor = "table-row-background-selected";
+        } else if (states.odd) {
+          style.backgroundColor = "table-row-background-odd";
+        } else {
+          style.backgroundColor = "table-row-background-even";
+        }
+
+        return style;
+      }
+    },
+
+    "virtual-list-header-cell": {
+      alias: "atom",
+
+      style(states) {
+        return {
+          font: "bold",
+          paddingTop: 3,
+          paddingLeft: 5
+        };
+      }
+    },
+
     "group-item": {
       include: "label",
       alias: "label",

package/source/class/qx/theme/simple/Decoration.js

@@ -930,6 +930,22 @@ qx.Theme.define("qx.theme.simple.Decoration", {
       }
     },
 
+    "virtual-background-header": {
+      style: {
+        gradientStart: ["button-box-bright", 40],
+        gradientEnd: ["button-box-dark", 70],
+        backgroundColor: "button-box-bright"
+      }
+    },
+
+    "virtual-background-span": {
+      include: "table-header-cell",
+      style: {
+        color: "table-row-line",
+        width: [0, 0, 1, 0]
+      }
+    },
+
     "progressive-table-header": {
       include: "button-box",
 

package/source/class/qx/theme/tangible/Appearance.js

@@ -645,7 +645,7 @@ qx.Theme.define("qx.theme.tangible.Appearance", {
       alias: "selectbox",
 
       style(states) {
-        return { 
+        return {
           padding: [0, 2],
           backgroundColor: "surface"
         };
@@ -657,10 +657,10 @@ qx.Theme.define("qx.theme.tangible.Appearance", {
       alias: "combobox",
 
       style(states) {
-        return { 
+        return {
           decorator: undefined,
           backgroundColor: "surface"
-         };
+        };
       }
     },
 
@@ -1006,18 +1006,18 @@ qx.Theme.define("qx.theme.tangible.Appearance", {
         };
       }
     },
+
     "menubar-button/icon": {
       style(states) {
         return {
-          textColor: states.disabled 
-            ? "text-disabled-on-surface" 
-            : ( states.pressed || states.hovered )
-            ? "text-on-primary" 
+          textColor: states.disabled
+            ? "text-disabled-on-surface"
+            : states.pressed || states.hovered
+            ? "text-on-primary"
             : "text-on-surface"
-        }
+        };
       }
     },
-    
 
     /*
     ---------------------------------------------------------------------------

package/source/class/qx/tool/cli/Cli.js

@@ -338,9 +338,13 @@ Version: v${await qx.tool.config.Utils.getQxVersion()}
         configFilename: compileJsonFilename
       }));
 
+      // Boot the compiler API, load the compile.json and create configuration data
       await compilerApi.load();
       let config = compilerApi.getConfiguration();
 
+      // Validate configuration data against the schema
+      await qx.tool.config.Compile.getInstance().load(config);
+
       /*
        * Open the lockfile and check versions
        */

package/source/class/qx/tool/cli/Watch.js

@@ -154,6 +154,9 @@ qx.Class.define("qx.tool.cli.Watch", {
         dir = path.join(lib.getRootDir(), lib.getThemePath());
         dirs.push(dir);
       });
+      if (analyser.getProxySourcePath()) {
+        dirs.push(path.resolve(analyser.getProxySourcePath()));
+      }
       var applications = (this.__applications = []);
       this.__maker.getApplications().forEach(function (application) {
         var data = {

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

@@ -359,9 +359,6 @@ qx.Class.define("qx.tool.cli.commands.Compile", {
         this.argv["feedback"] = configDb.db("qx.default.feedback", true);
       }
 
-      // Validate compile.json against the schema
-      await qx.tool.config.Compile.getInstance().load();
-
       if (this.argv.verbose) {
         console.log(`
 Compiler:  v${this.getCompilerVersion()} in ${require.main.filename}
@@ -1122,6 +1119,11 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
             .getAnalyser()
             .setApplicationTypes(targetConfig["application-types"]);
         }
+        if (targetConfig["proxySourcePath"]) {
+          maker
+            .getAnalyser()
+            .setProxySourcePath(targetConfig["proxySourcePath"]);
+        }
 
         maker.setLocales(data.locales || ["en"]);
         if (data.writeAllTranslations) {

package/source/class/qx/tool/cli/commands/Es6ify.js

@@ -36,6 +36,10 @@ qx.Class.define("qx.tool.cli.commands.Es6ify", {
             describe: "Verbose logging"
           },
 
+          gitPreCommit: {
+            describe: "When used as a Git pre-commit hook"
+          },
+
           overwrite: {
             type: "boolean",
             default: true,
@@ -68,6 +72,7 @@ qx.Class.define("qx.tool.cli.commands.Es6ify", {
           throw err;
         }
       }
+
       let exclude = this.argv.exclude;
       if (exclude) {
         if (!qx.lang.Type.isArray(exclude)) {
@@ -90,6 +95,52 @@ qx.Class.define("qx.tool.cli.commands.Es6ify", {
         await ify.transform();
       };
 
+      if (this.argv.gitPreCommit) {
+        let result = await qx.tool.utils.Utils.runCommand(
+          process.cwd(),
+          "git",
+          "diff",
+          "--cached",
+          "--name-only",
+          "--diff-filter=ACMR"
+        );
+
+        if (result.exitCode != 0) {
+          qx.tool.compiler.Console.error(
+            `Failed to run 'git diff': ${JSON.stringify(result, null, 2)}`
+          );
+
+          process.exit(1);
+          return;
+        }
+        let lines = result.output
+          .split(/\n/)
+          .filter(str => !!str.match(/^source\/class\/.*\.js$/));
+        for (let filename of lines) {
+          await processFile(filename);
+          result = await qx.tool.utils.Utils.runCommand(
+            process.cwd(),
+            "git",
+            "add",
+            filename
+          );
+
+          if (result.exitCode != 0) {
+            qx.tool.compiler.Console.error(
+              `Failed to run 'git add ${filename}': ${JSON.stringify(
+                result,
+                null,
+                2
+              )}`
+            );
+
+            process.exit(1);
+            return;
+          }
+        }
+        process.exit(0);
+      }
+
       const scanImpl = async filename => {
         let basename = path.basename(filename);
         let stat = await fs.promises.stat(filename);

package/source/class/qx/tool/compiler/Analyser.js

@@ -24,6 +24,7 @@
 /* eslint no-inner-declarations: 0 */
 
 var fs = require("fs");
+const path = require("path");
 var async = require("async");
 
 var hash = require("object-hash");
@@ -69,6 +70,13 @@ qx.Class.define("qx.tool.compiler.Analyser", {
       check: "String"
     },
 
+    /** Directory for proxy source files, if they are to be used */
+    proxySourcePath: {
+      init: null,
+      nullable: true,
+      check: "String"
+    },
+
     /** Supported application types */
     applicationTypes: {
       init: ["node", "browser"],
@@ -919,8 +927,7 @@ qx.Class.define("qx.tool.compiler.Analyser", {
           );
         }
         metaWrittenLog[classname] = true;
-        var filename =
-          qx.tool.compiler.ClassFile.getOutputPath(t, classname) + "on";
+        var filename = t.getClassOutputPath(classname) + "on";
         return writeFile(filename, JSON.stringify(meta, null, 2), {
           encoding: "utf-8"
         });
@@ -937,8 +944,7 @@ qx.Class.define("qx.tool.compiler.Analyser", {
         if (cachedMeta[classname]) {
           return Promise.resolve(cachedMeta[classname]);
         }
-        var filename =
-          qx.tool.compiler.ClassFile.getOutputPath(t, classname) + "on";
+        var filename = t.getClassOutputPath(classname) + "on";
         return readFile(filename, { encoding: "utf-8" })
           .then(str => JSON.parse(str))
           .then(meta => (cachedMeta[classname] = meta))
@@ -1065,15 +1071,9 @@ qx.Class.define("qx.tool.compiler.Analyser", {
         return;
       }
 
-      var sourceClassFilename = qx.tool.compiler.ClassFile.getSourcePath(
-        library,
-        className
-      );
+      var sourceClassFilename = this.getClassSourcePath(library, className);
 
-      var outputClassFilename = qx.tool.compiler.ClassFile.getOutputPath(
-        this,
-        className
-      );
+      var outputClassFilename = this.getClassOutputPath(className);
 
       const scanFile = async () => {
         let sourceStat = await qx.tool.utils.files.Utils.safeStat(
@@ -1085,6 +1085,12 @@ qx.Class.define("qx.tool.compiler.Analyser", {
         }
 
         var dbClassInfo = db.classInfo[className];
+        if (
+          !dbClassInfo ||
+          (!forceScan && dbClassInfo.filename != sourceClassFilename)
+        ) {
+          forceScan = true;
+        }
 
         if (!forceScan) {
           let outputStat = await qx.tool.utils.files.Utils.safeStat(
@@ -1119,7 +1125,8 @@ qx.Class.define("qx.tool.compiler.Analyser", {
           : null;
         dbClassInfo = db.classInfo[className] = {
           mtime: sourceStat.mtime,
-          libraryName: library.getNamespace()
+          libraryName: library.getNamespace(),
+          filename: sourceClassFilename
         };
 
         // Analyse it and collect unresolved symbols and dependencies
@@ -1147,6 +1154,48 @@ qx.Class.define("qx.tool.compiler.Analyser", {
       qx.tool.utils.Promisify.callback(scanFile(), cb);
     },
 
+    /**
+     * Returns the absolute path to the class file
+     *
+     * @param library  {qx.tool.compiler.app.Library}
+     * @param className {String}
+     * @returns {String}
+     */
+    getClassSourcePath(library, className) {
+      let filename =
+        className.replace(/\./g, path.sep) +
+        library.getSourceFileExtension(className);
+      if (this.getProxySourcePath()) {
+        let test = path.join(this.getProxySourcePath(), filename);
+        if (fs.existsSync(test)) {
+          return path.resolve(test);
+        }
+      }
+
+      return path.join(
+        library.getRootDir(),
+        library.getSourcePath(),
+        className.replace(/\./g, path.sep) +
+          library.getSourceFileExtension(className)
+      );
+    },
+
+    /**
+     * Returns the path to the rewritten class file
+     *
+     * @param className {String}
+     * @returns {String}
+     */
+    getClassOutputPath(className) {
+      var filename = path.join(
+        this.getOutputDir(),
+        "transpiled",
+        className.replace(/\./g, path.sep) + ".js"
+      );
+
+      return filename;
+    },
+
     /**
      * Returns the CLDR data for a given locale
      * @param locale {String} the locale string

package/source/class/qx/tool/compiler/ClassFile.js

@@ -200,10 +200,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
     this.__metaStack = [];
     this.__metaDefinitions = {};
     this.__library = library;
-    this.__sourceFilename = qx.tool.compiler.ClassFile.getSourcePath(
-      library,
-      className
-    );
+    this.__sourceFilename = analyser.getClassSourcePath(library, className);
 
     this.__requiredClasses = {};
     this.__environmentChecks = {
@@ -317,10 +314,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
      * @returns {string}
      */
     getOutputPath() {
-      return qx.tool.compiler.ClassFile.getOutputPath(
-        this.__analyser,
-        this.__className
-      );
+      return this.__analyser.getClassOutputPath(this.__className);
     },
 
     /**
@@ -1314,7 +1308,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
             path.traverse(COLLECT_CLASS_NAMES_VISITOR, {
               collectedClasses: t.__classMeta.interfaces
             });
-          } else if (keyName == "include") {
+          } else if (keyName == "include" || keyName == "patch") {
             path.skip();
             path.traverse(COLLECT_CLASS_NAMES_VISITOR, {
               collectedClasses: t.__classMeta.mixins
@@ -1359,11 +1353,25 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                   meta.allowNull = data.nullable;
                 }
                 if (data.check !== undefined) {
+                  let checks;
                   if (qx.lang.Type.isArray(data.check)) {
-                    meta.possibleValues = data.check;
+                    checks = meta.possibleValues = data.check;
                   } else {
                     meta.check = data.check;
+                    checks = [data.check];
                   }
+                  checks.forEach(check => {
+                    if (!qx.tool.compiler.ClassFile.SYSTEM_CHECKS[check]) {
+                      let symbolData = t.__analyser.getSymbolType(check);
+                      if (symbolData?.symbolType == "class") {
+                        t._requireClass(check, {
+                          load: false,
+                          usage: "dynamic",
+                          location: path.node.loc
+                        });
+                      }
+                    }
+                  });
                 }
                 if (data.init !== undefined) {
                   meta.defaultValue = data.init;
@@ -1690,16 +1698,17 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                 let arg = path.node.arguments[0];
                 if (types.isLiteral(arg)) {
                   if (typeof arg.value != "string") {
-                    log.error(
-                      `${t.__className}: ` +
-                        "Only literal string arguments to require() are supported: " +
-                        arg.value
+                    t.addMarker(
+                      "compiler.requireLiteralArguments",
+                      path.node.loc,
+                      arg.value
                     );
                   } else {
                     qx.tool.compiler.Console.log(
                       `${t.__className}:${path.node.loc.start.line}:` +
                         ` automatically detected \'require(${arg.value})\``
                     );
+
                     t.addCommonjsModule(
                       arg.value,
                       t.__className,
@@ -2944,42 +2953,13 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
       "in  instanceof  int interface let  long  native  new null  package private protected public  return  short static " +
       "super  switch  synchronized  this throw throws  transient true try typeof  var void volatile  while with  yield";
     str.split(/\s+/).forEach(word => (statics.RESERVED_WORDS[word] = true));
+    statics.SYSTEM_CHECKS = {};
+    "Boolean,String,Number,Integer,PositiveNumber,PositiveInteger,Error,RegExp,Object,Array,Map,Function,Date,Node,Element,Document,Window,Event,Class,Mixin,Interface,Theme,Color,Decorator,Font"
+      .split(",")
+      .forEach(word => (statics.SYSTEM_CHECKS[word] = true));
   },
 
   statics: {
-    /**
-     * Returns the absolute path to the class file
-     *
-     * @param library  {qx.tool.compiler.app.Library}
-     * @param className {String}
-     * @returns {String}
-     */
-    getSourcePath(library, className) {
-      return pathModule.join(
-        library.getRootDir(),
-        library.getSourcePath(),
-        className.replace(/\./g, pathModule.sep) +
-          library.getSourceFileExtension(className)
-      );
-    },
-
-    /**
-     * Returns the path to the rewritten class file
-     *
-     * @param analyser {qx.tool.compiler.Analyser}
-     * @param className {String}
-     * @returns {String}
-     */
-    getOutputPath(analyser, className) {
-      var filename = pathModule.join(
-        analyser.getOutputDir(),
-        "transpiled",
-        className.replace(/\./g, pathModule.sep) + ".js"
-      );
-
-      return filename;
-    },
-
     /**
      * Returns the root namespace from the classname, or null if it cannot be determined
      * @param className
@@ -3176,6 +3156,8 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
       "qx.promise": true,
       "qx.promise.warnings": true,
       "qx.promise.longStackTraces": true
-    }
+    },
+
+    SYSTEM_CHECKS: null
   }
 });

package/source/class/qx/tool/compiler/Console.js

@@ -252,6 +252,8 @@ qx.Class.define("qx.tool.compiler.Console", {
         "qx.tool.compiler.symbol.unresolved": "Unresolved use of symbol %1",
         "qx.tool.compiler.environment.unreachable":
           "Environment check '%1' may be indeterminable, add to Manifest/provides/environment or use class name prefix",
+        "qx.tool.compiler.compiler.requireLiteralArguments":
+          "Wrong class name or filename - expected to find at least %1 but only found [%2]",
 
         "qx.tool.compiler.target.missingAppLibrary":
           "Cannot find the application library for %1",

package/source/class/qx/tool/compiler/Es6ify.js

@@ -179,6 +179,7 @@ qx.Class.define("qx.tool.compiler.Es6ify", {
           qx.tool.compiler.Console.warn(
             `Can not find a stable format for ${this.__filename}`
           );
+
           break;
         }
         result = babelCore.transform(src, config);

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

@@ -436,9 +436,13 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       // class will always bundle local modules specified for an
       // application in compile.json, but will not bundle `require()`d
       // modules that are Node modules.
-      bootPackage.addJavascriptMeta(
-        new qx.tool.compiler.targets.meta.Browserify(appMeta)
-      );
+      if (
+        appMeta.getEnvironmentValue("qx.compiler.applicationType") == "browser"
+      ) {
+        bootPackage.addJavascriptMeta(
+          new qx.tool.compiler.targets.meta.Browserify(appMeta)
+        );
+      }	
 
       /*
        * Assemble the Parts