Cornerstone of Component moodule - method for creating new components
193027
function (componentDescription) {
                var i = components.length,
                    app;

                // Old-school declaration
                // > franky.Component.extend({
                //  id: 'hello',
                //  init: function () {
                //      console.log('hello');
                //  }
                // });
                if (franky.isObject(componentDescription)) {
                    app = franky.beget(franky.ComponentBase, componentDescription);
                    // Short form declaration
                    // > franky.Component.extend('hello', function () {
                    //      console.log('hello');
                    // });
                } else if (franky.isString(componentDescription) && franky.isFunction(arguments[1])) {
                    app = franky.beget(franky.ComponentBase, {
                        id: componentDescription,
                        init: arguments[1]
                    });
                    // Dependencies injection form declaration
                    // > franky.Component.extend('hello', ['$logger', function ($logger) {
                    //      $logger.say('hello');
                    // }]);
                } else if (franky.isString(componentDescription) && franky.isArray(arguments[1])) {
                    var args = arguments[1];
                    app = franky.beget(franky.ComponentBase, {
                        id: componentDescription,
                        init: function () {
                            var deps = franky.filter(args, function (item) {
                                return franky.isString(item);
                            });
                            deps = franky.map(deps, function (serviceName) {
                                if (!services[serviceName]) {
                                    throw new Error('Service ' + serviceName + ' hasnt defined');
                                }
                                return services[serviceName]();
                            });
                            var defs = franky.filter(args, function (item) {

                                return franky.isFunction(item);
                            });
                            if (defs.length > 1) {
                                throw new Error('Too much declaration functions');
                            }
                            defs[0].apply(this, deps);
                        }
                    });
                } else {
                    throw new Error('Unknown definition structure, try to use extend("yourName", function() { ... init code ... })');
                }

                if (!app.id) {
                    franky.error('extend method expects id field in description object');
                }

                components.push(app);
                // fill index
                componentsIndex[app.id] = i;
                return components[i];

            }
308758
function createTableLayout(){
    var tableItem = {
        type: 'component',
        componentName: 'Table'
    };

    var stackItem = myLayout.root.getItemsById('stack-topleft')[0];
    stackItem.addChild(tableItem);
    // get focus on the search tab
    stackItem.setActiveContentItem(myLayout.root.getItemsById('node-list')[0]);
    globalFunc.initTable();
}
15275
protected static function init() {
        global $CFG;

        // Init only once per request/CLI execution, we ignore changes done afterwards.
        if (isset(self::$plugintypes)) {
            return;
        }

        if (defined('IGNORE_COMPONENT_CACHE') and IGNORE_COMPONENT_CACHE) {
            self::fill_all_caches();
            return;
        }

        if (!empty($CFG->alternative_component_cache)) {
            // Hack for heavily clustered sites that want to manage component cache invalidation manually.
            $cachefile = $CFG->alternative_component_cache;

            if (file_exists($cachefile)) {
                if (CACHE_DISABLE_ALL) {
                    // Verify the cache state only on upgrade pages.
                    $content = self::get_cache_content();
                    if (sha1_file($cachefile) !== sha1($content)) {
                        die('Outdated component cache file defined in $CFG->alternative_component_cache, can not continue');
                    }
                    return;
                }
                $cache = array();
                include($cachefile);
                self::$plugintypes      = $cache['plugintypes'];
                self::$plugins          = $cache['plugins'];
                self::$subsystems       = $cache['subsystems'];
                self::$parents          = $cache['parents'];
                self::$subplugins       = $cache['subplugins'];
                self::$classmap         = $cache['classmap'];
                self::$classmaprenames  = $cache['classmaprenames'];
                self::$filemap          = $cache['filemap'];
                return;
            }

            if (!is_writable(dirname($cachefile))) {
                die('Can not create alternative component cache file defined in $CFG->alternative_component_cache, can not continue');
            }

            // Lets try to create the file, it might be in some writable directory or a local cache dir.

        } else {
            // Note: $CFG->cachedir MUST be shared by all servers in a cluster,
            //       use $CFG->alternative_component_cache if you do not like it.
            $cachefile = "$CFG->cachedir/core_component.php";
        }

        if (!CACHE_DISABLE_ALL and !self::is_developer()) {
            // 1/ Use the cache only outside of install and upgrade.
            // 2/ Let developers add/remove classes in developer mode.
            if (is_readable($cachefile)) {
                $cache = false;
                include($cachefile);
                if (!is_array($cache)) {
                    // Something is very wrong.
                } else if (!isset($cache['version'])) {
                    // Something is very wrong.
                } else if ((float) $cache['version'] !== (float) self::fetch_core_version()) {
                    // Outdated cache. We trigger an error log to track an eventual repetitive failure of float comparison.
                    error_log('Resetting core_component cache after core upgrade to version ' . self::fetch_core_version());
                } else if ($cache['plugintypes']['mod'] !== "$CFG->dirroot/mod") {
                    // $CFG->dirroot was changed.
                } else {
                    // The cache looks ok, let's use it.
                    self::$plugintypes      = $cache['plugintypes'];
                    self::$plugins          = $cache['plugins'];
                    self::$subsystems       = $cache['subsystems'];
                    self::$parents          = $cache['parents'];
                    self::$subplugins       = $cache['subplugins'];
                    self::$classmap         = $cache['classmap'];
                    self::$classmaprenames  = $cache['classmaprenames'];
                    self::$filemap          = $cache['filemap'];
                    return;
                }
                // Note: we do not verify $CFG->admin here intentionally,
                //       they must visit admin/index.php after any change.
            }
        }

        if (!isset(self::$plugintypes)) {
            // This needs to be atomic and self-fixing as much as possible.

            $content = self::get_cache_content();
            if (file_exists($cachefile)) {
                if (sha1_file($cachefile) === sha1($content)) {
                    return;
                }
                // Stale cache detected!
                unlink($cachefile);
            }

            // Permissions might not be setup properly in installers.
            $dirpermissions = !isset($CFG->directorypermissions) ? 02777 : $CFG->directorypermissions;
            $filepermissions = !isset($CFG->filepermissions) ? ($dirpermissions & 0666) : $CFG->filepermissions;

            clearstatcache();
            $cachedir = dirname($cachefile);
            if (!is_dir($cachedir)) {
                mkdir($cachedir, $dirpermissions, true);
            }

            if ($fp = @fopen($cachefile.'.tmp', 'xb')) {
                fwrite($fp, $content);
                fclose($fp);
                @rename($cachefile.'.tmp', $cachefile);
                @chmod($cachefile, $filepermissions);
            }
            @unlink($cachefile.'.tmp'); // Just in case anything fails (race condition).
            self::invalidate_opcode_php_cache($cachefile);
        }
    }
672212
def _create_component(tag_name, allow_children=True, callbacks=[]):
    
    def _component(*children, **kwargs):
        if 'children' in kwargs:
            children = kwargs.pop('children')
        else:
            # Flatten children under specific circumstances
            # This supports the use case of div([a, b, c])
            # And allows users to skip the * operator
            if len(children) == 1 and isinstance(children[0], list):
                # We want children to be tuples and not lists, so
                # they can be immutable
                children = tuple(children[0])
        if 'style' in kwargs:
            style = kwargs.pop('style')
        else:
            style = None
        if 'attributes' in kwargs:
            attributes = kwargs['attributes']
        else:
            attributes = dict(**kwargs)

        if (tag_name == 'a') and ('href' not in attributes):
            attributes['href'] = '#'

        if not allow_children and children:
            # We don't allow children, but some were passed in
            raise ValueError(
                '<{tag_name} /> cannot have children'.format(tag_name=tag_name))

        for cb in callbacks:
            cbname = cb['name']
            if cbname in attributes:
                if attributes[cbname] is not None:
                    from google.colab import output as colab_output
                    callback_id = cbname+'callback-' + str(uuid.uuid4())
                    register_callback(callback_id, attributes[cbname])
                    #js="google.colab.kernel.invokeFunction('{callback_id}', [], {kwargs})"
                    js = "window.vdomr_invokeFunction('{callback_id}', [], {kwargs})"
                    js = js.replace('{callback_id}', callback_id)
                    js = js.replace('{kwargs}', cb['kwargs'])
                    attributes[cbname] = js
                else:
                    attributes[cbname] = ''

        v = VDOM(tag_name, attributes, style, children)
        return v

    return _component
79519
function newComponent (call) {
    // get clone of call and reset original
    call = resetCall(call)
    // require ImmutableCoreComponent
    assert.ok(GLOBAL.immutableCoreComponent !== undefined, 'ImmutableAI configuration error: immutableCoreComponent required')
    // get component - throws error if not found
    var component = GLOBAL.immutableCoreComponent.component(call.module)
    // return function wrapper that calls new with session
    return args => {
        // make sure args is object
        if (!defined(args)) {
            args = {}
        }
        // add session to args if not defined
        if (!defined(args.session)) {
            args.session = call.session
        }
        // create new component
        return component.new(args)
    }
}
1079364
function (cfg, ctxt) {
        this.$Container.constructor.apply(this, arguments);
        if (!this._frame) {
            /* this._frame could be overriden in sub-classes */
            this._frame = ariaWidgetsFramesFrameFactory.createFrame({
                skinnableClass : this._skinnableClass,
                sclass : cfg.sclass,
                state : "normal",
                width : cfg.width,
                height : cfg.height,
                printOptions : cfg.printOptions
            });
        }
    }
84804
function initModule (args) {
    // require string name
    this.assert(typeof args.name === 'string' && args.name.length, 101)
    // component must not already be defined
    this.assert(!defined(this.global().components[args.name]), 102, `${args.name} component already defined`)
    // store name
    this.name = args.name
    // create module name from string with `Component` appended
    this.moduleName = `${this.name}Component`
    // create new module - throws error if defined
    this.module = ImmutableCore.module(this.moduleName, {})
    // add info to module meta
    this.module.meta.class = 'ImmutableCoreComponent'
    this.module.meta.instance = this
    // add component to global register
    this.global().components[this.name] = this
}
77110
function component(settings = {}) {

	/**
	 * decorator
	 * @param  {function} ComponentClass
	 */
	return Class => {

		initCoreMap(storage, Class);

		let map = storage.get(Class);
		map.set('@component', settings);

		for(let callbackName of customElementHooks){
			Class.prototype[`${callbackName}Callback`] = function(vars){
				let callbacks = map.get('@callbacks').get(callbackName);
				this::init(callbackName, callbacks, vars);
			};
		}
	}
}
928455
protected Component newAddComponent() {
        return new PaletteButton("addButton") {
            private static final long serialVersionUID = 1L;

            @Override
            protected void onComponentTag(ComponentTag tag) {
                super.onComponentTag(tag);
                tag.getAttributes().put("onclick", getAddOnClickJS());
            }
        };
    }
102519
private static <T> T createCustomComponent(Class<T> componentType, String componentSpec,
            Map<String, String> configProperties, IPluginRegistry pluginRegistry) throws Exception {
        return createCustomComponent(componentType, componentSpec, configProperties, pluginRegistry, null);
    }
419542
@Override
    public UIComponent createComponent(ValueExpression componentExpression,
                                       FacesContext context,
                                       String componentType)
          throws FacesException {
        return getWrapped().createComponent(componentExpression, context, componentType);
    }
742920
function() {
		var closeStack, popout, label, maximise;

		/**
		 * Popout control to launch component in new window.
		 */
		popout = lm.utils.fnBind( this.parent.popout, this.parent );
		label = this.layoutManager.config.labels.popout;
		new lm.controls.HeaderButton( this, label, 'lm_popout', popout );

		/**
		 * Maximise control - set the component to the full size of the layout
		 */
		maximise = lm.utils.fnBind( this.parent.toggleMaximise, this.parent );
		label = this.layoutManager.config.labels.maximise;
		new lm.controls.HeaderButton( this, label, 'lm_maximise', maximise );

		/**
		 * Close button
		 */
		if( this.parent.config.isClosable ) {
			closeStack = lm.utils.fnBind( this.parent.remove, this.parent );
			label = this.layoutManager.config.labels.close;
			new lm.controls.HeaderButton( this, label, 'lm_close', closeStack );
		}
	}
334713
function(components){
		var clist_all = new this.klass.CellList();
		for(var i=0;i<components.length;i++){
			clist_all.extend(components[i].getnodeobjs());
		}
		this.puzzle.painter.repaintBlocks(clist_all);
	}
1018834
protected function setup_components() {
		$this->load_components();

		$components = $this->get_components();
		$this->set_component_parents( $components );
		/** @var \ComposePress\Core\Abstracts\Component[] $components */
		foreach ( $components as $component ) {
			if ( method_exists( $component, 'init' ) ) {
				$component->init();
			}
		}
	}
1258944
function defineComponent(/*mixins*/) {
      // unpacking arguments by hand benchmarked faster
      var l = arguments.length;
      var mixins = new Array(l);
      for (var i = 0; i < l; i++) {
        mixins[i] = arguments[i];
      }

      var Component = function() {};

      Component.toString = Component.prototype.toString = prettyPrintMixins;
      if (debug.enabled) {
        Component.describe = Component.prototype.describe = Component.toString();
      }

      // 'options' is optional hash to be merged with 'defaults' in the component definition
      Component.attachTo = attachTo;
      // enables extension of existing "base" Components
      Component.mixin = function() {
        var newComponent = defineComponent(); //TODO: fix pretty print
        var newPrototype = Object.create(Component.prototype);
        newPrototype.mixedIn = [].concat(Component.prototype.mixedIn);
        newPrototype.defaults = utils.merge(Component.prototype.defaults);
        newPrototype.attrDef = Component.prototype.attrDef;
        compose.mixin(newPrototype, arguments);
        newComponent.prototype = newPrototype;
        newComponent.prototype.constructor = newComponent;
        return newComponent;
      };
      Component.teardownAll = teardownAll;

      // prepend common mixins to supplied list, then mixin all flavors
      if (debug.enabled) {
        mixins.unshift(withLogging);
      }
      mixins.unshift(withBase, advice.withAdvice, registry.withRegistration);
      compose.mixin(Component.prototype, mixins);

      return Component;
    }
1073476
private function createComponentsTbl()
    {
        Schema::create('tbl_components', function (Blueprint $table) {
            $table->increments('id')->unsigned();
            $table->string('vendor');
            $table->string('name');
            $table->tinyInteger('status')->default(1);
            $table->boolean('required')->default(0);
            $table->text('options')->nullable();

            $table->unique(['vendor', 'name']);
        });
    }
236359
private static function buildComponents()
    {
        static $components_built = false;
        static $components = array();

        if ($components_built) {
            return;
        }

        $components['animation'] = new SwatYUIComponent('animation');
        $components['animation']->addJavaScript();

        $components['autocomplete'] = new SwatYUIComponent('autocomplete');
        $components['autocomplete']->addJavaScript();

        $components['base'] = new SwatYUIComponent('base');
        $components['base']->addStyleSheet();

        $components['button'] = new SwatYUIComponent('button');
        $components['button']->addJavaScript();
        $components['button']->addStyleSheet(
            'button/assets/skins/sam',
            '',
            false
        );

        $components['calendar'] = new SwatYUIComponent('calendar');
        $components['calendar']->addJavaScript();

        $components['charts'] = new SwatYUIComponent('charts');
        $components['charts']->addJavaScript();

        $components['cookie'] = new SwatYUIComponent('cookie');
        $components['cookie']->addJavaScript();

        $components['connection'] = new SwatYUIComponent('connection');
        $components['connection']->addJavaScript();

        $components['container'] = new SwatYUIComponent('container');
        $components['container']->addJavaScript();
        $components['container']->addStyleSheet('container/assets', '', false);

        $components['container_core'] = new SwatYUIComponent('container_core');
        $components['container_core']->addJavaScript('container');
        $components['container_core']->addStyleSheet(
            'container/assets',
            'container-core',
            false
        );

        $components['datasource'] = new SwatYUIComponent('datasource');
        $components['datasource']->addJavaScript();

        $components['datatable'] = new SwatYUIComponent('datatable');
        $components['datatable']->addJavaScript();
        $components['datatable']->addStyleSheet(
            'datatable/assets/skins/sam',
            '',
            false
        );

        $components['dom'] = new SwatYUIComponent('dom');
        $components['dom']->addJavaScript();

        $components['dragdrop'] = new SwatYUIComponent('dragdrop');
        $components['dragdrop']->addJavaScript();

        $components['editor'] = new SwatYUIComponent('editor');
        $components['editor']->addJavaScript();
        $components['editor']->addStyleSheet(
            'editor/assets/skins/sam',
            '',
            false
        );

        $components['simpleeditor'] = new SwatYUIComponent('simpleeditor');
        $components['simpleeditor']->addJavaScript('editor');
        $components['simpleeditor']->addStyleSheet(
            'editor/assets/skins/sam',
            '',
            false
        );

        $components['element'] = new SwatYUIComponent('element');
        $components['element']->addJavaScript();

        $components['event'] = new SwatYUIComponent('event');
        $components['event']->addJavaScript();

        $components['event-delegate'] = new SwatYUIComponent('event-delegate');
        $components['event-delegate']->addJavaScript();

        $components['event-mouseenter'] = new SwatYUIComponent(
            'event-mouseenter'
        );

        $components['event-mouseenter']->addJavaScript();

        $components['fonts'] = new SwatYUIComponent('fonts');
        $components['fonts']->addStyleSheet();

        $components['grids'] = new SwatYUIComponent('grids');
        $components['grids']->addStyleSheet();

        $components['imagecropper'] = new SwatYUIComponent('imagecropper');
        $components['imagecropper']->addJavaScript();
        $components['imagecropper']->addStyleSheet(
            'imagecropper/assets/skins/sam',
            '',
            false
        );

        $components['json'] = new SwatYUIComponent('json');
        $components['json']->addJavaScript();

        $components['logger'] = new SwatYUIComponent('logger');
        $components['logger']->addJavaScript();

        $components['menu'] = new SwatYUIComponent('menu');
        $components['menu']->addJavaScript();
        $components['menu']->addStyleSheet('menu/assets/skins/sam', '', false);

        $components['paginator'] = new SwatYUIComponent('paginator');
        $components['paginator']->addJavaScript();
        $components['paginator']->addStyleSheet(
            'paginator/assets/skins/sam',
            '',
            false
        );

        $components['reset-fonts-grids'] = new SwatYUIComponent(
            'reset-fonts-grids'
        );
        $components['reset-fonts-grids']->addStyleSheet('', '', false);

        $components['reset'] = new SwatYUIComponent('reset');
        $components['reset']->addStyleSheet();

        $components['resize'] = new SwatYUIComponent('resize');
        $components['resize']->addJavaScript();
        $components['resize']->addStyleSheet(
            'resize/assets/skins/sam',
            '',
            false
        );

        $components['selector'] = new SwatYUIComponent('selector');
        $components['selector']->addJavaScript();

        $components['slider'] = new SwatYUIComponent('slider');
        $components['slider']->addJavaScript();

        $components['stylesheet'] = new SwatYUIComponent('stylesheet');
        $components['stylesheet']->addJavaScript();

        $components['swf'] = new SwatYUIComponent('swf');
        $components['swf']->addJavaScript();

        $components['tabview'] = new SwatYUIComponent('tabview');
        $components['tabview']->addJavaScript();
        $components['tabview']->addStyleSheet(
            'tabview/assets/skins/sam',
            '',
            false
        );

        $components['treeview'] = new SwatYUIComponent('treeview');
        $components['treeview']->addJavaScript();

        $components['yahoo'] = new SwatYUIComponent('yahoo');
        $components['yahoo']->addJavaScript();

        // dependencies
        $components['animation']->addDependency($components['yahoo']);
        $components['animation']->addDependency($components['dom']);
        $components['animation']->addDependency($components['event']);

        $components['autocomplete']->addDependency($components['yahoo']);
        $components['autocomplete']->addDependency($components['dom']);
        $components['autocomplete']->addDependency($components['event']);
        $components['autocomplete']->addDependency($components['connection']);
        $components['autocomplete']->addDependency($components['animation']);
        $components['autocomplete']->addDependency($components['datasource']);

        $components['button']->addDependency($components['yahoo']);
        $components['button']->addDependency($components['dom']);
        $components['button']->addDependency($components['event']);
        $components['button']->addDependency($components['element']);
        $components['button']->addDependency($components['container_core']);
        $components['button']->addDependency($components['menu']);

        $components['calendar']->addDependency($components['yahoo']);
        $components['calendar']->addDependency($components['dom']);
        $components['calendar']->addDependency($components['event']);

        $components['charts']->addDependency($components['yahoo']);
        $components['charts']->addDependency($components['dom']);
        $components['charts']->addDependency($components['event']);
        $components['charts']->addDependency($components['element']);
        $components['charts']->addDependency($components['datasource']);
        $components['charts']->addDependency($components['json']);
        $components['charts']->addDependency($components['swf']);

        $components['cookie']->addDependency($components['yahoo']);

        $components['connection']->addDependency($components['yahoo']);
        $components['connection']->addDependency($components['event']);

        $components['container']->addDependency($components['yahoo']);
        $components['container']->addDependency($components['dom']);
        $components['container']->addDependency($components['event']);
        $components['container']->addDependency($components['connection']);
        $components['container']->addDependency($components['animation']);

        $components['container_core']->addDependency($components['yahoo']);
        $components['container_core']->addDependency($components['dom']);
        $components['container_core']->addDependency($components['event']);
        $components['container_core']->addDependency($components['connection']);
        $components['container_core']->addDependency($components['animation']);

        $components['datatable']->addDependency($components['yahoo']);
        $components['datatable']->addDependency($components['datasource']);
        $components['datatable']->addDependency($components['dom']);
        $components['datatable']->addDependency($components['dragdrop']);
        $components['datatable']->addDependency($components['event']);
        $components['datatable']->addDependency($components['element']);
        $components['datatable']->addDependency($components['paginator']);

        $components['dom']->addDependency($components['yahoo']);

        $components['dragdrop']->addDependency($components['yahoo']);
        $components['dragdrop']->addDependency($components['dom']);
        $components['dragdrop']->addDependency($components['event']);

        $components['editor']->addDependency($components['yahoo']);
        $components['editor']->addDependency($components['dom']);
        $components['editor']->addDependency($components['event']);
        $components['editor']->addDependency($components['element']);
        $components['editor']->addDependency($components['button']);

        $components['simpleeditor']->addDependency($components['yahoo']);
        $components['simpleeditor']->addDependency($components['dom']);
        $components['simpleeditor']->addDependency($components['event']);
        $components['simpleeditor']->addDependency($components['element']);

        $components['element']->addDependency($components['yahoo']);
        $components['element']->addDependency($components['dom']);
        $components['element']->addDependency($components['event']);

        $components['event']->addDependency($components['yahoo']);

        $components['event-delegate']->addDependency($components['event']);

        $components['event-mouseenter']->addDependency($components['event']);

        $components['grids']->addDependency($components['fonts']);

        $components['imagecropper']->addDependency($components['yahoo']);
        $components['imagecropper']->addDependency($components['dom']);
        $components['imagecropper']->addDependency($components['event']);
        $components['imagecropper']->addDependency($components['dragdrop']);
        $components['imagecropper']->addDependency($components['element']);
        $components['imagecropper']->addDependency($components['resize']);

        $components['json']->addDependency($components['yahoo']);

        $components['logger']->addDependency($components['yahoo']);
        $components['logger']->addDependency($components['dom']);
        $components['logger']->addDependency($components['event']);
        $components['logger']->addDependency($components['dragdrop']);

        $components['menu']->addDependency($components['yahoo']);
        $components['menu']->addDependency($components['dom']);
        $components['menu']->addDependency($components['event']);
        $components['menu']->addDependency($components['container_core']);

        $components['paginator']->addDependency($components['yahoo']);
        $components['paginator']->addDependency($components['dom']);
        $components['paginator']->addDependency($components['event']);
        $components['paginator']->addDependency($components['element']);

        $components['resize']->addDependency($components['yahoo']);
        $components['resize']->addDependency($components['dom']);
        $components['resize']->addDependency($components['event']);
        $components['resize']->addDependency($components['dragdrop']);
        $components['resize']->addDependency($components['element']);

        $components['selector']->addDependency($components['yahoo']);
        $components['selector']->addDependency($components['dom']);

        $components['slider']->addDependency($components['yahoo']);
        $components['slider']->addDependency($components['dom']);
        $components['slider']->addDependency($components['event']);
        $components['slider']->addDependency($components['dragdrop']);

        $components['stylesheet']->addDependency($components['yahoo']);

        $components['swf']->addDependency($components['yahoo']);
        $components['swf']->addDependency($components['dom']);
        $components['swf']->addDependency($components['event']);
        $components['swf']->addDependency($components['element']);

        $components['tabview']->addDependency($components['yahoo']);
        $components['tabview']->addDependency($components['dom']);
        $components['tabview']->addDependency($components['event']);
        $components['tabview']->addDependency($components['element']);

        $components['treeview']->addDependency($components['yahoo']);

        self::$components = $components;

        $components_built = true;
    }