@glimmer/component
Version:
Glimmer component library
52 lines • 9.15 kB
JavaScript
import { assert } from '@glimmer/util';
import { setComponentManager } from '@glimmer/application';
import BaseComponent from '../addon/-private/component';
import GlimmerComponentManager from './component-manager';
export default class Component extends BaseComponent {
/**
* Development-mode only name of the component, useful for debugging.
*/
get debugName() {
return this.constructor.name;
}
/*
* Legacy DOM access and lifecycle hooks. These will be deprecated in favor
* of render modifiers once Glimmer.js supports an element modifier manager
* API.
*/
/**
* Called when the component has been inserted into the DOM.
* Override this function to do any set up that requires an element in the document body.
*/
didInsertElement() { }
/**
* Called when the component has updated and rerendered itself.
* Called only during a rerender, not during an initial render.
*/
didUpdate() { }
/**
* The element corresponding to the main element of the component's template.
* The main element is the element in the template that has `...attributes` set on it:
*
* ```hbs
* <h1>Modal</h1>
* <div class="contents" ...attributes>
* {{yield}}
* </div>
* ```
*
* In this example, `this.element` would be the `div` with the class `contents`.
*
* You should not try to access this property until after the component's `didInsertElement()`
* lifecycle hook is called.
*/
get element() {
let { bounds } = this;
assert(bounds && bounds.firstNode === bounds.lastNode, `The 'element' property can only be accessed on components that contain a single root element in their template. Try using 'bounds' instead to access the first and last nodes.`);
return bounds.firstNode;
}
}
setComponentManager((owner) => {
return new GlimmerComponentManager(owner);
}, BaseComponent);
//# sourceMappingURL=data:application/json;base64,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