@woosh/meep-engine 3.15.0 → 3.16.0

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

@@ -1,69 +1,121 @@
-import View from "../../../src/view/View.js";
-import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
-import LabelView from "../../../src/view/common/LabelView.js";
-import EmptyView from "../../../src/view/elements/EmptyView.js";
-import { Color } from "../../../src/core/color/Color.js";
-import { objectKeyByValue } from "../../../src/core/model/object/objectKeyByValue.js";
-import { string_format_camel_to_kebab } from "../../../src/core/primitives/strings/string_format_camel_to_kebab.js";
-
-const DEFAULT_TYPE_COLOR = new Color(1, 1, 1);
-
-export class PortView extends View {
-    el = document.createElement('div');
-
-    /**
-     *
-     * @param {Port} port
-     * @param {PortVisualData} visual
-     * @param {NodeGraphVisualData} visualData
-     */
-    constructor({ port, visual, visualData }) {
-        super();
-
-        /**
-         *
-         * @type {Port}
-         */
-        this.port = port;
-        /**
-         *
-         * @type {PortVisualData}
-         */
-        this.visual = visual;
-
-        this.addClass('ui-port-view');
-
-        this.addClass(`direction-${objectKeyByValue(PortDirection, port.direction).toLocaleLowerCase()}`);
-
-        this.addClass(`data-type-${string_format_camel_to_kebab(port.dataType.name)}`);
-
-        //add port name label
-        const vName = new LabelView(port.name, {
-            classList: ['name']
-        });
-
-        this.addChild(vName);
-
-        let color = visualData.getDataColor(port.dataType.id);
-
-        if (color === undefined) {
-            console.warn(`No color for data type ${port.dataType}, using default`);
-
-            color = DEFAULT_TYPE_COLOR;
-        }
-
-        this.addChild(new EmptyView({
-            classList: ['marker'],
-            css: {
-                backgroundColor: `rgb(${color.r * 255}, ${color.g * 255}, ${color.b * 255})`
-            }
-        }));
-
-        this.on.linked.add(this.update, this);
-        this.bindSignal(visual.position.onChanged, this.update, this);
-    }
-
-    update() {
-        this.position.copy(this.visual.position);
-    }
-}
+import { assert } from "../../../src/core/assert.js";
+import View from "../../../src/view/View.js";
+import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
+import LabelView from "../../../src/view/common/LabelView.js";
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+import { objectKeyByValue } from "../../../src/core/model/object/objectKeyByValue.js";
+import { string_format_camel_to_kebab } from "../../../src/core/primitives/strings/string_format_camel_to_kebab.js";
+
+/**
+ * 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 {
+    el = document.createElement('div');
+
+    /**
+     * The dot itself. What a wire is drawn to, and what {@link NodeView#measure} measures.
+     * @readonly
+     * @type {HTMLElement}
+     */
+    marker;
+
+    /**
+     * The type the port is currently shown as carrying. See {@link #setDataType}.
+     * @type {DataType|null}
+     */
+    dataType = null;
+
+    /**
+     *
+     * @param {Port} port
+     * @param {PortVisualData} visual
+     * @param {NodeGraphVisualData} visualData
+     */
+    constructor({ port, visual, visualData }) {
+        super();
+
+        // The node measures this port's marker into `visual`; without one the port has no anchor,
+        // and a wire that reaches for it later finds nothing. Stale visual data — a description
+        // that gained a port after a document was written — is how that happens.
+        assert.defined(visual, 'visual');
+        assert.notNull(visual, 'visual');
+
+        /**
+         *
+         * @type {Port}
+         */
+        this.port = port;
+        /**
+         *
+         * @type {PortVisualData}
+         */
+        this.visual = visual;
+        /**
+         * Where a type's colour is looked up.
+         * @type {NodeGraphVisualData}
+         */
+        this.visualData = visualData;
+
+        this.addClass('ui-port-view');
+
+        this.addClass(`direction-${objectKeyByValue(PortDirection, port.direction).toLocaleLowerCase()}`);
+
+        const vMarker = new EmptyView({ classList: ['marker'] });
+
+        this.marker = vMarker.el;
+
+        this.addChild(vMarker);
+
+        this.setDataType(port.dataType);
+
+        //add port name label
+        this.addChild(new LabelView(port.name, {
+            classList: ['name']
+        }));
+    }
+
+    /**
+     * 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) {
+        assert.defined(dataType, 'dataType');
+        assert.notNull(dataType, 'dataType');
+
+        if (this.dataType === dataType) {
+            return;
+        }
+
+        if (this.dataType !== null) {
+            this.setClass(`data-type-${string_format_camel_to_kebab(this.dataType.name)}`, false);
+        }
+
+        this.dataType = dataType;
+
+        this.addClass(`data-type-${string_format_camel_to_kebab(dataType.name)}`);
+
+        // an unstyled type comes back as the neutral default rather than undefined
+        const color = this.visualData.getDataColor(dataType.id);
+
+        this.marker.style.backgroundColor = `rgb(${color.r * 255}, ${color.g * 255}, ${color.b * 255})`;
+
+        this.el.setAttribute('title', dataType.name);
+    }
+}

package/editor/view/node-graph/actions/ConnectionDeleteAction.d.ts

@@ -1,14 +1,22 @@
 /**
- * Delete a connection from a node graph.
- * Holds onto the connection object so that revert restores it with the same identity.
+ * Delete a connection from a node graph, together with the path it was drawn along.
+ * Holds onto both so that revert restores them with the same identity.
  */
 export class ConnectionDeleteAction extends Action<any> {
     /**
      *
      * @param {NodeGraph} graph
      * @param {Connection} connection
+     * @param {NodeGraphVisualData} [visual] source of the connection's path; without it the path is
+     *        left alone, which is what a caller with no visual data wants
      */
-    constructor(graph: NodeGraph, connection: Connection);
+    constructor(graph: NodeGraph, connection: Connection, visual?: NodeGraphVisualData);
+    /**
+     * The path this connection had, kept so that undoing brings back the drawing that was there
+     * rather than a straight line where a route used to be.
+     * @type {ConnectionVisualData|undefined}
+     */
+    connectionVisual: ConnectionVisualData | undefined;
     /**
      *
      * @type {NodeGraph}
@@ -19,6 +27,11 @@ export class ConnectionDeleteAction extends Action<any> {
      * @type {Connection}
      */
     connection: Connection;
+    /**
+     *
+     * @type {NodeGraphVisualData|undefined}
+     */
+    visual: NodeGraphVisualData | undefined;
     apply(): Promise<void>;
     revert(): Promise<void>;
 }

package/editor/view/node-graph/actions/ConnectionDeleteAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConnectionDeleteAction.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/ConnectionDeleteAction.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACI;;;;OAIG;IACH,sDAcC;IAXG;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,uBAA4B;IAGhC,uBAEC;IAED,wBAEC;CACJ;uBAnCsB,6CAA6C"}
+{"version":3,"file":"ConnectionDeleteAction.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/ConnectionDeleteAction.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAQI;;;;;;OAMG;IACH,oFAoBC;IAlCD;;;;OAIG;IACH,kBAFU,uBAAqB,SAAS,CAEX;IAYzB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,uBAA4B;IAE5B;;;OAGG;IACH,QAFU,sBAAoB,SAAS,CAEnB;IAGxB,uBASC;IAED,wBAMC;CACJ;uBA7DsB,6CAA6C"}

package/editor/view/node-graph/actions/ConnectionDeleteAction.js

@@ -1,16 +1,25 @@
 import { Action } from "../../../../src/core/process/undo/Action.js";
 
 /**
- * Delete a connection from a node graph.
- * Holds onto the connection object so that revert restores it with the same identity.
+ * Delete a connection from a node graph, together with the path it was drawn along.
+ * Holds onto both so that revert restores them with the same identity.
  */
 export class ConnectionDeleteAction extends Action {
+    /**
+     * The path this connection had, kept so that undoing brings back the drawing that was there
+     * rather than a straight line where a route used to be.
+     * @type {ConnectionVisualData|undefined}
+     */
+    connectionVisual = undefined;
+
     /**
      *
      * @param {NodeGraph} graph
      * @param {Connection} connection
+     * @param {NodeGraphVisualData} [visual] source of the connection's path; without it the path is
+     *        left alone, which is what a caller with no visual data wants
      */
-    constructor(graph, connection) {
+    constructor(graph, connection, visual = undefined) {
         super();
 
         /**
@@ -24,13 +33,30 @@ export class ConnectionDeleteAction extends Action {
          * @type {Connection}
          */
         this.connection = connection;
+
+        /**
+         *
+         * @type {NodeGraphVisualData|undefined}
+         */
+        this.visual = visual;
     }
 
     async apply() {
         this.graph.deleteConnection(this.connection.id);
+
+        if (this.visual !== undefined) {
+            // connection IDs are pooled; a stale path must not leak onto an unrelated future wire
+            this.connectionVisual = this.visual.getConnection(this.connection.id);
+
+            this.visual.removeConnection(this.connection.id);
+        }
     }
 
     async revert() {
         this.graph.addConnection(this.connection);
+
+        if (this.visual !== undefined && this.connectionVisual !== undefined) {
+            this.visual.addConnection(this.connection.id, this.connectionVisual);
+        }
     }
 }

package/editor/view/node-graph/actions/NodeCreateAction.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Add a node to a graph, at a position, with its starting parameters.
+ *
+ * The counterpart of {@link ./NodeDeleteAction.js}, and built the same way: the instance and its
+ * visual data are created once, on the first application, and retained so that redo restores the
+ * same objects under the same id rather than a lookalike. Anything that captured a reference to the
+ * node between the two — a selection, a later action on the timeline — still refers to it.
+ *
+ * Visual data is created here rather than being left to the view, so a node is placed where the
+ * author put it before any view has had a chance to generate a default at the origin.
+ */
+export class NodeCreateAction extends Action<any> {
+    /**
+     * @param {NodeGraph} graph
+     * @param {NodeGraphVisualData} visual
+     * @param {NodeDescriptionVisualRegistry} visualRegistry source of the node's visual prototype
+     * @param {NodeDescription} description type of node to create
+     * @param {number} x graph-space position
+     * @param {number} y graph-space position
+     * @param {object} [parameters] starting parameter values, applied inside this action so undo
+     *        takes them with the node
+     */
+    constructor(graph: NodeGraph, visual: NodeGraphVisualData, visualRegistry: NodeDescriptionVisualRegistry, description: NodeDescription, x: number, y: number, parameters?: object);
+    /**
+     * The instance, once created. Retained across revert so redo restores it rather than a copy.
+     * @type {NodeInstance|null}
+     */
+    node: NodeInstance | null;
+    /**
+     * @type {NodeVisualData|undefined}
+     */
+    nodeVisual: NodeVisualData | undefined;
+    /**
+     * @type {NodeGraph}
+     */
+    graph: NodeGraph;
+    /**
+     * @type {NodeGraphVisualData}
+     */
+    visual: NodeGraphVisualData;
+    /**
+     * @type {NodeDescriptionVisualRegistry}
+     */
+    visualRegistry: NodeDescriptionVisualRegistry;
+    /**
+     * @type {NodeDescription}
+     */
+    description: NodeDescription;
+    /**
+     * @type {number}
+     */
+    x: number;
+    /**
+     * @type {number}
+     */
+    y: number;
+    /**
+     * @type {object}
+     */
+    parameters: object;
+    apply(): Promise<void>;
+    revert(): Promise<void>;
+}
+import { Action } from "../../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=NodeCreateAction.d.ts.map

package/editor/view/node-graph/actions/NodeCreateAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeCreateAction.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/NodeCreateAction.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IAYI;;;;;;;;;OASG;IACH,2IALW,MAAM,KACN,MAAM,eACN,MAAM,EAwChB;IA1DD;;;OAGG;IACH,MAFU,eAAa,IAAI,CAEf;IAEZ;;OAEG;IACH,YAFU,iBAAe,SAAS,CAEX;IAenB;;OAEG;IACH,iBAAkB;IAElB;;OAEG;IACH,4BAAoB;IAEpB;;OAEG;IACH,8CAAoC;IAEpC;;OAEG;IACH,6BAA8B;IAE9B;;OAEG;IACH,GAFU,MAAM,CAEN;IAEV;;OAEG;IACH,GAFU,MAAM,CAEN;IAEV;;OAEG;IACH,YAFU,MAAM,CAEY;IAGhC,uBAuBC;IAED,wBAOC;CACJ;uBA3GsB,6CAA6C"}

package/editor/view/node-graph/actions/NodeCreateAction.js

@@ -0,0 +1,108 @@
+import { Action } from "../../../../src/core/process/undo/Action.js";
+
+/**
+ * Add a node to a graph, at a position, with its starting parameters.
+ *
+ * The counterpart of {@link ./NodeDeleteAction.js}, and built the same way: the instance and its
+ * visual data are created once, on the first application, and retained so that redo restores the
+ * same objects under the same id rather than a lookalike. Anything that captured a reference to the
+ * node between the two — a selection, a later action on the timeline — still refers to it.
+ *
+ * Visual data is created here rather than being left to the view, so a node is placed where the
+ * author put it before any view has had a chance to generate a default at the origin.
+ */
+export class NodeCreateAction extends Action {
+    /**
+     * The instance, once created. Retained across revert so redo restores it rather than a copy.
+     * @type {NodeInstance|null}
+     */
+    node = null;
+
+    /**
+     * @type {NodeVisualData|undefined}
+     */
+    nodeVisual = undefined;
+
+    /**
+     * @param {NodeGraph} graph
+     * @param {NodeGraphVisualData} visual
+     * @param {NodeDescriptionVisualRegistry} visualRegistry source of the node's visual prototype
+     * @param {NodeDescription} description type of node to create
+     * @param {number} x graph-space position
+     * @param {number} y graph-space position
+     * @param {object} [parameters] starting parameter values, applied inside this action so undo
+     *        takes them with the node
+     */
+    constructor(graph, visual, visualRegistry, description, x, y, parameters = {}) {
+        super();
+
+        /**
+         * @type {NodeGraph}
+         */
+        this.graph = graph;
+
+        /**
+         * @type {NodeGraphVisualData}
+         */
+        this.visual = visual;
+
+        /**
+         * @type {NodeDescriptionVisualRegistry}
+         */
+        this.visualRegistry = visualRegistry;
+
+        /**
+         * @type {NodeDescription}
+         */
+        this.description = description;
+
+        /**
+         * @type {number}
+         */
+        this.x = x;
+
+        /**
+         * @type {number}
+         */
+        this.y = y;
+
+        /**
+         * @type {object}
+         */
+        this.parameters = parameters;
+    }
+
+    async apply() {
+        const graph = this.graph;
+
+        if (this.node === null) {
+            const id = graph.createNode(this.description);
+
+            const node = graph.getNodeSafe(id);
+
+            node.setParameters(this.parameters);
+
+            this.node = node;
+
+            this.nodeVisual = this.visual.ensureNode(node, this.visualRegistry);
+            this.nodeVisual.dimensions.position.set(this.x, this.y);
+
+            return;
+        }
+
+        // redo: visual data goes back first, because adding the node builds its view, and a view
+        // built before the data is in place generates a fresh one at the origin and binds to that
+        this.visual.addNode(this.node.id, this.nodeVisual);
+
+        graph.addNode(this.node);
+    }
+
+    async revert() {
+        const id = this.node.id;
+
+        this.graph.deleteNode(id);
+
+        // node ids are pooled: stale visual data must not be picked up by an unrelated future node
+        this.visual.removeNode(id);
+    }
+}

package/editor/view/node-graph/actions/NodeDeleteAction.d.ts

@@ -25,6 +25,12 @@ export class NodeDeleteAction extends Action<any> {
      * @type {Connection[]}
      */
     connections: Connection[];
+    /**
+     * The path each of those connections was drawn along, in the same order. An entry is undefined
+     * where the connection had never been routed.
+     * @type {(ConnectionVisualData|undefined)[]}
+     */
+    connectionVisuals: (ConnectionVisualData | undefined)[];
     /**
      *
      * @type {NodeGraph}

package/editor/view/node-graph/actions/NodeDeleteAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeDeleteAction.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/NodeDeleteAction.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAmBI;;;;;OAKG;IACH,mEAFW,MAAM,EAsBhB;IA5CD;;;OAGG;IACH,MAFU,eAAa,IAAI,CAEf;IAEZ;;;OAGG;IACH,YAFU,iBAAe,SAAS,CAEX;IAEvB;;;OAGG;IACH,aAFU,YAAY,CAEL;IAWb;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,QAFU,MAAM,CAEI;IAGxB,uBAiBC;IAED,wBAcC;CACJ;uBAvFsB,6CAA6C"}
+{"version":3,"file":"NodeDeleteAction.d.ts","sourceRoot":"","sources":["../../../../../editor/view/node-graph/actions/NodeDeleteAction.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IA0BI;;;;;OAKG;IACH,mEAFW,MAAM,EAsBhB;IAnDD;;;OAGG;IACH,MAFU,eAAa,IAAI,CAEf;IAEZ;;;OAGG;IACH,YAFU,iBAAe,SAAS,CAEX;IAEvB;;;OAGG;IACH,aAFU,YAAY,CAEL;IAEjB;;;;OAIG;IACH,mBAFU,CAAC,uBAAqB,SAAS,CAAC,EAAE,CAErB;IAWnB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,QAFU,MAAM,CAEI;IAGxB,uBAwBC;IAED,wBAsBC;CACJ;uBA7GsB,6CAA6C"}

package/editor/view/node-graph/actions/NodeDeleteAction.js

@@ -23,6 +23,13 @@ export class NodeDeleteAction extends Action {
      */
     connections = [];
 
+    /**
+     * The path each of those connections was drawn along, in the same order. An entry is undefined
+     * where the connection had never been routed.
+     * @type {(ConnectionVisualData|undefined)[]}
+     */
+    connectionVisuals = [];
+
     /**
      *
      * @param {NodeGraph} graph
@@ -64,10 +71,17 @@ export class NodeDeleteAction extends Action {
 
         this.connections = connection_ids.map(id => graph.getConnection(id));
 
+        this.connectionVisuals = this.connections.map(connection => this.visual.getConnection(connection.id));
+
         graph.deleteNode(nodeId);
 
-        // node IDs are pooled, stale visual data must not leak onto an unrelated future node
+        // node and connection IDs are pooled, stale visual data must not leak onto an unrelated
+        // future node or wire
         this.visual.removeNode(nodeId);
+
+        for (const connection of this.connections) {
+            this.visual.removeConnection(connection.id);
+        }
     }
 
     async revert() {
@@ -81,8 +95,16 @@ export class NodeDeleteAction extends Action {
 
         graph.addNode(this.node);
 
-        for (const connection of this.connections) {
+        for (let i = 0; i < this.connections.length; i++) {
+            const connection = this.connections[i];
+
             graph.addConnection(connection);
+
+            const connectionVisual = this.connectionVisuals[i];
+
+            if (connectionVisual !== undefined) {
+                this.visual.addConnection(connection.id, connectionVisual);
+            }
         }
     }
 }

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

@@ -38,6 +38,40 @@ export function wire_to_bezier(result: number[] | Float64Array, x0: number, y0:
  * @returns {number}
  */
 export function wire_distance_to_point(px: number, py: number, x0: number, y0: number, x1: number, y1: number): number;
+/**
+ * Fill in the path of a wire that has not been routed.
+ *
+ * Everything that draws or hit-tests a wire works from a {@link ConnectionVisualData}, so that
+ * routed and unrouted wires are one case rather than two. This is how an unrouted one becomes one
+ * of those.
+ *
+ * @param {ConnectionVisualData} result
+ * @param {number} x0 source endpoint
+ * @param {number} y0
+ * @param {number} x1 target endpoint
+ * @param {number} y1
+ * @returns {void}
+ */
+export function wire_build_direct(result: ConnectionVisualData, x0: number, y0: number, x1: number, y1: number): void;
+/**
+ * The path a wire should be drawn along.
+ *
+ * A wire has a route only while its nodes have not moved since it was found. Dragging a node takes
+ * its ports with it and leaves the route behind, and re-routing on every frame of a drag is not
+ * affordable — so a route that no longer meets its own ports is set aside and the wire is drawn the
+ * way an unrouted one is, until the graph is routed again.
+ *
+ * The fallback is written into `scratch`, so the result is only good until the next call.
+ *
+ * @param {ConnectionVisualData|undefined} route what the layout found, if anything
+ * @param {number} x0 where the wire leaves, now
+ * @param {number} y0
+ * @param {number} x1 where it arrives, now
+ * @param {number} y1
+ * @param {ConnectionVisualData} scratch
+ * @returns {ConnectionVisualData}
+ */
+export function wire_resolve_path(route: ConnectionVisualData | undefined, x0: number, y0: number, x1: number, y1: number, scratch: ConnectionVisualData): ConnectionVisualData;
 /**
  * Horizontal reach of a wire out of each endpoint, in graph units
  * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"connection_wire_geometry.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/connection_wire_geometry.js"],"names":[],"mappings":"AAwBA;;;;;;;;GAQG;AACH,+CANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;AAED;;;;;;;GAOG;AACH,oCANW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;AAED;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;AAQD;;;;;;;;;;GAUG;AACH,2CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyBlB;AA/FD;;;GAGG;AACH,iCAFU,MAAM,CAEsB"}
+{"version":3,"file":"connection_wire_geometry.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/connection_wire_geometry.js"],"names":[],"mappings":"AA6BA;;;;;;;;GAQG;AACH,+CANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;AAED;;;;;;;GAOG;AACH,oCANW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;AAED;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;AAQD;;;;;;;;;;GAUG;AACH,2CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyBlB;AAED;;;;;;;;;;;;;GAaG;AACH,oEANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAOhB;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,yCARW,uBAAqB,SAAS,MAC9B,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,uDAuBhB;AAtKD;;;GAGG;AACH,iCAFU,MAAM,CAEsB"}