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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qooxdoo/framework",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.3",
   "description": "The JS Framework for Coders",
   "author": "The qooxdoo project",
   "keywords": [

package/source/class/qx/Class.js

@@ -75,7 +75,6 @@ qx.Bootstrap.define("qx.Class", {
       event: ["string", "object"], // String or null
       check: null, // Array, String, Function
       transform: null, // String, Function
-      async: "boolean", // Boolean
       deferredInit: "boolean", // Boolean
       validate: ["string", "function"], // String, Function
       isEqual: ["string", "function"], // String, Function
@@ -803,10 +802,18 @@ qx.Bootstrap.define("qx.Class", {
      * @param members {Map}
      *   The map of members to attach
      *
+     * @param events {Map?}
+     *   The map of events declared by the mixin (used for member validation)
+     *
      * @param patch {Boolean ? false}
      *   Enable patching
+     *
+     * @param mixin {qx.Mixin?}
+     *   The mixin being applied, if any. Used to store per-mixin-per-class base
+     *   method references so that super calls resolve correctly when the same
+     *   mixin is included in multiple classes.
      */
-    addMembers(clazz, members, events, patch) {
+    addMembers(clazz, members, events, patch, mixin) {
       let proto = clazz.prototype;
       let classOwnMembers = {}; // Track class members to restore after mixin addition
 
@@ -906,6 +913,18 @@ qx.Bootstrap.define("qx.Class", {
               member.self = clazz;
             }
             member.base = clazz.prototype[key];
+            // Fix: per-mixin-per-class storage to prevent clobbering when the same mixin
+            // is included/patched into multiple classes, or when multiple mixins override
+            // the same method in the same class.
+            if (mixin) {
+              if (!clazz.$mixinBases) {
+                clazz.$mixinBases = new Map();
+              }
+              if (!clazz.$mixinBases.has(mixin)) {
+                clazz.$mixinBases.set(mixin, {});
+              }
+              clazz.$mixinBases.get(mixin)[key] = clazz.prototype[key];
+            }
           }
 
           // Create the storage for this member
@@ -1127,7 +1146,7 @@ qx.Bootstrap.define("qx.Class", {
 
         // Attach members
         if (entry.$$members) {
-          qx.Class.addMembers(clazz, entry.$$members, entry.$$events, patch);
+          qx.Class.addMembers(clazz, entry.$$members, entry.$$events, patch, entry);
         }
 
         // Attach properties
@@ -1875,7 +1894,7 @@ qx.Bootstrap.define("qx.Class", {
      */
     isPropertyInitialized(object, name) {
       let property = object.constructor.prototype.$$allProperties[name];
-      return !!(property && property.isInitialized(object));
+      return !!(property && property.hasLocalValue(object));
     },
 
     /**

package/source/class/qx/Mixin.js

@@ -348,7 +348,7 @@ qx.Bootstrap.define("qx.Mixin", {
           //  implementation is the first mixin's method
           for (var i = mixedInIndex - 1; i > -1; i--) {
             var peerMixin = mixedInAt.$$flatIncludes[i];
-            if (peerMixin.$$members[methodName]) {
+            if (peerMixin.$$members && peerMixin.$$members[methodName]) {
               fn = peerMixin.$$members[methodName];
               break;
             }
@@ -356,12 +356,21 @@ qx.Bootstrap.define("qx.Mixin", {
 
           // Try looking in the class itself
           if (!fn && mixedInAt.prototype[methodName]) {
-            fn = mixedInAt.prototype[methodName];
-            for (let i = 0; i < mixedInAt.$$flatIncludes.length; i++) {
-              if (!mixedInAt.$$flatIncludes[i].$$members[methodName]) {
-                continue;
+            // Use per-mixin-per-class storage to avoid clobbering when the same mixin
+            // is included in multiple classes or when multiple mixins override the same method
+            if (mixedInAt.$mixinBases && mixedInAt.$mixinBases.has(mixin)) {
+              fn = mixedInAt.$mixinBases.get(mixin)[methodName] ?? null;
+            }
+            if (!fn) {
+              // Fallback: traverse .base chain (works for patch=true since each patch
+              // creates a unique wrapper function with its own .base property)
+              fn = mixedInAt.prototype[methodName];
+              for (let i = 0; i < mixedInAt.$$flatIncludes.length; i++) {
+                if (!mixedInAt.$$flatIncludes[i].$$members || !mixedInAt.$$flatIncludes[i].$$members[methodName]) {
+                  continue;
+                }
+                fn = fn.base;
               }
-              fn = fn.base;
             }
           }
 

package/source/class/qx/core/check/AbstractCheck.js

@@ -23,13 +23,17 @@ qx.Bootstrap.define("qx.core.check.AbstractCheck", {
   extend: Object,
   implement: qx.core.check.ICheck,
 
+  /**
+   * 
+   * @param {boolean} nullable 
+   */
   construct(nullable) {
     super();
     this.__nullable = !!nullable;
   },
 
   members: {
-    /** @type{Boolean} whether null is allowed */
+    /** @type {Boolean} whether null is allowed */
     __nullable: null,
 
     /**

package/source/class/qx/core/check/CheckFactory.js

@@ -68,6 +68,12 @@ qx.Bootstrap.define("qx.core.check.CheckFactory", {
       expr = expr.replace(/<.*>/g, ""); // remove generics
 
       let checkname = expr;
+      if (checkname.includes("||")) {
+        //For now, if the typename contains ||, we just accept it.
+        //That's what it was like in version 7
+        return new qx.core.check.Any();
+      }
+
       if (checkname.endsWith("?")) {
         checkname = checkname.substring(0, checkname.length - 1);
         nullable = true;

package/source/class/qx/core/check/DynamicTypeCheck.js

@@ -22,6 +22,11 @@
 qx.Bootstrap.define("qx.core.check.DynamicTypeCheck", {
   extend: qx.core.check.AbstractCheck,
 
+  /**
+   * 
+   * @param {string} typename 
+   * @param {boolean} nullable 
+   */
   construct(typename, nullable) {
     super(nullable);
     this.__typename = typename;

package/source/class/qx/core/property/ExplicitPropertyStorage.js

@@ -25,16 +25,10 @@ qx.Bootstrap.define("qx.core.property.ExplicitPropertyStorage", {
 
   /**
    * @param {qx.core.property.Property} property
-   * @param {Function} clazz Qooxdoo class which the property relates to
    */
-  construct(property, clazz) {
+  construct(property) {
     super();
-    let def = property.getDefinition();
     this.__property = property;
-    this.__get = def.get;
-    this.__getAsync = def.getAsync || def.get;
-    this.__set = def.set;
-    this.__setAsync = def.setAsync || def.set;
   },
 
   members: {
@@ -42,32 +36,26 @@ qx.Bootstrap.define("qx.core.property.ExplicitPropertyStorage", {
      * @type {qx.core.property.Property}
      */
     __property: null,
+    
     /**
      * @Override
      */
     get(thisObj, property) {
-      return this.__get.call(thisObj, property, thisObj);
+      return this.__property.getDefinition().get.call(thisObj, property, thisObj);
     },
 
     /**
      * @Override
      */
     getAsync(thisObj, property) {
-      return this.__getAsync.call(thisObj, property, thisObj);
+      return this.__property.getDefinition().getAsync.call(thisObj, property, thisObj);
     },
 
     /**
      * @Override
      */
     set(thisObj, property, value) {
-      this.__set.call(thisObj, value, property, thisObj);
-    },
-
-    /**
-     * @Override
-     */
-    setAsync(thisObj, property, value) {
-      return this.__setAsync.call(thisObj, property, value);
+      this.__property.getDefinition().set.call(thisObj, value, property, thisObj);
     },
 
     /**
@@ -80,8 +68,8 @@ qx.Bootstrap.define("qx.core.property.ExplicitPropertyStorage", {
     /**
      * @Override
      */
-    isAsyncStorage() {
-      return this.__property.isAsync();
+    supportsGetAsync() {
+      return !!this.__property.getDefinition().getAsync;
     }
   }
 });

package/source/class/qx/core/property/IPropertyStorage.js

@@ -48,25 +48,6 @@ qx.Interface.define("qx.core.property.IPropertyStorage", {
      */
     set(thisObj, property, value) {},
 
-    /**
-     * Sets a value asynchronously
-     *
-     * @param {qx.core.Object} thisObj
-     * @param {qx.core.propety.IProperty} property the property to set the value of
-     * @param {*} value
-     */
-    async setAsync(thisObj, property, value) {},
-
-    /**
-     * Called when the property is reset; for standard properties, this just passes through to
-     * `set`, but pseudo properties may need to call the implemented `reset` method
-     *
-     * @param {qx.core.Object} thisObj
-     * @param {qx.core.propety.IProperty} property the property to set the value of
-     * @param {*} value
-     */
-    reset(thisObj, property, value) {},
-
     /**
      * Deletes the value
      *
@@ -76,8 +57,8 @@ qx.Interface.define("qx.core.property.IPropertyStorage", {
     dereference(thisObj, property) {},
 
     /**
-     * Returns whether the storage supports asynchronous backing, ie the getter could be async
+     * Returns whether the storage supports asynchronous getting.
      */
-    isAsyncStorage() {}
+    supportsGetAsync() {}
   }
 });

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

@@ -41,19 +41,20 @@ qx.Bootstrap.define("qx.core.property.Property", {
      * will return null, instead of throwing an error.
      */
     "qx.core.property.Property.inheritableDefaultIsNull": false,
+
     /**
      * If set to true, then properties with init values will have their apply method called during construction.
-     * Default is false to maintain backward compatibility with v7 behavior.
-     */
-    "qx.core.property.Property.applyDuringConstruct": false,//TODO should this be true?
+     * You should only set this to false if you have a lot of legacy code which would take too much time/effort to modify to work with the new behavior.
+    */
+    "qx.core.property.Property.applyDuringConstruct": true,
 
     /**
      * Only relevant when applyDuringConstruct is true.
      * This contains regexes matching classnames which are excluded from the auto apply behaviour.
      * They refer to concrete classes only, not the superclasses.
      *
-     * Currently (2025-12-03), only "qx." classes are excluded because enabling applyDuringConstruct
-     * would create problems which are difficult to fix.
+     * Currently (2025-DEC-03), only "qx." classes are excluded because enabling applyDuringConstruct
+     * would create problems which are too difficult and time-consuming to fix.
      *
      * @type {Array<RegExp | string>}
      */
@@ -189,10 +190,11 @@ qx.Bootstrap.define("qx.core.property.Property", {
 
       // Figure out the storage implementation
       if (def.storage) {
+        //if it's an object, use it directly as storage
         if (qx.Class.hasInterface(def.storage.constructor, qx.core.property.IPropertyStorage)) {
           this.__storage = def.storage;
         } else {
-          this.__storage = new def.storage();
+          this.__storage = qx.core.property.PropertyStorageFactory.getStorage(def.storage);
         }
       } else {
         if (def.immutable == "replace") {
@@ -201,7 +203,7 @@ qx.Bootstrap.define("qx.core.property.Property", {
           } else if (def.check == "Object") {
             this.__storage = qx.core.property.PropertyStorageFactory.getStorage(qx.core.property.ImmutableObjectStorage);
           } else if (def.check == "qx.data.Array") {
-            this.__storage = qx.core.property.PropertyStorageFactory.getStorage(qx.core.property.ImmutableDataArrayStorage);
+            this.__storage = qx.core.property.PropertyStorageFactory.getStorage(qx.core.property.ImmutableDataArrayStorage);//cbh
           } else {
             throw new Error(
               `${this}: ` + "only `check : 'Array'` and `check : 'Object'` " + "properties may have `immutable : 'replace'`."
@@ -209,7 +211,7 @@ qx.Bootstrap.define("qx.core.property.Property", {
           }
         } else {
           if (typeof def.get == "function" || typeof def.getAsync == "function") {
-            this.__storage = new qx.core.property.ExplicitPropertyStorage(this, this.__clazz);
+            this.__storage = new qx.core.property.ExplicitPropertyStorage(this);
           } else {
             this.__storage = qx.core.property.PropertyStorageFactory.getStorage(qx.core.property.SimplePropertyStorage);
           }
@@ -537,6 +539,12 @@ qx.Bootstrap.define("qx.core.property.Property", {
           return self.resetAsync(this);
         });
       }
+
+      if (this.__pseudoProperty) {
+        this.__supportsGetAsync = this.__clazz.prototype["get" + qx.Bootstrap.firstUp(this.__propertyName) + "Async"] !== undefined;
+      } else {
+        this.__supportsGetAsync = this.__storage.supportsGetAsync();
+      }
     },
 
     /**
@@ -841,35 +849,20 @@ qx.Bootstrap.define("qx.core.property.Property", {
         }
       }
 
+      //store the old value
+      let oldValue = this.__getImpl(thisObj, true);
       let state = this.getPropertyState(thisObj);
 
+      //validate and transform the value
       if (this.__validate) {
         this.__callFunction(thisObj, this.__validate, value, this);
       }
 
-      let oldValue = this.__getImpl(thisObj, true);
-
       if (this.__transform) {
         value = this.__callFunction(thisObj, this.__transform, value, oldValue, this.__propertyName);
       }
 
-      if (method == "reset") {
-        if (scope == "user") {
-          this.__storage.reset(thisObj, this, value);
-        } else if (scope == "themed") {
-          if (value === undefined) {
-            delete state.themeValue;
-          }
-        }
-        value = this.__getImpl(thisObj, true);
-      }
-
-      if (this.isInheritable()) {
-        if (value === "inherit") {
-          value = state.inheritedValue;
-        }
-      }
-
+      //perform additional checks if promise
       let check = this.getCheck();
       if (qx.core.Environment.get("qx.debug")) {
         if (!check || check instanceof qx.core.check.Any) {
@@ -877,13 +870,15 @@ qx.Bootstrap.define("qx.core.property.Property", {
             this.warn(
               "Property " +
                 this +
-                " is being set to a promise, bt its check is not a Promise. The property will be set to the promise itself."
+                " is being set to a promise, but its check is not a Promise. The property will be set to the promise itself."
             );
           }
         }
       }
 
-      if (method !== "reset" && check) {
+      //use check for validation and coercion if necessary,
+      //but only if not resetting
+      if (!(value === "inherit" && this.isInheritable()) && method !== "reset" && check) {
         if (!(value === null && oldValue === null) && !check.matches(value, thisObj)) {
           let coerced = check.coerce(value, thisObj);
           if (qx.lang.Type.isPromise(value) || coerced === null || !check.matches(coerced, thisObj)) {
@@ -893,6 +888,39 @@ qx.Bootstrap.define("qx.core.property.Property", {
         }
       }
 
+      //Modify the value in the underlying storage
+      if (method == "reset") {
+        if (scope == "user") {
+          this.__storage.set(thisObj, this, value);
+        } else if (scope == "themed") {
+          if (value === undefined) {
+            delete state.themeValue;            
+          }
+        }
+        value = this.__getImpl(thisObj, true);
+      } else {
+        if (scope == "user") {
+          // Always set the value to the storage if it is a user value; this is because themable properties
+          // might be equal now, but if the theme value changes, the user's override needs to remain.
+          if (method == "set" || method == "init") {
+            this.__storage.set(thisObj, this, value);
+          }
+        } else if (scope == "themed") {        
+          if (value !== undefined) {
+            state.themeValue = value;
+            value = this.__getImpl(thisObj);
+          }        
+        } 
+      }
+
+      // If the value is "inherit" and the property is inheritable, we need to calculate the inherited value
+      if (this.isInheritable() && value === "inherit") {
+        value = state.inheritedValue;
+      }
+      
+      //the final value has now been deternined.
+      //If it's not equal to the old value or state.applyMethodCalled was not set,
+      //we call apply and fire event            
       let isEqual = this.isEqual(thisObj, value, oldValue);
       if (!isEqual && this.isMutating(thisObj)) {
         this.warn("Property " + this + " is currently mutating");
@@ -914,23 +942,6 @@ qx.Bootstrap.define("qx.core.property.Property", {
 
       this.__setMutating(thisObj, true);
 
-      if (scope == "user") {
-        // Always set the value to the storage if it is a user value; this is because themable properties
-        // might be equal now, but if the theme value changes, the user's override needs to remain.
-        if (method == "set" || method == "init") {
-          this.__storage.set(thisObj, this, value);
-        }
-      } else if (scope == "themed") {
-        if (method != "reset") {
-          if (value !== undefined) {
-            state.themeValue = value;
-            value = this.get(thisObj);
-          }
-        }
-      } else if (qx.core.Environment.get("qx.debug")) {
-        throw new Error(`Invalid scope=${scope} in ${this.classname}.__setImpl`);
-      }
-
       if (value === undefined) {
         value = null;
       }
@@ -976,21 +987,22 @@ qx.Bootstrap.define("qx.core.property.Property", {
 
       let state = this.getPropertyState(thisObj);
 
+      //store the old value
+      //we get it synchronously here because if this property supports async get,
+      //we may not always want to fetch the value asynchronously
+      //this means the apply method will be called with undefined as oldValue
+      let oldValue = this.__getImpl(thisObj, true);
+
+      //validate and transform the value
       if (this.__validate) {
         this.__callFunction(thisObj, this.__validate, value, this);
       }
 
-      let oldValue = await this.__getAsyncImpl(thisObj, true);
 
       if (this.__transform) {
         value = this.__callFunction(thisObj, this.__transform, value, oldValue, this.__propertyName);
       }
 
-      if (method == "reset") {
-        this.__storage.reset(thisObj, this, value);
-        value = await this.__getAsyncImpl(thisObj, true);
-      }
-
       let check = this.getCheck();
       if (qx.core.Environment.get("qx.debug")) {
         if (!check || check instanceof qx.core.check.Any) {
@@ -1014,6 +1026,22 @@ qx.Bootstrap.define("qx.core.property.Property", {
         }
       }
 
+      //Actually modify the underlying storage
+      if (method == "reset") {
+        this.__storage.set(thisObj, this, value);
+        value = this.__getImpl(thisObj, true);
+      } else {
+        if (scope == "user") {
+          // Always set the value to the storage if it is a user value; this is because themable properties
+          // might be equal now, but if the theme value changes, the user's override needs to remain.
+          if (method == "set" || method == "init") {
+            this.__storage.set(thisObj, this, value);
+          }
+        } else if (qx.core.Environment.get("qx.debug")) {
+          throw new Error(`Invalid scope=${scope} in ${this.classname}.__setAsyncImpl`);
+        }
+      }
+
       let isEqual = this.isEqual(thisObj, value, oldValue);
       if (!isEqual && this.isMutating(thisObj)) {
         this.warn("Property " + this + " is currently mutating");
@@ -1037,16 +1065,6 @@ qx.Bootstrap.define("qx.core.property.Property", {
       let promise = new Promise(r => (resolve = r));
       this.__setMutating(thisObj, promise);
 
-      if (scope == "user") {
-        // Always set the value to the storage if it is a user value; this is because themable properties
-        // might be equal now, but if the theme value changes, the user's override needs to remain.
-        if (method == "set" || method == "init") {
-          this.__storage.set(thisObj, this, value);
-        }
-      } else if (qx.core.Environment.get("qx.debug")) {
-        throw new Error(`Invalid scope=${scope} in ${this.classname}.__setAsyncImpl`);
-      }
-
       if (value === undefined) {
         value = null;
       }
@@ -1075,8 +1093,6 @@ qx.Bootstrap.define("qx.core.property.Property", {
 
         if (value !== undefined) {
           return value;
-        } else if (this.isAsync()) {
-          return undefined;
         }
 
         let state = this.getPropertyState(thisObj);
@@ -1105,7 +1121,7 @@ qx.Bootstrap.define("qx.core.property.Property", {
 
       if (value !== undefined) {
         return value;
-      } else if (this.isAsync()) {
+      } else if (this.__supportsGetAsync) {
         if (!safe) {
           throw new Error("Property " + this + " has not been initialized - try using getAsync() instead");
         } else {
@@ -1133,6 +1149,11 @@ qx.Bootstrap.define("qx.core.property.Property", {
      * @returns {Promise<*>}
      */
     async __getAsyncImpl(thisObj, safe) {
+      if (qx.core.Environment.get("qx.debug")) {
+        if (!this.__supportsGetAsync) {
+          this.warn(`Called getAsync/resetAsync in property ${this} which does not support async getter.`);
+        }
+      }
       const getRaw = async () => {
         let value = this.__storage.get(thisObj, this);
 
@@ -1140,12 +1161,14 @@ qx.Bootstrap.define("qx.core.property.Property", {
           return value;
         }
 
-        value = await this.__storage.getAsync(thisObj, this);
+        value = this.getInitValue(thisObj);
         if (value !== undefined) {
           return value;
         }
 
-        return this.getInitValue(thisObj);
+        if (this.__supportsGetAsync) {
+          return await this.__storage.getAsync(thisObj, this);
+        }
       };
 
       let value = await getRaw();
@@ -1383,23 +1406,24 @@ qx.Bootstrap.define("qx.core.property.Property", {
     promiseReady(thisObj) {},
 
     /**
-     * Whether the property is initialized
+     * Whether the property has a defined value stored locally,
+     * meaning we can safely get it synchronously
      *
      * @param {qx.core.Object} thisObj the object on which the property is defined
      * @return {Boolean}
      */
-    isInitialized(thisObj) {
+    hasLocalValue(thisObj) {
       let value = this.__getImpl(thisObj, true);
       return value !== undefined;
     },
 
     /**
-     * Whether the property supports async
+     * Whether the property supports getting asynchronously from the underlying storage
      *
      * @return {Boolean}
      */
-    isAsync() {
-      return !!this.__definition?.async;
+    supportsGetAsync() {
+      return this.__supportsGetAsync;      
     },
 
     /**

package/source/class/qx/core/property/SimplePropertyStorage.js

@@ -37,7 +37,7 @@ qx.Bootstrap.define("qx.core.property.SimplePropertyStorage", {
      * @Override
      */
     async getAsync(thisObj, property) {
-      return this.get(thisObj, property);
+      // nothing
     },
 
     /**
@@ -52,22 +52,6 @@ qx.Bootstrap.define("qx.core.property.SimplePropertyStorage", {
       data.value = value;
     },
 
-    /**
-     * @Override
-     */
-    async setAsync(thisObj, property, value) {
-      return qx.Promise.resolve(value).then(value => {
-        this.set(thisObj, property, value);
-      });
-    },
-
-    /**
-     * @Override
-     */
-    reset(thisObj, property, value) {
-      this.set(thisObj, property, value);
-    },
-
     /**
      * @Override
      */
@@ -78,7 +62,7 @@ qx.Bootstrap.define("qx.core.property.SimplePropertyStorage", {
     /**
      * @Override
      */
-    isAsyncStorage() {
+    supportsGetAsync() {
       return false;
     },
 

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

@@ -77,7 +77,7 @@ qx.Mixin.define("qx.data.MBinding", {
      */
     bindAsync: qx.core.Environment.select("qx.promise", {
       true(sourcePropertyChain, targetObject, targetProperty, options) {
-        var binding = qx.data.SingleValueBinding.bind(this, sourcePropertyChain, targetObject, targetProperty || "value", options);
+        var binding = qx.data.SingleValueBinding.bind(this, sourcePropertyChain, targetObject, targetProperty || "value", {...options, async: true});
         return binding.getInitPromise().then(() => binding);
       },
       false(sourcePropertyChain, targetObject, targetProperty, options) {