@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

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

@@ -0,0 +1,202 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2019-2022 Zenesis Ltd, https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com, @johnspackman)
+     * Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+qx.Class.define("qx.tool.cli.Flag", {
+  extend: qx.tool.cli.AbstractValue,
+
+  properties: {
+  },
+
+  members: {
+    /**
+     * Returns a string that can be used to in the usage output of the command
+     *
+     * @return {String}
+     */
+    usage() {
+      let str = "--" + qx.lang.String.hyphenate(this.getName());
+      if (this.getShortCode()) { str += "|-" + this.getShortCode(); }
+
+      const TYPES = {
+        string: "String",
+        boolean: "Boolean",
+        integer: "Integer",
+        float: "Float"
+      };
+
+      let type = this.getType();
+      if (this.isArray()) {
+        str += " [" + (TYPES[type] || type) + "]";
+      } else {
+        if (type) {
+          if (qx.lang.Type.isArray(type)) {
+            str += " [" + type + "]";
+          } else {
+            str += " (" + TYPES[type] + ")";
+          }
+        }
+      }
+      str +=
+        "  ::  " +
+        (this.getValue() === null ? "-" : `[default: ${this.getValue()}]`);
+      if (this.getDescription()) { str += "  ::  " + this.getDescription(); }
+      return str;
+    },
+
+    /**
+     * Parses the flag
+     *
+     * @param {String} cmdName the command name/flag being parsed
+     * @param {Function} fnGetMore function to get more arguments
+     */
+    parse(cmdName, fnGetMore) {
+      let initialValue = null;
+      let pos = cmdName.indexOf("=");
+      if (pos > -1) {
+        initialValue = cmdName.substring(pos + 1);
+        cmdName = cmdName.substring(0, pos);
+      }
+
+      let eatAll = false;
+      let argIndex = 0;
+
+      function getArg(index) {
+        if (initialValue !== null) { return index == 0 ? initialValue : fnGetMore(index - 1); }
+        return fnGetMore(index);
+      }
+
+      function next() {
+        let value = getArg(argIndex++);
+        if (value == "--") {
+          eatAll = true;
+        }
+        if (!eatAll && value) {
+          if (value[0] == "-") { value = null; }
+        }
+        if (value === null) { argIndex--; }
+        return value;
+      }
+
+      let type = this.getType();
+
+      const parseNext = (arg, pass) => {
+        switch (type) {
+          case "string":
+          case null:
+            if (arg === null) { return null; }
+            return arg;
+
+          case "boolean":
+            if (arg === null) { return true; }
+            if (arg == "true" || arg == "yes" || arg == "1") { return true; }
+            if (arg == "false" || arg == "no" || arg == "0") { return false; }
+            if (initialValue === null && pass == 0) {
+              argIndex--;
+              return true;
+            }
+            throw new Error(
+              "Invalid value for " +
+              this.toString() +
+              ", expected nothing (true) or the words true or false"
+            );
+
+          case "integer":
+            if (arg === null) {
+              throw new Error(
+                `Invalid value for ${this.toString()}, expected an integer`
+              );
+            }
+            var value = parseInt(arg, 10);
+            if (isNaN(arg)) {
+              throw new Error(
+                `Invalid value for ${this.toString()}, expected an integer`
+              );
+            }
+            return value;
+
+          case "float":
+            if (arg === null) {
+              throw new Error(
+                `Invalid value for ${this.toString()}, expected a number`
+              );
+            }
+            var value = parseFloat(arg);
+            if (isNaN(arg)) {
+              throw new Error(
+                `Invalid value for ${this.toString()}, expected a number`
+              );
+            }
+            return value;
+        }
+
+        // Handle enum types (array of valid values)
+        if (qx.lang.Type.isArray(type)) {
+          if (arg === null) {
+            throw new Error(
+              `Invalid value for ${this.toString()}, expected one of: ${type.join(", ")}`
+            );
+          }
+          if (!type.includes(arg)) {
+            throw new Error(
+              `Invalid value for ${this.toString()}, expected one of: ${type.join(", ")}, but got: ${arg}`
+            );
+          }
+          return arg;
+        }
+
+        if (arg === null) {
+          throw new Error(
+            `Invalid value for ${this.toString()}, expected a string`
+          );
+        }
+        return arg;
+      };
+
+      let arg = next();
+      let result = null;
+      if (arg == "--") {
+        result = parseNext(null, 0);
+        this.setValue(result);
+        return;
+      }
+      if (this.isArray()) {
+        if (arg === null) {
+          throw new Error(
+            `Invalid value for ${this.toString()}, expected at least one value`
+          );
+        }
+        if (initialValue !== null) {
+          result = initialValue.split(",");
+        } else {
+          result = [];
+          do {
+            let value = parseNext(arg, result.length);
+            result.push(value);
+            arg = next();
+          } while (arg);
+        }
+      } else {
+        result = parseNext(arg, 0);
+      }
+
+      if (initialValue) { fnGetMore(argIndex - 1, true); }
+      else { fnGetMore(argIndex, true); }
+      this.setValue(result);
+    }
+  }
+});

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

@@ -0,0 +1,39 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2019-2022 Zenesis Ltd, https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com, @johnspackman)
+     * Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+qx.Class.define("qx.tool.cli.Parser", {
+  extend: qx.core.Object,
+
+  construct(argv, rootCmd) {
+    super();
+    this.__argv = argv;
+    this.__rootCmd = rootCmd;
+  },
+
+  members: {
+    parse() {
+      let argv = this.__argv;
+      let cmd = null;
+      for (let i = 0; i < argv.length; i++) {
+        let arg = argv[0];
+        if (arg.startsWith("--")) {
+        }
+      }
+    }
+  }
+});

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

@@ -1,3 +1,28 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2019-2022 Zenesis Ltd, https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (john.spackman@zenesis.com, @johnspackman)
+     * Henner Kollmann (Henner.Kollmann@gmx.de, @hkollmann)
+
+************************************************************************ */
+
 /**
- * doc is missing
+ * The qx.tool.cli namespace contains classes for building command line interface applications.
+ *
+ * This includes:
+ * - AbstractCliApp: Base class for CLI applications
+ * - Command: Command definitions with arguments and flags
+ * - Parser: Command line argument parser
+ * - AbstractValue, Argument, Flag: Value types for command line parameters
  */

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

@@ -57,7 +57,7 @@ qx.Class.define("qx.tool.compiler.Analyser", {
     this.__libraries = [];
     this.__librariesByNamespace = {};
     this.__initialClassesToScan = new qx.tool.utils.IndexedArray();
-    this.__cldrs = {};
+    this.__locales = {};
     this.__translations = {};
     this.__classFiles = {};
     this.__environmentChecks = {};
@@ -206,7 +206,7 @@ qx.Class.define("qx.tool.compiler.Analyser", {
 
     __classes: null,
     __initialClassesToScan: null,
-    __cldrs: null,
+    __locales: null,
     __translations: null,
 
     /** @type{qx.tool.compiler.app.ManifestFont[]} list of fonts in provides.fonts */
@@ -655,19 +655,17 @@ qx.Class.define("qx.tool.compiler.Analyser", {
     },
 
     /**
-     * Returns the CLDR data for a given locale
+     * Returns the locale data for a given locale
      * @param locale {String} the locale string
-     * @returns {Promise<qx.tool.compiler.app.Cldr>}
+     * @returns Promise({options})
      */
-    async getCldr(locale) {
-      var t = this;
-      var cldr = this.__cldrs[locale];
-      if (cldr) {
-        return cldr;
+    async getLocale(locale) {
+      var options = this.__locales[locale];
+      if (options) {
+        return options;
       }
-      return qx.tool.compiler.app.Cldr.loadCLDR(locale).then(
-        cldr => (t.__cldrs[locale] = cldr)
-      );
+      this.__locales[locale] = {};
+      return options;
     },
 
     /**
@@ -1090,7 +1088,7 @@ qx.Class.define("qx.tool.compiler.Analyser", {
 
     /**
      * Whether the compilation context has changed since last analysis
-     * e.g. compiler version, environment variables
+     * e.g. compiler version, environment variables, or available libraries
      *
      * @return {Boolean}
      */
@@ -1113,6 +1111,36 @@ qx.Class.define("qx.tool.compiler.Analyser", {
         return true;
       }
 
+      // And Qooxdoo version (this can differ from the compiler version when cross compiling)
+      if (db.libraries.qx !== this.findLibrary("qx").getVersion()) {
+        return true;
+      }
+
+      // Check if the list of available libraries has changed (issue #10194)
+      // This ensures that newly added packages are detected without requiring --clean
+      if (db.libraries) {
+        const currentLibraries = this.getLibraries().reduce((acc, library) => {
+          acc[library.getNamespace()] = library.getVersion();
+          return acc;
+        }, {});
+
+        const dbLibraryKeys = Object.keys(db.libraries).sort();
+        const currentLibraryKeys = Object.keys(currentLibraries).sort();
+
+        // Check if a library was added or removed
+        if (dbLibraryKeys.length !== currentLibraryKeys.length ||
+            !dbLibraryKeys.every((key, index) => key === currentLibraryKeys[index])) {
+          return true;
+        }
+
+        // Check if any library version changed
+        for (let ns in currentLibraries) {
+          if (db.libraries[ns] !== currentLibraries[ns]) {
+            return true;
+          }
+        }
+      }
+
       return false;
     },
 

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

@@ -810,7 +810,13 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
           } else if (param.type == "ArrayPattern") {
             param.elements.forEach(elem => addDecl(elem));
           } else if (param.type == "ObjectPattern") {
-            param.properties.forEach(prop => addDecl(prop.value));
+            param.properties.forEach(prop => {
+              if (prop.type == "RestElement") {
+                addDecl(prop);
+              } else {
+                addDecl(prop.value);
+              }
+            });
           } else {
             t.addMarker("testForFunctionParameterType", node.loc, param.type);
           }
@@ -1199,6 +1205,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
             environment: "object", // Map
             defer: "function" // Function
           },
+
           normal: {
             "@": "object",
             "@construct": "object",
@@ -1208,6 +1215,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
             implement: "object", // Interface[]
             include: "object", // Mixin[]
             construct: "function", // Function
+            delegate: "object", // Map
             statics: "object", // Map
             properties: "object", // Map
             members: "object", // Map
@@ -1358,9 +1366,20 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
         if (isSpecialFunctionName) {
           makeMeta(keyName, null, functionNode);
         }
-        enterFunction(path, functionNode);
+        const FUNCTION_NODE_TYPES = {
+          FunctionExpression: true,
+          ArrowFunctionExpression: true,
+          FunctionDeclaration: true,
+          ObjectMethod: true
+        };
+        let isFunction = FUNCTION_NODE_TYPES[functionNode.type];
+        if (isFunction) {
+          enterFunction(path, functionNode);
+        }
         path.traverse(VISITOR);
-        exitFunction(path, functionNode);
+        if (isFunction) {
+          exitFunction(path, functionNode);
+        }
         path.skip();
         t.__classMeta.functionName = null;
       }
@@ -1516,6 +1535,9 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
               });
             }
             path.traverse(VISITOR);
+          } else if (keyName == "delegate") {
+            path.skip();
+            path.traverse(VISITOR);
           } else if (keyName == "aliases") {
             path.skip();
             if (!prop.value.properties) {
@@ -1703,7 +1725,8 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
             ClassDeclaration: 1,
             ClassMethod: 1,
             LabeledStatement: 1,
-            BreakStatement: 1
+            BreakStatement: 1,
+            ContinueStatement: 1
           };
 
           // These are AST node types we expect to find at the root of the identifier, and which will
@@ -2149,7 +2172,7 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                   t.addMarker(
                     "translate.invalidMessageId",
                     path.node.loc,
-                    arg0
+                    arg0 ?? ""
                   );
                 } else {
                   addTranslation({ msgid: arg0 });
@@ -2164,8 +2187,8 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                   t.addMarker(
                     "translate.invalidMessageIds",
                     path.node.loc,
-                    arg0,
-                    arg1
+                    arg0 ?? "",
+                    arg1 ?? ""
                   );
                 } else {
                   addTranslation({ msgid: arg0, msgid_plural: arg1 });
@@ -2387,7 +2410,9 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
                 // Object destructuring `var {a,b} = {...}`
               } else if (decl.id.type == "ObjectPattern") {
                 decl.id.properties.forEach(prop => {
-                  if (prop.value.type == "AssignmentPattern") {
+                  if (prop.type == "RestElement") {
+                    t.addDeclaration(prop.argument.name);
+                  } else if (prop.value.type == "AssignmentPattern") {
                     t.addDeclaration(prop.value.left.name);
                   } else {
                     t.addDeclaration(prop.value.name);
@@ -2560,7 +2585,10 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
         this.__scope.vars[name] = valueName || true;
         var unresolved = this.__scope.unresolved;
         delete unresolved[name];
-        var re = new RegExp(name + "\\.");
+        // Escape special regex characters and anchor to start of string
+        // to prevent "x" from matching "qx.foo" (only match "x.foo")
+        var escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        var re = new RegExp("^" + escapedName + "\\.");
         for (var tmp in unresolved) {
           if (re.test(tmp)) {
             delete unresolved[tmp];
@@ -3136,10 +3164,6 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
      * These options are passed to Babel for JSX compilation; they can be changed by the CLI etc
      * as needed.
      *
-     * Note that at the moment they use a class that does not exist!  `qx.html.Jsx` is coming soon
-     * to a PR near you, but in the mean time you could use the compile.json `jsx` setting to
-     * change these to something else, eg `{ pragma: "jsx.dom", pragmaFrag: "jsx.Fragment }` and
-     * use https://github.com/alecsgone/jsx-render in your application's code.
      */
     JSX_OPTIONS: {
       pragma: "qx.html.Jsx.createElement",

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

@@ -183,6 +183,8 @@ qx.Class.define("qx.tool.compiler.Console", {
           "Unexpected property %2 in %1 definition",
         "qx.tool.compiler.compiler.wrongClassName":
           "Wrong class name or filename - expected to find at least %1 but only found [%2]",
+        "qx.tool.compiler.class.reservedWordDecl":
+          "Do not use the reserved word '%1' as a variable name",
         "qx.tool.compiler.compiler.membersNotAnObject":
           "The members property of class %1 is not an object",
 

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

@@ -211,6 +211,53 @@ qx.Class.define("qx.tool.compiler.MetaDatabase", {
       }
     },
 
+    /**
+     * Scans directories recursively for .js files and populates the database.
+     * Calls addFile() for each discovered file, then reparseAll().
+     *
+     * @param {String[]} dirs directories to scan
+     * @param {Object} [options]
+     * @param {Boolean} [options.force] reparse even if up to date (default: false)
+     * @param {Object}  [options.ignore] an `ignore` instance for exclude patterns
+     * @param {Boolean} [options.verbose] log each processed file
+     */
+    async loadFromDirectories(dirs, options = {}) {
+      const classFiles = [];
+
+      const scanImpl = async filename => {
+        let basename = path.basename(filename);
+
+        if (options.ignore) {
+          let relativePath = path.relative(process.cwd(), filename);
+          if (options.ignore.ignores(relativePath)) {
+            return;
+          }
+        }
+
+        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 file of files) {
+            await scanImpl(path.join(filename, file));
+          }
+        }
+      };
+
+      for (let dir of dirs) {
+        await scanImpl(dir);
+      }
+
+      for (let filename of classFiles) {
+        if (options.verbose) {
+          qx.tool.compiler.Console.info(`Processing ${filename} ...`);
+        }
+        await this.addFile(filename, options.force || false);
+      }
+      await this.reparseAll();
+    },
+
     __createDerivedClassLookup() {
       const lookup = {};
 

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

@@ -157,7 +157,13 @@ qx.Class.define("qx.tool.compiler.MetaExtraction", {
           Program(path) {
             path.skip();
             let found = false;
-            path.get("body").forEach(path => {
+            // Babel's path.get() may return either an array or a single NodePath object
+            // depending on the AST structure and Babel version, so we normalize to array
+            let bodyPaths = path.get("body");
+            if (!Array.isArray(bodyPaths)) {
+              bodyPaths = [bodyPaths];
+            }
+            bodyPaths.forEach(path => {
               let node = path.node;
               if (
                 node.type == "ExpressionStatement" &&
@@ -228,7 +234,13 @@ qx.Class.define("qx.tool.compiler.MetaExtraction", {
 
       path.skip();
       let ctorAnnotations = {};
-      path.get("properties").forEach(path => {
+      // Babel's path.get() may return either an array or a single NodePath object
+      // depending on the AST structure and Babel version, so we normalize to array
+      let propertiesPaths = path.get("properties");
+      if (!Array.isArray(propertiesPaths)) {
+        propertiesPaths = [propertiesPaths];
+      }
+      propertiesPaths.forEach(path => {
         let property = path.node;
         let propertyName;
         if (property.key.type === "Identifier") {
@@ -358,40 +370,48 @@ qx.Class.define("qx.tool.compiler.MetaExtraction", {
           let type = propertyName;
           let annotations = {};
           metaData[type] = {};
-          path.get("value.properties").forEach(memberPath => {
-            let member = memberPath.node;
-            const name = qx.tool.utils.BabelHelpers.collapseMemberExpression(
-              member.key
-            );
-            if (name[0] == "@") {
-              annotations[name] = memberPath.get("value").toString();
-              return;
+          if (path.node.value.type == "ObjectExpression") {
+            // Babel's path.get() may return either an array or a single NodePath object
+            // depending on the AST structure and Babel version, so we normalize to array
+            let memberPaths = path.get("value.properties");
+            if (!Array.isArray(memberPaths)) {
+              memberPaths = [memberPaths];
             }
+            memberPaths.forEach(memberPath => {
+              let member = memberPath.node;
+              const name = qx.tool.utils.BabelHelpers.collapseMemberExpression(
+                member.key
+              );
+              if (name[0] == "@") {
+                annotations[name] = memberPath.get("value").toString();
+                return;
+              }
 
-            let memberMeta = (metaData[type][name] = {
-              jsdoc: qx.tool.utils.BabelHelpers.getJsDoc(member.leadingComments)
-            });
-
-            memberMeta.access = name.startsWith("__")
-              ? "private"
-              : name.startsWith("_")
-                ? "protected"
-                : "public";
-            memberMeta.location = {
-              start: member.loc.start,
-              end: member.loc.end
-            };
+              let memberMeta = (metaData[type][name] = {
+                jsdoc: qx.tool.utils.BabelHelpers.getJsDoc(member.leadingComments)
+              });
+
+              memberMeta.access = name.startsWith("__")
+                ? "private"
+                : name.startsWith("_")
+                  ? "protected"
+                  : "public";
+              memberMeta.location = {
+                start: member.loc.start,
+                end: member.loc.end
+              };
 
-            if (
-              member.type === "ObjectMethod" ||
-              (member.type === "ObjectProperty" &&
-                member.value.type === "FunctionExpression")
-            ) {
-              memberMeta.type = "function";
-              memberMeta.params = [];
-              collapseParamMeta(member, memberMeta);
-            }
-          });
+              if (
+                member.type === "ObjectMethod" ||
+                (member.type === "ObjectProperty" &&
+                  member.value.type === "FunctionExpression")
+              ) {
+                memberMeta.type = "function";
+                memberMeta.params = [];
+                collapseParamMeta(member, memberMeta);
+              }
+            });
+          }
           for (let metaName in annotations) {
             let bareName = metaName.substring(1);
             let memberMeta = metaData[type][bareName];

package/source/class/qx/tool/compiler/app/Library.js

@@ -268,7 +268,7 @@ qx.Class.define("qx.tool.compiler.app.Library", {
       }
       if (data.provides && data.provides.boot) {
         qx.tool.compiler.Console.print(
-          "qx.tool.cli.compile.deprecatedProvidesBoot",
+          "qx.tool.compiler.cli.compile.deprecatedProvidesBoot",
           rootDir
         );
       }

package/source/class/qx/tool/compiler/app/WebFont.js

@@ -81,6 +81,8 @@ qx.Class.define("qx.tool.compiler.app.WebFont", {
   },
 
   members: {
+    __generateForTargetPromise: undefined,
+
     __library: null,
     __fontData: null,