@playcanvas/web-components 0.10.1 → 0.11.1

package/dist/entity.d.ts

@@ -1,4 +1,4 @@
-import { AppBase, Entity, Vec3 } from 'playcanvas';
+import { Entity, Vec3 } from 'playcanvas';
 import { AsyncElement } from './async-element';
 /**
  * The EntityElement interface provides properties and methods for manipulating
@@ -62,6 +62,11 @@ declare class EntityElement extends AsyncElement {
      */
     private _built;
     private _entity;
+    /**
+     * The application element this entity is registered with, cached at creation time so the
+     * entity can be unregistered even once this element has left the DOM.
+     */
+    private _appElement;
     /**
      * The PlayCanvas entity instance. `null` until the element is ready, and again once it has
      * been removed from the document — await {@link whenReady} or the element's `ready()`
@@ -69,8 +74,16 @@ declare class EntityElement extends AsyncElement {
      * @returns The entity instance, or `null`.
      */
     get entity(): Entity | null;
-    createEntity(app: AppBase): void;
-    buildHierarchy(app: AppBase): void;
+    /**
+     * Handles the destruction of the backing entity. Resets the element so a later re-insertion
+     * starts clean: `_built` must be cleared alongside `_entity`, or _buildHierarchy would bail
+     * and a re-created entity would never be parented. Readiness is re-armed for the same
+     * reason — with the entity gone, a resolved ready promise would resume its awaiters against
+     * a null `entity`.
+     *
+     * @param entity - The entity that was destroyed.
+     */
+    private _onEntityDestroy;
     connectedCallback(): void;
     disconnectedCallback(): void;
     /**
@@ -149,11 +162,5 @@ declare class EntityElement extends AsyncElement {
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
     addEventListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: string, listener: EventListener, options?: boolean | EventListenerOptions): void;
-    hasListeners(type: string): boolean;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-entity': EntityElement;
-    }
 }
 export { EntityElement };

package/dist/index.d.ts

@@ -35,5 +35,42 @@ import { MaterialElement } from './material';
 import { ModelElement } from './model';
 import { SceneElement } from './scene';
 import { SkyElement } from './sky';
+import type { ScriptAttributesChangeEvent, ScriptEnableChangeEvent, ScriptNameChangeEvent } from './components/script-component';
+declare global {
+    interface HTMLElementEventMap {
+        scriptattributeschange: ScriptAttributesChangeEvent;
+        scriptenablechange: ScriptEnableChangeEvent;
+        scriptnamechange: ScriptNameChangeEvent;
+    }
+    interface HTMLElementTagNameMap {
+        'pc-app': AppElement;
+        'pc-asset': AssetElement;
+        'pc-button': ButtonComponentElement;
+        'pc-camera': CameraComponentElement;
+        'pc-collision': CollisionComponentElement;
+        'pc-element': ElementComponentElement;
+        'pc-entity': EntityElement;
+        'pc-gsplat': GSplatComponentElement;
+        'pc-layoutchild': LayoutChildComponentElement;
+        'pc-layoutgroup': LayoutGroupComponentElement;
+        'pc-light': LightComponentElement;
+        'pc-listener': ListenerComponentElement;
+        'pc-material': MaterialElement;
+        'pc-model': ModelElement;
+        'pc-module': ModuleElement;
+        'pc-particles': ParticleSystemComponentElement;
+        'pc-render': RenderComponentElement;
+        'pc-rigidbody': RigidBodyComponentElement;
+        'pc-scene': SceneElement;
+        'pc-screen': ScreenComponentElement;
+        'pc-script': ScriptElement;
+        'pc-scripts': ScriptComponentElement;
+        'pc-scrollbar': ScrollbarComponentElement;
+        'pc-scrollview': ScrollViewComponentElement;
+        'pc-sky': SkyElement;
+        'pc-sound': SoundSlotElement;
+        'pc-sounds': SoundComponentElement;
+    }
+}
 export { AsyncElement, ModuleElement, AppElement, EntityElement, AssetElement, ButtonComponentElement, CameraComponentElement, CollisionComponentElement, ComponentElement, ElementComponentElement, LayoutChildComponentElement, LayoutGroupComponentElement, ParticleSystemComponentElement, LightComponentElement, ListenerComponentElement, RenderComponentElement, RigidBodyComponentElement, ScreenComponentElement, ScrollbarComponentElement, ScrollViewComponentElement, ScriptComponentElement, ScriptElement, SoundComponentElement, SoundSlotElement, GSplatComponentElement, MaterialElement, ModelElement, SceneElement, SkyElement, whenReady };
 export type { AsyncElementTagName } from './async-element';

package/dist/material.d.ts

@@ -6,11 +6,6 @@ type OccludeSpecular = 'none' | 'ao' | 'gloss-dependent';
 type OpacityDither = 'none' | 'bayer8' | 'bluenoise' | 'ignnoise';
 type ColorChannel = 'r' | 'g' | 'b' | 'a' | 'rgb';
 type ScalarChannel = 'r' | 'g' | 'b' | 'a';
-/**
- * The texture slots a `pc-material` can populate. Each is backed by a `pc-asset` id rather than a
- * `Texture`, so the element can be authored before the asset has loaded.
- */
-type TextureSlot = 'aoMap' | 'diffuseMap' | 'emissiveMap' | 'glossMap' | 'heightMap' | 'metalnessMap' | 'normalMap' | 'opacityMap';
 /**
  * The MaterialElement interface provides properties and methods for manipulating
  * {@link https://developer.playcanvas.com/user-manual/web-components/tags/pc-material/ | `<pc-material>`} elements.
@@ -130,9 +125,12 @@ declare class MaterialElement extends HTMLElement {
     private _mapHandles;
     private _updateScheduled;
     private _glossConflictWarned;
+    /**
+     * The material. `null` until the containing application has created it — an element present
+     * at startup has its material once the application is ready.
+     */
     material: StandardMaterial | null;
     connectedCallback(): Promise<void>;
-    createMaterial(): void;
     disconnectedCallback(): void;
     /**
      * Coalesces `material.update()` across a burst of attribute or property writes, so that setting
@@ -159,7 +157,7 @@ declare class MaterialElement extends HTMLElement {
      * @param id - The id of the `pc-asset`, or an empty string to clear the slot.
      * @param slot - The material property to write.
      */
-    setMap(id: string, slot: TextureSlot): void;
+    private _setMap;
     /**
      * @param slot - The material property to write.
      * @param texture - The loaded texture.
@@ -998,13 +996,15 @@ declare class MaterialElement extends HTMLElement {
      * @returns The use tonemap flag.
      */
     get useTonemap(): boolean;
+    /**
+     * Returns the {@link StandardMaterial} created by the `<pc-material>` element with the given
+     * `id`, or `undefined` if there is no such element or its material has not been created yet.
+     *
+     * @param id - The `id` of the `<pc-material>` element.
+     * @returns The material, or `undefined`.
+     */
     static get(id: string): StandardMaterial | null | undefined;
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-material': MaterialElement;
-    }
-}
 export { MaterialElement };

package/dist/model.d.ts

@@ -1,3 +1,4 @@
+import type { Entity } from 'playcanvas';
 import { AsyncElement } from './async-element';
 /**
  * The ModelElement interface provides properties and methods for manipulating
@@ -8,8 +9,28 @@ import { AsyncElement } from './async-element';
 declare class ModelElement extends AsyncElement {
     private _asset;
     private _entity;
+    /**
+     * Incremented on every new load and on disconnect, and captured by a load when it starts. A
+     * load that resumes from an await or a load callback abandons itself if the value has moved
+     * on, so a superseded load can neither instantiate a second entity nor parent one that has
+     * since been destroyed.
+     */
+    private _loadGeneration;
+    /**
+     * The pending asset-load subscription of the current load, if it is waiting for its asset.
+     * Held so that whatever supersedes the load can detach the handler from the asset, rather
+     * than leave it registered until the asset loads (or forever, if it never does).
+     */
+    private _loadHandle;
+    /**
+     * The root entity of the instantiated model. `null` until the container asset has loaded
+     * and been instantiated, and again once the element has been removed from the document.
+     * @returns The model's root entity, or `null`.
+     */
+    get entity(): Entity | null;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    private _detachLoadHandler;
     private _instantiate;
     private _loadModel;
     private _unloadModel;
@@ -26,9 +47,4 @@ declare class ModelElement extends AsyncElement {
     static get observedAttributes(): string[];
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-model': ModelElement;
-    }
-}
 export { ModelElement };

package/dist/module.d.ts

@@ -19,11 +19,5 @@ declare class ModuleElement extends HTMLElement {
     /** @ignore */
     constructor();
     private loadModule;
-    getLoadPromise(): Promise<void>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'pc-module': ModuleElement;
-    }
 }
 export { ModuleElement };

package/dist/parse.d.ts

@@ -15,7 +15,8 @@
  * `getEntity` is the exception: it resolves a reference to a live entity rather than parsing a
  * literal, and returns `null` instead of falling back to a default.
  */
-import { Color, Entity, Quat, Vec2, Vec3, Vec4 } from 'playcanvas';
+import type { Entity } from 'playcanvas';
+import { Color, Quat, Vec2, Vec3, Vec4 } from 'playcanvas';
 /**
  * Splits an attribute value into exactly `count` numeric components. Returns `null` when the
  * value does not consist of exactly `count` whitespace-separated finite numbers.
@@ -58,12 +59,14 @@ export declare const parseColor: <T extends Color | null>(value: string | null,
  * the value is invalid — the latter also logs a warning listing the valid names.
  *
  * @param value - The attribute value to parse (`null` when the attribute is absent).
- * @param valid - The valid names: an array, or a map whose keys are the valid names.
+ * @param valid - The valid names: an array, or a map whose keys are the valid names. Only the keys
+ * are read, so the map's value type is unconstrained - engine enums are mostly numeric constants,
+ * but some (e.g. `SCALEMODE_BLEND`) are strings.
  * @param defaultValue - The value to use when the attribute is absent or invalid.
  * @param attribute - The attribute name, used in the warning message.
  * @returns The resolved enum name.
  */
-export declare const parseEnum: <T extends string>(value: string | null, valid: readonly T[] | ReadonlyMap<T, number>, defaultValue: T, attribute: string) => T;
+export declare const parseEnum: <T extends string>(value: string | null, valid: readonly T[] | ReadonlyMap<T, unknown>, defaultValue: T, attribute: string) => T;
 /**
  * Parses a number attribute value. Returns the parsed number when the value is a finite number.
  * Returns `defaultValue` when the attribute is absent (`null`), or when the value is not a