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

package/source/class/qx/data/SingleValueBinding.js

@@ -97,6 +97,12 @@ qx.Class.define("qx.data.SingleValueBinding", {
    *       be called if the set of the value fails.
    * @property {string} ignoreConverter A string which will be matched using the current
    *       property chain. If it matches, the converter will not be called.
+   * @property {boolean} async If true, the following will happen:
+   * - The binding's init promise (returned by `getInitPromise`) will resolve only after the initial value has been set on the target. 
+   * If any properties in the source and target chains have async getters,
+   * the initial set may happen on a later tick.
+   * - The binding will call setAsync on the target value instead of the synchronous `set` and the init promise will resolve after the initial setAsync call has resolved.
+   * 
    * 
    *
    * @callback converter
@@ -126,6 +132,7 @@ qx.Class.define("qx.data.SingleValueBinding", {
       throw new Error("SourcePath and targetPath must be specified");
     }
     this.__options = options ?? {};
+    this.__async = !!this.__options.async;
     let tracker = {};
 
     const Utils = qx.event.Utils;
@@ -169,6 +176,10 @@ qx.Class.define("qx.data.SingleValueBinding", {
   },
 
   members: {
+    /**
+     * Whether this binding is asynchronous
+     */
+    __async: false,
     /**
      * @type {*}
      */
@@ -202,6 +213,14 @@ qx.Class.define("qx.data.SingleValueBinding", {
      */
     __options: null,
 
+    /**
+     * 
+     * @returns {boolean}
+     */
+    isAsync() {
+      return this.__async;
+    },
+
     /**
      * Promises/A+ thenable compliance, this means that you can await the binding for initialisation
      * https://promisesaplus.com/
@@ -320,7 +339,7 @@ qx.Class.define("qx.data.SingleValueBinding", {
       }
       this.__record = null; // invalidate record representation cache
       this.__targetSegments = qx.data.SingleValueBinding.__parseSegments(this, value);
-      this.__targetSegments.at(-1).addListener("changeInput", this.__updateTarget, this);
+      this.__targetSegments.at(-1).setChangeInputCallback(() => this.__updateTarget());
     },
 
     /**
@@ -577,27 +596,6 @@ qx.Class.define("qx.data.SingleValueBinding", {
       return out;
     },
 
-    /**
-     * Splits a property path into segments.
-     * @param {string} path
-     * @returns {string[]} an array of segments, split by dot and square brackets.
-     * For example, splitSegments(`a.b[0].c`) will return `["a", "b", "[0]", "c"]`
-     */
-    splitSegments(path) {
-      let out = [];
-      for (let dotSplit of path.split(".")) {
-        let bracketSplits = dotSplit.split("[");
-        for (let i = 0; i < bracketSplits.length; i++) {
-          let bracketSplit = bracketSplits[i];
-          if (i > 0) {
-            bracketSplit = "[" + bracketSplit;
-          }
-          out.push(bracketSplit);
-        }
-      }
-      return out.filter(s => s.length > 0);
-    },
-
     /**
      * Finds all bindings for an object, as either a source or target
      *
@@ -673,72 +671,6 @@ qx.Class.define("qx.data.SingleValueBinding", {
       }
     },
 
-    /**
-     * Helper method that sets a value for a named property
-     *
-     * @param {qx.core.Object} target object to have a property set
-     * @param {String} propertyName the name of the property
-     * @param {Object?} value the value to set
-     */
-    set(target, propertyName, value) {
-      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
-      if (!prop) {
-        let setFuncName = "set" + qx.lang.String.firstUp(propertyName);
-        if (typeof target[setFuncName] == "function") {
-          return target[setFuncName](value);
-        } else {
-          throw new Error(`Property ${propertyName} not found on ${target.classname}`);
-        }
-      }
-
-      if (prop.isAsync()) {
-        return prop.setAsync(target, value);
-      } else {
-        return prop.set(target, value);
-      }
-    },
-
-    /**
-     * Helper method to get a value of a named property
-     *
-     * @param {qx.core.Object} target object to have a property get
-     * @param {String} propertyName the name of the property
-     * @returns {Object?} the property value
-     */
-    get(target, propertyName) {
-      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
-      if (prop.isAsync()) {
-        return prop.getAsync(target);
-      } else {
-        return prop.get(target);
-      }
-    },
-
-    /**
-     * Helper method that resets a named property
-     *
-     * @param {qx.core.Object} target object to have a property set
-     * @param {String} propertyName the name of the property
-     
-     */
-    reset(target, propertyName) {
-      let prop = qx.util.PropertyUtil.getProperty(target.constructor, propertyName);
-      if (!prop) {
-        let setFuncName = "reset" + qx.lang.String.firstUp(propertyName);
-        if (typeof target[setFuncName] == "function") {
-          return target[setFuncName]();
-        } else {
-          throw new Error(`Property ${propertyName} not found on ${target.classname}`);
-        }
-      }
-
-      if (prop.isAsync()) {
-        return prop.resetAsync(target);
-      } else {
-        return prop.reset(target);
-      }
-    },
-
     /**
      *
      * Internal helper for getting the current set value at the property chain.
@@ -783,26 +715,52 @@ qx.Class.define("qx.data.SingleValueBinding", {
      * @return {qx.data.binding.AbstractSegment[]?} the new array of segments
      */
     __parseSegments(binding, path) {
-      let segsStrings = qx.data.SingleValueBinding.splitSegments(path);
+      let segsStrings = this.__splitSegments(path);
+      //should be let segsStrings = path.split(/\.|(?=\[)|(?<=\])/g);// split by dot or square brackets, but keep the brackets as part of the segments
+      //but this breaks our Rhino because it's really old
+      //TODO update Rhino
+
       let segments = [];
 
-      for (let seg of segsStrings) {
+      let previous;
+      for (let segStr of segsStrings) {
+        let seg;
         //if it's an array index:
-        if (seg.startsWith("[")) {
-          segments.push(new qx.data.binding.ArrayIndexSegment(binding, seg));
+        if (segStr.startsWith("[")) {
+          seg = new qx.data.binding.ArrayIndexSegment(binding, segStr);
         } else {
           //otherwise, it's a normal path
-          segments.push(new qx.data.binding.PropNameSegment(binding, seg));
+          seg = new qx.data.binding.PropNameSegment(binding, segStr);
         }
-      }
-
-      segments.forEach((seg, index) => {
-        if (index < segments.length - 1) {
-          seg.setOutputReceiver(segments[index + 1]);
+        if (previous) {
+          previous.setOutputReceiver(seg);
         }
-      });
+        previous = seg;
+        segments.push(seg);
+      }      
 
       return segments;
-    }
+    },
+
+    /**
+     * Splits a property path into segments.
+     * @param {string} path
+     * @returns {string[]} an array of segments, split by dot and square brackets.
+     * For example, splitSegments(`a.b[0].c`) will return `["a", "b", "[0]", "c"]`
+     */
+    __splitSegments(path) {
+      let out = [];
+      for (let dotSplit of path.split(".")) {
+        let bracketSplits = dotSplit.split("[");
+        for (let i = 0; i < bracketSplits.length; i++) {
+          let bracketSplit = bracketSplits[i];
+          if (i > 0) {
+            bracketSplit = "[" + bracketSplit;
+          }
+          out.push(bracketSplit);
+        }
+      }
+      return out.filter(s => s.length > 0);
+    },
   }
 });

package/source/class/qx/data/binding/AbstractSegment.js

@@ -47,15 +47,12 @@ qx.Class.define("qx.data.binding.AbstractSegment", {
     }
   },
 
-  /**
-   * Fired when this segment's input changed, and it has been received and fully processed by the next segments in the chain,
-   * i.e. any async set/get operations have completed.
-   */
-  events: {
-    changeInput: "qx.event.type.Data"
-  },
-
   members: {
+    /**
+     * Called when this segment's input changed, and it has been received and fully processed by the next segments in the chain,
+     * i.e. any async set/get operations have completed.
+     */
+    __changeInputCallback: () => {},
     /**
      * @type {qx.data.SingleValueBinding}
      */
@@ -70,6 +67,14 @@ qx.Class.define("qx.data.binding.AbstractSegment", {
      */
     __outputReceiver: null,
 
+    /**
+     * 
+     * @param {Function} callback 
+     */
+    setChangeInputCallback(callback) {
+      this.__changeInputCallback = callback;
+    },
+
     /**
      *
      * @returns {qx.data.SingleValueBinding} the binding that this segment belongs to. Useful for debugging purposes.
@@ -125,9 +130,9 @@ qx.Class.define("qx.data.binding.AbstractSegment", {
 
       let out = this._applyInput(value, old);
       if (qx.lang.Type.isPromise(out)) {
-        return out.then(() => this.fireDataEvent("changeInput", value, old));
+        return out.then(() => this.__changeInputCallback(value, old));
       } else {
-        return this.fireDataEvent("changeInput", value, old);
+        return this.__changeInputCallback(value, old);
       }
     },
 

package/source/class/qx/data/binding/PropNameSegment.js

@@ -69,6 +69,10 @@ qx.Class.define("qx.data.binding.PropNameSegment", {
      * Apply for `input`
      */
     _applyInput(value, oldValue) {
+      if (!this.getOutputReceiver()) {
+        return;
+      }
+
       if (oldValue) {
         let eventName = this.__getEventName(oldValue);
         eventName && oldValue.removeListener(eventName, this.__onChangeInputProperty, this);
@@ -81,9 +85,7 @@ qx.Class.define("qx.data.binding.PropNameSegment", {
         this.setEventName(eventName);
       }
 
-      if (this.getOutputReceiver()) {
-        return this.updateOutput();
-      }
+      return this.updateOutput();
     },
 
     updateOutput() {
@@ -95,10 +97,15 @@ qx.Class.define("qx.data.binding.PropNameSegment", {
         if (property === null) {
           return this._setOutput(null);
         }
-        if (!property.isAsync() || property.isInitialized(input)) {
-          let nextInput = property.get(input, this.__propName);
+        if (!property.supportsGetAsync() || property.hasLocalValue(input)) {
+          let nextInput = property.get(input);
           return this._setOutput(nextInput);
         } else {
+          if (qx.core.Environment.get("qx.debug")) {
+            if (!(this.getBinding()?.isAsync())) {
+              this.warn(`In binding ${this}, property "${this.__propName}" wasn't available synchronously but the binding is not async. This will cause the target to be updated in a later tick. If you want to await the initial set, use 'object.bindAsync' or add 'async: true' in the binding options.`);
+            }
+          }
           let promise = property.getAsync(input);
           return promise.then(nextInput => this._setOutput(nextInput));
         }
@@ -109,13 +116,31 @@ qx.Class.define("qx.data.binding.PropNameSegment", {
      * @override
      */
     setTargetValue(targetValue) {
-      if (this.getInput() == null || this.getInput() === undefined) {
+      let input = this.getInput();
+      if (input == null || input === undefined) {
         return;
       }
+
+      let async = this.getBinding()?.isAsync();
+      
+      //get the setter method name
+      let upname = qx.lang.String.firstUp(this.__propName);
+
+      let method;
       if (targetValue !== undefined) {
-        return qx.data.SingleValueBinding.set(this.getInput(), this.__propName, targetValue);
+        if (async) {
+          method = `set${upname}Async`;
+        } else {
+          method = `set${upname}`;
+        }
+        return input[method](targetValue);
       } else {
-        return qx.data.SingleValueBinding.reset(this.getInput(), this.__propName);
+        if (async) {
+          method = `reset${upname}Async`;
+        } else {
+          method = `reset${upname}`;
+        }
+        return input[method]();
       }
     },
 
@@ -125,9 +150,7 @@ qx.Class.define("qx.data.binding.PropNameSegment", {
      * @param {qx.event.type.Data} evt
      */
     __onChangeInputProperty(evt) {
-      if (this.getOutputReceiver()) {
-        return this._setOutput(evt.getData());
-      }
+      return this._setOutput(evt.getData());
     },
 
     /**

package/source/class/qx/test/Mixin.js

@@ -631,6 +631,225 @@ qx.Class.define("qx.test.Mixin", {
       o.dispose();
     },
 
+    /**
+     * Primary bug: when the same mixin is included in two different classes,
+     * addMembers() overwrites the shared mixin function's .base pointer on the
+     * second include, causing the first class's super() call to resolve to the
+     * wrong base method. Per-mixin-per-class $mixinBases storage fixes this.
+     */
+    testMixinInMultipleClasses() {
+      // Two unrelated base classes, each with a 'describe' method
+      qx.Class.define("qx.MBase1", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base1";
+          }
+        }
+      });
+      qx.Class.define("qx.MBase2", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base2";
+          }
+        }
+      });
+
+      // Same mixin included in both classes
+      qx.Mixin.define("qx.MDual", {
+        members: {
+          describe() {
+            return super.describe() + " + Mixin";
+          }
+        }
+      });
+
+      qx.Class.define("qx.MChild1", { extend: qx.MBase1, include: [qx.MDual] });
+      qx.Class.define("qx.MChild2", { extend: qx.MBase2, include: [qx.MDual] });
+
+      var c1 = new qx.MChild1();
+      var c2 = new qx.MChild2();
+
+      // Without the fix, c1.describe() would call Base2 (last include clobbered fn.base)
+      this.assertEquals("Base1 + Mixin", c1.describe());
+      this.assertEquals("Base2 + Mixin", c2.describe());
+
+      c1.dispose();
+      c2.dispose();
+      qx.Class.undefine("qx.MChild1");
+      qx.Class.undefine("qx.MChild2");
+      qx.Class.undefine("qx.MDual");
+      qx.Class.undefine("qx.MBase1");
+      qx.Class.undefine("qx.MBase2");
+    },
+
+    /**
+     * Regression test: when two different mixins both override the same method
+     * and are both patched into the same class, a naive per-class base cache
+     * (keyed by method name only) would be overwritten by the second patch,
+     * making the first mixin's super() resolve back to itself → infinite recursion.
+     * The per-mixin-per-class $mixinBases Map avoids this by using the mixin as
+     * the lookup key, so each mixin retains its own base reference.
+     */
+    testPatchTwoMixinsSameMethodNoInfiniteRecursion() {
+      qx.Class.define("qx.IRBase", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "base";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MIR1", {
+        members: {
+          describe() {
+            return super.describe() + " [m1]";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MIR2", {
+        members: {
+          describe() {
+            return super.describe() + " [m2]";
+          }
+        }
+      });
+
+      qx.Class.patch(qx.IRBase, qx.MIR1);
+      qx.Class.patch(qx.IRBase, qx.MIR2);
+
+      var obj = new qx.IRBase();
+      // Without per-mixin base storage, MIR1's super() resolves to MIR1 itself → stack overflow
+      this.assertEquals("base [m1] [m2]", obj.describe());
+
+      obj.dispose();
+      qx.Class.undefine("qx.IRBase");
+      qx.Class.undefine("qx.MIR1");
+      qx.Class.undefine("qx.MIR2");
+    },
+
+    /**
+     * Mixin-in-mixin: an outer mixin composes an inner mixin (via include:)
+     * with no members of its own. When the outer mixin is applied to two
+     * different classes, the inner mixin's super() call must resolve to each
+     * class's own base — not the last class to include it (which would clobber
+     * the shared .base pointer on the inner mixin's function object).
+     */
+    testMixinInMixinMultipleClasses() {
+      // Inner mixin with a greet() calling super
+      qx.Mixin.define("qx.MInner", {
+        members: {
+          greet() {
+            return super.greet() + " [inner]";
+          }
+        }
+      });
+
+      // Pure composition mixin: no own members, just includes MInner
+      qx.Mixin.define("qx.MOuter", {
+        include: [qx.MInner]
+      });
+
+      qx.Class.define("qx.MIMBase1", {
+        extend: qx.core.Object,
+        members: {
+          greet() {
+            return "Alpha";
+          }
+        }
+      });
+      qx.Class.define("qx.MIMBase2", {
+        extend: qx.core.Object,
+        members: {
+          greet() {
+            return "Beta";
+          }
+        }
+      });
+
+      // Both classes include MOuter — MInner.greet's .base gets clobbered on the
+      // second include without per-mixin-per-class storage
+      qx.Class.define("qx.MIMClass1", { extend: qx.MIMBase1, include: [qx.MOuter] });
+      qx.Class.define("qx.MIMClass2", { extend: qx.MIMBase2, include: [qx.MOuter] });
+
+      var c1 = new qx.MIMClass1();
+      var c2 = new qx.MIMClass2();
+      // MInner.greet's super must resolve to each class's own base, not the last one applied
+      this.assertEquals("Alpha [inner]", c1.greet());
+      this.assertEquals("Beta [inner]", c2.greet());
+
+      c1.dispose();
+      c2.dispose();
+      qx.Class.undefine("qx.MIMClass1");
+      qx.Class.undefine("qx.MIMClass2");
+      qx.Class.undefine("qx.MIMBase1");
+      qx.Class.undefine("qx.MIMBase2");
+      qx.Class.undefine("qx.MOuter");
+      qx.Class.undefine("qx.MInner");
+    },
+
+    /**
+     * Deep inheritance: the mixin is included in an ancestor class several
+     * levels up. A second unrelated class also includes the same mixin,
+     * clobbering the shared .base pointer. The baseClassMethod lookup must
+     * traverse the inheritance chain to find $mixinBases on the ancestor and
+     * return the correct (per-class) base function.
+     */
+    testDeepInheritanceMixinBaseResolution() {
+      qx.Class.define("qx.DIBase1", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base1";
+          }
+        }
+      });
+      qx.Class.define("qx.DIBase2", {
+        extend: qx.core.Object,
+        members: {
+          describe() {
+            return "Base2";
+          }
+        }
+      });
+
+      qx.Mixin.define("qx.MDI", {
+        members: {
+          describe() {
+            return super.describe() + " [mixin]";
+          }
+        }
+      });
+
+      // Mixin applied at Parent1; Child1 and Grandchild1 inherit it
+      qx.Class.define("qx.DIParent1", { extend: qx.DIBase1, include: [qx.MDI] });
+      qx.Class.define("qx.DIChild1", { extend: qx.DIParent1 });
+      qx.Class.define("qx.DIGrandchild1", { extend: qx.DIChild1 });
+
+      // Second unrelated class including the same mixin — clobbers MDI.$$members.describe.base
+      qx.Class.define("qx.DIParent2", { extend: qx.DIBase2, include: [qx.MDI] });
+
+      var deep = new qx.DIGrandchild1();
+      var other = new qx.DIParent2();
+
+      // $mixinBases must be found on DIParent1 (ancestor), not on the instance's own class
+      this.assertEquals("Base1 [mixin]", deep.describe());
+      this.assertEquals("Base2 [mixin]", other.describe());
+
+      deep.dispose();
+      other.dispose();
+      qx.Class.undefine("qx.DIGrandchild1");
+      qx.Class.undefine("qx.DIChild1");
+      qx.Class.undefine("qx.DIParent1");
+      qx.Class.undefine("qx.DIParent2");
+      qx.Class.undefine("qx.MDI");
+      qx.Class.undefine("qx.DIBase1");
+      qx.Class.undefine("qx.DIBase2");
+    },
+
     testDoubleMixin() {
       qx.Class.define("qx.D", {
         extend: qx.core.Object,

package/source/class/qx/test/Promise.js

@@ -566,7 +566,7 @@ qx.Class.define("qx.test.Promise", {
 
     /**
      * Tests that a property apply method can return a promise; in this case, the
-     * property *is* marked as async, and we use the setAlphaAsync to test chaining
+     * and we use the setAlphaAsync to test chaining
      */
     testPropertySetValueAsyncApply2() {
       var t = this;
@@ -576,7 +576,6 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             apply: "_applyAlpha",
 
             event: "changeAlpha"
@@ -632,9 +631,8 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             event: "changeAlpha",
-            apply: () => { }
+            apply: () => {}
           }
         }
       });
@@ -685,8 +683,9 @@ qx.Class.define("qx.test.Promise", {
         });
 
         asyncObj.getAlphaAsync();
-        asyncObj.bind("alpha", syncObj, "bravo");
-        asyncObj.setAlphaAsync("zyx");
+        asyncObj.bindAsync("alpha", syncObj, "bravo").then(() => {
+          asyncObj.setAlphaAsync("zyx");
+        });
         qx.Promise.all([p1, p2]).then(function () {
           var p3 = new qx.Promise();
           syncObj.addListenerOnce("changeBravo", evt => {
@@ -707,10 +706,11 @@ qx.Class.define("qx.test.Promise", {
       /*
        * Test binding a "normal" sync property to an async property
        */
-      if (!qx.core.Environment.get("qx.core.property.Property.applyDuringConstruct")) {
-        console.warn("Not working with applyDuringConstruct = false, skipping testBinding async-to-sync part");
-        return;  // Test wird übersprungen, zählt als "ok"
-      }
+      //2026-FEB-25  - Commented this out because it causes this unit test to fail.
+      // if (!qx.core.Environment.get("qx.core.property.Property.applyDuringConstruct")) {
+      //   console.warn("Not working with applyDuringConstruct = false, skipping testBinding async-to-sync part");
+      //   return;
+      // }
       asyncToSync.then(function () {
         var asyncObj = new AsyncClazz();
         var syncObj = new SyncClazz();
@@ -755,7 +755,6 @@ qx.Class.define("qx.test.Promise", {
           alpha: {
             init: null,
             nullable: true,
-            async: true,
             apply: "_applyAlpha",
             event: "changeAlpha"
           }