@qooxdoo/framework 7.9.2 → 8.0.0-beta.1

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

@@ -819,6 +819,10 @@
  *     <tr>
  *       <td>qx.blankpage</td><td><i>String</i></td><td><code>URI to blank.html page</code></td>
  *     </tr>
+ *     <tr>
+ *       <td>qx.future.checkjsdoc</td><td><i>Boolean</i></td><td><code>true</code></td>
+ *       <td><i>default:</i> <code>false</code></td>
+ *     </tr>
 
  *     <tr>
  *       <td colspan="4"><b>module</b></td>
@@ -832,10 +836,6 @@
  *       <td><i>default:</i> <code>true</code></td>
  *     </tr>
  *     <tr>
- *       <td>module.property</td><td><i>Boolean</i></td><td><code>true</code></td>
- *       <td><i>default:</i> <code>true</code></td>
- *     </tr>
- *     <tr>
  *       <td>module.events</td><td><i>Boolean</i></td><td><code>true</code></td>
  *       <td><i>default:</i> <code>true</code></td>
  *     </tr>
@@ -891,7 +891,6 @@ qx.Bootstrap.define("qx.core.Environment", {
       "qx.dynlocale": true,
       "qx.dyntheme": true,
       "qx.blankpage": "qx/static/blank.html",
-      "qx.data.marshal.Json.breakOnNonPojos": false,
       "qx.debug.databinding": false,
       "qx.debug.dispose": false,
       "qx.debug.startupTimings": false,
@@ -905,7 +904,6 @@ qx.Bootstrap.define("qx.core.Environment", {
       // qooxdoo modules
       "module.databinding": true,
       "module.logger": true,
-      "module.property": true,
       "module.events": true,
       "module.objectid": true,
       "qx.nativeScrollBars": false,
@@ -1229,9 +1227,16 @@ qx.Bootstrap.define("qx.core.Environment", {
       }
       if (this.__environmentBackup === undefined) {
         qx.Bootstrap.warn("Modifying environment settings at runtime is enabled. This is a security risk and should not be done in production code.");
-        this.__environmentBackup = Object.assign({}, this.__cache);
-        this.__checksBackup = Object.assign({}, this._checks);
+        this.__environmentBackup = {};
+        this.__checksBackup = {};
+      }
+
+      if (this.__environmentBackup[key] === undefined) {
+        //this means there is no override for that key, so we back up the current values
+        this.__environmentBackup[key] = this.__cache[key];
+        this.__checksBackup[key] = this._checks[key];
       }
+
       this.__cache[key] = value;
       delete this._checks[key];
       delete this._checksMap[key];
@@ -1244,15 +1249,7 @@ qx.Bootstrap.define("qx.core.Environment", {
      * @param key {String} The key of the environment setting to remove.
      */
     remove: qx.Bootstrap.getEnvironmentSetting("qx.environment.allowRuntimeMutations") ? function(key) {
-      if (key === undefined) {
-        throw new TypeError("Key must be provided to remove an environment setting.");
-      }
-      if (this.__environmentBackup === undefined || this.__environmentBackup[key] === undefined) {
-        throw new TypeError(`Environment setting "${key}" does not exist.`);
-      }
-      delete this.__cache[key];
-      delete this._checks[key];
-      delete this._checksMap[key];
+      qx.core.Environment.set(key, undefined);
     }: undefined,
 
     /**
@@ -1267,17 +1264,23 @@ qx.Bootstrap.define("qx.core.Environment", {
         return;
       }
       if (key !== undefined && this.__environmentBackup[key] === undefined) {
-        throw new TypeError(`Environment setting "${key}" does not exist.`);
+        // no backup available, nothing to reset
+        return;
       }
+      
       if (key === undefined) {
         // reset all keys
-        this.__cache = Object.assign({}, this.__environmentBackup);
-        this._checks = Object.assign({}, this.__checksBackup);
+        Object.assign(this.__cache, this.__environmentBackup);
+        this.__environmentBackup = {};
+        Object.assign(this._checks, this.__checksBackup);
+        this.__checksBackup = {};
         return;
       }
       // only reset the particular key 
       this.__cache[key] = this.__environmentBackup[key];
+      delete this.__environmentBackup[key];
       this._checks[key] = this.__checksBackup[key];
+      delete this.__checksBackup[key];
     }: undefined,
 
     /**

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

@@ -79,7 +79,7 @@ qx.Mixin.define("qx.core.MEvent", {
       var id; // store id in closure context
       var callback = function (e) {
         self.removeListenerById(id);
-        listener.call(context, e);
+        return listener.call(context, e);
       };
       // check for wrapped callback storage
       if (!listener.$$wrapped_callback) {

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

@@ -36,7 +36,8 @@ qx.Mixin.define("qx.core.MObjectId", {
       init: null,
       check: "qx.core.Object",
       nullable: true,
-      apply: "_applyQxOwner"
+      apply: "_applyQxOwner",
+      autoApply: false
     },
 
     /** {String} The ID of the object.  */
@@ -48,7 +49,8 @@ qx.Mixin.define("qx.core.MObjectId", {
         );
       },
       nullable: true,
-      apply: "_applyQxObjectId"
+      apply: "_applyQxObjectId",
+      autoApply: false
     }
   },
 
@@ -59,15 +61,15 @@ qx.Mixin.define("qx.core.MObjectId", {
    */
   statics: {
     handleObjects(clazz, instance, id) {
-      const objectsDef = clazz.$$objects;
-      const clazzObject = objectsDef?.[id]?.call(instance);
+      let objectsDef = clazz.$$objects;
+      let clazzObject = objectsDef?.[id]?.call(instance);
 
       if (clazzObject !== undefined) {
         return clazzObject;
       }
 
-      for (const mixin of clazz.$$includes ?? []) {
-        const mixinObject = qx.core.MObjectId.handleObjects(
+      for (let mixin of clazz.$$includes ?? []) {
+        let mixinObject = qx.core.MObjectId.handleObjects(
           mixin,
           instance,
           id

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

@@ -20,157 +20,193 @@
  * 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) {
-      var setter = qx.core.Property.$$method.set;
-
-      if (qx.Bootstrap.isString(data)) {
-        if (!this[setter[data]]) {
-          if (this["set" + qx.Bootstrap.firstUp(data)] != undefined) {
-            this["set" + qx.Bootstrap.firstUp(data)](value);
-            return this;
-          }
-
-          throw new Error(
-            "No such property: " +
-              data +
-              " in " +
-              this.classname +
-              " (" +
-              this +
-              ")"
-          );
+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
+            };
         }
 
-        return this[setter[data]](value);
-      } else {
-        for (var prop in data) {
-          if (!this[setter[prop]]) {
-            if (this["set" + qx.Bootstrap.firstUp(prop)] != undefined) {
-              this["set" + qx.Bootstrap.firstUp(prop)](data[prop]);
-              continue;
+        // 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;
+          }
 
-            throw new Error(
-              "No such property: " +
-                prop +
-                " in " +
-                this.classname +
-                " (" +
-                this +
-                ")"
-            );
+          // 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;
           }
 
-          this[setter[prop]](data[prop]);
+          // Neither was true
+          throw new Error("No such property: " + data);
         }
 
+        // Allow for the case where no properties were given
         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
-     * @throws {Error} if a property defined does not exist
-     */
-    get(prop) {
-      var getter = qx.core.Property.$$method.get;
-
-      if (!this[getter[prop]]) {
-        if (this["get" + qx.Bootstrap.firstUp(prop)] != undefined) {
-          return this["get" + qx.Bootstrap.firstUp(prop)]();
+      },
+
+
+      /**
+       * 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]) {
+              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);
         }
 
-        throw new Error(
-          "No such property: " +
-            prop +
-            " in " +
-            this.classname +
-            " (" +
-            this +
-            ")"
-        );
-      }
+        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 this[getter[prop]]();
-    },
-
-    /**
-     * 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) {
-      var resetter = qx.core.Property.$$method.reset;
-
-      if (!this[resetter[prop]]) {
-        if (this["reset" + qx.Bootstrap.firstUp(prop)] != undefined) {
-          this["reset" + qx.Bootstrap.firstUp(prop)]();
-          return;
+        // 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 +
-            " in " +
-            this.classname +
-            " (" +
-            this +
-            ")"
-        );
-      }
+        // If the property exists as a member variable, get it directly
+        if (prop in this)
+        {
+          return this[prop];
+        }
 
-      this[resetter[prop]]();
-    },
-
-    /**
-     * Checks if the property is initialized, i.e. has a defined init value or
-     * has got a value by a setter method.
-     *
-     * @param prop {String} Name of the property
-     * @return {Boolean} If the property is initialized
-     * @throws {Error} If the property defined does not exist
-     */
-    isPropertyInitialized(prop) {
-      if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert.assertString(prop);
-
-        if (!this["get" + qx.Bootstrap.firstUp(prop)]) {
-          throw new Error(
-            "No such property: " +
-              prop +
-              " in " +
-              this.classname +
-              " (" +
-              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)]();
         }
-      }
 
-      return (
-        this["$$user_" + prop] !== undefined ||
-        this["$$init_" + prop] !== undefined
-      );
+        throw new Error("No such property: " + prop);
+      }
     }
-  }
-});
+  });