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

package/source/class/qx/core/MProperty.js

@@ -20,193 +20,165 @@
  * This mixin offers the basic property features which include generic
  * setter, getter and resetter.
  */
-qx.Mixin.define(
-  "qx.core.MProperty",
-  {
-    members:
-    {
-      /**
-       * Sets either multiple properties at once by using a property
-       * list or sets one property and its value by the first and
-       * second argument. As a fallback, if no generated property
-       * setter could be found, a handwritten setter will be searched
-       * and invoked if available.
-       *
-       * @param data {Object | String}
-       *   a map of property values. The key is the name of the property.
-       *
-       * @param value {var?}
-       *   the value, only used when <code>data</code> is a string.
-       *
-       * @return {Object}
-       *   Returns this instance if <code>data</code> is a map or a
-       *   non-generated setter is called; otherwise returns
-       *   <code>value</code>.
-       *
-       * @throws {Error} if a property defined does not exist
-       */
-      set(data, value)
-      {
-        // If there's just a single property name and value, convert
-        // it to a map as if there were multiple property names and
-        // values.
-        if (qx.Bootstrap.isString(data))
-        {
-          data =
-            {
-              [data] : value
-            };
-        }
-
-        // Set each property specified in the map
-        for (let prop in data)
-        {
-          // If the property exists as a member variable, set it directly
-          if (prop in this)
-          {
-            if (data[prop] !== undefined)
-            {
-              this[`$$variant_${prop}`] = "set";
-              this[prop] = data[prop];
-            }
-            continue;
-          }
-
-          // Otherwise, see if there's a hand-written setter method
-          if (this["set" + qx.Bootstrap.firstUp(prop)] != undefined)
-          {
-            this["set" + qx.Bootstrap.firstUp(prop)](data[prop]);
-            continue;
-          }
+qx.Mixin.define("qx.core.MProperty", {
+  members: {
+    /**
+     * Sets either multiple properties at once by using a property
+     * list or sets one property and its value by the first and
+     * second argument. As a fallback, if no generated property
+     * setter could be found, a handwritten setter will be searched
+     * and invoked if available.
+     *
+     * @param data {Object | String}
+     *   a map of property values. The key is the name of the property.
+     *
+     * @param value {var?}
+     *   the value, only used when <code>data</code> is a string.
+     *
+     * @return {Object}
+     *   Returns this instance if <code>data</code> is a map or a
+     *   non-generated setter is called; otherwise returns
+     *   <code>value</code>.
+     *
+     * @throws {Error} if a property defined does not exist
+     */
+    set(data, value) {
+      // If there's just a single property name and value, convert
+      // it to a map as if there were multiple property names and
+      // values.
+      if (qx.Bootstrap.isString(data)) {
+        data = {
+          [data]: value
+        };
+      }
 
-          // Neither was true
-          throw new Error("No such property: " + data);
+      // Set each property specified in the map
+      for (let prop in data) {
+        // Otherwise, see if there's a hand-written setter method
+        if (this["set" + qx.Bootstrap.firstUp(prop)] != undefined) {
+          this["set" + qx.Bootstrap.firstUp(prop)](data[prop]);
+          continue;
         }
+        // Neither was true
+        throw new Error("No such property: " + prop + " in " + this.classname + " (" + this + ")");
+      }
 
-        // Allow for the case where no properties were given
-        return this;
-      },
-
-
-      /**
-       * Sets a property or multiple properties asynchronously.
-       * First tries calling `setPropetyNameAsync` if it exists,
-       * otherwise falls back to `setPropertyName`.
-       * 
-       * @overload
-       * @param {string} data Name of property to set
-       * @param {*} value Value to set it to
-       * 
-       * @overload
-       * @param {Object<string, *>} data Map of properties to set
-       * 
-       * @returns {qx.core.Object | Promise<*>} This instance if a map was provided, 
-       * or, if a single property is set,
-       * a promise which resolves when the setting has completed
-       * to the set value of the property.
-       */
-      async setAsync(data, value) {
-        const setValueImpl = async (propName, value) => {
-          let upname = qx.Bootstrap.firstUp(propName);
-          let setterName = "set" + upname + "Async";
+      // Allow for the case where no properties were given
+      return this;
+    },
+
+    /**
+     * Sets a property or multiple properties asynchronously.
+     * First tries calling `setPropetyNameAsync` if it exists,
+     * otherwise falls back to `setPropertyName`.
+     *
+     * @overload
+     * @param {string} data Name of property to set
+     * @param {*} value Value to set it to
+     *
+     * @overload
+     * @param {Object<string, *>} data Map of properties to set
+     *
+     * @returns {qx.core.Object | Promise<*>} This instance if a map was provided,
+     * or, if a single property is set,
+     * a promise which resolves when the setting has completed
+     * to the set value of the property.
+     */
+    async setAsync(data, value) {
+      const setValueImpl = async (propName, value) => {
+        let upname = qx.Bootstrap.firstUp(propName);
+        let setterName = "set" + upname + "Async";
+
+        if (!this[setterName]) {
+          setterName = "set" + upname;
+        }
 
+        if (qx.core.Environment.get("qx.debug")) {
           if (!this[setterName]) {
-            setterName = "set" + upname;
-          }
-
-          if (qx.core.Environment.get("qx.debug")) {
-            if (!this[setterName]) {
-              throw new Error(
-                `No such property: ${propName} in ${this.classname} (${this})`
-              );
-            }
+            throw new Error(`No such property: ${propName} in ${this.classname} (${this})`);
           }
-
-          return await this[setterName](value);
-        };
-
-        if (qx.Bootstrap.isString(data)) {
-          return await setValueImpl(data, value);
         }
 
-        for (let propName in data) {
-          await setValueImpl(propName, data[propName]);
-        }
-        return this;
-      },
-
-      /**
-       * Returns the value of the given property. If no generated getter could
-       * be found, a fallback tries to access a handwritten getter.
-       *
-       * @param prop {String}
-       *   Name of the property.
-       *
-       * @return {var}
-       *   The value of the value
-       * 
-       * @param safe {Boolean?false}
-       *
-       * @throws {Error}
-       *   if a property defined does not exist
-       */
-      get(prop, safe)
-      {
-        if (safe) {
-          let property = qx.Class.getByProperty(this.constructor, prop);
-          if (property) {
-            return property.getSafe(this);
-          }
-        }
+        return await this[setterName](value);
+      };
 
-        // Otherwise, see if there's a hand-written getter method
-        if (this["get" + qx.Bootstrap.firstUp(prop)] != undefined)
-        {
-          return this["get" + qx.Bootstrap.firstUp(prop)]();
-        }
+      if (qx.Bootstrap.isString(data)) {
+        return await setValueImpl(data, value);
+      }
 
-        // If the property exists as a member variable, get it directly
-        if (prop in this)
-        {
-          return this[prop];
+      for (let propName in data) {
+        await setValueImpl(propName, data[propName]);
+      }
+      return this;
+    },
+
+    /**
+     * Returns the value of the given property. If no generated getter could
+     * be found, a fallback tries to access a handwritten getter.
+     *
+     * @param prop {String}
+     *   Name of the property.
+     *
+     * @return {var}
+     *   The value of the value
+     *
+     * @param safe {Boolean?false}
+     *
+     * @throws {Error}
+     *   if a property defined does not exist
+     */
+    get(prop, safe) {
+      if (safe) {
+        let property = qx.Class.getByProperty(this.constructor, prop);
+        if (property) {
+          return property.getSafe(this);
         }
+      }
 
-        throw new Error("No such property: " + prop);
-      },
-
-      /**
-       * 
-       * Returns the value of the given property.
-       * If the property is not initialized, it will return undefined.
-       *
-       * @param prop {String}
-       *   Name of the property.
-       * 
-       * @returns {*}
-       */      
-      getSafe(prop) {
-        return this.get(prop, true);
-      },
-
-      /**
-       * Resets the value of the given property. If no generated resetter
-       * could be found, a handwritten resetter will be invoked, if available.
-       *
-       * @param prop {String}
-       *   Name of the property.
-       *
-       * @throws {Error}
-       *   if a property defined does not exist
-       */
-      reset(prop)
-      {
-        // Reset the property
-        if (this["reset" + qx.Bootstrap.firstUp(prop)] != undefined)
-        {
-          return this["reset" + qx.Bootstrap.firstUp(prop)]();
-        }
+      // Otherwise, see if there's a hand-written getter method
+      if (this["get" + qx.Bootstrap.firstUp(prop)] != undefined) {
+        return this["get" + qx.Bootstrap.firstUp(prop)]();
+      }
 
-        throw new Error("No such property: " + prop);
+      // If the property exists as a member variable, get it directly
+      if (prop in this) {
+        return this[prop];
       }
+
+      throw new Error("No such property: " + prop);
+    },
+
+    /**
+     *
+     * Returns the value of the given property.
+     * If the property is not initialized, it will return undefined.
+     *
+     * @param prop {String}
+     *   Name of the property.
+     *
+     * @returns {*}
+     */
+    getSafe(prop) {
+      return this.get(prop, true);
+    },
+
+    /**
+     * Resets the value of the given property. If no generated resetter
+     * could be found, a handwritten resetter will be invoked, if available.
+     *
+     * @param prop {String}
+     *   Name of the property.
+     *
+     * @throws {Error}
+     *   if a property defined does not exist
+     */
+    reset(prop) {
+      // Reset the property
+      if (this["reset" + qx.Bootstrap.firstUp(prop)] != undefined) {
+        return this["reset" + qx.Bootstrap.firstUp(prop)]();
+      }
+
+      throw new Error("No such property: " + prop);
     }
-  });
+  }
+});

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;
@@ -61,6 +66,10 @@ qx.Bootstrap.define("qx.core.check.DynamicTypeCheck", {
           }
           tmp = tmp.superclass;
         }
+      } else if (typeof window[this.__typename] === "function") {
+        //handle cases where the check is a globally-defined class
+        let clazz = window[this.__typename];
+        return value instanceof clazz;
       }
 
       return false;

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() {}
   }
 });