@playcanvas/web-components 0.14.0 → 0.16.0

package/dist/vscode.html-custom-data.json

@@ -906,6 +906,65 @@
       ],
       "references": []
     },
+    {
+      "name": "pc-anim-clip",
+      "description": "The AnimClipElement interface provides properties and methods for manipulating\n[`<pc-anim-clip>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim-clip/)\nelements. The AnimClipElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nA clip declares one named animation on its parent `<pc-anim>`. `name` is both the clip's name\nand the track looked up in the clip's source: an explicit `asset` (a `container`, an\n`animation` `.glb`, or an `animclip` JSON), or, without one, the container of the `<pc-model>`\nenclosing the parent `<pc-anim>`. A source holding a single track supplies it whatever it is\nnamed; in a multi-track source the track named `name` is chosen, falling back to the first\nwith a warning. The element becomes ready once its resolved track is assigned.\n\n---\n\n\n### **Events:**\n - **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.\n\n### **Methods:**\n - **ready(): __** - Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+      "attributes": [
+        {
+          "name": "asset",
+          "description": "The id of the `pc-asset` supplying the clip's track.",
+          "values": []
+        },
+        {
+          "name": "loop",
+          "description": "Whether the clip loops.",
+          "values": []
+        },
+        {
+          "name": "name",
+          "description": "The name of the clip.",
+          "values": []
+        },
+        {
+          "name": "speed",
+          "description": "The playback speed of the clip.",
+          "values": []
+        }
+      ],
+      "references": []
+    },
+    {
+      "name": "pc-anim",
+      "description": "The AnimComponentElement interface provides properties and methods for manipulating\n[`<pc-anim>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-anim/) elements.\nThe AnimComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element drives animation clips over the host entity's hierarchy. Clips come from\n`<pc-anim-clip>` children — or, when the element is a direct child of a `<pc-model>` and\ndeclares no clips, every animation of that model's container asset is assigned, named by track\nname, in container order. The first clip plays automatically (opt out with `activate=\"false\"`);\nswitch clips declaratively through the `clip` attribute, or imperatively through play\nand transition. Tracks bind to scene nodes by name, so any hierarchy whose node names\nmatch a clip's curves can be animated — a model's skeleton is simply the common case.\n\nThe engine reports no clip completion: a non-looping clip holds its last pose silently. Poll\nthe underlying AnimComponent (via component) for playback state beyond what\nthis element exposes.\n\n---\n\n\n### **Events:**\n - **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.\n\n### **Methods:**\n - **pause()** - Pauses playback, preserving the playhead — play resumes from where it stopped.\n- **play(name: _string_)** - Resumes playback, optionally switching to a named clip first (a hard cut). A name that\nmatches no clip leaves the selection unchanged.\n- **ready(): __** - Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.\n- **transition(name: _string_, time: _number_)** - Cross-fades to a named clip and ensures playback is running. A name that matches no clip\nleaves the selection unchanged.",
+      "attributes": [
+        {
+          "name": "activate",
+          "description": "Whether playback starts automatically once a clip is assigned.",
+          "values": []
+        },
+        {
+          "name": "clip",
+          "description": "The name of the active clip.",
+          "values": []
+        },
+        {
+          "name": "enabled",
+          "description": "The enabled state of the component.",
+          "values": []
+        },
+        {
+          "name": "speed",
+          "description": "The playback speed multiplier applied across all clips.",
+          "values": []
+        },
+        {
+          "name": "transition-time",
+          "description": "The cross-fade duration of clip switches made through the `clip` attribute.",
+          "values": []
+        }
+      ],
+      "references": []
+    },
     {
       "name": "pc-button",
       "description": "The ButtonComponentElement interface provides properties and methods for manipulating\n[`<pc-button>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-button/) elements.\nThe ButtonComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **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.\n\n### **Methods:**\n - **ready(): __** - Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
@@ -1329,6 +1388,198 @@
       ],
       "references": []
     },
+    {
+      "name": "pc-joint",
+      "description": "The JointComponentElement interface provides properties and methods for manipulating\n[`<pc-joint>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-joint/) elements.\nThe JointComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe entity holding the joint is not itself constrained. Its world transform defines the joint\nframe — the anchor point and axes the constraint operates about — with the local X axis as the\nprimary axis: a hinge rotates about it, a slider translates along it and a ball joint twists\nabout it. The constrained bodies are referenced by `entity-a` and `entity-b`, both of which need\na rigid body component; leaving `entity-b` empty constrains `entity-a` to a fixed point in world\nspace. The underlying engine component is in alpha, so its API may change.\n\n---\n\n\n### **Events:**\n - **break** - Fired when the impulse on the joint exceeds `break-impulse` and the constraint breaks. A broken joint no longer constrains its bodies; calling `refreshFrames()` on the underlying component re-attaches it. Bubbles and is composed.\n- **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.\n\n### **Methods:**\n - **ready(): __** - Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",
+      "attributes": [
+        {
+          "name": "angular-damping",
+          "description": "The spring damping of the joint per angular axis. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "angular-equilibrium",
+          "description": "The rest angle of the joint's angular springs. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "angular-limits-x",
+          "description": "The rotation limits of the joint about its X axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "angular-limits-y",
+          "description": "The rotation limits of the joint about its Y axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "angular-limits-z",
+          "description": "The rotation limits of the joint about its Z axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "angular-motion-x",
+          "description": "How the joint constrains rotation about its X axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "angular-motion-y",
+          "description": "How the joint constrains rotation about its Y axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "angular-motion-z",
+          "description": "How the joint constrains rotation about its Z axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "angular-stiffness",
+          "description": "The spring stiffness of the joint per angular axis. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "break-impulse",
+          "description": "The impulse above which the joint breaks.",
+          "values": []
+        },
+        {
+          "name": "enable-collision",
+          "description": "Whether collision is enabled between the two constrained bodies.",
+          "values": []
+        },
+        {
+          "name": "enable-limits",
+          "description": "Whether the limits of the joint are enforced.",
+          "values": []
+        },
+        {
+          "name": "enabled",
+          "description": "The enabled state of the component.",
+          "values": []
+        },
+        {
+          "name": "entity-a",
+          "description": "The reference to the `<pc-entity>` providing the first constrained body.",
+          "values": []
+        },
+        {
+          "name": "entity-b",
+          "description": "The reference to the `<pc-entity>` providing the second constrained body.",
+          "values": []
+        },
+        {
+          "name": "limits",
+          "description": "The rotation or travel limits of the joint. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-damping",
+          "description": "The spring damping of the joint per linear axis. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-equilibrium",
+          "description": "The rest point of the joint's linear springs. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-limits-x",
+          "description": "The translation limits of the joint along its X axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-limits-y",
+          "description": "The translation limits of the joint along its Y axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-limits-z",
+          "description": "The translation limits of the joint along its Z axis. Accepts 2 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "linear-motion-x",
+          "description": "How the joint constrains translation along its X axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "linear-motion-y",
+          "description": "How the joint constrains translation along its Y axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "linear-motion-z",
+          "description": "How the joint constrains translation along its Z axis.",
+          "values": [
+            { "name": "locked" },
+            { "name": "limited" },
+            { "name": "free" }
+          ]
+        },
+        {
+          "name": "linear-stiffness",
+          "description": "The spring stiffness of the joint per linear axis. Accepts 3 space-separated numbers.",
+          "values": []
+        },
+        {
+          "name": "max-motor-force",
+          "description": "The maximum torque or force of the joint's motor.",
+          "values": []
+        },
+        {
+          "name": "motor-speed",
+          "description": "The target speed of the joint's motor.",
+          "values": []
+        },
+        {
+          "name": "swing-limit-y",
+          "description": "The maximum swing of the joint around the joint frame's Y axis.",
+          "values": []
+        },
+        {
+          "name": "swing-limit-z",
+          "description": "The maximum swing of the joint around the joint frame's Z axis.",
+          "values": []
+        },
+        {
+          "name": "twist-limit",
+          "description": "The maximum twist of the joint about its primary axis.",
+          "values": []
+        },
+        {
+          "name": "type",
+          "description": "The type of the joint.",
+          "values": [
+            { "name": "fixed" },
+            { "name": "ball" },
+            { "name": "hinge" },
+            { "name": "slider" },
+            { "name": "6dof" }
+          ]
+        }
+      ],
+      "references": []
+    },
     {
       "name": "pc-layoutchild",
       "description": "The LayoutChildComponentElement interface provides properties and methods for manipulating\n[`<pc-layoutchild>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-layoutchild/) elements.\nThe LayoutChildComponentElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\n---\n\n\n### **Events:**\n - **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.\n\n### **Methods:**\n - **ready(): __** - Returns a promise that resolves with this element when it's ready. This is the low-level\nprimitive underlying whenReady, which is the recommended way to wait for elements.\n\nReadiness tracks the element's current lifecycle: once a ready element is torn down (for\nexample by removing it from the document), this returns a fresh promise that resolves when\nthe element is next ready. A promise obtained earlier stays resolved — call this again\nafter re-inserting an element rather than reusing a promise from before its removal.",