@qooxdoo/framework 7.9.1 → 8.0.0-beta.1

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

@@ -30,6 +30,21 @@
  * * user friendly OO interfaces like {@link #self} or {@link #base}
  *
  * @require(qx.core.ObjectRegistry)
+ * @require(qx.core.property.Property)
+ * @require(qx.core.property.PropertyStorageFactory)
+ * @require(qx.core.property.SimplePropertyStorage)
+ * @require(ExplicitPropertyStorage)
+ * @require(GroupProperty)
+ * @require(ImmutableArrayStorage)
+ * @require(ImmutableDataArrayStorage)
+ * @require(ImmutableObjectStorage)
+ * @require(Property)
+ * @require(PropertyStorageFactory)
+ * @require(SimplePropertyStorage)
+ * @require(qx.core.check.Any)
+ * @require(qx.core.check.CheckFactory)
+ * @require(qx.core.check.JsDocCheck)
+ * @require(qx.core.check.SimpleCheck)
  */
 qx.Class.define("qx.core.Object", {
   extend: Object,
@@ -37,9 +52,9 @@ qx.Class.define("qx.core.Object", {
     "module.databinding": qx.data.MBinding,
     "module.logger": qx.core.MLogging,
     "module.events": qx.core.MEvent,
-    "module.property": qx.core.MProperty,
     "module.objectid": qx.core.MObjectId,
-    "qx.debug": qx.core.MAssert
+    "qx.debug": qx.core.MAssert,
+    true: qx.core.MProperty
   }),
 
   /*
@@ -51,7 +66,15 @@ qx.Class.define("qx.core.Object", {
   /**
    * Create a new instance
    */
-  construct() {},
+  construct() {
+    this.$$propertyValues = {};
+  
+    if (qx.core.Environment.get("qx.dev.LeakDetector.enabled")) {
+      if (!(this instanceof qx.dev.LeakDetector)) {
+        qx.dev.LeakDetector.getInstance().objectConstructed(this);
+      }
+    }
+  },
 
   /*
   *****************************************************************************
@@ -61,7 +84,7 @@ qx.Class.define("qx.core.Object", {
 
   statics: {
     /** Internal type */
-    $$type: "Object"
+    $$type: "Class"
   },
 
   /*
@@ -71,10 +94,6 @@ qx.Class.define("qx.core.Object", {
   */
 
   members: {
-    __Property: qx.core.Environment.get("module.property")
-      ? qx.core.Property
-      : null,
-
     /*
     ---------------------------------------------------------------------------
       BASICS
@@ -88,10 +107,7 @@ qx.Class.define("qx.core.Object", {
      */
     toHashCode() {
       if (!this.$$hash && !this.$$disposed) {
-        if (
-          !qx.core.Environment.get("qx.automaticMemoryManagement") ||
-          qx.Class.hasInterface(this.constructor, qx.core.IDisposable)
-        ) {
+        if (!qx.core.Environment.get("qx.automaticMemoryManagement") || qx.Class.hasInterface(this.constructor, qx.core.IDisposable)) {
           qx.core.ObjectRegistry.register(this);
         } else {
           qx.core.ObjectRegistry.toHashCode(this);
@@ -160,10 +176,7 @@ qx.Class.define("qx.core.Object", {
 
       if (qx.core.Environment.get("qx.debug")) {
         if (!qx.Bootstrap.isFunctionOrAsyncFunction(func)) {
-          throw new Error(
-            "Cannot call super class. Method is not derived: " +
-              args.callee.displayName
-          );
+          throw new Error("Cannot call super class. Method is not derived: " + args.callee.displayName);
         }
       }
 
@@ -184,44 +197,6 @@ qx.Class.define("qx.core.Object", {
       return args.callee.self;
     },
 
-    /*
-    ---------------------------------------------------------------------------
-      CLONE SUPPORT
-    ---------------------------------------------------------------------------
-    */
-
-    /**
-     *
-     * Returns a clone of this object. Copies over all user configured
-     * property values. Do not configure a parent nor apply the appearance
-     * styles directly.
-     *
-     * @return {qx.core.Object} The clone
-     */
-    clone() {
-      if (!qx.core.Environment.get("module.property")) {
-        throw new Error("Cloning only possible with properties.");
-      }
-
-      var clazz = this.constructor;
-      var clone = new clazz();
-      var props = qx.Class.getProperties(clazz);
-      var user = this.__Property.$$store.user;
-      var setter = this.__Property.$$method.set;
-      var name;
-
-      // Iterate through properties
-      for (var i = 0, l = props.length; i < l; i++) {
-        name = props[i];
-        if (this.hasOwnProperty(user[name])) {
-          clone[setter[name]](this[user[name]]);
-        }
-      }
-
-      // Return clone
-      return clone;
-    },
-
     /*
     ---------------------------------------------------------------------------
       USER DATA
@@ -266,6 +241,49 @@ qx.Class.define("qx.core.Object", {
       this.__userData = null;
     },
 
+    /*
+    ---------------------------------------------------------------------------
+      CLONE SUPPORT
+    ---------------------------------------------------------------------------
+    */
+
+    /**
+     * Returns a clone of this object. Copies over all user configured
+     * property values. Do not configure a parent nor apply the appearance
+     * styles directly.
+     *
+     * @return {qx.core.Object} The clone
+     */
+    clone() {
+      if (!qx.core.Environment.get("module.property")) {
+        throw new Error("Cloning only possible with properties.");
+      }
+
+      var clazz = this.constructor;
+      var clone = new clazz();
+      var props = qx.Class.getProperties(clazz);
+      var name;
+
+      // Iterate through properties and copy user values
+      for (var i = 0, l = props.length; i < l; i++) {
+        name = props[i];
+        var property = clazz.prototype.$$allProperties[name];
+
+        if (property && this.$$propertyValues && this.$$propertyValues[name] !== undefined) {
+          var value = this.$$propertyValues[name].value;
+          if (value !== undefined) {
+            var setter = "set" + qx.lang.String.firstUp(name);
+            if (clone[setter]) {
+              clone[setter](value);
+            }
+          }
+        }
+      }
+
+      // Return clone
+      return clone;
+    },
+
     /*
     ---------------------------------------------------------------------------
       DISPOSER
@@ -310,10 +328,7 @@ qx.Class.define("qx.core.Object", {
       // Debug output
       if (qx.core.Environment.get("qx.debug")) {
         if (qx.core.Environment.get("qx.debug.dispose.level") > 2) {
-          qx.Bootstrap.debug(
-            this,
-            "Disposing " + this.classname + "[" + this.toHashCode() + "]"
-          );
+          qx.Bootstrap.debug(this, "Disposing " + this.classname + "[" + this.toHashCode() + "]");
         }
       }
 
@@ -359,11 +374,7 @@ qx.Class.define("qx.core.Object", {
             value = this[key];
 
             // Check for Objects but respect values attached to the prototype itself
-            if (
-              value !== null &&
-              typeof value === "object" &&
-              !qx.Bootstrap.isString(value)
-            ) {
+            if (value !== null && typeof value === "object" && !qx.Bootstrap.isString(value)) {
               // Check prototype value
               // undefined is the best, but null may be used as a placeholder for
               // private variables (hint: checks in qx.Class.define). We accept both.
@@ -374,14 +385,7 @@ qx.Class.define("qx.core.Object", {
               if (qx.core.Environment.get("qx.debug.dispose.level") > 1) {
                 qx.Bootstrap.warn(
                   this,
-                  "Missing destruct definition for '" +
-                    key +
-                    "' in " +
-                    this.classname +
-                    "[" +
-                    this.toHashCode() +
-                    "]: " +
-                    value
+                  "Missing destruct definition for '" + key + "' in " + this.classname + "[" + this.toHashCode() + "]: " + value
                 );
 
                 delete this[key];
@@ -390,6 +394,12 @@ qx.Class.define("qx.core.Object", {
           }
         }
       }
+
+      if (qx.core.Environment.get("qx.dev.LeakDetector.enabled")) {
+        if (!(this instanceof qx.dev.LeakDetector)) {
+          qx.dev.LeakDetector.getInstance().objectDisposed(this);
+        }
+      }
     },
 
     /*
@@ -473,38 +483,14 @@ qx.Class.define("qx.core.Object", {
     // Cleanup object registry
     qx.core.ObjectRegistry.unregister(this);
 
-    // Cleanup user data
-    this.__userData = null;
-
-    // only of properties are available
-    if (qx.core.Environment.get("module.property")) {
-      // Cleanup properties
-      var clazz = this.constructor;
-      var properties;
-      var store = this.__Property.$$store;
-      var storeUser = store.user;
-      var storeTheme = store.theme;
-      var storeInherit = store.inherit;
-      var storeUseinit = store.useinit;
-      var storeInit = store.init;
-
-      while (clazz) {
-        properties = clazz.$$properties;
-        if (properties) {
-          for (var name in properties) {
-            if (properties[name].dereference) {
-              this[storeUser[name]] =
-                this[storeTheme[name]] =
-                this[storeInherit[name]] =
-                this[storeUseinit[name]] =
-                this[storeInit[name]] =
-                  undefined;
-            }
-          }
-        }
-
-        clazz = clazz.superclass;
+    // Update LeakDetector
+    if (qx.core.Environment.get("qx.dev.LeakDetector.enabled")) {
+      if (!(this instanceof qx.dev.LeakDetector)) {
+        qx.dev.LeakDetector.getInstance().objectDestructed(this);
       }
     }
+
+    // Cleanup user data
+    this.__userData = null;
   }
 });

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

@@ -0,0 +1,111 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023-24 Zenesis Limited (https://www.zenesis.com)
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (github.com/johnspackman)
+
+************************************************************************ */
+
+/**
+ * Type checking for basic, native types
+ */
+qx.Bootstrap.define("qx.core.check.AbstractCheck", {
+  extend: Object,
+  implement: qx.core.check.ICheck,
+
+  construct(nullable) {
+    super();
+    this.__nullable = !!nullable;
+  },
+
+  members: {
+    /** @type{Boolean} whether null is allowed */
+    __nullable: null,
+
+    /**
+     * @override
+     */
+    isNullable() {
+      return this.__nullable;
+    },
+
+    /**
+     * @override
+     */
+    isCompatible(check) {
+      return check instanceof this.constructor;
+    },
+
+    /**
+     * @override
+     */
+    needsDereference() {
+      return false;
+    },
+
+    /**
+     * @override
+     */
+    coerce(value, thisObj) {
+      if (value === undefined) {
+        return null;
+      }
+      if (value === null) {
+        if (this.isNullable()) {
+          return null;
+        }
+      } else if (this.matches(value, thisObj)) {
+        return value;
+      }
+      value = this._coerceImpl(value, thisObj);
+      if (value !== null && this.matches(value, thisObj)) {
+        return value;
+      }
+      return null;
+    },
+
+    /**
+     * @override
+     */
+    matches(value, thisObj) {
+      if (value === null || value === undefined) {
+        return this.isNullable();
+      }
+      return this._matchesImpl(value, thisObj);
+    },
+
+    /**
+     * Default implementation for `matches` method - this has teh same semantics as `matches` but
+     * handles the cases where the value is null or undefined.
+     *
+     * @param {*} value
+     * @returns {Boolean}
+     */
+    _matchesImpl(value, thisObj) {
+      return false;
+    },
+
+    /**
+     * Default implementation for `coerce` method - this has the same semantics as `coerce` but
+     * will only be called if `value` is not null or undefined and does not match the check.
+     * The return value must pass the `matches` test for this check, and if it does not then
+     * the value will be chnaged to null by `coerce()`
+     *
+     * @param {*} value
+     * @returns {*}
+     */
+    _coerceImpl(value) {
+      return value;
+    }
+  }
+});

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

@@ -0,0 +1,63 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023-24 Zenesis Limited (https://www.zenesis.com)
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (github.com/johnspackman)
+
+************************************************************************ */
+
+/**
+ * Implementation of check for any value
+ */
+qx.Bootstrap.define("qx.core.check.Any", {
+  extend: Object,
+  implement: qx.core.check.ICheck,
+
+  construct(nullable) {
+    super();
+    this.__nullable = nullable;
+  },
+
+  members: {
+    /** @type{Boolean} whether null is allowed */
+    __nullable: null,
+
+    /**
+     * @override
+     */
+    matches(value) {
+      return true;
+    },
+
+    /**
+     * @override
+     */
+    isNullable() {
+      return this.__nullable;
+    },
+
+    /**
+     * @override
+     */
+    isCompatible(check) {
+      return true;
+    },
+
+    /**
+     * @override
+     */
+    needsDereference() {
+      return false;
+    }
+  }
+});

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

@@ -0,0 +1,151 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023-24 Zenesis Limited (https://www.zenesis.com)
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (github.com/johnspackman)
+
+************************************************************************ */
+
+/**
+ * Provider of checks for property values, cached by expression
+ *
+ * NOTE :: The default checks are initialised only on demand - this is not a
+ * performance requirement, but rather to manage the dependency of classes during
+ * the early stages of loading an application.
+ *
+ * @require(qx.core.check.DynamicTypeCheck)
+ *
+ * @typedef {String|Function|Array<String>} CheckType
+ */
+qx.Bootstrap.define("qx.core.check.CheckFactory", {
+  extend: Object,
+  type: "singleton",
+
+  construct() {
+    super();
+    this.__checks = {};
+    this.addCheck("any", new qx.core.check.Any());
+    this.addCheck("any?", new qx.core.check.Any(true));
+  },
+
+  members: {
+    /** @type {Object<String,qx.core.check.ICheck>} the list of known checks */
+    __checks: null,
+
+    /**
+     * Gets a `qx.core.check.Check` instance that can be used to verify property value
+     * compatibility; note that one will be created if it does not already exist
+     *
+     * @param {CheckType} expr
+     * @return {qx.core.check.Check}
+     */
+    getCheck(expr, nullable) {
+      nullable = !!nullable;
+      if (typeof expr == "function") {
+        return new qx.core.check.SimpleCheck(expr, false);
+      }
+      if (qx.lang.Type.isArray(expr)) {
+        for (let i = 0; i < expr.length; i++) {
+          if (expr[i] === null) {
+            nullable = true;
+            qx.lang.Array.removeAt(expr, i);
+            break;
+          }
+        }
+        return new qx.core.check.IsOneOfCheck(expr, nullable);
+      }
+
+      expr = expr.replace(/<.*>/g, ""); // remove generics
+
+      let checkname = expr;
+      if (checkname.endsWith("?")) {
+        checkname = checkname.substring(0, checkname.length - 1);
+        nullable = true;
+      }
+      if (nullable) {
+        expr = checkname + "?";
+      }
+
+      let check = this.__checks[expr];
+      if (check) {
+        return check;
+      }
+
+      let clazz = qx.core.check.CheckFactory.__STANDARD_CHECKS[checkname];
+      if (clazz) {
+        check = new clazz(nullable);
+        if (check.isNullable() === null) {
+          check = new clazz(nullable);
+        }
+        this.__checks[expr] = check;
+        return check;
+      }
+
+      if (checkname.indexOf("(") > 0) {
+        check = new qx.core.check.SimpleCheck(new Function("value", "return " + checkname), nullable);
+      } else {
+        check = new qx.core.check.DynamicTypeCheck(checkname, nullable);
+      }
+      if (check) {
+        this.__checks[expr] = check;
+        return check;
+      }
+
+      return null;
+    },
+
+    /**
+     * Adds a check for a given expression - cannot be used to change an existing expression
+     *
+     * @param {String} expr the string expression to match
+     * @param {qx.core.check.ICheck} check the check instance
+     */
+    addCheck(expr, check) {
+      if (this.__checks[expr]) {
+        throw new Error("Check already exists for " + expr);
+      }
+      this.__checks[expr] = check;
+    }
+  },
+
+  statics: {
+    __STANDARD_CHECKS: {
+      Boolean: qx.core.check.standard.BooleanCheck,
+      String: qx.core.check.standard.StringCheck,
+      Number: qx.core.check.standard.NumberCheck,
+      Integer: qx.core.check.standard.IntegerCheck,
+      PositiveNumber: qx.core.check.standard.PositiveNumberCheck,
+      PositiveInteger: qx.core.check.standard.PositiveIntegerCheck,
+      Error: qx.core.check.standard.ErrorCheck,
+      RegExp: qx.core.check.standard.RegExpCheck,
+      Object: qx.core.check.standard.ObjectCheck,
+      Array: qx.core.check.standard.ArrayCheck,
+      Map: qx.core.check.standard.MapCheck,
+      Function: qx.core.check.standard.FunctionCheck,
+      Date: qx.core.check.standard.DateCheck,
+      Node: qx.core.check.standard.NodeCheck,
+      Element: qx.core.check.standard.ElementCheck,
+      Document: qx.core.check.standard.DocumentCheck,
+      Window: qx.core.check.standard.WindowCheck,
+      Event: qx.core.check.standard.EventCheck,
+      Promise: qx.core.check.standard.PromiseCheck,
+      Class: qx.core.check.standard.ClassCheck,
+      Mixin: qx.core.check.standard.MixinCheck,
+      Interface: qx.core.check.standard.InterfaceCheck,
+      Theme: qx.core.check.standard.ThemeCheck,
+      Color: qx.core.check.standard.ColorCheck,
+      Decorator: qx.core.check.standard.DecoratorCheck,
+      Font: qx.core.check.standard.FontCheck
+    }
+  }
+});

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

@@ -0,0 +1,90 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023-24 Zenesis Limited (https://www.zenesis.com)
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (github.com/johnspackman)
+
+************************************************************************ */
+
+/**
+ * Implementation of check for class instances
+ */
+qx.Bootstrap.define("qx.core.check.DynamicTypeCheck", {
+  extend: qx.core.check.AbstractCheck,
+
+  construct(typename, nullable) {
+    super(nullable);
+    this.__typename = typename;
+  },
+
+  members: {
+    /** @type{String} the name of the class to check against */
+    __typename: null,
+
+    /**
+     *
+     * @returns {string} Name of the class for this check
+     */
+    getTypename() {
+      return this.__typename;
+    },
+
+    /**
+     * @override
+     */
+    _matchesImpl(value) {
+      if (qx.Class.isDefined(this.__typename)) {
+        let clazz = qx.Class.getByName(this.__typename);
+        let tmp = value.constructor;
+        while (tmp) {
+          if (tmp === clazz) {
+            return true;
+          }
+          tmp = tmp.superclass;
+        }
+      } else if (qx.Interface && qx.Interface.isDefined(this.__typename)) {
+        let ifc = qx.Interface.getByName(this.__typename);
+        let tmp = value;
+        while (tmp) {
+          if (qx.Class.implementsInterface(tmp, ifc)) {
+            return true;
+          }
+          tmp = tmp.superclass;
+        }
+      }
+
+      return false;
+    },
+
+    /**
+     * @override
+     */
+    isCompatible(check) {
+      if (!(check instanceof this.constructor)) {
+        return false;
+      }
+      if (this.isNullable() && !check.isNullable()) {
+        return false;
+      }
+      let tmp = this.__clazz;
+      let requiredSuperclass = check.__clazz;
+      while (tmp) {
+        if (tmp === requiredSuperclass) {
+          return true;
+        }
+        tmp = tmp.superclass;
+      }
+      return false;
+    }
+  }
+});