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

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

@@ -1465,6 +1465,27 @@ qx.Theme.define("qx.theme.classic.Appearance", {
       }
     },
 
+    "selectbox-arrow-button": "widget",
+
+    /*
+    ---------------------------------------------------------------------------
+      CHECKED SELECT BOX
+    ---------------------------------------------------------------------------
+    */
+
+    "checked-selectbox": "selectbox",
+
+    "checked-selectbox/allNone": {
+      include: "button"
+    },
+
+    "checked-selectbox/tag": "tag",
+
+    tag: {
+      alias: "button",
+      include: "button"
+    },
+
     /*
     ---------------------------------------------------------------------------
       DATE CHOOSER

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

@@ -1728,6 +1728,27 @@ qx.Theme.define("qx.theme.modern.Appearance", {
       }
     },
 
+    "selectbox-arrow-button": "widget",
+
+    /*
+    ---------------------------------------------------------------------------
+      CHECKED SELECT BOX
+    ---------------------------------------------------------------------------
+    */
+
+    "checked-selectbox": "selectbox",
+
+    "checked-selectbox/allNone": {
+      include: "button"
+    },
+
+    "checked-selectbox/tag": "tag",
+
+    tag: {
+      alias: "button",
+      include: "button"
+    },
+
     /*
     ---------------------------------------------------------------------------
       DATE CHOOSER

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

@@ -1204,6 +1204,27 @@ qx.Theme.define("qx.theme.simple.Appearance", {
       }
     },
 
+    "selectbox-arrow-button": "widget",
+
+    /*
+    ---------------------------------------------------------------------------
+      CHECKED SELECT BOX
+    ---------------------------------------------------------------------------
+    */
+
+    "checked-selectbox": "selectbox",
+
+    "checked-selectbox/allNone": {
+      include: "button"
+    },
+
+    "checked-selectbox/tag": "tag",
+
+    tag: {
+      alias: "button",
+      include: "button"
+    },
+
     /*
     ---------------------------------------------------------------------------
       COMBO BOX

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

@@ -1313,6 +1313,8 @@ qx.Theme.define("qx.theme.tangible.Appearance", {
       }
     },
 
+    "selectbox-arrow-button": "widget",
+
     /*
     ---------------------------------------------------------------------------
       CHECKED SELECT BOX

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

@@ -41,12 +41,28 @@ qx.Class.define("qx.tool.cli.AbstractCliApp", {
         console.log((cmd || rootCmd).usage());
         process.exit((!cmd || errors) ? 1 : 0);
       }
+      let exitCode = 0;
       try {
-        process.exit(await run.call(cmd, cmd) ?? 0);
+        exitCode = await run.call(cmd, cmd) ?? 0;
       } catch (ex) {
         console.error("ERROR:\n" + (ex.stack ?? ex.message) + "\n");
-        process.exit(1);
+        exitCode = 1;
       }
+      // Close undici's global connection pool before exiting.
+      // Native fetch (undici) keeps HTTP keep-alive connections open which would prevent
+      // natural process exit. node:undici is available as a built-in from Node.js 22+.
+      try {
+        const { getGlobalDispatcher } = require("node:undici");
+        await getGlobalDispatcher().close();
+      } catch (e) {
+        // node:undici not available on this Node.js version — proceed
+      }
+      // Use process.exitCode instead of process.exit() to avoid a libuv race on Windows + Node 24:
+      // close() resolves, but undici's internal uv_async_t handles are still tearing down; calling
+      // process.exit() immediately marks them UV_HANDLE_CLOSING, then a background task fires
+      // uv_async_send() on one → assertion fails (libuv 1.50.x made this a hard crash, not a no-op).
+      // Setting exitCode and returning lets the event loop drain naturally instead.
+      process.exitCode = exitCode;
     },
 
     /**

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

@@ -3164,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/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/cli/api/CompilerApi.js

@@ -51,8 +51,7 @@ qx.Class.define("qx.tool.compiler.cli.api.CompilerApi", {
       init: null,
       nullable: true,
       check: "qx.tool.compiler.cli.Command",
-      event: "changeCommand",
-      async: true
+      event: "changeCommand"
     }
   },
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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