@qooxdoo/framework 7.9.2 → 8.0.0-beta.1

package/source/class/qx/Bootstrap.js

@@ -6,6 +6,7 @@
 
    Copyright:
      2004-2008 1&1 Internet AG, Germany, http://www.1und1.de
+     2022 Derrell Lipman
 
    License:
      MIT: https://opensource.org/licenses/MIT
@@ -15,396 +16,198 @@
      * Sebastian Werner (wpbasti)
      * Andreas Ecker (ecker)
      * Martin Wittemann (martinwittemann)
+     * Derrell Lipman (derrell)
 
 ************************************************************************ */
 
-/**
- * Create namespace
- *
- * @ignore(qx.data)
- * @ignore(qx.data.IListData)
- * @ignore(qx.util.OOUtil)
- */
-if (!window.qx) {
-  window.qx = {};
-}
-
-/**
- * This wraps a function with a plain `function`; JavaScript does not allow methods which are defined
- * using object method shorthand (eg `{ construct() { this.base(arguments); }}`) to be used as constructors,
- * the constructor must be a plain old `function`.
- *
- * @param {Function} construct
- * @returns {Function}
- */
-function createPlainFunction(construct) {
-  return function () {
-    return construct.apply(this, [].slice.call(arguments));
-  };
-}
-
-/**
- * Bootstrap qx.Bootstrap to create myself later
- * This is needed for the API browser etc. to let them detect me
- */
-qx.Bootstrap = {
-  genericToString() {
-    return "[Class " + this.classname + "]";
-  },
-
-  createNamespace(name, object) {
-    var splits = name.split(".");
-    var part = splits[0];
-    var parent =
-      qx.$$namespaceRoot && qx.$$namespaceRoot[part]
-        ? qx.$$namespaceRoot
-        : window;
-
-    for (var i = 0, len = splits.length - 1; i < len; i++, part = splits[i]) {
-      if (!parent[part]) {
-        parent = parent[part] = {};
-      } else {
-        parent = parent[part];
-      }
-    }
-
-    // store object
-    parent[part] = object;
-
-    // return last part name (e.g. classname)
-    return part;
-  },
-
-  setDisplayName(fcn, classname, name) {
-    fcn.displayName = classname + "." + name + "()";
-  },
-
-  setDisplayNames(functionMap, classname) {
-    for (var name in functionMap) {
-      var value = functionMap[name];
-      if (value instanceof Function) {
-        value.displayName = classname + "." + (value.name || name) + "()";
-      }
-    }
-  },
+// Undeclared member variables we've already notified the user of
+let undeclared = {};
 
-  base(args, varargs) {
-    if (qx.Bootstrap.DEBUG) {
-      if (!qx.Bootstrap.isFunction(args.callee.base)) {
-        throw new Error(
-          "Cannot call super class. Method is not derived: " +
-            args.callee.displayName
-        );
-      }
-    }
+// For debugging, allow not hiding internal variables  with `enumerable: false`
+let allEnumerable = false;
 
-    if (arguments.length === 1) {
-      return args.callee.base.call(this);
-    } else {
-      return args.callee.base.apply(
-        this,
-        Array.prototype.slice.call(arguments, 1)
-      );
-    }
-  },
+// To be imlemented in the future
+let FUTURE = false;
 
-  define(name, config) {
-    var isStrictMode = function () {
-      return typeof this == "undefined";
-    };
+// Bootstrap the Bootstrap static class
+window.qx = Object.assign(window.qx || {}, {
+  $$namespaceRoot: window,
 
-    if (!config) {
-      config = { statics: {} };
-    }
+  Bootstrap: {
+    /** Undeclared member variables we've already notified the user of */
+    $$undeclared: {},
 
-    var clazz;
-    var proto = null;
+    /** @type {Map} Stores all defined classes */
+    $$registry: {},
 
-    qx.Bootstrap.setDisplayNames(config.statics, name);
+    _allowedStaticKeys: {
+      "@": "object",
+      type: "string", // String
+      include: "object", // Mixin[]
+      statics: "object", // Map
+      environment: "object", // Map
+      events: "object", // Map
+      defer: "function" // Function
+    },
 
-    if (config.members || config.extend) {
-      qx.Bootstrap.setDisplayNames(config.members, name + ".prototype");
+    _allowedNonStaticKeys: {
+      "@": "object",
+      "@construct": "object",
+      "@destruct": "object",
+      type: "string", // String
+      extend: "function", // Function
+      // extendNativeClass: "boolean", // Boolean -- Does not work yet
+      implement: "object", // Interface[]
+      include: "object", // Mixin[]
+      construct: "function", // Function
+      statics: "object", // Map
+      properties: "object", // Map
+      members: "object", // Map
+      objects: "object", // Map
+      environment: "object", // Map
+      events: "object", // Map
+      delegate: "object", // Map
+      defer: "function", // Function
+      destruct: "function" // Function
+    },
 
-      let construct = config.construct;
-      // Object methods include the method name as part of the signature (eg `construct() {}`),
-      //  whereas plain functions just have `function() {}`
-      if (construct && !construct.toString().match(/^function\s*\(/)) {
-        construct = createPlainFunction(construct);
+    define(className, config) {
+      let clazz;
+      let proxy;
+      let handler;
+      let path;
+      let classnameComponents;
+      let implicitType = false;
+
+      // Ensure the desginated class has not already been defined
+      if (className && qx.Bootstrap.$$registry[className]) {
+        throw new Error(`${className} is already defined; cannot redefine a class`);
       }
-      clazz = construct || new Function();
-
-      this.extendClass(clazz, clazz, config.extend, name, basename);
-
-      var statics = config.statics || {};
-      // use keys to include the shadowed in IE
-      for (
-        var i = 0, keys = qx.Bootstrap.keys(statics), l = keys.length;
-        i < l;
-        i++
-      ) {
-        var key = keys[i];
-        clazz[key] = statics[key];
-      }
-
-      proto = clazz.prototype;
-      // Enable basecalls within constructor
-      proto.base = qx.Bootstrap.base;
-      proto.name = proto.classname = name;
-
-      var members = config.members || {};
-      var key, member;
-
-      // use keys to include the shadowed in IE
-      for (
-        var i = 0, keys = qx.Bootstrap.keys(members), l = keys.length;
-        i < l;
-        i++
-      ) {
-        key = keys[i];
-        member = members[key];
-
-        // Enable basecalls for methods
-        // Hint: proto[key] is not yet overwritten here
-        if (member instanceof Function && proto[key]) {
-          member.base = proto[key];
-        }
 
-        proto[key] = member;
+      // Process environment
+      let environment = config.environment || {};
+      for (let key in environment) {
+        qx["core"]["Environment"].add(key, environment[key]);
       }
-    } else {
-      clazz = config.statics || {};
-
-      // Merge class into former class (needed for 'optimize: ["statics"]')
-      if (qx.Bootstrap.$$registry && qx.Bootstrap.$$registry[name]) {
-        var formerClass = qx.Bootstrap.$$registry[name];
-
-        // Add/overwrite properties and return early if necessary
-        if (this.keys(clazz).length !== 0) {
-          // Execute defer to prevent too early overrides
-          if (config.defer) {
-            config.defer(clazz, proto);
-          }
 
-          for (var curProp in clazz) {
-            formerClass[curProp] = clazz[curProp];
+      // Explicit null `extend` key means extend from Object. Otherwise,
+      // falsy `extend` means it's a static class.
+      if (config.extend === null || (!config.extend && config.type != "static")) {
+        config.extend = Object;
+      } else if (!config.extend) {
+        if (qx["core"]["Environment"].get("qx.debug")) {
+          if (config.type && config.type != "static") {
+            throw new Error(`${className}: ` + `No 'extend' key, but 'type' is not 'static' ` + `(found ${config.type})`);
           }
-          return formerClass;
         }
+
+        implicitType = true;
+        config.type = "static";
       }
-    }
 
-    // Store type info
-    clazz.$$type = "Class";
+      if (qx["core"]["Environment"].get("qx.debug")) {
+        Object.keys(config).forEach(key => {
+          let allowedKeys = config.type == "static" ? qx.Bootstrap._allowedStaticKeys : qx.Bootstrap._allowedNonStaticKeys;
 
-    // Attach toString
-    if (!clazz.hasOwnProperty("toString")) {
-      clazz.toString = this.genericToString;
-    }
-
-    // Create namespace
-    var basename = name ? this.createNamespace(name, clazz) : "";
+          // Ensure this key is allowed
+          if (!(key in allowedKeys)) {
+            if (config.type == "static") {
+              throw new Error(`${className}: ` + `disallowed key in static class configuration: ${key}`);
+            } else {
+              throw new Error(`${className}: ` + `unrecognized key in class configuration: ${key}`);
+            }
+          }
 
-    // Store names in constructor/object
-    clazz.classname = name;
-    if (!isStrictMode()) {
-      try {
-        clazz.name = name;
-      } catch (ex) {
-        // Nothing
+          // Ensure its value is of the correct type
+          if (typeof config[key] != allowedKeys[key]) {
+            throw new Error(`${className}: ` + `typeof value for key ${key} must be ${allowedKeys[key]}; ` + `found ${typeof config[key]}`);
+          }
+        });
       }
-    }
-    clazz.basename = basename;
-    clazz.$$events = config.events;
 
-    // Execute defer section
-    if (config.defer) {
-      this.addPendingDefer(clazz, function () {
-        config.defer(clazz, proto);
-      });
-    }
+      // Create the new class
+      clazz = qx.Bootstrap._extend(className, config);
 
-    // Store class reference in global class registry
-    if (name != null) {
-      qx.Bootstrap.$$registry[name] = clazz;
-    }
+      // Add singleton getInstance()
+      if (config.type === "singleton") {
+        clazz.getInstance = qx.Bootstrap.getInstance;
+      }
 
-    return clazz;
-  },
+      clazz.classname = className;
+      qx.Bootstrap.setDisplayName(clazz, className, "constructor");
 
-  /**
-   * Tests whether an object is an instance of qx.core.Object without using instanceof - this
-   * is only for certain low level instances which would otherwise cause a circular, load time
-   * dependency
-   *
-   * @param object {Object?} the object to test
-   * @return {Boolean} true if object is an instance of qx.core.Object
-   */
-  isQxCoreObject(object) {
-    if (object === object.constructor) {
-      return false;
-    }
-    var clz = object.constructor;
-    while (clz) {
-      if (clz.classname === "qx.core.Object") {
-        return true;
+      // Attach toString
+      if (!clazz.hasOwnProperty("toString")) {
+        clazz.toString = qx.Bootstrap.genericToString;
       }
-      clz = clz.superclass;
-    }
-    return false;
-  }
-};
 
-/**
- * Internal class that is responsible for bootstrapping the qooxdoo
- * framework at load time.
- */
-qx.Bootstrap.define("qx.Bootstrap", {
-  statics: {
-    /** Timestamp of qooxdoo based application startup */
-    LOADSTART: qx.$$start || new Date(),
+      // Add statics
+      for (let key in config.statics || {}) {
+        let staticFuncOrVar = config.statics[key];
 
-    /**
-     * Mapping for early use of the qx.debug environment setting.
-     */
-    DEBUG: (function () {
-      // make sure to reflect all changes here to the environment class!
-      var debug = true;
-      if (qx.$$environment && qx.$$environment["qx.debug"] === false) {
-        debug = false;
-      }
-      return debug;
-    })(),
+        if (typeof staticFuncOrVar == "function") {
+          // Allow easily identifying this method
+          qx.Bootstrap.setDisplayName(staticFuncOrVar, className, key);
+        }
 
-    /**
-     * Minimal accessor API for the environment settings given from the
-     * generator.
-     *
-     * WARNING: This method only should be used if the
-     * {@link qx.core.Environment} class is not loaded!
-     *
-     * @param key {String} The key to get the value from.
-     * @return {var} The value of the setting or <code>undefined</code>.
-     */
-    getEnvironmentSetting(key) {
-      if (qx.$$environment) {
-        return qx.$$environment[key];
+        // Add this static as a class property
+        Object.defineProperty(clazz, key, {
+          value: staticFuncOrVar,
+          writable: true,
+          configurable: true,
+          enumerable: allEnumerable || true
+        });
       }
-    },
 
-    /**
-     * Minimal mutator for the environment settings given from the generator.
-     * It checks for the existence of the environment settings and sets the
-     * key if its not given from the generator. If a setting is available from
-     * the generator, the setting will be ignored.
-     *
-     * WARNING: This method only should be used if the
-     * {@link qx.core.Environment} class is not loaded!
-     *
-     * @param key {String} The key of the setting.
-     * @param value {var} The value for the setting.
-     */
-    setEnvironmentSetting(key, value) {
-      if (!qx.$$environment) {
-        qx.$$environment = {};
-      }
-      if (qx.$$environment[key] === undefined) {
-        qx.$$environment[key] = value;
+      // Members are only allowed for non-static classes.
+      if (config.extend) {
+        // Add members
+        if (config.members) {
+          qx.Bootstrap.addMembers(clazz, config.members);
+        }
       }
-    },
 
-    /**
-     * Creates a namespace and assigns the given object to it.
-     *
-     * @internal
-     * @signature function(name, object)
-     * @param name {String} The complete namespace to create. Typically, the last part is the class name itself
-     * @param object {Object} The object to attach to the namespace
-     * @return {String} last part of the namespace (which object is assigned to)
-     * @throws {Error} when the given object already exists.
-     */
-    createNamespace: qx.Bootstrap.createNamespace,
+      //
+      // Store destruct onto class. We wrap their function (or an empty
+      // function) in code that also handles any properties that
+      // require `dereference : true`
+      //
+      let destruct = config.destruct || function () {};
 
-    /**
-     * Offers the ability to change the root for creating namespaces from window to
-     * whatever object is given.
-     *
-     * @param root {Object} The root to use.
-     * @internal
-     */
-    setRoot(root) {
-      qx.$$namespaceRoot = root;
-    },
+      clazz.$$destructor = destruct;
+      qx.Bootstrap.setDisplayName(destruct, className, "destruct");
 
-    /**
-     * Call the same method of the super class.
-     *
-     * @signature function(args, varargs)
-     * @param args {arguments} the arguments variable of the calling method
-     * @param varargs {var} variable number of arguments passed to the overwritten function
-     * @return {var} the return value of the method of the base class.
-     */
-    base: qx.Bootstrap.base,
-
-    /**
-     * Define a new class using the qooxdoo class system.
-     * Lightweight version of {@link qx.Class#define} with less features.
-     *
-     * @signature function(name, config)
-     * @param name {String?} Name of the class. If null, the class will not be
-     *   attached to a namespace.
-     * @param config {Map ? null} Class definition structure. The configuration map has the following keys:
-     *     <table>
-     *       <tr><th>Name</th><th>Type</th><th>Description</th></tr>
-     *       <tr><th>extend</th><td>Class</td><td>The super class the current class inherits from.</td></tr>
-     *       <tr><th>construct</th><td>Function</td><td>The constructor of the class.</td></tr>
-     *       <tr><th>statics</th><td>Map</td><td>Map of static values / functions of the class.</td></tr>
-     *       <tr><th>members</th><td>Map</td><td>Map of instance members of the class.</td></tr>
-     *       <tr><th>defer</th><td>Function</td><td>Function that is called at the end of
-     *          processing the class declaration.</td></tr>
-     *     </table>
-     * @return {Class} The defined class.
-     */
-    define: qx.Bootstrap.define,
+      // If there's a specified classname...
+      if (className) {
+        // Create that namespace
+        qx.Bootstrap.createNamespace(className, clazz);
 
-    /**
-     * Tests whether an object is an instance of qx.core.Object without using instanceof - this
-     * is only for certain low level instances which would otherwise cause a circular, load time
-     * dependency
-     *
-     * @param object {Object?} the object to test
-     * @return {Boolean} true if object is an instance of qx.core.Object
-     */
-    isQxCoreObject: qx.Bootstrap.isQxCoreObject,
-
-    /**
-     * Sets the display name of the given function
-     *
-     * @signature function(fcn, classname, name)
-     * @param fcn {Function} the function to set the display name for
-     * @param classname {String} the name of the class the function is defined in
-     * @param name {String} the function name
-     */
-    setDisplayName: qx.Bootstrap.setDisplayName,
+        // Store class reference in global class registry
+        qx.Bootstrap.$$registry[className] = clazz;
+      }
 
-    /**
-     * Set the names of all functions defined in the given map
-     *
-     * @signature function(functionMap, classname)
-     * @param functionMap {Object} a map with functions as values
-     * @param classname {String} the name of the class, the functions are
-     *   defined in
-     */
-    setDisplayNames: qx.Bootstrap.setDisplayNames,
+      // Now that the class has been defined, arrange to call its
+      // (optional) defer function
+      if (config.defer) {
+        // Execute defer section
+        qx.Bootstrap.addPendingDefer(clazz, () => {
+          config.defer(clazz, clazz.prototype, {
+            add(name, config) {
+              qx.Bootstrap.addProperties(
+                clazz,
+                {
+                  [name]: config
+                },
+
+                true
+              );
+            }
+          });
+        });
+      }
 
-    /**
-     * This method will be attached to all classes to return
-     * a nice identifier for them.
-     *
-     * @internal
-     * @signature function()
-     * @return {String} The class identifier
-     */
-    genericToString: qx.Bootstrap.genericToString,
+      return clazz;
+    },
 
     /**
      * Inherit a clazz from a super class.
@@ -416,11 +219,10 @@ qx.Bootstrap.define("qx.Bootstrap", {
      *
      * @param clazz {Function} The class's wrapped constructor
      * @param construct {Function} The unwrapped constructor
-     * @param superClass {Function} The super class
-     * @param name {Function} fully qualified class name
-     * @param basename {Function} the base name
+     * @param superClass {qx.Class} The super class
+     * @param name {String} fully qualified class name
      */
-    extendClass(clazz, construct, superClass, name, basename) {
+    extendClass(clazz, construct, superClass, name) {
       var superproto = superClass ? superClass.prototype : null;
 
       // Use helper function/class to save the unnecessary constructor call while
@@ -433,8 +235,9 @@ qx.Bootstrap.define("qx.Bootstrap", {
       clazz.prototype = proto;
 
       // Store names in prototype
-      proto.name = proto.classname = name;
-      proto.basename = basename;
+      // proto.name was set in v7 and earlier, but is excluded here because it causes conflicts with common
+      //  property names
+      /*proto.name =*/ proto.classname = name;
 
       /*
         - Store base constructor to constructor-
@@ -451,287 +254,210 @@ qx.Bootstrap.define("qx.Bootstrap", {
       construct.self = clazz.constructor = proto.constructor = clazz;
     },
 
-    /** Private list of classes which have a defer method that needs to be executed */
-    __pendingDefers: [],
-
-    /**
-     * Adds a callback for a class so that it's defer method can be called, either after all classes
-     * are loaded or when absolutely necessary because of load-time requirements of other classes.
-     *
-     * @param clazz {Class} Class to add a callback to
-     * @param cb {Function} Callback function
-     */
-    addPendingDefer(clazz, cb) {
-      if (qx.$$loader && qx.$$loader.delayDefer) {
-        this.__pendingDefers.push(clazz);
-        clazz.$$pendingDefer = cb;
-      } else {
-        cb.call(clazz);
-      }
-    },
-
-    /**
-     * Executes the defer methods for classes which are required by the dependency information in
-     * dbClassInfo (which is a map in the format generated by qxcompiler).  Defer methods are of course
-     * only executed once but they are always put off until absolutely necessary to avoid potential
-     * side effects and recursive and/or difficult to resolve dependencies.
-     *
-     * @param dbClassInfo {Object} qxcompiler map
-     */
-    executePendingDefers(dbClassInfo) {
-      var executeForDbClassInfo = function (dbClassInfo) {
-        if (dbClassInfo.environment) {
-          var required = dbClassInfo.environment.required;
-          if (required) {
-            for (var key in required) {
-              var info = required[key];
-              if (info.load && info.className) {
-                executeForClassName(info.className);
-              }
+    _extend(classname, config) {
+      const type = config.type || "class";
+      const superclass = config.extend || Object;
+      let initFunctions = [];
+      let subclass;
+      let initialConstruct = config.construct;
+
+      if (config.type != "static") {
+        // If the constructor function is defined as a "method" using
+        // shorthand syntax, e.g.,
+        // qx.Class.define("myApp.X",
+        //   {
+        //      construct(x) {}
+        //   });
+        //
+        // rather than as an actual function, e.g.,
+        // qx.Class.define("myApp.X",
+        //   {
+        //      construct : function(x) {}
+        //   });
+        //
+        // then it's not allowed by the spec to be a constructor. We
+        // must wrap it.
+        //
+        subclass = function (...args) {
+          let ret;
+
+          // add abstract and singleton checks
+          if (type === "abstract") {
+            if (subclass.classname === classname) {
+              throw new Error("The class '," + classname + "' is abstract! It is not possible to instantiate it.");
             }
           }
-        }
-        for (var key in dbClassInfo.dependsOn) {
-          var depInfo = dbClassInfo.dependsOn[key];
-          if (depInfo.require || depInfo.usage === "dynamic") {
-            executeForClassName(key);
+
+          if (type === "singleton") {
+            if (!subclass.$$allowconstruct) {
+              throw new Error(
+                "The class '" +
+                  classname +
+                  "' is a singleton! It is not possible to instantiate it " +
+                  "directly. Use the static getInstance() method instead."
+              );
+            }
           }
-        }
-      };
 
-      var executeForClassName = function (className) {
-        var clazz = getByName(className);
-        if (!clazz) {
-          return;
-        }
-        if (clazz.$$deferComplete) {
-          return;
-        }
-        var dbClassInfo = clazz.$$dbClassInfo;
-        if (dbClassInfo) {
-          executeForDbClassInfo(dbClassInfo);
-        }
-        execute(clazz);
-      };
-
-      var execute = function (clazz) {
-        var cb = clazz.$$pendingDefer;
-        if (cb) {
-          delete clazz.$$pendingDefer;
-          clazz.$$deferComplete = true;
-          cb.call(clazz);
-        }
-      };
-
-      var getByName = function (name) {
-        var clazz = qx.Bootstrap.getByName(name);
-        if (!clazz) {
-          var splits = name.split(".");
-          var part = splits[0];
-          var root =
-            qx.$$namespaceRoot && qx.$$namespaceRoot[part]
-              ? qx.$$namespaceRoot
-              : window;
-          var tmp = root;
-
-          for (
-            var i = 0, len = splits.length - 1;
-            tmp && i < len;
-            i++, part = splits[i]
-          ) {
-            tmp = tmp[part];
+          // Call the constructor; note that we catch the return value of the constructor - this is allowed only because
+          //   of `qxWeb` and backwards compatibility, but it is nonsense to return a different instance than `this`
+          if (initialConstruct) {
+            ret = initialConstruct.apply(this, args);
+          } else if (superclass === Object) {
+            superclass.apply(this, args);
+          } else {
+            ret = superclass.apply(this, args);
           }
-          if (tmp != root) {
-            clazz = tmp;
+          if (ret !== undefined && ret !== this) {
+            qx.log.Logger.error(
+              `The constructor of class '${classname}' returned a different instance than 'this'. This is highly suspect, not recommended, and should be removed.`
+            );
           }
-        }
-        return clazz;
-      };
 
-      if (!dbClassInfo) {
-        var pendingDefers = this.__pendingDefers;
-        this.__pendingDefers = [];
-        pendingDefers.forEach(execute);
-        return;
+          return ret !== undefined ? ret : this;
+        };
+      } else {
+        subclass = function () {
+          throw new Error(`${classname}: can not instantiate a static class`);
+        };
       }
 
-      executeForDbClassInfo(dbClassInfo);
-    },
+      // Allow easily identifying this class
+      qx.Bootstrap.setDisplayName(subclass, classname);
 
-    /**
-     * Find a class by its name
-     *
-     * @param name {String} class name to resolve
-     * @return {Class} the class
-     */
-    getByName(name) {
-      return qx.Bootstrap.$$registry[name];
-    },
+      // This is a class
+      subclass.$$type = "Class";
 
-    /** @type {Map} Stores all defined classes */
-    $$registry: {},
+      // If its class type was specified, save it
+      if (config.type) {
+        subclass.$$classtype = config.type;
+      }
 
-    /*
-    ---------------------------------------------------------------------------
-      OBJECT UTILITY FUNCTIONS
-    ---------------------------------------------------------------------------
-    */
+      // Ensure there's something unique to compare constructors to.
+      if (!config.construct) {
+        config.construct = function () {};
+      }
 
-    /**
-     * Get the number of own properties in the object.
-     *
-     * @param map {Object} the map
-     * @return {Integer} number of objects in the map
-     * @lint ignoreUnused(key)
-     */
-    objectGetLength(map) {
-      return qx.Bootstrap.keys(map).length;
+      // Keep track of the original constructor so we know when to
+      // construct mixins
+      subclass.$$originalConstructor = config.construct;
+
+      qx.Bootstrap.extendClass(subclass, config.construct, superclass, classname);
+
+      // Save any init functions that need to be called upon instantiation
+      Object.defineProperty(subclass, "$$initFunctions", {
+        value: initFunctions,
+        writable: false,
+        configurable: false,
+        enumerable: allEnumerable || false
+      });
+
+      return subclass;
     },
 
     /**
-     * Inserts all keys of the source object into the
-     * target objects. Attention: The target map gets modified.
+     * Removes a class from qooxdoo defined by {@link #define}
      *
-     * @param target {Object} target object
-     * @param source {Object} object to be merged
-     * @param overwrite {Boolean ? true} If enabled existing keys will be overwritten
-     * @return {Object} Target with merged values from the source object
+     * @param name {String}
+     *   Name of the class
      */
-    objectMergeWith(target, source, overwrite) {
-      if (overwrite === undefined) {
-        overwrite = true;
+    undefine(name) {
+      // Nothing to do if the class name isn't registered
+      if (!(name in qx.Bootstrap.$$registry)) {
+        return;
       }
 
-      for (var key in source) {
-        if (overwrite || target[key] === undefined) {
-          target[key] = source[key];
-        }
+      // Delete the class from the registry
+      delete qx.Bootstrap.$$registry[name];
+
+      // Delete the class reference from the namespaces and all
+      // empty namespaces
+      let ns = name.split(".");
+
+      // Build up an array containing all namespace objects including window
+      let objects = [window];
+      for (let i = 0; i < ns.length; i++) {
+        objects.push(objects[i][ns[i]]);
       }
 
-      return target;
+      // go through all objects and check for the constructor or
+      // empty namespaces
+      for (let i = objects.length - 1; i >= 1; i--) {
+        var last = objects[i];
+        var parent = objects[i - 1];
+        if (
+          // The class being undefined, but parent classes in case it is a
+          // nested class that is being undefined
+          (i == objects.length - 1 && qx.Bootstrap.isFunction(last)) ||
+          qx.Bootstrap.objectGetLength(last) === 0
+        ) {
+          delete parent[ns[i - 1]];
+        } else {
+          break;
+        }
+      }
     },
 
     /**
-     * IE does not return "shadowed" keys even if they are defined directly
-     * in the object.
+     * Attach members to a class
      *
-     * @internal
-     * @type {String[]}
-     */
-    __shadowedKeys: [
-      "isPrototypeOf",
-      "hasOwnProperty",
-      "toLocaleString",
-      "toString",
-      "valueOf",
-      "propertyIsEnumerable",
-      "constructor"
-    ],
-
-    /**
-     * Get the keys of a map as array as returned by a "for ... in" statement.
+     * @param clazz {Class}
+     *   Class to add members to
      *
-     * @signature function(map)
-     * @internal
-     * @param map {Object} the map
-     * @return {Array} array of the keys of the map
+     * @param members {Map}
+     *   The map of members to attach
      */
-    keys: {
-      ES5: Object.keys,
-
-      BROKEN_IE(map) {
-        if (
-          map === null ||
-          (typeof map !== "object" && typeof map !== "function")
-        ) {
-          throw new TypeError("Object.keys requires an object as argument.");
-        }
-
-        var arr = [];
-        var hasOwnProperty = Object.prototype.hasOwnProperty;
-        for (var key in map) {
-          if (hasOwnProperty.call(map, key)) {
-            arr.push(key);
+    addMembers(clazz, members) {
+      for (let key in members) {
+        let member = members[key];
+        let proto = clazz.prototype;
+
+        if (qx["core"]["Environment"].get("qx.debug")) {
+          if (proto[key] !== undefined && key.charAt(0) === "_" && key.charAt(1) === "_") {
+            throw new Error(`Overwriting private member "${key}" ` + `of Class "${clazz.classname}" ` + "is not allowed");
           }
         }
 
-        // IE does not return "shadowed" keys even if they are defined directly
-        // in the object. This is incompatible with the ECMA standard!!
-        // This is why this checks are needed.
-        var shadowedKeys = qx.Bootstrap.__shadowedKeys;
-        for (var i = 0, a = shadowedKeys, l = a.length; i < l; i++) {
-          if (hasOwnProperty.call(map, a[i])) {
-            arr.push(a[i]);
-          }
-        }
+        if (typeof member == "function") {
+          // Allow easily identifying this method
+          qx.Bootstrap.setDisplayName(member, clazz.classname, key);
 
-        return arr;
-      },
-
-      default(map) {
-        if (
-          map === null ||
-          (typeof map !== "object" && typeof map !== "function")
-        ) {
-          throw new TypeError("Object.keys requires an object as argument.");
-        }
-
-        var arr = [];
-
-        var hasOwnProperty = Object.prototype.hasOwnProperty;
-        for (var key in map) {
-          if (hasOwnProperty.call(map, key)) {
-            arr.push(key);
+          // Allow base calls
+          if (key in clazz.prototype) {
+            member.base = clazz.prototype[key];
           }
         }
 
-        return arr;
+        // Create the storage for this member
+        Object.defineProperty(clazz.prototype, key, {
+          value: member,
+          writable: true,
+          configurable: true,
+          enumerable: allEnumerable || true
+        });
       }
-    }[
-      typeof Object.keys === "function"
-        ? "ES5"
-        : (function () {
-            for (var key in { toString: 1 }) {
-              return key;
-            }
-          })() !== "toString"
-        ? "BROKEN_IE"
-        : "default"
-    ],
+    },
 
     /**
-     * Mapping from JavaScript string representation of objects to names
+     * This method will be attached to all classes to return a nice
+     * identifier for them.
+     *
      * @internal
-     * @type {Map}
+     * @signature function()
+     * @return {String} The class identifier
      */
-    __classToTypeMap: {
-      "[object String]": "String",
-      "[object Array]": "Array",
-      "[object Object]": "Object",
-      "[object RegExp]": "RegExp",
-      "[object Number]": "Number",
-      "[object Boolean]": "Boolean",
-      "[object Date]": "Date",
-      "[object Function]": "Function",
-      "[object AsyncFunction]": "Function",
-      "[object Error]": "Error",
-      "[object Blob]": "Blob",
-      "[object ArrayBuffer]": "ArrayBuffer",
-      "[object FormData]": "FormData"
+    genericToString() {
+      return this.classname;
     },
 
-    /*
-    ---------------------------------------------------------------------------
-      FUNCTION UTILITY FUNCTIONS
-    ---------------------------------------------------------------------------
-    */
-
     /**
      * Returns a function whose "this" is altered.
      *
      * *Syntax*
      *
-     * <pre class='javascript'>qx.Bootstrap.bind(myFunction, [self, [varargs...]]);</pre>
+     * <pre class='javascript'>
+     * qx.Bootstrap.bind(myFunction, [self, [varargs...]]);
+     * </pre>
      *
      * *Example*
      *
@@ -747,63 +473,138 @@ qx.Bootstrap.define("qx.Bootstrap", {
      * myBoundFunction(); // this will make the element myElement red.
      * </pre>
      *
-     * @param func {Function} Original function to wrap
-     * @param self {Object ? null} The object that the "this" of the function will refer to.
-     * @param varargs {arguments ? null} The arguments to pass to the function.
-     * @return {Function} The bound function.
+     * @param func {Function}
+     *   Original function to wrap
+     *
+     * @param self {Object ? null}
+     *   The object that the "this" of the function will refer to.
+     *
+     * @param varargs {arguments ? null}
+     *   The variable number of arguments to pass to the function
+     *
+     * @return {Function}
+     *   The bound function.
      */
     bind(func, self, varargs) {
-      var fixedArgs = Array.prototype.slice.call(
-        arguments,
-        2,
-        arguments.length
-      );
-
-      return function () {
-        var args = Array.prototype.slice.call(arguments, 0, arguments.length);
-        return func.apply(self, fixedArgs.concat(args));
-      };
+      var fixedArgs = Array.prototype.slice.call(arguments, 2);
+      return func.bind(self, ...fixedArgs);
     },
 
-    /*
-    ---------------------------------------------------------------------------
-      STRING UTILITY FUNCTIONS
-    ---------------------------------------------------------------------------
-    */
-
     /**
-     * Convert the first character of the string to upper case.
+     * Helper method to handle singletons
      *
-     * @param str {String} the string
-     * @return {String} the string with an upper case first character
+     * @return {Object}
+     *   The singleton instance
+     *
+     * @internal
      */
-    firstUp(str) {
-      return str.charAt(0).toUpperCase() + str.substr(1);
+    getInstance() {
+      if (this.$$instance === null) {
+        throw new Error(
+          "Singleton instance of " +
+            this +
+            " is requested, but not ready yet. This is most likely due" +
+            " to a recursive call in the constructor path."
+        );
+      }
+
+      if (!this.$$instance) {
+        // Allow calling the constructor
+        this.$$allowconstruct = true;
+
+        // null means "object is being created"; needed for another call
+        // of getInstance() during instantiation
+        this.$$instance = null;
+
+        // Obtain the singleton instance
+        this.$$instance = new this();
+
+        // Disallow, again, calling the constructor
+        delete this.$$allowconstruct;
+      }
+
+      return this.$$instance;
+    },
+
+    createNamespace(name, object) {
+      var splits = name.split(".");
+      var part = splits[0];
+      var parent = qx.$$namespaceRoot && qx.$$namespaceRoot[part] ? qx.$$namespaceRoot : window;
+
+      for (var i = 0, len = splits.length - 1; i < len; i++, part = splits[i]) {
+        if (!parent[part]) {
+          parent = parent[part] = {};
+        } else {
+          parent = parent[part];
+        }
+      }
+
+      // store object
+      parent[part] = object;
+
+      // return last part name (e.g. classname)
+      return part;
     },
 
     /**
-     * Convert the first character of the string to lower case.
+     * Offers the ability to change the root for creating namespaces from
+     * window to whatever object is given.
      *
-     * @param str {String} the string
-     * @return {String} the string with a lower case first character
+     * @param root {Object}
+     *   The root to use.
+     *
+     * @internal
      */
-    firstLow(str) {
-      return str.charAt(0).toLowerCase() + str.substr(1);
+    setRoot(root) {
+      qx.$$namespaceRoot = root;
     },
 
-    /*
-    ---------------------------------------------------------------------------
-      TYPE UTILITY FUNCTIONS
-    ---------------------------------------------------------------------------
-    */
+    getDisplayName(f) {
+      return f.$$displayName || "<non-qooxdoo>";
+    },
+
+    setDisplayName(f, classname, name) {
+      if (name) {
+        f.$$displayName = f.displayName = `${classname}.${name}()`;
+      } else {
+        f.$$displayName = f.displayName = `${classname}()`;
+      }
+    },
+
+    setDisplayNames(functionMap, classname) {
+      for (let name in functionMap) {
+        let f = functionMap[name];
+
+        if (f instanceof Function) {
+          f.$$displayName = f.displayName = `${classname}.${f.name || name}()`;
+        }
+      }
+    },
+
+    base(args, varargs) {
+      if (qx.Bootstrap.DEBUG) {
+        if (typeof args.callee.base != "function") {
+          throw new Error("Cannot call super class. Method is not derived: " + qx.Bootstrap.getDisplayName(args.callee));
+        }
+      }
+
+      if (arguments.length === 1) {
+        return args.callee.base.call(this);
+      } else {
+        return args.callee.base.apply(this, Array.prototype.slice.call(arguments, 1));
+      }
+    },
 
     /**
      * Get the internal class of the value. See
      * http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
      * for details.
      *
-     * @param value {var} value to get the class for
-     * @return {String} the internal class of the value
+     * @param value {var}
+     *   value to get the class for
+     *
+     * @return {String}
+     *   The internal class of the value
      */
     getClass(value) {
       // The typeof null and undefined is "object" under IE8
@@ -812,24 +613,40 @@ qx.Bootstrap.define("qx.Bootstrap", {
       } else if (value === null) {
         return "Null";
       }
-      var classString = Object.prototype.toString.call(value);
-      return (
-        qx.Bootstrap.__classToTypeMap[classString] || classString.slice(8, -1)
-      );
+
+      let classString = Object.prototype.toString.call(value);
+      return qx.Bootstrap._classToTypeMap[classString] || classString.slice(8, -1);
+    },
+
+    /**
+     * Find a class by its name
+     *
+     * @param name {String}
+     *   class name to resolve
+     *
+     * @return {Class}
+     *   The class
+     */
+    getByName(name) {
+      return qx.Bootstrap.$$registry[name];
     },
 
     /**
      * Whether the value is a string.
      *
-     * @param value {var} Value to check.
-     * @return {Boolean} Whether the value is a string.
+     * @param value {var}
+     *   Value to check.
+     *
+     * @return {Boolean}
+     *   Whether the value is a string.
      */
     isString(value) {
-      // Added "value !== null" because IE throws an exception "Object expected"
-      // by executing "value instanceof String" if value is a DOM element that
-      // doesn't exist. It seems that there is an internal difference between a
-      // JavaScript null and a null returned from calling DOM.
-      // e.q. by document.getElementById("ReturnedNull").
+      // Added "value !== null" because IE throws an exception
+      // "Object expected" by executing "value instanceof String" if
+      // value is a DOM element that doesn't exist. It seems that
+      // there is an internal difference between a JavaScript null
+      // and a null returned from calling DOM. e.q. by
+      // document.getElementById("ReturnedNull").
       return (
         value !== null &&
         (typeof value === "string" ||
@@ -846,42 +663,30 @@ qx.Bootstrap.define("qx.Bootstrap", {
      * @return {Boolean} Whether the value is an array.
      */
     isArray(value) {
-      // Added "value !== null" because IE throws an exception "Object expected"
-      // by executing "value instanceof Array" if value is a DOM element that
-      // doesn't exist. It seems that there is an internal difference between a
-      // JavaScript null and a null returned from calling DOM.
-      // e.q. by document.getElementById("ReturnedNull").
+      // Added "value !== null" because IE throws an exception
+      // "Object expected" by executing "value instanceof Array" if
+      // value is a DOM element that doesn't exist. It seems that
+      // there is an internal difference between a JavaScript null
+      // and a null returned from calling DOM. e.q. by
+      // document.getElementById("ReturnedNull").
       return (
         value !== null &&
         (value instanceof Array ||
-          (value &&
-            qx.data &&
-            qx.data.IListData &&
-            qx.util.OOUtil.hasInterface(
-              value.constructor,
-              qx.data.IListData
-            )) ||
+          (value && qx.data && qx.data.IListData && qx.util.OOUtil.hasInterface(value.constructor, qx.data.IListData)) ||
           qx.Bootstrap.getClass(value) === "Array" ||
           (!!value && !!value.$$isArray))
       );
     },
 
     /**
-     * Whether the value is an POJO (ie {foo: 1})
-     * or an object which is created from a ES6-style class or prototypical-inheritance-based class;
-     * If you need to determine whether something is a POJO and not created from a class, use isPojo instead
+     * Whether the value is an object. Note that built-in types like Window
+     * are not reported to be objects.
      *
-     * Note that built-in types like Window are not deemed to be objects.
-     *
-     * @param {*} value value to check.
+     * @param value {var} Value to check.
      * @return {Boolean} Whether the value is an object.
      */
     isObject(value) {
-      return (
-        value !== undefined &&
-        value !== null &&
-        qx.Bootstrap.getClass(value) === "Object"
-      );
+      return value !== undefined && value !== null && qx.Bootstrap.getClass(value) === "Object";
     },
 
     /**
@@ -905,67 +710,488 @@ qx.Bootstrap.define("qx.Bootstrap", {
       return name === "Function" || name === "AsyncFunction";
     },
 
-    /*
-    ---------------------------------------------------------------------------
-      LOGGING UTILITY FUNCTIONS
-    ---------------------------------------------------------------------------
-    */
-
-    $$logs: [],
-
     /**
-     * Sending a message at level "debug" to the logger.
+     * Tests whether an object is an instance of qx.core.Object without
+     * using instanceof - this is only for certain low level instances
+     * which would otherwise cause a circular, load time dependency
      *
-     * @param object {Object} Contextual object (either instance or static class)
-     * @param message {var} Any number of arguments supported. An argument may
-     *   have any JavaScript data type. All data is serialized immediately and
-     *   does not keep references to other objects.
+     * @param object {Object?} the object to test
+     * @return {Boolean} true if object is an instance of qx.core.Object
      */
-    debug(object, message) {
-      qx.Bootstrap.$$logs.push(["debug", arguments]);
+    isQxCoreObject(object) {
+      if (object === object.constructor) {
+        return false;
+      }
+
+      let clz = object.constructor;
+      let qxCoreObject = ["qx", "core", "Object"].join(".");
+      while (clz) {
+        if (clz.classname === qxCoreObject) {
+          return true;
+        }
+        clz = clz.superclass;
+      }
+
+      return false;
     },
 
     /**
-     * Sending a message at level "info" to the logger.
+     * Convert the first character of the string to upper case.
      *
-     * @param object {Object} Contextual object (either instance or static class)
-     * @param message {var} Any number of arguments supported. An argument may
-     *   have any JavaScript data type. All data is serialized immediately and
-     *   does not keep references to other objects.
+     * @param str {String} the string
+     * @return {String} the string with an upper case first character
      */
-    info(object, message) {
-      qx.Bootstrap.$$logs.push(["info", arguments]);
+    firstUp(str) {
+      return str.charAt(0).toUpperCase() + str.substr(1);
     },
 
     /**
-     * Sending a message at level "warn" to the logger.
+     * Convert the first character of the string to lower case.
      *
-     * @param object {Object} Contextual object (either instance or static class)
-     * @param message {var} Any number of arguments supported. An argument may
-     *   have any JavaScript data type. All data is serialized immediately and
-     *   does not keep references to other objects.
+     * @param str {String} the string
+     * @return {String} the string with a lower case first character
      */
-    warn(object, message) {
-      qx.Bootstrap.$$logs.push(["warn", arguments]);
+    firstLow(str) {
+      return str.charAt(0).toLowerCase() + str.substr(1);
     },
 
     /**
-     * Sending a message at level "error" to the logger.
-     *
-     * @param object {Object} Contextual object (either instance or static class)
-     * @param message {var} Any number of arguments supported. An argument may
-     *   have any JavaScript data type. All data is serialized immediately and
-     *   does not keep references to other objects.
+     * Mapping from JavaScript string representation of objects to names
+     * @internal
+     * @type {Map}
      */
-    error(object, message) {
-      qx.Bootstrap.$$logs.push(["error", arguments]);
+    _classToTypeMap: {
+      "[object String]": "String",
+      "[object Array]": "Array",
+      "[object Object]": "Object",
+      "[object RegExp]": "RegExp",
+      "[object Number]": "Number",
+      "[object Boolean]": "Boolean",
+      "[object Date]": "Date",
+      "[object Function]": "Function",
+      "[object AsyncFunction]": "Function",
+      "[object Error]": "Error",
+      "[object Blob]": "Blob",
+      "[object ArrayBuffer]": "ArrayBuffer",
+      "[object FormData]": "FormData"
+    }
+  },
+
+  core: {
+    // Bootstrap Aspect class
+    Aspect: {
+      wrap(fullName, f, type) {
+        return f;
+      }
     },
 
-    /**
-     * Prints the current stack trace at level "info"
-     *
-     * @param object {Object} Contextual object (either instance or static class)
-     */
-    trace(object) {}
+    // Bootstrap Environment class
+    Environment: {
+      $$environment: {},
+
+      get(key) {
+        return qx["core"]["Environment"].$$environment[key];
+      },
+
+      add(key, value) {
+        qx["core"]["Environment"].$$environment[key] = value;
+      }
+    }
   }
 });
+
+//
+// Pull ourself up by our bootstraps!
+//
+qx.Bootstrap.define("qx.Bootstrap", {
+  type: "static",
+  statics: Object.assign(
+    {
+      /** Timestamp of qooxdoo based application startup */
+      LOADSTART: qx.$$start || new Date(),
+
+      /**
+       * Mapping for early use of the qx.debug environment setting.
+       */
+      DEBUG: (function () {
+        // make sure to reflect all changes here to the environment class!
+        var debug = true;
+        if (qx.$$environment && qx.$$environment["qx.debug"] === false) {
+          debug = false;
+        }
+
+        return debug;
+      })(),
+
+      /**
+       * Minimal accessor API for the environment settings given from
+       * the generator.
+       *
+       * WARNING: This method only should be used if the {@link
+       * qx["core"]["Environment"]} class is not loaded!
+       *
+       * @param key {String}
+       *   The key to get the value from.
+       *
+       * @return {var}
+       *   The value of the setting or <code>undefined</code>.
+       */
+      getEnvironmentSetting(key) {
+        if (qx.$$environment) {
+          return qx.$$environment[key];
+        }
+
+        return undefined;
+      },
+
+      /**
+       * Minimal mutator for the environment settings given from the
+       * generator. It checks for the existence of the environment settings
+       * and sets the key if its not given from the generator. If a setting
+       * is available from the generator, the setting will be ignored.
+       *
+       * WARNING: This method only should be used if the
+       * {@link qx.core.Environment} class is not loaded!
+       *
+       * @param key {String} The key of the setting.
+       * @param value {var} The value for the setting.
+       */
+      setEnvironmentSetting(key, value) {
+        if (!qx.$$environment) {
+          qx.$$environment = {};
+        }
+
+        if (qx.$$environment[key] === undefined) {
+          qx.$$environment[key] = value;
+        }
+      },
+
+      /**
+       * Private list of classes which have a defer method that
+       * needs to be executed
+       */
+      __pendingDefers: [],
+
+      /**
+       * Adds a callback for a class so that it's defer method can be
+       * called, either after all classes are loaded or when absolutely
+       * necessary because of load-time requirements of other classes.
+       *
+       * @param clazz {Class}
+       *   Class to add a callback to
+       *
+       * @param cb {Function}
+       *   Callback function
+       */
+      addPendingDefer(clazz, cb) {
+        if (qx.$$loader && qx.$$loader.delayDefer) {
+          this.__pendingDefers.push(clazz);
+          clazz.$$pendingDefer = cb;
+        } else {
+          cb.call(clazz);
+        }
+      },
+
+      /**
+       * Executes the defer methods for classes which are required by the
+       * dependency information in dbClassInfo (which is a map in the format
+       * generated by qxcompiler). Defer methods are of course only executed
+       * once but they are always put off until absolutely necessary to
+       * avoid potential side effects and recursive and/or difficult to
+       * resolve dependencies.
+       *
+       * @param dbClassInfo {Object}
+       *   qxcompiler map
+       */
+      executePendingDefers(dbClassInfo) {
+        let execute;
+        let executeForDbClassInfo;
+        let executeForClassName;
+        let getByName;
+
+        execute = function (clazz) {
+          let cb = clazz.$$pendingDefer;
+          if (cb) {
+            delete clazz.$$pendingDefer;
+            clazz.$$deferComplete = true;
+            cb.call(clazz);
+          }
+        };
+
+        executeForDbClassInfo = function (dbClassInfo) {
+          if (dbClassInfo.environment) {
+            let required = dbClassInfo.environment.required;
+            if (required) {
+              for (let key in required) {
+                let info = required[key];
+                if (info.load && info.className) {
+                  executeForClassName(info.className);
+                }
+              }
+            }
+          }
+
+          for (let key in dbClassInfo.dependsOn) {
+            let depInfo = dbClassInfo.dependsOn[key];
+            if (depInfo.require || depInfo.usage === "dynamic") {
+              executeForClassName(key);
+            }
+          }
+        };
+
+        executeForClassName = function (className) {
+          let clazz = getByName(className);
+          if (!clazz) {
+            return;
+          }
+
+          if (clazz.$$deferComplete) {
+            return;
+          }
+          let dbClassInfo = clazz.$$dbClassInfo;
+          if (dbClassInfo) {
+            executeForDbClassInfo(dbClassInfo);
+          }
+          execute(clazz);
+        };
+
+        getByName = function (name) {
+          let clazz = qx.Bootstrap.getByName(name);
+          if (!clazz) {
+            let splits = name.split(".");
+            let part = splits[0];
+            let root = qx.$$namespaceRoot && qx.$$namespaceRoot[part] ? qx.$$namespaceRoot : window;
+            let tmp = root;
+
+            for (let i = 0, len = splits.length - 1; tmp && i < len; i++, part = splits[i]) {
+              tmp = tmp[part];
+            }
+            if (tmp != root) {
+              clazz = tmp;
+            }
+          }
+          return clazz;
+        };
+
+        if (!dbClassInfo) {
+          let pendingDefers = this.__pendingDefers;
+          this.__pendingDefers = [];
+          pendingDefers.forEach(execute);
+          return;
+        }
+
+        executeForDbClassInfo(dbClassInfo);
+      },
+
+      /*
+       -----------------------------------------------------------------------
+       OBJECT UTILITY FUNCTIONS
+       -----------------------------------------------------------------------
+       */
+
+      /**
+       * Get the number of own properties in the object.
+       *
+       * @param map {Object}
+       *   the map
+       *
+       * @return {Integer}
+       *   number of objects in the map
+       *
+       * @lint ignoreUnused(key)
+       */
+      objectGetLength(map) {
+        return qx.Bootstrap.keys(map).length;
+      },
+
+      /**
+       * Inserts all keys of the source object into the target
+       * objects. Attention: The target map gets modified.
+       *
+       * @param target {Object}
+       *   target object
+       *
+       * @param source {Object}
+       *   object to be merged
+       *
+       * @param overwrite {Boolean ? true}
+       *   If enabled existing keys will be overwritten
+       *
+       * @return {Object}
+       *   Target with merged values from the source object
+       */
+      objectMergeWith(target, source, overwrite) {
+        if (overwrite === undefined) {
+          overwrite = true;
+        }
+
+        for (let key in source) {
+          if (overwrite || target[key] === undefined) {
+            target[key] = source[key];
+          }
+        }
+
+        return target;
+      },
+
+      /**
+       * IE does not return "shadowed" keys even if they are defined directly
+       * in the object.
+       *
+       * @internal
+       * @type {String[]}
+       */
+      _shadowedKeys: ["isPrototypeOf", "hasOwnProperty", "toLocaleString", "toString", "valueOf", "propertyIsEnumerable", "constructor"],
+
+      /**
+       * Get the keys of a map as array as returned by a "for ... in"
+       * statement.
+       *
+       * @signature function(map)
+       *
+       * @internal
+       *
+       * @param map {Object}
+       *   the map
+       *
+       * @return {Array}
+       *   array of the keys of the map
+       */
+      keys: {
+        ES5: Object.keys,
+
+        BROKEN_IE(map) {
+          if (map === null || (typeof map !== "object" && typeof map !== "function")) {
+            throw new TypeError("Object.keys requires an object as argument.");
+          }
+
+          let arr = [];
+          let hasOwnProperty = Object.prototype.hasOwnProperty;
+          for (let key in map) {
+            if (hasOwnProperty.call(map, key)) {
+              arr.push(key);
+            }
+          }
+
+          // IE does not return "shadowed" keys even if they are
+          // defined directly in the object. This is incompatible
+          // with the ECMA standard!! This is why this checks are
+          // needed.
+          var shadowedKeys = qx.Bootstrap._shadowedKeys;
+          for (let i = 0, a = shadowedKeys, l = a.length; i < l; i++) {
+            if (hasOwnProperty.call(map, a[i])) {
+              arr.push(a[i]);
+            }
+          }
+
+          return arr;
+        },
+
+        default(map) {
+          if (map === null || (typeof map !== "object" && typeof map !== "function")) {
+            throw new TypeError("Object.keys requires an object as argument.");
+          }
+
+          let arr = [];
+
+          let hasOwnProperty = Object.prototype.hasOwnProperty;
+          for (let key in map) {
+            if (hasOwnProperty.call(map, key)) {
+              arr.push(key);
+            }
+          }
+
+          return arr;
+        }
+      }[
+        typeof Object.keys === "function"
+          ? "ES5"
+          : (function () {
+              for (let key in { toString: 1 }) {
+                return key;
+              }
+            })() !== "toString"
+          ? "BROKEN_IE"
+          : "default"
+      ],
+
+      /*
+    -----------------------------------------------------------------------
+    LOGGING UTILITY FUNCTIONS
+    -----------------------------------------------------------------------
+    */
+
+      $$logs: [],
+
+      /**
+       * Sending a message at level "debug" to the logger.
+       *
+       * @param object {Object}
+       *   Contextual object (either instance or static class)
+       *
+       * @param message {var}
+       *   Any number of arguments supported. An argument may have any
+       *   JavaScript data type. All data is serialized immediately and does
+       *   not keep references to other objects.
+       */
+      debug(object, message) {
+        qx.Bootstrap.$$logs.push(["debug", arguments]);
+      },
+
+      /**
+       * Sending a message at level "info" to the logger.
+       *
+       * @param object {Object}
+       *   Contextual object (either instance or static class)
+       *
+       * @param message {var}
+       *   Any number of arguments supported. An argument may have any
+       *   JavaScript data type. All data is serialized immediately and does
+       *   not keep references to other objects.
+       */
+      info(object, message) {
+        qx.Bootstrap.$$logs.push(["info", arguments]);
+      },
+
+      /**
+       * Sending a message at level "warn" to the logger.
+       *
+       * @param object {Object}
+       *   Contextual object (either instance or static class)
+       *
+       * @param message {var}
+       *   Any number of arguments supported. An argument may have any
+       *   JavaScript data type. All data is serialized immediately and does
+       *   not keep references to other objects.
+       */
+      warn(object, message) {
+        qx.Bootstrap.$$logs.push(["warn", arguments]);
+      },
+
+      /**
+       * Sending a message at level "error" to the logger.
+       *
+       * @param object {Object}
+       *   Contextual object (either instance or static class)
+       *
+       * @param message {var}
+       *   Any number of arguments supported. An argument may have any
+       *   JavaScript data type. All data is serialized immediately and does
+       *   not keep references to other objects.
+       */
+      error(object, message) {
+        qx.Bootstrap.$$logs.push(["error", arguments]);
+      },
+
+      /**
+       * Prints the current stack trace at level "info"
+       *
+       * @param object {Object}
+       *   Contextual object (either instance or static class)
+       */
+      trace(object) {}
+    },
+
+    qx.Bootstrap
+  )
+});