@playcanvas/web-components 0.13.1 → 0.15.0

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

@@ -544,6 +544,11 @@
           "description": "The UV channel the metalness map samples.",
           "values": []
         },
+        {
+          "name": "name",
+          "description": "The name of the material - the label shown wherever materials surface by name, such as profilers, GPU captures and the assignments `pc-model.hierarchy()` reports.",
+          "values": []
+        },
         {
           "name": "normal-map",
           "description": "The id of the `pc-asset` used as the normal map.",
@@ -698,7 +703,7 @@
     },
     {
       "name": "pc-model",
-      "description": "The ModelElement interface provides properties and methods for manipulating\n[`<pc-model>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-model/) elements.\nThe ModelElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once its container asset has loaded and the instantiated hierarchy has\nbeen added to the scene — `entity` is non-null by then. A failed load also settles readiness,\nwith `entity` remaining `null`: readiness means the load settled, not that it succeeded — listen\nfor `error`, or check `entity`, to tell the outcomes apart. Changing `asset` re-arms readiness\nand instantiates anew, so a `ready()` obtained after the change resolves against the new\nhierarchy. A `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never\nbecomes ready.\n\n---\n\n\n### **Events:**\n - **error** - Fired when the container asset fails to load, with the engine's error in `message`. Does not bubble. The element still becomes ready — readiness means the load settled, not that it succeeded.\n- **load** - Fired each time a container asset finishes instantiating, including re-instantiation after `asset` changes. Does not bubble — listen on this element, or use a capture-phase listener on an ancestor.\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.",
+      "description": "The ModelElement interface provides properties and methods for manipulating\n[`<pc-model>`](https://developer.playcanvas.com/user-manual/web-components/tags/pc-model/) elements.\nThe ModelElement interface also inherits the properties and methods of the\nHTMLElement interface.\n\nThe element becomes ready once its container asset has loaded and the instantiated hierarchy has\nbeen added to the scene — `entity` is non-null by then. A failed load also settles readiness,\nwith `entity` remaining `null`: readiness means the load settled, not that it succeeded — listen\nfor `error`, or check `entity`, to tell the outcomes apart. Changing `asset` re-arms readiness\nand instantiates anew, so a `ready()` obtained after the change resolves against the new\nhierarchy. A `pc-model` outside a `pc-app`, or referencing an unknown asset id, warns and never\nbecomes ready.\n\n---\n\n\n### **Events:**\n - **error** - Fired when the container asset fails to load, with the engine's error in `message`. Does not bubble. The element still becomes ready — readiness means the load settled, not that it succeeded.\n- **load** - Fired each time a container asset finishes instantiating, including re-instantiation after `asset` changes. Does not bubble — listen on this element, or use a capture-phase listener on an ancestor.\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 - **hierarchy(): __** - Returns a snapshot of the instantiated node tree, or `null` while there is none (the\ncontainer asset has not loaded, or the element has left the document). One call grounds a\nsession — a browser console, a test, an agent — in the vocabulary `pc-node` binding\nresolves against: the instantiated names (HierarchyNode.name), paths, match\nindices, attached component types and the material assignments of render components\n(HierarchyNode.materials). `String(...)` of the result, or of any node in it,\nis the printable form.\n\nThe snapshot is plain data, computed afresh each call: it does not follow later changes\nto the hierarchy, and mutating it changes nothing.\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",
@@ -749,6 +754,11 @@
           "description": "Which match to bind when `name` matches more than one node, 0-based in depth-first order. Optional for a unique match; required for an ambiguous one.",
           "values": []
         },
+        {
+          "name": "material-overrides",
+          "description": "Overrides material assignments on the bound node's render component, as a JSON object from selector to `pc-material` id — for example `{\"name:CarPaint\": \"candy-red\", \"index:7\": \"smoked-glass\"}`. A `name:X` key selects every mesh instance whose baseline material is named `X`; an `index:N` key selects mesh instance `N` and wins over a name rule for the same instance. Assignments no rule matches keep their baseline materials, and removing the attribute restores all of them. Use `pc-model.hierarchy()` to discover the names and indices a node offers.",
+          "values": []
+        },
         {
           "name": "name",
           "description": "The name of the node to bind, resolved within the nearest ancestor `pc-model` (or `pc-node`) once it has instantiated.",
@@ -1319,6 +1329,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.",