@graphty/graphty-element 2.6.2 → 3.0.0

package/dist/src/Edge.d.ts

@@ -18,15 +18,31 @@ interface EdgeLine {
 interface EdgeOpts {
     metadata?: object;
 }
+/**
+ * Move an edge to a row of the current snapshot. Only the data manager calls it, as an edge is
+ * added, removed or renumbered by a compacting freeze.
+ * @param edge - The edge.
+ * @param row - Its logical edge index, or INVALID_INDEX.
+ */
+export declare function placeEdgeRow(edge: Edge, row: number): void;
+/**
+ * Hand an edge the record the graph now holds for it. Only the data manager calls it, from the
+ * render half of the graph's derivation, when a command, an undo or a redo changed the record;
+ * no entry point exports it, so `edge.data` is always the graph's record.
+ * @param edge - The edge.
+ * @param record - The record.
+ */
+export declare function adoptEdgeRecord(edge: Edge, record: AdHocData): void;
 /**
  * Represents a directed edge between two nodes in the graph visualization.
  * Handles rendering of edge lines, arrow heads/tails, and labels with support for various styles.
  */
 export declare class Edge {
+    #private;
     parentGraph: Graph | GraphContext;
     opts: EdgeOpts;
-    srcId: NodeIdType;
-    dstId: NodeIdType;
+    readonly srcId: NodeIdType;
+    readonly dstId: NodeIdType;
     /**
      * This edge's identity: the element-assigned counter the store stamped into its
      * `graphty.edgeId` column, printed as a string.
@@ -44,11 +60,19 @@ export declare class Edge {
      * Every Edge has one. An edge whose endpoint ids graph-format will not store is REJECTED
      * before a render object is built for it, so there is no such thing as an Edge with no row --
      * which is what makes `index` safe to read without a guard everywhere downstream.
+     * @returns The row.
      */
-    index: number;
+    get index(): number;
+    private set index(value);
+    private row;
     dstNode: Node;
     srcNode: Node;
-    data: AdHocData;
+    /**
+     * The record this edge carries, as the graph holds it: deep-frozen, so a write to it throws. A
+     * change goes through the graph (`updateNodes`, `session.data.updateNodes`, ...), which is what undo sees.
+     * @returns The record.
+     */
+    get data(): AdHocData;
     mesh: AbstractMesh | PatternedLineMesh;
     arrowMesh: AbstractMesh | null;
     arrowTailMesh: AbstractMesh | null;
@@ -137,11 +161,11 @@ export declare class Edge {
     /**
      * Where this edge sits among the edges sharing its ordered endpoint pair, counting from zero.
      *
-     * Derived on every read from the data manager's edge cache rather than stored, so a removal
-     * cannot leave it stale. Nothing draws with it yet -- two parallel edges still render as two
+     * Derived on every read from the graph store rather than stored, so a removal cannot leave it
+     * stale. Nothing draws with it yet -- two parallel edges still render as two
      * coincident lines -- but a style layer can read it, and the geometry work that eventually
      * separates parallel edges needs exactly this number.
-     * @returns the rank, or -1 for an edge the cache no longer holds
+     * @returns the rank, or -1 for an edge the store no longer holds
      */
     get parallelRank(): number;
     /**
@@ -394,64 +418,4 @@ export declare class Edge {
      */
     private createArrowText;
 }
-/**
- * Every edge the graph holds, indexed by its ordered endpoint pair.
- *
- * The inner value is an ARRAY, not one edge: two edges between the same ordered pair are two
- * edges. This class used to throw `"Attempting to create duplicate Edge"` on the second one, which
- * is why the data manager carried two separate guards that dropped a repeated record before it
- * could reach here -- and those drops are what pinned `statistics().repeatedEdgeCount` at zero for
- * every multigraph the element has ever loaded.
- *
- * Ask {@link EdgeMap.first} when the question genuinely has one answer, and {@link EdgeMap.get}
- * otherwise. Neither ever returns undefined for the pair itself: an absent pair is an empty array.
- */
-export declare class EdgeMap {
-    map: Map<NodeIdType, Map<NodeIdType, Edge[]>>;
-    /**
-     * Whether any edge runs between the specified source and destination nodes.
-     * @param srcId - The source node ID
-     * @param dstId - The destination node ID
-     * @returns True when at least one edge exists, false otherwise
-     */
-    has(srcId: NodeIdType, dstId: NodeIdType): boolean;
-    /**
-     * Adds an edge to the map, alongside any edges already running between the same pair.
-     * @param srcId - The source node ID
-     * @param dstId - The destination node ID
-     * @param e - The edge instance to store
-     */
-    set(srcId: NodeIdType, dstId: NodeIdType, e: Edge): void;
-    /**
-     * Every edge running from one node to another, in the order they were added.
-     * @param srcId - The source node ID
-     * @param dstId - The destination node ID
-     * @returns The edges, which is an empty array when there are none
-     */
-    get(srcId: NodeIdType, dstId: NodeIdType): readonly Edge[];
-    /**
-     * The first edge running from one node to another, for a caller whose question has one answer.
-     * @param srcId - The source node ID
-     * @param dstId - The destination node ID
-     * @returns The oldest edge between the pair, or undefined when there is none
-     */
-    first(srcId: NodeIdType, dstId: NodeIdType): Edge | undefined;
-    /**
-     * How many EDGES the map holds, which under parallel edges is more than the number of pairs.
-     * @returns The total count of all edges
-     */
-    get size(): number;
-    /**
-     * Removes ONE edge from the map, leaving any other edges between the same pair alone.
-     * @param srcId - The source node ID
-     * @param dstId - The destination node ID
-     * @param e - The edge to remove
-     * @returns True if that edge was removed, false if the map did not hold it
-     */
-    delete(srcId: NodeIdType, dstId: NodeIdType, e: Edge): boolean;
-    /**
-     * Removes all edges from the map.
-     */
-    clear(): void;
-}
 export {};