@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

package/source/class/qx/dev/LeakDetector.js

@@ -0,0 +1,144 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025-26 Zenesis Limited, 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)
+
+************************************************************************ */
+
+/**
+ * Adds leak detection to qx.core.Object, so that we can track constructed and destructed
+ * Qooxdoo objects.  WeakRefs are used so that we do not prevent garbage collection, which
+ * means that we only operate on platforms which support WeakRef - this code will warn if
+ * WeakRef does not exist and will not crash if WeakRef is not supported (it will just do
+ * nothing).
+ *
+ * @ignore(WeakRef)
+ */
+qx.Class.define("qx.dev.LeakDetector", {
+  extend: qx.core.Object,
+
+  construct() {
+    super();
+    this.__lookup = {};
+    if (WeakRef === undefined) {
+      console.warn(
+        "LeakDetector: WeakRef not supported on this platform, qx.core.LeakDetector will not be able to track objects"
+      );
+      return;
+    }
+  },
+
+  members: {
+    /** @type<String,WeakRef<qx.core.Object>> Lookup by hash code of all objects */
+    __lookup: null,
+
+    /**
+     * Collects statistics on currently alive objects, grouped by class name
+     *
+     * @returns {Object<String,Integer>} count of class instances, indexex by classname
+     */
+    getStaticsByClass() {
+      let classes = {};
+      for (let hash in this.__lookup) {
+        let ref = this.__lookup[hash];
+        let obj = ref.deref();
+        if (obj) {
+          let classname = obj.classname;
+          if (!classes[classname]) {
+            classes[classname] = 0;
+          }
+          classes[classname]++;
+        } else {
+          // Object has been GC'd, remove from lookup
+          delete this.__lookup[hash];
+        }
+      }
+      let arr = [];
+      for (let key in classes) {
+        arr.push({
+          key: key,
+          count: classes[key]
+        });
+      }
+      return arr;
+    },
+
+    /**
+     * Called when an object is constructed
+     *
+     * @param {qx.core.Object} obj
+     */
+    objectConstructed(obj) {
+      if (WeakRef === undefined) {
+        return;
+      }
+      let hash = obj.toHashCode();
+      if (this.__lookup[hash]) {
+        throw new Error("LeakDetector: Object already constructed?", obj);
+      }
+      this.__lookup[hash] = new WeakRef(obj);
+    },
+
+    /**
+     * Called when an object is destructed
+     *
+     * @param {qx.core.Object} obj
+     */
+    objectDestructed(obj) {
+      let hash = obj.toHashCode();
+      if (this.__lookup[hash]) {
+        delete this.__lookup[hash];
+      }
+    },
+
+    /**
+     * Called when an object is disposed
+     *
+     * @param {qx.core.Object} obj
+     */
+    objectDisposed(obj) {
+      let hash = obj.toHashCode();
+      if (this.__lookup[hash]) {
+        delete this.__lookup[hash];
+      }
+    }
+  },
+
+  statics: {
+    /** @type{qx.dev.LeakDetector} */
+    __instance: null,
+
+    /**
+     *
+     * @returns {qx.dev.LeakDetector} The singleton instance
+     */
+    getInstance() {
+      if (this.__instance === null) {
+        if (!qx.core.Environment.get("qx.dev.LeakDetector.enabled")) {
+          console.warn(
+            "LeakDetector singleton instance not available (recompile with 'qx.dev.LeakDetector.enabled' set to true to enable)"
+          );
+          return null;
+        } else {
+          this.__instance = new qx.dev.LeakDetector();
+        }
+      }
+      return this.__instance;
+    }
+  },
+
+  environment: {
+    "qx.dev.LeakDetector.enabled": false
+  }
+});

package/source/class/qx/dev/unit/AsyncWrapper.js

@@ -36,6 +36,7 @@ qx.Class.define("qx.dev.unit.AsyncWrapper", {
    * @param context {Object?window} Optional execution context for deferredFunction
    */
   construct(delay, deferredFunction, context) {
+    super();
     if (delay === undefined && deferredFunction === undefined) {
       // scale default delay if wait() is called without arguments
       if (qx.core.Environment.get("qx.test.delay.scale")) {

package/source/class/qx/dev/unit/MMock.js

@@ -111,13 +111,18 @@ qx.Mixin.define("qx.dev.unit.MMock", {
      * @ignore(sinon.assert.expose)
      */
     __exposeAssertions() {
-      var temp = {};
+      let temp = {};
+      let origWarning = qx.Class.$$options["Warn member not declared"];
       sinon.assert.expose(temp, { includeFail: false });
+
+      // Turn off warnings about Member not declared while exposing assertions
+      qx.Class.$$options["Warn member not declared"] = false;
       for (var method in temp) {
         if (!this[method]) {
           this[method] = temp[method];
         }
       }
+      qx.Class.$$options["Warn member not declared"] = origWarning;
     },
 
     /**
@@ -518,7 +523,7 @@ qx.Mixin.define("qx.dev.unit.MMock", {
      */
     __stubProperty(object, prop) {
       // Leave constructor and properties intact
-      if (prop === "constructor" || typeof object[prop] !== "function") {
+      if (prop === "constructor" || (object.$$allProperties && object.$$allProperties[prop]) || typeof object[prop] !== "function") {
         return;
       }
 

package/source/class/qx/dev/unit/Sinon.js

@@ -5985,7 +5985,6 @@ qx.Bootstrap.define("qx.dev.unit.Sinon",
                   return timer.id;
               }
 
-              /* eslint consistent-return: "off" */
               /**
                * Timer comparitor
                *
@@ -17296,7 +17295,6 @@ qx.Bootstrap.define("qx.dev.unit.Sinon",
               return timer.id;
           }
 
-          /* eslint consistent-return: "off" */
           function compareTimers(a, b) {
               // Sort first by absolute timing
               if (a.callAt < b.callAt) {
@@ -17396,7 +17394,6 @@ qx.Bootstrap.define("qx.dev.unit.Sinon",
               if (typeof timer.func === "function") {
                   timer.func.apply(null, timer.args);
               } else {
-                  /* eslint no-eval: "off" */
                   var eval2 = eval;
                   (function () {
                       eval2(timer.func);
@@ -17486,7 +17483,6 @@ qx.Bootstrap.define("qx.dev.unit.Sinon",
                           try {
                               delete _global[method];
                           } catch (ignore) {
-                              /* eslint no-empty: "off" */
                           }
                       }
                   }

package/source/class/qx/dev/unit/TestCase.js

@@ -201,7 +201,10 @@ qx.Class.define("qx.dev.unit.TestCase", {
       if (this.__autoDispose) {
         this.__autoDispose.forEach(function (obj) {
           if (!obj.isDisposed()) {
-            if (obj instanceof qx.ui.core.Widget) {
+            // Do not make an actual reference to qx.ui.core.Widget otherwise the compiler will load
+            // dependencies and that prevents this class from being used in node-only builds
+            const Widget = qx.Class.getByName("qx.ui.core.Widget");
+            if (obj instanceof Widget) {
               obj.destroy();
             } else if (obj instanceof qx.core.Object) {
               obj.dispose();

package/source/class/qx/dev/unit/TestClass.js

@@ -61,6 +61,8 @@ qx.Class.define("qx.dev.unit.TestClass", {
       return;
     }
 
+    this.setName(clazz.classname);
+    
     if (!qx.Class.isSubClassOf(clazz, qx.dev.unit.TestCase)) {
       this.addFail(
         "Sub class check.",
@@ -83,8 +85,6 @@ qx.Class.define("qx.dev.unit.TestClass", {
         this.addTestMethod(testCase, test);
       }
     }
-
-    this.setName(clazz.classname);
   },
 
   /*

package/source/class/qx/dev/unit/TestFunction.js

@@ -40,6 +40,7 @@ qx.Class.define("qx.dev.unit.TestFunction", {
    *    parameter is set the other parameters are ignored.
    */
   construct(testCase, methodName, testFunction) {
+    super();
     if (testFunction) {
       this.setTestFunction(testFunction);
     }

package/source/class/qx/dev/unit/TestLoaderBasic.js

@@ -30,6 +30,7 @@ qx.Class.define("qx.dev.unit.TestLoaderBasic", {
    * @param nameSpace {String} Test namespace, e.g. myapplication.test.*
    */
   construct(nameSpace) {
+    super();
     if (nameSpace) {
       this.setTestNamespace(nameSpace);
     }

package/source/class/qx/dev/unit/TestRunner.js

@@ -0,0 +1,106 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2007-2008 1&1 Internet AG, Germany, http://www.1und1.de
+
+   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)
+
+************************************************************************ */
+
+/**
+ * Helper class to simulate the TestRunner, but without loading all the classes
+ */
+qx.Class.define("qx.dev.unit.TestRunner", {
+  extend: qx.core.Object,
+  statics: {
+    /** @type{Object<String,qx.dev.unit.TestLoaderBasic>} list of loaders, one per package, indexed by package name */
+    __loaders: null,
+
+    /**
+     * Unit tests all methods in a class where the method name begins "test", unless the
+     * `methodNames` parameter is provided to list the method names explicitly.  Tests can be
+     * asynchronous, so this returns a promise
+     *
+     *  @param clazz {Class} the class to unit test
+     *  @param methodNames {String[]?} optional list of method names
+     *  @return {qx.Promise} promise for completion of all tests
+     */
+    async runAll(clazz, methodNames) {
+      function showExceptions(arr) {
+        arr.forEach(item => {
+          qx.log.Logger.error(item.test.getClassName() + "." + item.test.getName() + ": " + item.exception);
+        });
+      }
+
+      if (!methodNames) {
+        methodNames = [];
+        Object.keys(clazz.prototype).forEach(function (name) {
+          if (name.length < 5 || !name.startsWith("test") || name.substring(4, 5) != name.substring(4, 5).toUpperCase()) {
+            return;
+          }
+          methodNames.push(name);
+        });
+      }
+
+      await new qx.Promise(resolve => {
+        var pos = clazz.classname.lastIndexOf(".");
+        var pkgname = clazz.classname.substring(0, pos);
+        if (qx.dev.unit.TestRunner.__loaders === null) {
+          qx.dev.unit.TestRunner.__loaders = {};
+        }
+        var loader = qx.dev.unit.TestRunner.__loaders[pkgname];
+        if (!loader) {
+          loader = new qx.dev.unit.TestLoaderBasic(pkgname);
+          qx.dev.unit.TestRunner.__loaders[pkgname] = loader;
+        }
+        let testClasses = loader.getSuite().getTestClasses();
+        if (!testClasses.find(tc => tc.getName() == clazz.classname)) {
+          loader.getSuite().add(clazz);
+        }
+
+        var testResult = new qx.dev.unit.TestResult();
+        testResult.addListener("startTest", evt => {
+          qx.log.Logger.info("Running test " + evt.getData().getFullName());
+        });
+        testResult.addListener("endTest", evt => {
+          qx.log.Logger.info("End of " + evt.getData().getFullName());
+          setTimeout(next, 1);
+        });
+        testResult.addListener("wait", evt => qx.log.Logger.info("Waiting for " + evt.getData().getFullName()));
+
+        testResult.addListener("failure", evt => showExceptions(evt.getData()));
+        testResult.addListener("error", evt => showExceptions(evt.getData()));
+        testResult.addListener("skip", evt => showExceptions(evt.getData()));
+
+        var methodNameIndex = -1;
+        function next() {
+          methodNameIndex++;
+          if (!methodNames) {
+            if (methodNameIndex === 0) {
+              loader.runTests(testResult, clazz.classname, null);
+            } else {
+              resolve();
+            }
+          } else {
+            if (methodNameIndex < methodNames.length) {
+              loader.runTests(testResult, clazz.classname, methodNames[methodNameIndex]);
+            } else {
+              resolve();
+            }
+          }
+        }
+
+        next();
+      });
+    }
+  }
+});

package/source/class/qx/event/IEventDispatcher.js

@@ -32,8 +32,10 @@ qx.Interface.define("qx.event.IEventDispatcher", {
      * @return {Boolean} Whether the event dispatcher is responsible for the this event
      */
     canDispatchEvent(target, event, type) {
-      this.assertInstance(event, qx.event.type.Event);
-      this.assertString(type);
+      if (qx.core.Environment.get("qx.debug")) {
+        this.assertInstance(event, qx.event.type.Event);
+        this.assertString(type);
+      }
     },
 
     /**
@@ -45,8 +47,10 @@ qx.Interface.define("qx.event.IEventDispatcher", {
      * @return {qx.Promise?} a promise, if one or more of the event handlers returned a promise
      */
     dispatchEvent(target, event, type) {
-      this.assertInstance(event, qx.event.type.Event);
-      this.assertString(type);
+      if (qx.core.Environment.get("qx.debug")) {
+        this.assertInstance(event, qx.event.type.Event);
+        this.assertString(type);
+      }
     }
   }
 });

package/source/class/qx/event/Manager.js

@@ -277,6 +277,10 @@ qx.Class.define("qx.event.Manager", {
       if (entryMap && entryMap.size > 0) {
         var listeners = [...entryMap.values()];
 
+        if (qx.core.Environment.get("runtime.name") == "rhino") {
+          return listeners;
+        }
+
         return new Proxy(listeners, {
           deleteProperty(target, property) {
             if (property !== "length") {

package/source/class/qx/event/Messaging.js

@@ -40,6 +40,8 @@
  * </pre>
  */
 qx.Bootstrap.define("qx.event.Messaging", {
+  extend: qx.core.Object,
+
   construct() {
     this._listener = {};
     this.__listenerIdCount = 0;

package/source/class/qx/event/Pool.js

@@ -25,6 +25,13 @@ qx.Class.define("qx.event.Pool", {
   extend: qx.util.ObjectPool,
   type: "singleton",
 
+  properties: {
+    size: {
+      refine: true,
+      event: null
+    }
+  },
+
   // Even though this class contains almost no code it is required because the
   // legacy code needs a place to patch the event pooling behavior.
 

package/source/class/qx/event/Registration.js

@@ -264,48 +264,10 @@ qx.Class.define("qx.event.Registration", {
      *     Returns true, when the event was NOT prevented.
      */
     dispatchEvent(target, event) {
-      return this.getManager(target).dispatchEvent(target, event);
-    },
-
-    /**
-     * Create an event object and dispatch it on the given target.
-     *
-     * @param target {Object} Any valid event target
-     * @param type {String} Event type to fire
-     * @param clazz {Class?qx.event.type.Event} The event class
-     * @param args {Array?null} Arguments, which will be passed to
-     *       the event's init method.
-     * @return {Event} the event
-     * @see #createEvent
-     */
-    __fireEvent(target, type, clazz, args) {
-      if (qx.core.Environment.get("qx.debug")) {
-        if (arguments.length > 2 && clazz === undefined && args !== undefined) {
-          throw new Error(
-            "Create event of type " +
-              type +
-              " with undefined class. Please use null to explicit fallback to default event type!"
-          );
-        }
-
-        var msg =
-          "Could not fire event '" +
-          type +
-          "' on target '" +
-          (target ? target.classname : "undefined") +
-          "': ";
-
-        qx.core.Assert.assertNotUndefined(
-          target,
-          msg + "Invalid event target."
-        );
-
-        qx.core.Assert.assertNotNull(target, msg + "Invalid event target.");
-      }
-
-      var evt = this.createEvent(type, clazz || null, args);
-      this.getManager(target).dispatchEvent(target, evt);
-      return evt;
+      return qx.event.Registration.getManager(target).dispatchEvent(
+        target,
+        event
+      );
     },
 
     /**
@@ -354,15 +316,17 @@ qx.Class.define("qx.event.Registration", {
         qx.core.Assert.assertNotNull(target, msg + "Invalid event target.");
       }
 
-      var evt = this.createEvent(type, clazz || null, args);
-      var tracker = {};
-      var self = this;
-      qx.event.Utils.then(tracker, function () {
-        return self.getManager(target).dispatchEvent(target, evt);
-      });
-      return qx.event.Utils.then(tracker, function () {
+      var evt = qx.event.Registration.createEvent(type, clazz || null, args);
+      var promise = qx.event.Registration.getManager(target).dispatchEvent(
+        target,
+        evt
+      );
+
+      if (qx.lang.Type.isPromise(promise)) {
+        return promise.then(() => !evt.getDefaultPrevented());
+      } else {
         return !evt.getDefaultPrevented();
-      });
+      }
     },
 
     /**
@@ -379,14 +343,28 @@ qx.Class.define("qx.event.Registration", {
      * @see #createEvent
      */
     fireEventAsync(target, type, clazz, args) {
-      if (qx.core.Environment.get("qx.promise")) {
-        return qx.Promise.resolve(this.fireEvent(target, type, clazz, args));
-      } else {
+      if (!qx.core.Environment.get("qx.promise")) {
         throw new Error(
-          this.classname +
-            ".fireEventAsync not supported because qx.promise==false"
+          `${qx.event.Registration.classname}.fireEventAsync not supported because qx.promise==false`
+        );
+      }
+
+      if (qx.core.Environment.get("qx.debug")) {
+        if (arguments.length > 2 && clazz === undefined && args !== undefined) {
+          throw new Error(
+            `Create event of type ${type} with undefined class. Please use null to explicit fallback to default event type!`
+          );
+        }
+
+        var msg = `Could not fire event '${type}' on target '${target?.classname || "undefined"}': `;
+        qx.core.Assert.assertNotUndefined(
+          target,
+          msg + "Invalid event target."
         );
+        qx.core.Assert.assertNotNull(target, msg + "Invalid event target.");
       }
+
+      return qx.Promise.resolve(this.fireEvent(target, type, clazz, args));
     },
 
     /**

package/source/class/qx/event/Timer.js

@@ -158,6 +158,8 @@ qx.Class.define("qx.event.Timer", {
   */
 
   members: {
+    __onceFunc: undefined,
+
     __intervalHandler: null,
     __oninterval: null,
 

package/source/class/qx/event/Utils.js

@@ -17,7 +17,7 @@
 ************************************************************************ */
 
 /**
- * Utility methods which implement a fast, psuedo-promises mechanism used by event handlers
+ * Utility methods which implement a fast, pseudo-promises mechanism used by event handlers
  * and dispatchers.
  *
  * Event handlers are allowed to return instances of `qx.Promise`, in which case the event
@@ -58,6 +58,22 @@ qx.Class.define("qx.event.Utils", {
   statics: {
     ABORT: "[[ qx.event.Utils.ABORT ]]",
 
+    /**
+     * If lastPromise is a promise, chains next onto it. Otherwise, returns next.
+     * @param {Promise} lastPromise 
+     * @param {*} next 
+     * @returns {*}
+     */
+    queuePromise(lastPromise, next) {
+      if (lastPromise && qx.lang.Type.isPromise(lastPromise)) {
+        return lastPromise.then(() => next);
+      }
+      if (qx.lang.Type.isPromise(next)) {
+        return next;
+      }
+      return null;
+    },
+
     /**
      * Evaluates a value, and adds it to the tracker
      *
@@ -97,18 +113,19 @@ qx.Class.define("qx.event.Utils", {
         if (tracker.promises === undefined) {
           tracker.promises = [];
         }
-        var ex = null;
-        try {
-          throw new Error("");
-        } catch (e) {
-          ex = e;
-        }
-        tracker.promises.push({ promise: newPromise, ex: ex });
+        tracker.promises.push({ promise: newPromise, ex: new Error("") });
       }
       tracker.promise = newPromise;
       return tracker.promise;
     },
 
+    /**
+     * Equivalent of `promise.then()`
+     *
+     * @param tracker {Object} the tracker object
+     * @param fn {Function} the function to call when previous promises are complete
+     * @return {qx.Promise?} the new promise, or the return value from `fn` if no promises are in use
+     */
     /**
      * Equivalent of `promise.then()`
      *