@playcanvas/web-components 0.11.0 → 0.12.0

package/README.md

@@ -30,7 +30,7 @@ PlayCanvas Web Components are a set of custom HTML elements for building 3D inte
 
 ## Examples
 
-[![image](https://github.com/user-attachments/assets/25ac8dd3-abc9-4d65-8950-3d72ed1f7152)](https://playcanvas.github.io/web-components/examples)
+<img width="3840" height="2160" alt="image" src="https://github.com/user-attachments/assets/e113cd2a-300d-4713-a1f4-ada647a8f04c" />
 
 See PlayCanvas Web Components in action here: https://playcanvas.github.io/web-components/examples
 

package/dist/app.d.ts

@@ -1,6 +1,7 @@
-import { AppBase, Entity } from 'playcanvas';
+import type { Entity } from 'playcanvas';
+import { AppBase } from 'playcanvas';
 import { AsyncElement } from './async-element';
-import { EntityElement } from './entity';
+import type { EntityBaseElement } from './entity-base';
 /**
  * The AppElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-app/ | `<pc-app>`} elements.
@@ -31,11 +32,18 @@ declare class AppElement extends AsyncElement {
      */
     private _optionsLocked;
     private _bar;
-    private _hierarchyReady;
+    /**
+     * Incremented on every connect and disconnect. Boot captures the value on entry and abandons
+     * itself wherever it resumes from an await if the value has moved on — so a boot whose
+     * element was removed cannot complete against a torn-down element, and a boot whose element
+     * was removed and re-inserted (which starts a boot of its own) cannot race the newer one.
+     */
+    private _bootGeneration;
     /**
      * The elements backing this application's entities, keyed by the entity itself. Registered
-     * by EntityElement at creation and removed when an entity is destroyed, this joins engine
-     * scene nodes back to their owning elements by identity - never by name.
+     * by EntityElement at creation (and NodeElement at binding) and removed when an entity is
+     * destroyed or unbound, this joins engine scene nodes back to their owning elements by
+     * identity - never by name.
      */
     private _entityElements;
     private _picker;
@@ -68,39 +76,24 @@ declare class AppElement extends AsyncElement {
     constructor();
     connectedCallback(): Promise<void>;
     disconnectedCallback(): void;
-    _onWindowResize(): void;
-    _pickerCreate(): void;
-    _pickerDestroy(): void;
-    /**
-     * Registers the element that created an entity. Called by EntityElement when it creates its
-     * entity.
-     *
-     * @param entity - The entity.
-     * @param element - The element that created it.
-     * @ignore
-     */
-    _registerEntityElement(entity: Entity, element: EntityElement): void;
-    /**
-     * Removes the registration for a destroyed entity. Called by EntityElement.
-     *
-     * @param entity - The entity.
-     * @ignore
-     */
-    _unregisterEntityElement(entity: Entity): void;
-    /**
-     * Returns the `<pc-entity>` element whose backing entity is `entity`, or `null` if the
-     * entity was not created by an element of this application - for example, a node inside a
-     * model's instantiated hierarchy, or an entity created through the engine API.
+    private _onWindowResize;
+    private _pickerCreate;
+    private _pickerDestroy;
+    /**
+     * Returns the `<pc-entity>` or `<pc-node>` element whose backing entity is `entity`, or
+     * `null` if the entity is not fronted by an element of this application - for example, an
+     * unbound node inside a model's instantiated hierarchy, or an entity created through the
+     * engine API.
      *
      * @param entity - The entity to look up.
-     * @returns The element backing the entity, or `null`.
+     * @returns The element fronting the entity, or `null`.
      */
-    elementFromEntity(entity: Entity): EntityElement | null;
+    elementFromEntity(entity: Entity): EntityBaseElement | null;
     /**
      * Resolves the element that owns a picked node: the nearest node up the parent chain -
-     * starting with the node itself - that was created by a `<pc-entity>` of this application.
-     * A hit inside a model's instantiated hierarchy therefore resolves to the element hosting
-     * the model.
+     * starting with the node itself - that is fronted by a `<pc-entity>` or `<pc-node>` of this
+     * application. A hit inside a model's instantiated hierarchy therefore resolves to the
+     * nearest bound `<pc-node>`, or failing that the element hosting the model.
      *
      * @param node - The picked node, or `null`.
      * @returns The owning element, or `null`.
@@ -128,11 +121,11 @@ declare class AppElement extends AsyncElement {
      * @returns The graph node under the pointer, or `null` if nothing was hit.
      */
     private _pickNode;
-    _onPointerMove(event: PointerEvent): Promise<void>;
-    _onPointerDown(event: PointerEvent): Promise<void>;
-    _onPointerUp(event: PointerEvent): Promise<void>;
-    _onPointerListenerAdded(type: string): void;
-    _onPointerListenerRemoved(type: string): void;
+    private _onPointerMove;
+    private _onPointerDown;
+    private _onPointerUp;
+    private _onPointerListenerAdded;
+    private _onPointerListenerRemoved;
     /**
      * Warns that a graphics option was written too late to have any effect. These options are read
      * once, when the element connects and creates its graphics device, so a later write updates
@@ -184,12 +177,6 @@ declare class AppElement extends AsyncElement {
      * @returns The depth buffer flag.
      */
     get depthBuffer(): boolean;
-    /**
-     * Gets the hierarchy ready flag.
-     * @returns The hierarchy ready flag.
-     * @ignore
-     */
-    get hierarchyReady(): boolean;
     /**
      * Sets whether the application shows its built-in loading bar while it boots and preloads its
      * assets. Enabled by default; setting `false` removes the bar immediately, while setting
@@ -233,9 +220,4 @@ declare class AppElement extends AsyncElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-app': AppElement;
-    }
-}
 export { AppElement };

package/dist/asset.d.ts

@@ -1,5 +1,8 @@
 import { Asset } from 'playcanvas';
 import { AsyncElement } from './async-element';
+type AddressMode = 'repeat' | 'clamp' | 'mirror';
+type MinFilterMode = 'nearest' | 'linear' | 'nearest-mip-nearest' | 'linear-mip-nearest' | 'nearest-mip-linear' | 'linear-mip-linear';
+type MagFilterMode = 'nearest' | 'linear';
 /**
  * The AssetElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-asset/ | `<pc-asset>`} elements.
@@ -13,8 +16,16 @@ import { AsyncElement } from './async-element';
  * immediately unless `lazy`. A `pc-asset` must be a direct child of `pc-app` — elements placed
  * elsewhere, or with an unsupported asset type, never become ready.
  *
- * Apart from `lazy`, these attributes are read once when the asset is created, so changing them
- * later has no effect.
+ * For `texture` and `textureatlas` assets, the texture options (`address-u`, `address-v`,
+ * `min-filter`, `mag-filter`, `anisotropy`, `mipmaps`, `srgb`, `flip-y`) apply when the texture is
+ * created and — like `lazy` — are observed: changing one updates a texture that has already
+ * loaded, and removing one restores the engine default. Changing `srgb` or `mipmaps` on a loaded
+ * texture recreates the underlying GPU resource, so prefer declaring those up front. Each option
+ * overrides the matching key in the `data` JSON; options left unset write nothing, leaving the
+ * engine's per-format defaults in force.
+ *
+ * Apart from `lazy` and the texture options, these attributes are read once when the asset is
+ * created, so changing them later has no effect.
  *
  * @attribute {string} id - The identifier used to reference the asset from other elements.
  * @attribute {string} src - The URL of the asset to load.
@@ -36,7 +47,15 @@ import { AsyncElement } from './async-element';
  * not that it succeeded.
  */
 declare class AssetElement extends AsyncElement {
+    private _addressU;
+    private _addressV;
+    private _anisotropy;
+    private _flipY;
     private _lazy;
+    private _magFilter;
+    private _minFilter;
+    private _mipmaps;
+    private _srgb;
     /**
      * The asset that is loaded. Available once the element is ready — await
      * {@link whenReady} or the element's `ready()` promise before accessing it.
@@ -46,16 +65,86 @@ declare class AssetElement extends AsyncElement {
     disconnectedCallback(): void;
     private _onAssetLoad;
     private _onAssetError;
-    createAsset(): void;
     /**
-     * Builds the `data` object for the asset from an optional inline `data` attribute (JSON) and,
-     * for sprites, from the convenience attributes (`atlas`, `frame-keys`, `pixels-per-unit`,
-     * `render-mode`). Returns `undefined` when there is no data to apply.
+     * Builds the `data` object for the asset from an optional inline `data` attribute (JSON), the
+     * texture option attributes (for `texture` and `textureatlas` assets), and the sprite
+     * convenience attributes (`atlas`, `frame-keys`, `pixels-per-unit`, `render-mode`). An
+     * attribute overrides the matching `data` JSON key. Returns `undefined` when there is no data
+     * to apply.
      * @param type - The resolved asset type.
      * @returns The asset data, or `undefined`.
      */
     private _buildData;
-    destroyAsset(): void;
+    /**
+     * Returns the engine texture behind this asset, when there is one: the resource itself for a
+     * `texture` asset, the atlas's texture for a `textureatlas` asset, `null` otherwise
+     * (including before the asset has loaded).
+     * @returns The texture, or `null`.
+     */
+    private _texture;
+    /**
+     * Writes one texture option through to the created asset, if any. The engine-JSON key is
+     * written into `asset.data`, mutated in place - replacing the whole object would make the
+     * registry re-patch every key, and a re-patched `srgb` or `mipmaps` recreates the texture
+     * even when unchanged. The in-place key is what a not-yet-started load reads at texture
+     * construction, and what any later reload reads. When the texture already exists, the
+     * corresponding property is assigned directly; `null` (attribute removed) deletes the key
+     * and restores the engine default. Assets of any other type are left untouched.
+     *
+     * @param key - The engine texture JSON key in `asset.data`.
+     * @param property - The Texture property to assign.
+     * @param dataValue - The engine-JSON value for `asset.data`, or `null` to delete the key.
+     * @param textureValue - The value for the Texture property, or `null` for the engine default.
+     */
+    private _applyTextureOption;
+    private _destroyAsset;
+    /**
+     * Sets the texture's horizontal (U) address mode: how texture coordinates outside the 0 to 1
+     * range sample the texture. Applies to `texture` and `textureatlas` assets, both when the
+     * texture is created and after it has loaded.
+     * @param value - The address mode, or `null` to use the engine default of 'repeat'.
+     */
+    set addressU(value: AddressMode | null);
+    /**
+     * Gets the texture's horizontal (U) address mode.
+     * @returns The address mode, or `null` when unset.
+     */
+    get addressU(): AddressMode | null;
+    /**
+     * Sets the texture's vertical (V) address mode: how texture coordinates outside the 0 to 1
+     * range sample the texture. Applies to `texture` and `textureatlas` assets, both when the
+     * texture is created and after it has loaded.
+     * @param value - The address mode, or `null` to use the engine default of 'repeat'.
+     */
+    set addressV(value: AddressMode | null);
+    /**
+     * Gets the texture's vertical (V) address mode.
+     * @returns The address mode, or `null` when unset.
+     */
+    get addressV(): AddressMode | null;
+    /**
+     * Sets the texture's maximum anisotropic filtering level, which improves quality at oblique
+     * viewing angles. Applies to `texture` and `textureatlas` assets, both when the texture is
+     * created and after it has loaded.
+     * @param value - The anisotropy level, or `null` to use the engine default of 1.
+     */
+    set anisotropy(value: number | null);
+    /**
+     * Gets the texture's maximum anisotropic filtering level.
+     * @returns The anisotropy level, or `null` when unset.
+     */
+    get anisotropy(): number | null;
+    /**
+     * Sets whether the texture's image data is flipped vertically at upload. Applies to `texture`
+     * and `textureatlas` assets, both when the texture is created and after it has loaded.
+     * @param value - The flip flag, or `null` to use the engine default of `false`.
+     */
+    set flipY(value: boolean | null);
+    /**
+     * Gets whether the texture's image data is flipped vertically at upload.
+     * @returns The flip flag, or `null` when unset.
+     */
+    get flipY(): boolean | null;
     /**
      * Sets whether the asset should be loaded lazily.
      * @param value - The lazy loading flag.
@@ -66,13 +155,64 @@ declare class AssetElement extends AsyncElement {
      * @returns The lazy loading flag.
      */
     get lazy(): boolean;
+    /**
+     * Sets the texture's magnification filter, used when the texture is displayed larger than its
+     * source size. Applies to `texture` and `textureatlas` assets, both when the texture is
+     * created and after it has loaded.
+     * @param value - The filter, or `null` to use the engine default of 'linear'.
+     */
+    set magFilter(value: MagFilterMode | null);
+    /**
+     * Gets the texture's magnification filter.
+     * @returns The filter, or `null` when unset.
+     */
+    get magFilter(): MagFilterMode | null;
+    /**
+     * Sets the texture's minification filter, used when the texture is displayed smaller than its
+     * source size. The mip variants blend within (and, for the second `linear`, between) mipmap
+     * levels. Applies to `texture` and `textureatlas` assets, both when the texture is created
+     * and after it has loaded.
+     * @param value - The filter, or `null` to use the engine default of 'linear-mip-linear'.
+     */
+    set minFilter(value: MinFilterMode | null);
+    /**
+     * Gets the texture's minification filter.
+     * @returns The filter, or `null` when unset.
+     */
+    get minFilter(): MinFilterMode | null;
+    /**
+     * Sets whether the texture generates and uses mipmaps. Changing this on a loaded texture
+     * recreates the underlying GPU resource, so prefer declaring it up front. Applies to
+     * `texture` and `textureatlas` assets.
+     * @param value - The mipmaps flag, or `null` to use the engine default of `true`.
+     */
+    set mipmaps(value: boolean | null);
+    /**
+     * Gets whether the texture generates and uses mipmaps.
+     * @returns The mipmaps flag, or `null` when unset.
+     */
+    get mipmaps(): boolean | null;
+    /**
+     * Sets whether the texture holds sRGB (gamma-encoded) color data, enabling hardware gamma
+     * decode. Free when set before the texture loads; changing it on a loaded texture recreates
+     * the underlying GPU resource. Applies to `texture` and `textureatlas` assets.
+     * @param value - The sRGB flag, or `null` to use the engine default of `false`.
+     */
+    set srgb(value: boolean | null);
+    /**
+     * Gets whether the texture holds sRGB (gamma-encoded) color data.
+     * @returns The sRGB flag, or `null` when unset.
+     */
+    get srgb(): boolean | null;
+    /**
+     * Returns the {@link Asset} created by the `<pc-asset>` element with the given `id`, or
+     * `undefined` if there is no such element or its asset has not been created yet.
+     *
+     * @param id - The `id` of the `<pc-asset>` element.
+     * @returns The asset, or `undefined`.
+     */
     static get(id: string): Asset | null | undefined;
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-asset': AssetElement;
-    }
-}
 export { AssetElement };

package/dist/async-element.d.ts

@@ -1,14 +1,16 @@
-import { AppElement } from './app';
-import { EntityElement } from './entity';
+import type { AppElement } from './app';
+import type { EntityBaseElement } from './entity-base';
 /**
  * Base class for all PlayCanvas Web Components that initialize asynchronously.
  *
- * @fires {CustomEvent} ready - Fired once the element is fully initialized. Bubbles and is
- * composed.
+ * @fires {CustomEvent} 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.
  */
 declare class AsyncElement extends HTMLElement {
     private _readyPromise;
     private _readyResolve;
+    private _readyResolved;
     /** @ignore */
     constructor();
     /**
@@ -18,20 +20,35 @@ declare class AsyncElement extends HTMLElement {
      */
     get closestApp(): AppElement | null;
     /**
-     * The nearest ancestor `<pc-entity>` element, or `null` if this element has no `<pc-entity>`
-     * ancestor. The search starts at the parent, so an element never resolves to itself.
-     * @returns The closest entity element, or `null`.
+     * The nearest ancestor element that fronts an entity — `<pc-entity>` or `<pc-node>` — or
+     * `null` if this element has no such ancestor. The search starts at the parent, so an element
+     * never resolves to itself.
+     * @returns The closest entity-fronting element, or `null`.
      */
-    get closestEntity(): EntityElement | null;
+    get closestEntity(): EntityBaseElement | null;
     /**
      * 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.
+     * event. Signals at most once per readiness cycle: a repeat call before {@link _resetReady}
+     * has re-armed the promise does nothing.
      */
     protected _onReady(): 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.
+     */
+    protected _resetReady(): void;
     /**
      * Returns a promise that resolves with this element when it's ready. This is the low-level
      * primitive underlying {@link whenReady}, 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 A promise that resolves with this element when it's ready.
      */
     ready(): Promise<this>;

package/dist/components/button-component.d.ts

@@ -1,4 +1,5 @@
-import { ButtonComponent, Color, Vec4 } from 'playcanvas';
+import type { ButtonComponent } from 'playcanvas';
+import { Color, Vec4 } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The ButtonComponentElement interface provides properties and methods for manipulating
@@ -25,7 +26,7 @@ declare class ButtonComponentElement extends ComponentElement {
     private _inactiveSpriteFrame;
     /** @ignore */
     constructor();
-    getInitialComponentData(): Record<string, any>;
+    protected getInitialComponentData(): Record<string, any>;
     /**
      * Gets the underlying PlayCanvas button component.
      * @returns The button component.
@@ -182,9 +183,4 @@ declare class ButtonComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-button': ButtonComponentElement;
-    }
-}
 export { ButtonComponentElement };

package/dist/components/camera-component.d.ts

@@ -1,4 +1,5 @@
-import { CameraComponent, Color, Vec4 } from 'playcanvas';
+import type { CameraComponent } from 'playcanvas';
+import { Color, Vec4 } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The CameraComponentElement interface provides properties and methods for manipulating
@@ -29,7 +30,7 @@ declare class CameraComponentElement extends ComponentElement {
     private _tonemap;
     /** @ignore */
     constructor();
-    getInitialComponentData(): {
+    protected getInitialComponentData(): {
         clearColor: Color;
         clearColorBuffer: boolean;
         clearDepthBuffer: boolean;
@@ -249,9 +250,4 @@ declare class CameraComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-camera': CameraComponentElement;
-    }
-}
 export { CameraComponentElement };

package/dist/components/collision-component.d.ts

@@ -1,4 +1,5 @@
-import { CollisionComponent, Quat, Vec3 } from 'playcanvas';
+import type { CollisionComponent } from 'playcanvas';
+import { Quat, Vec3 } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The CollisionComponentElement interface provides properties and methods for manipulating
@@ -6,6 +7,12 @@ import { ComponentElement } from './component';
  * The CollisionComponentElement interface also inherits the properties and methods of the
  * {@link HTMLElement} interface.
  *
+ * For `type="mesh"`, the collision geometry defaults to the host entity's own render component
+ * (its render asset) — a collider matching the visible mesh, which is what a mesh collider on a
+ * glTF node means. The default resolves each time the component applies, so a `pc-node` that
+ * retargets or rebinds picks up the new node's geometry. An entity with no asset-backed render
+ * component warns, and the collider has no shape.
+ *
  * @category Components
  */
 declare class CollisionComponentElement extends ComponentElement {
@@ -19,7 +26,7 @@ declare class CollisionComponentElement extends ComponentElement {
     private _type;
     /** @ignore */
     constructor();
-    getInitialComponentData(): {
+    protected getInitialComponentData(): {
         axis: number;
         angularOffset: Quat;
         convexHull: boolean;
@@ -29,6 +36,16 @@ declare class CollisionComponentElement extends ComponentElement {
         radius: number;
         type: "box" | "capsule" | "compound" | "cone" | "cylinder" | "mesh" | "sphere";
     };
+    protected initComponent(): void;
+    /**
+     * Defaults a mesh collider's geometry to the host entity's own render component. The
+     * engine's mesh collider only works with explicitly supplied geometry, and the element has
+     * no attribute to supply it - so the host's visible geometry, the meaning a mesh collider
+     * on a glTF node carries, fills the gap. Runs on every application (so a rebound `pc-node`
+     * recomputes it) and on a runtime switch to `type="mesh"`; an explicitly assigned
+     * `renderAsset` is never overwritten.
+     */
+    private _applyMeshGeometryDefault;
     /**
      * Gets the underlying PlayCanvas collision component.
      * @returns The collision component.
@@ -53,9 +70,4 @@ declare class CollisionComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-collision': CollisionComponentElement;
-    }
-}
 export { CollisionComponentElement };

package/dist/components/component.d.ts

@@ -1,4 +1,4 @@
-import { Component } from 'playcanvas';
+import type { Component } from 'playcanvas';
 import { AsyncElement } from '../async-element';
 /**
  * Represents a component in the PlayCanvas engine.
@@ -10,6 +10,24 @@ declare class ComponentElement extends AsyncElement {
     private _enabled;
     private _component;
     private _appElement;
+    /**
+     * The element hosting this component, held so the host's readiness cycles can be observed
+     * even after `closestEntity` would no longer resolve (during teardown).
+     */
+    private _hostElement;
+    /**
+     * The listener re-applying this component when the host's readiness cycles. Held for
+     * removal on disconnect.
+     */
+    private _hostReadyListener;
+    /**
+     * Incremented on every connect and disconnect. connectedCallback captures the value on entry
+     * and abandons itself wherever it resumes from an await if the value has moved on — so a
+     * callback whose element was removed cannot act on a torn-down tree, and one whose element
+     * was removed and re-inserted (which runs a callback of its own) cannot add the component a
+     * second time.
+     */
+    private _connectionGeneration;
     /**
      * Creates a new ComponentElement instance.
      *
@@ -17,9 +35,28 @@ declare class ComponentElement extends AsyncElement {
      * @ignore
      */
     constructor(componentName: string);
-    getInitialComponentData(): {};
-    addComponent(): Promise<void>;
-    initComponent(): void;
+    /**
+     * Returns the data the component is created with. Overridden by subclasses to supply the
+     * initial values of their cached properties.
+     *
+     * @returns The initial component data.
+     */
+    protected getInitialComponentData(): {};
+    /**
+     * Creates the component on the host's current entity, removing it first from a previous
+     * entity that is still alive (a retargeted `<pc-node>` moves its decorations with it). When
+     * the entity already has a component of this type — a glTF node arriving with its authored
+     * `render` component, say — warns and leaves `component` null. The element-level warning is
+     * load-bearing: the engine's own duplicate-addComponent warning is Debug-stripped from
+     * production builds, which would otherwise leave a silent null.
+     */
+    private _applyComponent;
+    private _addComponent;
+    /**
+     * Configures the newly added component. Overridden by subclasses whose setup goes beyond
+     * the initial data — child-element handling, asset resolution and the like.
+     */
+    protected initComponent(): void;
     connectedCallback(): Promise<void>;
     disconnectedCallback(): void;
     /**

package/dist/components/element-component.d.ts

@@ -1,4 +1,5 @@
-import { Color, ElementComponent, Vec2, Vec4 } from 'playcanvas';
+import type { ElementComponent } from 'playcanvas';
+import { Color, Vec2, Vec4 } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The ElementComponentElement interface provides properties and methods for manipulating
@@ -37,8 +38,8 @@ declare class ElementComponentElement extends ComponentElement {
     private _wrapLines;
     /** @ignore */
     constructor();
-    initComponent(): void;
-    getInitialComponentData(): Record<string, any>;
+    protected initComponent(): void;
+    protected getInitialComponentData(): Record<string, any>;
     /**
      * Gets the underlying PlayCanvas element component.
      * @returns The element component.
@@ -312,9 +313,4 @@ declare class ElementComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-element': ElementComponentElement;
-    }
-}
 export { ElementComponentElement };

package/dist/components/gsplat-component.d.ts

@@ -1,4 +1,4 @@
-import { GSplatComponent } from 'playcanvas';
+import type { GSplatComponent } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The GSplatComponentElement interface provides properties and methods for manipulating
@@ -17,7 +17,7 @@ declare class GSplatComponentElement extends ComponentElement {
     private _lodRangeMax;
     /** @ignore */
     constructor();
-    getInitialComponentData(): {
+    protected getInitialComponentData(): {
         asset: import("playcanvas").Asset | null | undefined;
         castShadows: boolean;
         lodBaseDistance: number;
@@ -105,9 +105,4 @@ declare class GSplatComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-gsplat': GSplatComponentElement;
-    }
-}
 export { GSplatComponentElement };

package/dist/components/layoutchild-component.d.ts

@@ -1,4 +1,4 @@
-import { LayoutChildComponent } from 'playcanvas';
+import type { LayoutChildComponent } from 'playcanvas';
 import { ComponentElement } from './component';
 /**
  * The LayoutChildComponentElement interface provides properties and methods for manipulating
@@ -18,7 +18,7 @@ declare class LayoutChildComponentElement extends ComponentElement {
     private _excludeFromLayout;
     /** @ignore */
     constructor();
-    getInitialComponentData(): {
+    protected getInitialComponentData(): {
         minWidth: number;
         minHeight: number;
         maxWidth: number | null;
@@ -107,9 +107,4 @@ declare class LayoutChildComponentElement extends ComponentElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-layoutchild': LayoutChildComponentElement;
-    }
-}
 export { LayoutChildComponentElement };