@woosh/meep-engine 3.14.6 → 3.16.0

package/editor/view/node-graph/NodeIconView.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The glyph a node type carries, drawn.
+ *
+ * A {@link NodeDescription}'s icon is SVG path data in a 24x24 box and nothing else — no colour, no
+ * size, no stroke width. All of that is decided here and in the stylesheet, which is what lets one
+ * library of icons sit in a node's header, in a palette row and in a list of search results at
+ * three different sizes without three sets of artwork.
+ *
+ * The paths are built as SVG elements rather than assigned as markup: an icon is author-supplied
+ * data, and the one thing that must never happen is a node library turning into a way to put script
+ * on the page.
+ *
+ * `currentColor` and `vector-effect: non-scaling-stroke` are why a glyph takes the colour of the
+ * text beside it and keeps its line weight at whatever size the box ends up.
+ */
+export class NodeIconView extends View {
+    /**
+     * @param {string} icon SVG path data, see {@link NodeDescription#icon}. Several sub-paths in
+     *        one string are fine — that is one `d` attribute, and how most glyphs here are drawn.
+     * @param {string[]} [classList]
+     */
+    constructor(icon: string, { classList }?: string[]);
+    el: SVGSVGElement;
+}
+/**
+ * The box every node icon is drawn in. Fixed rather than per-icon so a library's glyphs line up
+ * with each other, which is the whole reason to have them.
+ *
+ * @type {string}
+ */
+export const ICON_VIEW_BOX: string;
+import View from "../../../src/view/View.js";
+//# sourceMappingURL=NodeIconView.d.ts.map

package/editor/view/node-graph/NodeIconView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeIconView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeIconView.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;OAIG;IACH,kBAJW,MAAM,kBAEN,MAAM,EAAE,EAsBlB;IAJG,kBAAa;CAKpB;AAED;;;;;GAKG;AACH,4BAFU,MAAM,CAEyB;iBApDxB,2BAA2B"}

package/editor/view/node-graph/NodeIconView.js

@@ -0,0 +1,54 @@
+import { SVG_NAMESPACE } from "../../../src/view/SVG.js";
+import View from "../../../src/view/View.js";
+
+/**
+ * The glyph a node type carries, drawn.
+ *
+ * A {@link NodeDescription}'s icon is SVG path data in a 24x24 box and nothing else — no colour, no
+ * size, no stroke width. All of that is decided here and in the stylesheet, which is what lets one
+ * library of icons sit in a node's header, in a palette row and in a list of search results at
+ * three different sizes without three sets of artwork.
+ *
+ * The paths are built as SVG elements rather than assigned as markup: an icon is author-supplied
+ * data, and the one thing that must never happen is a node library turning into a way to put script
+ * on the page.
+ *
+ * `currentColor` and `vector-effect: non-scaling-stroke` are why a glyph takes the colour of the
+ * text beside it and keeps its line weight at whatever size the box ends up.
+ */
+export class NodeIconView extends View {
+    /**
+     * @param {string} icon SVG path data, see {@link NodeDescription#icon}. Several sub-paths in
+     *        one string are fine — that is one `d` attribute, and how most glyphs here are drawn.
+     * @param {string[]} [classList]
+     */
+    constructor(icon, { classList = [] } = {}) {
+        super();
+
+        const svg = document.createElementNS(SVG_NAMESPACE, 'svg');
+
+        svg.setAttribute('viewBox', ICON_VIEW_BOX);
+        // decoration: the node's name says what it is, and a screen reader reading both says it twice
+        svg.setAttribute('aria-hidden', 'true');
+        svg.setAttribute('focusable', 'false');
+
+        const path = document.createElementNS(SVG_NAMESPACE, 'path');
+
+        path.setAttribute('d', icon);
+
+        svg.appendChild(path);
+
+        this.el = svg;
+
+        this.addClass('ui-node-icon-view');
+        this.addClasses(classList);
+    }
+}
+
+/**
+ * The box every node icon is drawn in. Fixed rather than per-icon so a library's glyphs line up
+ * with each other, which is the whole reason to have them.
+ *
+ * @type {string}
+ */
+export const ICON_VIEW_BOX = "0 0 24 24";

package/editor/view/node-graph/NodeView.d.ts

@@ -1,5 +1,26 @@
 export class NodeView extends View {
     /**
+     * A node of a graph, drawn.
+     *
+     * ## Who decides the size
+     *
+     * The browser. A node is as big as its header, its ports and its controls make it, and the
+     * points its wires meet are wherever the markers land in that layout. None of it is knowable
+     * from the model: a picker's width is the length of the text in it, and a host's own control is
+     * whatever the host drew.
+     *
+     * So it goes the other way — {@link #measure} writes the drawn box and the drawn port positions
+     * onto the {@link NodeVisualData}, and everything outside the DOM reads them from there: the
+     * wires, the router, the camera's framing, serialization. The estimate
+     * {@link NodeDescriptionVisualRegistry} makes from port and parameter counts is what stands in
+     * for a node nobody has drawn yet, and nothing more.
+     *
+     * Position is the one thing that flows the other way, from the model to the view: it is the
+     * author's, set by dragging or by the layout, and the view does what it is told with it.
+     *
+     * Which is why {@link View#size} is left alone here, and is not this node's box: writing it
+     * puts a `width` and a `height` on the element, and a node pinned to the size it had is a node
+     * that cannot grow when the next thing inside it does. Read the box off the visual data.
      *
      * @param {NodeInstance} node
      * @param {NodeVisualData} visual
@@ -7,8 +28,24 @@ export class NodeView extends View {
      * @param {boolean} enableDrag
      * @param {function(PortView, Port)} portCreationCallback
      * @param {function(NodeInstance, string, *)} [parameterSetCallback] invoked when the user commits a parameter edit
+     * @param {function({node: NodeInstance, commit: function(string, *)}):View|null} [parameterViewFactory]
+     *        supplies controls for state the generic parameter mechanism cannot describe — a
+     *        graph whose nodes carry name-keyed, vector- or enum-valued parameters of their own.
+     *        Whatever it returns is added below the description-driven rows; returning nothing
+     *        leaves the node with only those.
      */
-    constructor({ node, visual, visualData, enableDrag, portCreationCallback, parameterSetCallback }: NodeInstance);
+    constructor({ node, visual, visualData, enableDrag, portCreationCallback, parameterSetCallback, parameterViewFactory }: NodeInstance);
+    /**
+     * The view of each of this node's ports, by port id.
+     *
+     * @readonly
+     * @type {Map<number, PortView>}
+     */
+    readonly portViews: Map<number, PortView>;
+    /**
+     * @readonly
+     */
+    readonly on: any;
     /**
      *
      * @type {NodeInstance}
@@ -20,7 +57,40 @@ export class NodeView extends View {
      */
     visual: NodeVisualData;
     el: HTMLDivElement;
+    /**
+     * Read the node type's name again.
+     *
+     * A type's label is usually decided once, in a table, and never moves — so the header is written
+     * when the node is drawn and left alone. A type an author *made* is the exception: renaming one
+     * has to reach every node already on screen that is an instance of it, and rebuilding the canvas
+     * to change a word would throw away the camera, the selection and every measurement with it.
+     *
+     * @returns {void}
+     */
+    refreshLabel(): void;
+    /**
+     * Whether the drawn geometry has been recorded at least once.
+     *
+     * False for a node that has never been on screen: what its visual data holds is then the
+     * registry's estimate, and a consumer that cares about the difference — an automatic layout,
+     * above all — can ask.
+     *
+     * @returns {boolean}
+     */
+    isMeasured(): boolean;
+    /**
+     * Record the drawn box of this node, and where its ports ended up in it, on the visual data.
+     *
+     * Positions are relative to the node's own border box and in layout pixels, so they are
+     * unaffected by the camera: the graph is drawn under a scale transform, and a port that moved
+     * because somebody zoomed has not moved.
+     *
+     * @returns {boolean} whether anything could be measured
+     */
+    measure(): boolean;
     update(): void;
+    #private;
 }
 import View from "../../../src/view/View.js";
+import { PortView } from "./PortView.js";
 //# sourceMappingURL=NodeView.d.ts.map

package/editor/view/node-graph/NodeView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeView.js"],"names":[],"mappings":"AA0BA;IACI;;;;;;;;OAQG;IACH,gHAwKC;IA9JG;;;OAGG;IACH,mBAAgB;IAChB;;;OAGG;IACH,uBAAoB;IAEpB,mBAAuC;IAqJ3C,eAGC;CACJ;iBAxMgB,2BAA2B"}
+{"version":3,"file":"NodeView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeView.js"],"names":[],"mappings":"AAwDA;IAgDI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,sIA4OC;IA9TD;;;;;OAKG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAQ,CAAC,CAET;IAEtB;;OAEG;IACH,iBAYE;IAsEE;;;OAGG;IACH,mBAAgB;IAChB;;;OAGG;IACH,uBAAoB;IAEpB,mBAAuC;IAwN3C;;;;;;;;;OASG;IACH,gBAFa,IAAI,CAIhB;IAED;;;;;;;;OAQG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,WAFa,OAAO,CAqEnB;IA4BD,eAEC;;CACJ;iBAnfgB,2BAA2B;yBAInB,eAAe"}

package/editor/view/node-graph/NodeView.js

@@ -1,3 +1,4 @@
+import Signal from "../../../src/core/events/signal/Signal.js";
 import { noop } from "../../../src/core/function/noop.js";
 import Vector2 from "../../../src/core/geom/Vector2.js";
 import ObservedBoolean from "../../../src/core/model/ObservedBoolean.js";
@@ -8,9 +9,11 @@ import { DraggableAspect } from "../../../src/engine/ui/DraggableAspect.js";
 import LabelView from "../../../src/view/common/LabelView.js";
 import { CheckboxView } from "../../../src/view/elements/CheckboxView.js";
 import EmptyView from "../../../src/view/elements/EmptyView.js";
+import { DomLayoutFrame } from "../../../src/view/util/DomLayoutFrame.js";
 import View from "../../../src/view/View.js";
 import { NumberController } from "../ecs/components/common/NumberController.js";
 import { TextController } from "../ecs/components/common/TextController.js";
+import { NodeIconView } from "./NodeIconView.js";
 import { PortView } from "./PortView.js";
 
 /**
@@ -24,8 +27,103 @@ function default_parameter_set(node, parameterId, value) {
     node.setParameterValue(parameterId, value);
 }
 
+/**
+ * Where each direction's ports are drawn, in the order the groups are laid out.
+ *
+ * Inputs down the left, outputs down the right, and anything else along the bottom — which is the
+ * arrangement the wires already assume, since one leaves an output rightwards and arrives at an
+ * input from the left.
+ *
+ * @type {Array<{direction: PortDirection, className: string}>}
+ */
+const PORT_GROUPS = [
+    { direction: PortDirection.In, className: 'inputs' },
+    { direction: PortDirection.Out, className: 'outputs' },
+    { direction: PortDirection.Unspecified, className: 'unspecified' }
+];
+
+/**
+ * Scratch used by the reading half of {@link NodeView#measure}, which makes no model writes and so
+ * cannot be re-entered from one.
+ * @type {DomLayoutFrame}
+ */
+const measure_frame = new DomLayoutFrame();
+
+/**
+ * @type {Vector2}
+ */
+const v2_measure = new Vector2();
+
 export class NodeView extends View {
     /**
+     * The view of each of this node's ports, by port id.
+     *
+     * @readonly
+     * @type {Map<number, PortView>}
+     */
+    portViews = new Map();
+
+    /**
+     * @readonly
+     */
+    on = {
+        ...this.on,
+
+        /**
+         * A measurement pass has completed. Carries whether it changed the geometry recorded on the
+         * visual data — a listener that redraws something derived from it, wires above all, has
+         * work to do only when it did.
+         *
+         * @readonly
+         * @type {Signal<boolean>}
+         */
+        measured: new Signal()
+    };
+
+    /**
+     * @type {LabelView}
+     */
+    #label;
+
+    /**
+     * @type {ResizeObserver|null}
+     */
+    #observer = null;
+
+    /**
+     * @type {boolean}
+     */
+    #measured = false;
+
+    /**
+     * Where each port's marker was found in the last read, x and y per port, in the iteration order
+     * of {@link portViews}. Holds a measurement only for the length of one {@link measure} call.
+     * @type {Float64Array}
+     */
+    #port_centers;
+
+    /**
+     * A node of a graph, drawn.
+     *
+     * ## Who decides the size
+     *
+     * The browser. A node is as big as its header, its ports and its controls make it, and the
+     * points its wires meet are wherever the markers land in that layout. None of it is knowable
+     * from the model: a picker's width is the length of the text in it, and a host's own control is
+     * whatever the host drew.
+     *
+     * So it goes the other way — {@link #measure} writes the drawn box and the drawn port positions
+     * onto the {@link NodeVisualData}, and everything outside the DOM reads them from there: the
+     * wires, the router, the camera's framing, serialization. The estimate
+     * {@link NodeDescriptionVisualRegistry} makes from port and parameter counts is what stands in
+     * for a node nobody has drawn yet, and nothing more.
+     *
+     * Position is the one thing that flows the other way, from the model to the view: it is the
+     * author's, set by dragging or by the layout, and the view does what it is told with it.
+     *
+     * Which is why {@link View#size} is left alone here, and is not this node's box: writing it
+     * puts a `width` and a `height` on the element, and a node pinned to the size it had is a node
+     * that cannot grow when the next thing inside it does. Read the box off the visual data.
      *
      * @param {NodeInstance} node
      * @param {NodeVisualData} visual
@@ -33,6 +131,11 @@ export class NodeView extends View {
      * @param {boolean} enableDrag
      * @param {function(PortView, Port)} portCreationCallback
      * @param {function(NodeInstance, string, *)} [parameterSetCallback] invoked when the user commits a parameter edit
+     * @param {function({node: NodeInstance, commit: function(string, *)}):View|null} [parameterViewFactory]
+     *        supplies controls for state the generic parameter mechanism cannot describe — a
+     *        graph whose nodes carry name-keyed, vector- or enum-valued parameters of their own.
+     *        Whatever it returns is added below the description-driven rows; returning nothing
+     *        leaves the node with only those.
      */
     constructor({
                     node,
@@ -40,7 +143,8 @@ export class NodeView extends View {
                     visualData,
                     enableDrag = true,
                     portCreationCallback = noop,
-                    parameterSetCallback = default_parameter_set
+                    parameterSetCallback = default_parameter_set,
+                    parameterViewFactory = noop
                 }) {
         super();
 
@@ -64,9 +168,26 @@ export class NodeView extends View {
         });
 
         const nodeDescription = node.description;
-        const vName = new LabelView(nodeDescription.name, {
-            classList: ['name']
-        });
+
+        // The header: what the type is called, and the glyph it carries. A type's name is an
+        // address rather than a word — `div`, `mad` — so what is drawn is what the description says
+        // to draw. See NodeDescription#getDisplayLabel.
+        const vHeader = new EmptyView({ classList: ['name'] });
+
+        if (nodeDescription.icon !== "") {
+            vHeader.addChild(new NodeIconView(nodeDescription.icon, { classList: ['icon'] }));
+        }
+
+        const vLabel = new LabelView(nodeDescription.getDisplayLabel(), { classList: ['label'] });
+
+        vHeader.addChild(vLabel);
+
+        /**
+         * The header's text, kept so it can be re-read. See {@link #refreshLabel}.
+         * @type {LabelView}
+         */
+        this.#label = vLabel;
+
 
         const self = this;
 
@@ -177,35 +298,215 @@ export class NodeView extends View {
             vParams.addChild(buildParameterRow(param));
         });
 
+        // Anything the generic mechanism cannot express is the host's to draw. It commits through
+        // the same callback, so a custom control lands on the editor's action timeline exactly the
+        // way a built-in one does.
+        const vCustomParameters = parameterViewFactory({
+            node,
+            commit(parameterId, value) {
+                parameterSetCallback(node, parameterId, value);
+            }
+        });
+
+        if (vCustomParameters !== undefined && vCustomParameters !== null) {
+            vParams.addChild(vCustomParameters);
+        }
 
-        this.addChild(vParamContainer);
+        const has_parameters = vParams.children.length > 0;
 
-        this.addChild(vName);
+        this.setClass('has-parameters', has_parameters);
 
-        this.addChild(vPorts);
+        if (has_parameters) {
+            // an empty block would still be padding, and a node reserving room for controls it does
+            // not have is a node that reads as if something failed to draw
+            this.addChild(vParamContainer);
+        }
+
+        this.addChild(vHeader);
 
-        nodeDescription.getPorts().forEach(port => {
+        const ports = nodeDescription.getPorts();
 
-            const portVisualData = visual.getPort(port.id);
+        // One group per direction, in a fixed order, so the sides a node's ports are drawn on
+        // depend on what the ports are rather than on the order they happened to be declared in.
+        for (const group of PORT_GROUPS) {
+            const members = ports.filter(port => port.direction === group.direction);
 
-            const portView = new PortView({ port, visual: portVisualData, visualData });
+            if (members.length === 0) {
+                // no empty group in the way of the ones that do have ports
+                continue;
+            }
 
-            portCreationCallback(portView, port);
+            const vGroup = new EmptyView({ classList: [group.className] });
 
-            vPorts.addChild(portView);
+            for (const port of members) {
+                const portVisualData = visual.getPort(port.id);
 
-        });
+                const portView = new PortView({ port, visual: portVisualData, visualData });
 
-        this.setClass('has-inputs', nodeDescription.getPorts().some(p => p.direction === PortDirection.In));
-        this.setClass('has-outputs', nodeDescription.getPorts().some(p => p.direction === PortDirection.Out));
+                this.portViews.set(port.id, portView);
+
+                portCreationCallback(portView, port);
+
+                vGroup.addChild(portView);
+            }
+
+            vPorts.addChild(vGroup);
+        }
+
+        if (vPorts.children.length > 0) {
+            this.addChild(vPorts);
+        }
+
+        this.#port_centers = new Float64Array(this.portViews.size * 2);
+
+        this.setClass('has-inputs', ports.some(p => p.direction === PortDirection.In));
+        this.setClass('has-outputs', ports.some(p => p.direction === PortDirection.Out));
 
         this.on.linked.add(this.update, this);
         this.bindSignal(visual.dimensions.position.onChanged, this.update, this);
-        this.bindSignal(visual.dimensions.size.onChanged, this.update, this);
+
+        // The browser changes its mind about a node's box whenever what is in it changes — a picker
+        // switched to a longer option, a control the host rebuilt, a font that arrived late — and
+        // each of those moves the points the wires meet. Measuring once at link and trusting it
+        // would leave the wires attached to where the ports used to be.
+        this.on.linked.add(this.#startObserving, this);
+        this.on.unlinked.add(this.#stopObserving, this);
+
+        this.on.linked.add(this.measure, this);
+    }
+
+    /**
+     * Read the node type's name again.
+     *
+     * A type's label is usually decided once, in a table, and never moves — so the header is written
+     * when the node is drawn and left alone. A type an author *made* is the exception: renaming one
+     * has to reach every node already on screen that is an instance of it, and rebuilding the canvas
+     * to change a word would throw away the camera, the selection and every measurement with it.
+     *
+     * @returns {void}
+     */
+    refreshLabel() {
+        this.#label.updateText(this.node.description.getDisplayLabel());
+    }
+
+    /**
+     * Whether the drawn geometry has been recorded at least once.
+     *
+     * False for a node that has never been on screen: what its visual data holds is then the
+     * registry's estimate, and a consumer that cares about the difference — an automatic layout,
+     * above all — can ask.
+     *
+     * @returns {boolean}
+     */
+    isMeasured() {
+        return this.#measured;
+    }
+
+    /**
+     * Record the drawn box of this node, and where its ports ended up in it, on the visual data.
+     *
+     * Positions are relative to the node's own border box and in layout pixels, so they are
+     * unaffected by the camera: the graph is drawn under a scale transform, and a port that moved
+     * because somebody zoomed has not moved.
+     *
+     * @returns {boolean} whether anything could be measured
+     */
+    measure() {
+        if (!measure_frame.read(this.el)) {
+            // no layout box: detached, or inside something hidden. There is nothing to learn, and
+            // writing zeroes would collapse the node's box for everything that reads it.
+            return false;
+        }
+
+        // Everything is read off the frame before any of it is written back. The frame is shared
+        // between nodes, and a write here is a signal: a listener that measured another node in
+        // response would leave the rest of this pass measuring against that node's box.
+        const centers = this.#port_centers;
+
+        let at = 0;
+
+        for (const portView of this.portViews.values()) {
+            measure_frame.centerOf(v2_measure, portView.marker);
+
+            centers[at] = v2_measure.x;
+            centers[at + 1] = v2_measure.y;
+
+            at += 2;
+        }
+
+        const width = measure_frame.width;
+        const height = measure_frame.height;
+
+        const visual = this.visual;
+
+        let changed = false;
+
+        const size = visual.dimensions.size;
+
+        if (size.x !== width || size.y !== height) {
+            size.set(width, height);
+
+            changed = true;
+        }
+
+        at = 0;
+
+        for (const id of this.portViews.keys()) {
+            const x = centers[at];
+            const y = centers[at + 1];
+
+            at += 2;
+
+            const portVisual = visual.getPort(id);
+
+            if (portVisual === undefined) {
+                // no visual data for this port, so nothing reads a position for it either
+                continue;
+            }
+
+            const position = portVisual.position;
+
+            if (position.x !== x || position.y !== y) {
+                position.set(x, y);
+
+                changed = true;
+            }
+        }
+
+        this.#measured = true;
+
+        this.on.measured.send1(changed);
+
+        return true;
+    }
+
+    #startObserving() {
+        if (this.#observer !== null) {
+            return;
+        }
+
+        if (typeof ResizeObserver === "undefined") {
+            // no observer to be had, which is every environment without a layout engine. The link
+            // pass has already taken the one measurement such an environment can offer.
+            return;
+        }
+
+        this.#observer = new ResizeObserver(() => this.measure());
+
+        this.#observer.observe(this.el);
+    }
+
+    #stopObserving() {
+        if (this.#observer === null) {
+            return;
+        }
+
+        this.#observer.disconnect();
+
+        this.#observer = null;
     }
 
     update() {
         this.position.copy(this.visual.dimensions.position);
-        this.size.copy(this.visual.dimensions.size);
     }
 }

package/editor/view/node-graph/PortView.d.ts

@@ -1,3 +1,16 @@
+/**
+ * One port of a node, drawn as a marker and a label.
+ *
+ * A row of content rather than something placed at a coordinate: the node it belongs to is laid out
+ * by the browser, and where the port ends up is whatever that layout makes of it. The marker is the
+ * point the wires meet, and {@link NodeView} measures it and records it on the port's
+ * {@link PortVisualData} — so the position on the model is a report of where the dot is, not an
+ * instruction about where to put it.
+ *
+ * What the port looks like is decided by its type, and the type is not fixed: it starts as the
+ * one the port declares, and a host whose ports are typed by what is wired into them resolves
+ * another per node instance — see {@link #setDataType}, and `portDataType` on {@link NodeGraphView}.
+ */
 export class PortView extends View {
     /**
      *
@@ -7,6 +20,17 @@ export class PortView extends View {
      */
     constructor({ port, visual, visualData }: Port);
     el: HTMLDivElement;
+    /**
+     * The dot itself. What a wire is drawn to, and what {@link NodeView#measure} measures.
+     * @readonly
+     * @type {HTMLElement}
+     */
+    readonly marker: HTMLElement;
+    /**
+     * The type the port is currently shown as carrying. See {@link #setDataType}.
+     * @type {DataType|null}
+     */
+    dataType: DataType | null;
     /**
      *
      * @type {Port}
@@ -17,7 +41,23 @@ export class PortView extends View {
      * @type {PortVisualData}
      */
     visual: PortVisualData;
-    update(): void;
+    /**
+     * Where a type's colour is looked up.
+     * @type {NodeGraphVisualData}
+     */
+    visualData: NodeGraphVisualData;
+    /**
+     * Show the port as carrying a value of this type: the marker takes the type's colour, the
+     * element takes a class named after it, and the tooltip says its name.
+     *
+     * The declared type to begin with, and whatever a host resolves for this node instance after
+     * that. A library whose ports are typed by what is wired into them changes its answer about a
+     * port every time the graph changes, so this is called again rather than the view rebuilt.
+     * Setting the type the port already shows does nothing.
+     *
+     * @param {DataType} dataType
+     */
+    setDataType(dataType: DataType): void;
 }
 import View from "../../../src/view/View.js";
 //# sourceMappingURL=PortView.d.ts.map

package/editor/view/node-graph/PortView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PortView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/PortView.js"],"names":[],"mappings":"AAUA;IAGI;;;;;OAKG;IACH,gDA4CC;IApDD,mBAAmC;IAW/B;;;OAGG;IACH,WAAgB;IAChB;;;OAGG;IACH,uBAAoB;IAkCxB,eAEC;CACJ;iBApEgB,2BAA2B"}
+{"version":3,"file":"PortView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/PortView.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;;;OAKG;IACH,gDAyCC;IA9DD,mBAAmC;IAEnC;;;;OAIG;IACH,iBAFU,WAAW,CAEd;IAEP;;;OAGG;IACH,UAFU,WAAS,IAAI,CAEP;IAiBZ;;;OAGG;IACH,WAAgB;IAChB;;;OAGG;IACH,uBAAoB;IACpB;;;OAGG;IACH,gCAA4B;IAoBhC;;;;;;;;;;OAUG;IACH,sCAsBC;CACJ;iBAvHgB,2BAA2B"}