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

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

@@ -13,22 +13,13 @@
 
    Authors:
      * John Spackman (github.com/johnspackman)
+     * Patryk Malinowski (https://github.com/patryk-m-malinowski, pmalinowski116@gmail.com)
 
 ************************************************************************ */
 
 /**
  * Property implementation for actual properties
  *
- * TODO:
- *
- * `validate` implementation
- * `delegate` implementation
- * `inheritable` implementation (pass onto `obj._getChildren`; check for special `inherit` value)
- * Array check
- * FunctionCheck
- *
- * how does init of property values work?  `init` per class and `initFunction` per instance?
- *
  */
 qx.Bootstrap.define("qx.core.property.Property", {
   implement: qx.core.property.IProperty,
@@ -50,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,
+     * 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>}
      */
@@ -83,14 +75,14 @@ qx.Bootstrap.define("qx.core.property.Property", {
     /** @type {String} the name of the property */
     __propertyName: null,
 
-    /** @type {qx.Class} the class that defined the property */
+    /** @type {new () => qx.core.Object} the class that defined the property */
     __clazz: null,
 
     /** @type {Boolean} whether this is a pseudo property or not */
     __pseudoProperty: false,
 
     /**
-     * @type {qx.Class} the class that original defined this property, before it was cloned and
+     * @type {new () => qx.core.Object} the class that original defined this property, before it was cloned and
      * refined for the current `__clazz`
      */
     __superClass: null,
@@ -134,11 +126,9 @@ qx.Bootstrap.define("qx.core.property.Property", {
     /** @type {Boolean} whether the property needs to be dereferenced */
     __needsDereference: false,
 
-    isRefineAllowed(def) {},
-
     /**
      * The class where this property is defined
-     * @returns {Function}
+     * @returns {new () => qx.core.Object}
      */
     getClass() {
       return this.__clazz;
@@ -200,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") {
@@ -212,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'`."
@@ -220,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);
           }
@@ -274,11 +265,21 @@ qx.Bootstrap.define("qx.core.property.Property", {
         }
       }
 
-      if (def.init !== undefined) {
+      let hasInitVal = def.init !== undefined;
+
+      if (qx.core.Environment.get("qx.debug")) {
+        if (hasInitVal && def.initFunction) {
+          throw new Error(`${this}: init and initFunction are mutually exclusive. Please specify only one of them.`);
+        }
+      }
+
+      if (hasInitVal) {
         this.__initValue = def.init;
+        this.__initFunction = undefined;
       }
       if (def.initFunction) {
         this.__initFunction = def.initFunction;
+        this.__initValue = undefined;
       }
 
       if (qx.core.Environment.get("qx.debug")) {
@@ -433,6 +434,8 @@ qx.Bootstrap.define("qx.core.property.Property", {
       let initValue = this.__initValue;
       if (initValue !== undefined) {
         clazz.prototype["$$init_" + propertyName] = initValue;
+      } else if (this.__initFunction) {
+        clazz.prototype["$$init_" + propertyName] = undefined;
       }
 
       addMethod("init" + upname, function (...args) {
@@ -536,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();
+      }
     },
 
     /**
@@ -567,9 +576,9 @@ qx.Bootstrap.define("qx.core.property.Property", {
       }
       state.initMethodCalled = true;
 
-      if (value !== undefined && this.__definition?.init !== undefined) {
+      if (value !== undefined && (this.__initValue !== undefined || this.__initFunction !== undefined)) {
         this.warn(
-          `${this}: init() called with a value, ignoring - use deferredInit and do not specify an init value in the property definition`
+          `${this}: init() called with a value, ignoring - use deferredInit and do not specify an init/function value in the property definition`
         );
         value = undefined;
       }
@@ -840,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) {
@@ -876,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)) {
@@ -892,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");
@@ -913,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;
       }
@@ -975,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) {
@@ -1013,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");
@@ -1036,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;
       }
@@ -1074,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);
@@ -1104,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 {
@@ -1132,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);
 
@@ -1139,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();
@@ -1382,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) {