# AsyncElement
Class · extends `HTMLElement` · category: Base Classes
Source: https://github.com/playcanvas/web-components/blob/252f001881302c266c8d727044408c32be2bb5e7/src/async-element.ts#L13
Base class for all PlayCanvas Web Components that initialize asynchronously.
**fires** ready - Fired when the element is fully initialized — once per readiness
cycle, so an element that is torn down and re-initialized (for example by removing and
re-inserting it) fires it again. Bubbles and is composed.
## Accessors
### closestApp
```ts
get closestApp(): AppElement | null
```
The nearest ancestor `` element, or `null` if this element has no ``
ancestor. The search starts at the parent, so an element never resolves to itself.
### closestEntity
```ts
get closestEntity(): EntityBaseElement | null
```
The nearest ancestor element that fronts an entity — ``, `` or
`` — or `null` if this element has no such ancestor. The search starts at the
parent, so an element never resolves to itself.
## Methods
### _onReady
```ts
protected _onReady(): void
```
Called when the element is fully initialized and ready. Subclasses should call this when
they're ready. Resolves the ready promise and dispatches a bubbling, composed `ready`
event. Signals at most once per readiness cycle: a repeat call before [_resetReady](https://api.playcanvas.com/web-components/classes/AsyncElement.md#_resetready)
has re-armed the promise does nothing.
### _resetReady
```ts
protected _resetReady(): void
```
Returns the ready promise to its pending state. Subclasses should call this when the
resource their readiness announced is torn down (typically from `disconnectedCallback`),
so that a later re-initialization can signal readiness again. Does nothing while the
promise is still pending — an in-flight waiter carries over to the next readiness cycle
rather than being stranded on a promise nothing will ever resolve.
### ready
```ts
ready(): Promise
```
Returns a promise that resolves with this element when it's ready. This is the low-level
primitive underlying [whenReady](https://api.playcanvas.com/web-components/functions/whenReady.md), which is the recommended way to wait for elements.
Readiness tracks the element's current lifecycle: once a ready element is torn down (for
example by removing it from the document), this returns a fresh promise that resolves when
the element is next ready. A promise obtained earlier stays resolved — call this again
after re-inserting an element rather than reusing a promise from before its removal.
**Returns** `Promise<`[`AsyncElement`](https://api.playcanvas.com/web-components/classes/AsyncElement.md)`>`: A promise that resolves with this element when it's ready.