@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

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
@@ -397,6 +399,22 @@ qx.Mixin.define("qx.core.MObjectId", {
      */
     getOwnedQxObjects() {
       return this.__ownedQxObjects ? Object.values(this.__ownedQxObjects) : [];
+    },
+
+    /**
+     * @param {string}
+     * @returns {boolean} Whether this object has an owned object with the given ID that has been created
+     */
+    hasOwnedQxObject(id) {
+      return !!(this.__ownedQxObjects && this.__ownedQxObjects[id]);
+    },
+
+    /**
+     * 
+     * @returns {Object} An object mapping IDs to owned objects. Do not modify this object directly.
+     */
+    getAllQxObjectsById() {
+      return this.__ownedQxObjects ?? {};
     }
   }
 });

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

@@ -23,154 +23,162 @@
 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>.
+     * 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 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)) {
-        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 +
-              ")"
-          );
-        }
-
-        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;
-            }
-
-            throw new Error(
-              "No such property: " +
-                prop +
-                " in " +
-                this.classname +
-                " (" +
-                this +
-                ")"
-            );
-          }
+        data = {
+          [data]: value
+        };
+      }
 
-          this[setter[prop]](data[prop]);
+      // 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;
         }
-
-        return this;
+        // 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;
     },
 
     /**
-     * Returns the value of the given property. If no generated getter could be
-     * found, a fallback tries to access a handwritten getter.
+     * Sets a property or multiple properties asynchronously.
+     * First tries calling `setPropetyNameAsync` if it exists,
+     * otherwise falls back to `setPropertyName`.
      *
-     * @param prop {String} Name of the property.
-     * @return {var} The value of the value
-     * @throws {Error} if a property defined does not exist
+     * @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.
      */
-    get(prop) {
-      var getter = qx.core.Property.$$method.get;
+    async setAsync(data, value) {
+      const setValueImpl = async (propName, value) => {
+        let upname = qx.Bootstrap.firstUp(propName);
+        let setterName = "set" + upname + "Async";
 
-      if (!this[getter[prop]]) {
-        if (this["get" + qx.Bootstrap.firstUp(prop)] != undefined) {
-          return this["get" + qx.Bootstrap.firstUp(prop)]();
+        if (!this[setterName]) {
+          setterName = "set" + upname;
         }
 
-        throw new Error(
-          "No such property: " +
-            prop +
-            " in " +
-            this.classname +
-            " (" +
-            this +
-            ")"
-        );
+        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);
       }
 
-      return this[getter[prop]]();
+      for (let propName in data) {
+        await setValueImpl(propName, data[propName]);
+      }
+      return this;
     },
 
     /**
-     * Resets the value of the given property. If no generated resetter could be
-     * found, a handwritten resetter will be invoked, if available.
+     * 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.
-     * @throws {Error} if a property defined does not exist
+     * @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
      */
-    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;
+    get(prop, safe) {
+      if (safe) {
+        let property = qx.Class.getByProperty(this.constructor, prop);
+        if (property) {
+          return property.getSafe(this);
         }
+      }
+
+      // 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]]();
+      throw new Error("No such property: " + 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
+     * 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 {*}
      */
-    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 +
-              ")"
-          );
-        }
+    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);
     }
   }
 });