@statelyai/layout 0.3.0 → 0.4.0

package/src/layered/types.ts

@@ -1,5 +1,7 @@
+import type { NativeRoutingStrategy, RoutingSettings } from "../routing/types";
 import type { EntityRect, Graph, GraphEdge, GraphNode, GraphPort, Point } from "@statelyai/graph";
 import type { LayoutConstraints } from "@statelyai/graph/layout";
+import type { LayoutHint } from "./hints";
 import type { LayoutDirection } from "../types";
 import type { ElkLayeredOptionValueByName, LayeredAdvancedOptions } from "./elk-options";
 
@@ -21,6 +23,8 @@ export interface LayoutPadding {
 }
 
 export interface LayeredPhaseInput {
+  /** Authored edge order retained through label and long-edge expansion. */
+  modelOrderByEdgeId?: ReadonlyMap<string, number>;
   graph: Graph<unknown, unknown, unknown, unknown>;
   sizes: ReadonlyMap<string, NodeSize>;
   direction: LayoutDirection;
@@ -38,12 +42,15 @@ export interface AcyclicOrientation {
 }
 
 export interface LayerAssignment {
+  layerCount?: number;
   layerByNodeId: ReadonlyMap<string, number>;
   /** Layer-internal seed order produced by layerers whose insertion order is observable. */
   seedOrder?: readonly string[];
 }
 
 export interface LayerOrder {
+  /** Canonical clockwise physical port identities, independent of edge reversal. */
+  physicalPortOrderByNodeId?: ReadonlyMap<string, readonly string[]>;
   layers: readonly (readonly string[])[];
   /** Internal ELK sweep state retained for exact port-aware placement. */
   inputPortOrderByNodeId?: ReadonlyMap<string, readonly string[]>;
@@ -57,6 +64,8 @@ export interface NodePlacement {
 
 export interface EdgeRoutes {
   pointsByEdgeId: ReadonlyMap<string, readonly Point[]>;
+  /** Branch points generated on physical orthogonal hypersegments before restoration. */
+  junctionPointsByEdgeId?: ReadonlyMap<string, readonly Point[]>;
   /** ELK spline segment NUB controls retained until long-edge joining. */
   splineNubControlsByEdgeId?: ReadonlyMap<string, readonly Point[]>;
   /** Reversed fixed-side routes that must stay outside the node envelope during compaction. */
@@ -112,12 +121,16 @@ export interface CompoundEdgeAttachment {
 }
 
 export interface LayeredLayoutOptions {
+  /** Replace initial routes after initial placement and routing, without moving geometry. */
+  routing?: { strategy: Pick<NativeRoutingStrategy, "route">; settings?: RoutingSettings };
   direction?: LayoutDirection;
   compound?: (node: GraphNode) => CompoundLayoutOptions | undefined;
   edgeAttachment?: (edge: GraphEdge) => CompoundEdgeAttachment | undefined;
   spacing?: Partial<LayeredSpacing>;
   padding?: number | Partial<LayoutPadding>;
   constraints?: LayoutConstraints;
+  /** Reader-facing preferences applied during layering, ordering and placement. */
+  hints?: readonly LayoutHint[];
   measure?: (node: GraphNode) => NodeSize;
   crossingSweeps?: number;
   strategies?: LayeredStrategies;

package/src/layered/weighted-compaction.ts

@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Kiel University and others.
+ *
+ * Adapted from ELK v0.11.0 NetworkSimplexCompaction.java.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import { runNetworkSimplex, type SimplexEdge, type SimplexNode } from "./network-simplex";
+import { InfeasibleCompactionError } from "./compaction-errors";
+
+export interface CompactionConstraint {
+  source: string;
+  target: string;
+  delta: number;
+  weight: number;
+}
+
+/** Minimize weighted separation subject to integral lower-bound constraints. */
+export function solveWeightedCompaction(
+  groupIds: readonly string[],
+  constraints: readonly CompactionConstraint[],
+): Map<string, number> {
+  const nodes = groupIds.map((id, order): SimplexNode => ({
+    id,
+    order,
+    layer: 0,
+    incoming: [],
+    outgoing: [],
+    treeNode: false,
+  }));
+  if (nodes.length === 0) return new Map();
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const edges: SimplexEdge[] = [];
+  const add = (source: SimplexNode, target: SimplexNode, delta: number, weight: number): void => {
+    const edge: SimplexEdge = {
+      id: `constraint:${edges.length}`,
+      order: edges.length,
+      source,
+      target,
+      delta: Math.max(0, Math.ceil(delta)),
+      weight,
+      treeEdge: false,
+    };
+    edges.push(edge);
+    source.outgoing.push(edge);
+    target.incoming.push(edge);
+  };
+  for (const constraint of constraints) {
+    const source = byId.get(constraint.source);
+    const target = byId.get(constraint.target);
+    if (!source || !target) throw new Error("Unknown compaction group");
+    if (source !== target) add(source, target, constraint.delta, constraint.weight);
+  }
+  // Fail explicitly on invalid constraint cycles rather than hanging tight-tree growth.
+  const remaining = new Map(nodes.map((node) => [node, node.incoming.length]));
+  const queue = nodes.filter((node) => node.incoming.length === 0);
+  let visited = 0;
+  for (let index = 0; index < queue.length; index++) {
+    const node = queue[index]!;
+    visited++;
+    for (const edge of node.outgoing) {
+      const count = remaining.get(edge.target)! - 1;
+      remaining.set(edge.target, count);
+      if (count === 0) queue.push(edge.target);
+    }
+  }
+  if (visited !== nodes.length)
+    throw new InfeasibleCompactionError("Cyclic compaction constraints");
+  const sources = nodes.filter((node) => node.incoming.length === 0);
+  if (sources.length > 1) {
+    const source: SimplexNode = {
+      id: "",
+      order: nodes.length,
+      layer: 0,
+      incoming: [],
+      outgoing: [],
+      treeNode: false,
+    };
+    nodes.push(source);
+    for (const target of sources) add(source, target, 1, 0);
+  }
+  runNetworkSimplex(nodes, edges, Number.MAX_SAFE_INTEGER, undefined, false);
+  return new Map(groupIds.map((id) => [id, byId.get(id)!.layer]));
+}

package/src/routing/adapters.ts

@@ -88,6 +88,38 @@ export function routeToPolylines(
 ): readonly (readonly RoutePoint[])[] {
   return route.sections.map((s) => flattenPath(s.path, options));
 }
+/**
+ * One point list for consumers of `GraphEdge.points`. Sections are joined
+ * through their gaps (an edge label, for example); between orthogonal
+ * sections the join is orthogonal too, so it never adds a diagonal.
+ */
+export function routeToPoints(
+  route: Route,
+  options?: { readonly tolerance?: number },
+): RoutePoint[] {
+  const points: RoutePoint[] = [];
+  const axis = (a: RoutePoint, b: RoutePoint) =>
+    Math.abs(a.y - b.y) < 1e-9 ? "horizontal" : Math.abs(a.x - b.x) < 1e-9 ? "vertical" : undefined;
+  for (const polyline of routeToPolylines(route, options)) {
+    const a = points.at(-1),
+      b = polyline[0];
+    if (a && b && axis(a, b) === undefined) {
+      const before = points.length > 1 ? axis(points.at(-2)!, a) : undefined;
+      const after = polyline.length > 1 ? axis(b, polyline[1]!) : undefined;
+      if (before && after) {
+        if (before === "horizontal" && after === "horizontal") {
+          const x = (a.x + b.x) / 2;
+          points.push({ x, y: a.y }, { x, y: b.y });
+        } else if (before === "vertical" && after === "vertical") {
+          const y = (a.y + b.y) / 2;
+          points.push({ x: a.x, y }, { x: b.x, y });
+        } else points.push(before === "horizontal" ? { x: b.x, y: a.y } : { x: a.x, y: b.y });
+      }
+    }
+    points.push(...polyline.map((point) => ({ ...point })));
+  }
+  return points;
+}
 /** Compatibility for single-section native consumers. Refuses to erase gaps or topology. */
 export function routeToGraphPatch(
   route: Route,