@statelyai/layout 0.0.0 → 0.0.2

package/src/layered/network-simplex.ts

@@ -0,0 +1,346 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2020 Kiel University and others.
+ *
+ * Translated from ELK v0.11.0 NetworkSimplexLayerer.java and NetworkSimplex.java.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { GraphEdge } from "@statelyai/graph";
+import type { AcyclicOrientation, LayerAssigner, LayeredPhaseInput } from "./types";
+
+export interface SimplexNode {
+  id: string;
+  order: number;
+  layer: number;
+  incoming: SimplexEdge[];
+  outgoing: SimplexEdge[];
+  treeNode: boolean;
+}
+
+export interface SimplexEdge {
+  id: string;
+  order: number;
+  source: SimplexNode;
+  target: SimplexNode;
+  weight: number;
+  delta: number;
+  treeEdge: boolean;
+}
+
+function connectedEdges(node: SimplexNode): SimplexEdge[] {
+  return [...node.incoming, ...node.outgoing];
+}
+
+function otherNode(edge: SimplexEdge, node: SimplexNode): SimplexNode {
+  return edge.source === node ? edge.target : edge.source;
+}
+
+function getOrientedEndpoints(
+  edge: GraphEdge,
+  orientation: AcyclicOrientation,
+): readonly [string, string] {
+  return orientation.reversedEdgeIds.has(edge.id)
+    ? [edge.targetId, edge.sourceId]
+    : [edge.sourceId, edge.targetId];
+}
+
+function getComponents(input: LayeredPhaseInput, orientation: AcyclicOrientation): string[][] {
+  const adjacent = new Map(input.graph.nodes.map((node) => [node.id, [] as string[]]));
+  for (const edge of input.graph.edges) {
+    const [sourceId, targetId] = getOrientedEndpoints(edge, orientation);
+    if (sourceId === targetId) continue;
+    adjacent.get(sourceId)?.push(targetId);
+    adjacent.get(targetId)?.push(sourceId);
+  }
+  const visited = new Set<string>();
+  const components: string[][] = [];
+  for (const node of input.graph.nodes) {
+    if (visited.has(node.id)) continue;
+    const component: string[] = [];
+    visited.add(node.id);
+    const stack: Array<{ id: string; index: number }> = [{ id: node.id, index: 0 }];
+    component.push(node.id);
+    while (stack.length > 0) {
+      const frame = stack.at(-1);
+      if (!frame) break;
+      const nextId = adjacent.get(frame.id)?.[frame.index++];
+      if (nextId === undefined) {
+        stack.pop();
+      } else if (!visited.has(nextId)) {
+        visited.add(nextId);
+        component.push(nextId);
+        stack.push({ id: nextId, index: 0 });
+      }
+    }
+    if (components.length === 0 || component.length > (components[0]?.length ?? 0)) {
+      components.unshift(component);
+    } else {
+      components.push(component);
+    }
+  }
+  return components;
+}
+
+function createSimplexGraph(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  component: readonly string[],
+): { nodes: SimplexNode[]; edges: SimplexEdge[] } {
+  const memberIds = new Set(component);
+  const nodes = component.map((id, order): SimplexNode => ({
+    id,
+    order,
+    layer: 0,
+    incoming: [],
+    outgoing: [],
+    treeNode: false,
+  }));
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const edgeBySource = new Map(component.map((id) => [id, [] as GraphEdge[]]));
+  for (const edge of input.graph.edges) {
+    const [sourceId, targetId] = getOrientedEndpoints(edge, orientation);
+    if (sourceId !== targetId && memberIds.has(sourceId) && memberIds.has(targetId)) {
+      edgeBySource.get(sourceId)?.push(edge);
+    }
+  }
+  const edges: SimplexEdge[] = [];
+  for (const sourceId of component) {
+    for (const graphEdge of edgeBySource.get(sourceId) ?? []) {
+      const [orientedSourceId, targetId] = getOrientedEndpoints(graphEdge, orientation);
+      const source = nodeById.get(orientedSourceId);
+      const target = nodeById.get(targetId);
+      if (!source || !target) continue;
+      const edge: SimplexEdge = {
+        id: graphEdge.id,
+        order: edges.length,
+        source,
+        target,
+        weight: Math.max(1, input.edgeSettings?.(graphEdge)?.["priority.shortness"] ?? 1),
+        delta: 1,
+        treeEdge: false,
+      };
+      edges.push(edge);
+      source.outgoing.push(edge);
+      target.incoming.push(edge);
+    }
+  }
+  return { nodes, edges };
+}
+
+function assignInitialLayers(nodes: readonly SimplexNode[]): void {
+  const remainingIncoming = new Map(nodes.map((node) => [node, node.incoming.length]));
+  const queue = nodes.filter((node) => node.incoming.length === 0);
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node) continue;
+    for (const edge of node.outgoing) {
+      edge.target.layer = Math.max(edge.target.layer, node.layer + edge.delta);
+      const remaining = (remainingIncoming.get(edge.target) ?? 1) - 1;
+      remainingIncoming.set(edge.target, remaining);
+      if (remaining === 0) queue.push(edge.target);
+    }
+  }
+}
+
+function growTightTree(
+  nodes: readonly SimplexNode[],
+  edges: readonly SimplexEdge[],
+): SimplexEdge[] {
+  if (nodes.length === 0) return [];
+  const treeEdges: SimplexEdge[] = [];
+  const visitTight = (start: SimplexNode): number => {
+    const visitedEdges = new Set<SimplexEdge>();
+    const visit = (node: SimplexNode): number => {
+      let count = 1;
+      node.treeNode = true;
+      for (const edge of connectedEdges(node)) {
+        if (visitedEdges.has(edge)) continue;
+        visitedEdges.add(edge);
+        const opposite = otherNode(edge, node);
+        if (edge.treeEdge) {
+          count += visit(opposite);
+        } else if (!opposite.treeNode && edge.target.layer - edge.source.layer === edge.delta) {
+          edge.treeEdge = true;
+          treeEdges.push(edge);
+          count += visit(opposite);
+        }
+      }
+      return count;
+    };
+    return visit(start);
+  };
+
+  while (visitTight(nodes[0] as SimplexNode) < nodes.length) {
+    let minimumSlack = Number.POSITIVE_INFINITY;
+    let minimumEdge: SimplexEdge | undefined;
+    for (const edge of edges) {
+      if (edge.source.treeNode === edge.target.treeNode) continue;
+      const slack = edge.target.layer - edge.source.layer - edge.delta;
+      if (slack < minimumSlack) {
+        minimumSlack = slack;
+        minimumEdge = edge;
+      }
+    }
+    if (!minimumEdge) throw new Error("Network simplex could not grow a tight tree");
+    const shift = minimumEdge.target.treeNode ? -minimumSlack : minimumSlack;
+    for (const node of nodes) if (node.treeNode) node.layer += shift;
+  }
+  return treeEdges;
+}
+
+function getHeadComponent(
+  nodes: readonly SimplexNode[],
+  treeEdges: ReadonlySet<SimplexEdge>,
+  removed: SimplexEdge,
+): Set<SimplexNode> {
+  const head = new Set<SimplexNode>([removed.target]);
+  const stack = [removed.target];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    for (const edge of connectedEdges(node)) {
+      if (edge === removed || !treeEdges.has(edge)) continue;
+      const opposite = otherNode(edge, node);
+      if (!head.has(opposite)) {
+        head.add(opposite);
+        stack.push(opposite);
+      }
+    }
+  }
+  if (!head.has(removed.source)) return head;
+  const complement = new Set(nodes.filter((node) => !head.has(node)));
+  return complement;
+}
+
+function getCutValue(
+  nodes: readonly SimplexNode[],
+  edges: readonly SimplexEdge[],
+  treeEdges: ReadonlySet<SimplexEdge>,
+  edge: SimplexEdge,
+): number {
+  const head = getHeadComponent(nodes, treeEdges, edge);
+  let value = 0;
+  for (const candidate of edges) {
+    const sourceInHead = head.has(candidate.source);
+    const targetInHead = head.has(candidate.target);
+    if (!sourceInHead && targetInHead) value += candidate.weight;
+    else if (sourceInHead && !targetInHead) value -= candidate.weight;
+  }
+  return value;
+}
+
+function normalizeAndBalance(
+  nodes: readonly SimplexNode[],
+  previousLayerCounts: readonly number[] | undefined,
+): number[] {
+  const lowest = Math.min(...nodes.map((node) => node.layer));
+  const highest = Math.max(...nodes.map((node) => node.layer));
+  const filling = Array.from({ length: highest - lowest + 1 }, () => 0);
+  for (const node of nodes) {
+    node.layer -= lowest;
+    filling[node.layer] = (filling[node.layer] ?? 0) + 1;
+  }
+  for (const [layer, count] of previousLayerCounts?.entries() ?? []) {
+    if (layer >= filling.length) break;
+    filling[layer] = (filling[layer] ?? 0) + count;
+  }
+
+  for (const node of nodes) {
+    if (node.incoming.length !== node.outgoing.length) continue;
+    const minimumIncoming =
+      node.incoming.length === 0
+        ? -1
+        : Math.min(...node.incoming.map((edge) => edge.target.layer - edge.source.layer));
+    const minimumOutgoing =
+      node.outgoing.length === 0
+        ? -1
+        : Math.min(...node.outgoing.map((edge) => edge.target.layer - edge.source.layer));
+    let newLayer = node.layer;
+    for (
+      let layer = node.layer - minimumIncoming + 1;
+      layer < node.layer + minimumOutgoing;
+      layer++
+    ) {
+      if ((filling[layer] ?? Infinity) < (filling[newLayer] ?? Infinity)) newLayer = layer;
+    }
+    if ((filling[newLayer] ?? Infinity) < (filling[node.layer] ?? Infinity)) {
+      filling[node.layer] = (filling[node.layer] ?? 1) - 1;
+      filling[newLayer] = (filling[newLayer] ?? 0) + 1;
+      node.layer = newLayer;
+    }
+  }
+  return filling;
+}
+
+export function runNetworkSimplex(
+  nodes: SimplexNode[],
+  _edges: SimplexEdge[],
+  iterationLimit: number,
+  previousLayerCounts: readonly number[] | undefined,
+  balance = true,
+): number[] {
+  // ELK reindexes edges by walking each auxiliary node's outgoing list.
+  // This order decides deterministic ties in tight-tree growth and pivots.
+  const orderedEdges = nodes.flatMap((node) => node.outgoing);
+  orderedEdges.forEach((edge, index) => (edge.order = index));
+  assignInitialLayers(nodes);
+  if (orderedEdges.length > 0) {
+    const orderedTreeEdges = growTightTree(nodes, orderedEdges);
+    const treeEdges = new Set(orderedTreeEdges);
+    for (let iteration = 0; iteration < iterationLimit; iteration++) {
+      const leave = orderedTreeEdges.find(
+        (edge) => edge.treeEdge && getCutValue(nodes, orderedEdges, treeEdges, edge) < -1e-10,
+      );
+      if (!leave) break;
+      const head = getHeadComponent(nodes, treeEdges, leave);
+      let entering: SimplexEdge | undefined;
+      let minimumSlack = Number.POSITIVE_INFINITY;
+      for (const edge of orderedEdges) {
+        if (head.has(edge.source) && !head.has(edge.target)) {
+          const slack = edge.target.layer - edge.source.layer - edge.delta;
+          if (slack < minimumSlack) {
+            minimumSlack = slack;
+            entering = edge;
+          }
+        }
+      }
+      if (!entering) break;
+      leave.treeEdge = false;
+      treeEdges.delete(leave);
+      entering.treeEdge = true;
+      treeEdges.add(entering);
+      orderedTreeEdges.splice(orderedTreeEdges.indexOf(leave), 1);
+      orderedTreeEdges.push(entering);
+      let delta = entering.target.layer - entering.source.layer - entering.delta;
+      if (!head.has(entering.target)) delta = -delta;
+      for (const node of nodes) if (!head.has(node)) node.layer += delta;
+    }
+  }
+  if (balance) return normalizeAndBalance(nodes, previousLayerCounts);
+  const lowest = Math.min(...nodes.map((node) => node.layer));
+  const highest = Math.max(...nodes.map((node) => node.layer));
+  const filling = Array.from({ length: highest - lowest + 1 }, () => 0);
+  for (const node of nodes) {
+    node.layer -= lowest;
+    filling[node.layer] = (filling[node.layer] ?? 0) + 1;
+  }
+  return filling;
+}
+
+export const assignLayersWithNetworkSimplex: LayerAssigner = (input, orientation) => {
+  const components = getComponents(input, orientation);
+  const layerByNodeId = new Map<string, number>();
+  let previousLayerCounts: number[] | undefined;
+  const thoroughness = input.settings.thoroughness ?? 7;
+  for (const component of components) {
+    const { nodes, edges } = createSimplexGraph(input, orientation, component);
+    previousLayerCounts = runNetworkSimplex(
+      nodes,
+      edges,
+      thoroughness * 4 * Math.floor(Math.sqrt(nodes.length)),
+      previousLayerCounts,
+    );
+    for (const node of nodes) layerByNodeId.set(node.id, node.layer);
+  }
+  return { layerByNodeId };
+};

package/src/layered/node-promotion.ts

@@ -0,0 +1,197 @@
+import type { GraphEdge } from "@statelyai/graph";
+import type { AcyclicOrientation, LayerAssignment, LayeredPhaseInput } from "./types";
+
+function endpoints(edge: GraphEdge, orientation: AcyclicOrientation): readonly [string, string] {
+  return orientation.reversedEdgeIds.has(edge.id)
+    ? [edge.targetId, edge.sourceId]
+    : [edge.sourceId, edge.targetId];
+}
+
+function dummyCount(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  ranks: ReadonlyMap<string, number>,
+): number {
+  return input.graph.edges.reduce((total, edge) => {
+    const [source, target] = endpoints(edge, orientation);
+    return total + Math.max(0, (ranks.get(target) ?? 0) - (ranks.get(source) ?? 0) - 1);
+  }, 0);
+}
+
+function layerWidths(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  ranks: ReadonlyMap<string, number>,
+  pixels: boolean,
+): number[] {
+  const count = Math.max(0, ...ranks.values()) + 1;
+  const result = Array.from({ length: count }, () => 0);
+  for (const node of input.graph.nodes) {
+    const rank = ranks.get(node.id) ?? 0;
+    result[rank] =
+      (result[rank] ?? 0) +
+      (pixels
+        ? ((input.direction === "left" || input.direction === "right"
+            ? input.sizes.get(node.id)?.height
+            : input.sizes.get(node.id)?.width) ?? 0) + input.spacing.node
+        : 1);
+  }
+  for (const edge of input.graph.edges) {
+    const [source, target] = endpoints(edge, orientation);
+    for (let rank = (ranks.get(source) ?? 0) + 1; rank < (ranks.get(target) ?? 0); rank++) {
+      result[rank] =
+        (result[rank] ?? 0) +
+        (pixels ? Number(input.settings["spacing.edgeNodeBetweenLayers"] ?? 10) : 1);
+    }
+  }
+  return result;
+}
+
+function normalize(ranks: Map<string, number>): void {
+  const used = [...new Set(ranks.values())].sort((a, b) => a - b);
+  const normalized = new Map(used.map((rank, index) => [rank, index]));
+  for (const [id, rank] of ranks) ranks.set(id, normalized.get(rank) ?? rank);
+}
+
+/** Nikolov-style recursive promotion after phase-2 layering. */
+export function applyNodePromotion(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  assignment: LayerAssignment,
+): LayerAssignment {
+  const strategy = String(input.settings["layering.nodePromotion.strategy"] ?? "NONE");
+  if (strategy === "NONE") return assignment;
+  if (strategy === "MODEL_ORDER_LEFT_TO_RIGHT" || strategy === "MODEL_ORDER_RIGHT_TO_LEFT") {
+    return applyModelOrderPromotion(
+      input,
+      orientation,
+      assignment,
+      strategy.endsWith("LEFT_TO_RIGHT"),
+    );
+  }
+  let ranks = new Map(assignment.layerByNodeId);
+  normalize(ranks);
+  const baselineCountWidth = Math.max(...layerWidths(input, orientation, ranks, false));
+  const baselinePixelWidth = Math.max(...layerWidths(input, orientation, ranks, true));
+  const initialDummyCount = dummyCount(input, orientation, ranks);
+  const incoming = new Map(input.graph.nodes.map((node) => [node.id, [] as string[]]));
+  for (const edge of input.graph.edges) {
+    const [source, target] = endpoints(edge, orientation);
+    incoming.get(target)?.push(source);
+  }
+  const maxIterations = Number(input.settings["layering.nodePromotion.maxIterations"] ?? 0);
+  const percentageLimit =
+    strategy === "NODECOUNT_PERCENTAGE"
+      ? Math.ceil((input.graph.nodes.length * maxIterations) / 100)
+      : strategy === "DUMMYNODE_PERCENTAGE"
+        ? Math.ceil((initialDummyCount * maxIterations) / 100)
+        : Number.POSITIVE_INFINITY;
+  let iterations = 0;
+  let reduced = 0;
+  let changed: boolean;
+  do {
+    changed = false;
+    for (const node of input.graph.nodes) {
+      if ((incoming.get(node.id)?.length ?? 0) === 0) continue;
+      const candidate = new Map(ranks);
+      const visiting = new Set<string>();
+      const promote = (id: string): boolean => {
+        if (visiting.has(id)) return false;
+        visiting.add(id);
+        const next = (candidate.get(id) ?? 0) - 1;
+        if (next < 0) return false;
+        candidate.set(id, next);
+        for (const predecessor of incoming.get(id) ?? []) {
+          if ((candidate.get(predecessor) ?? 0) >= next && !promote(predecessor)) return false;
+        }
+        return true;
+      };
+      const before = dummyCount(input, orientation, ranks);
+      if (!promote(node.id)) continue;
+      normalize(candidate);
+      const after = dummyCount(input, orientation, candidate);
+      if (after >= before) continue;
+      const respectsBoundary =
+        strategy === "NIKOLOV"
+          ? Math.max(...layerWidths(input, orientation, candidate, false)) <= baselineCountWidth
+          : strategy === "NIKOLOV_PIXEL"
+            ? Math.max(...layerWidths(input, orientation, candidate, true)) <= baselinePixelWidth
+            : true;
+      if (!respectsBoundary) continue;
+      ranks = candidate;
+      reduced += before - after;
+      changed = true;
+    }
+    iterations++;
+    const belowBoundary =
+      strategy === "NODECOUNT_PERCENTAGE"
+        ? iterations < percentageLimit
+        : strategy === "DUMMYNODE_PERCENTAGE"
+          ? reduced < percentageLimit
+          : true;
+    if (!belowBoundary) break;
+  } while (changed && iterations <= input.graph.nodes.length * 2);
+  return { layerByNodeId: ranks };
+}
+
+function applyModelOrderPromotion(
+  input: LayeredPhaseInput,
+  orientation: AcyclicOrientation,
+  assignment: LayerAssignment,
+  leftToRight: boolean,
+): LayerAssignment {
+  const ranks = new Map(assignment.layerByNodeId);
+  const order = new Map(input.graph.nodes.map((node, index) => [node.id, index]));
+  const edges = input.graph.edges.map((edge) => endpoints(edge, orientation));
+  if (
+    leftToRight &&
+    (input.settings["layering.strategy"] ?? "NETWORK_SIMPLEX") === "NETWORK_SIMPLEX"
+  ) {
+    for (const [source, target] of edges) {
+      if ((order.get(source) ?? 0) <= (order.get(target) ?? 0)) continue;
+      ranks.set(target, ranks.get(source) ?? 0);
+    }
+    normalize(ranks);
+    return { layerByNodeId: ranks };
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const node of leftToRight ? input.graph.nodes : [...input.graph.nodes].reverse()) {
+      const rank = ranks.get(node.id) ?? 0;
+      const next = rank + (leftToRight ? 1 : -1);
+      if (next < 0) continue;
+      const peers = input.graph.nodes.filter(
+        (candidate) => (ranks.get(candidate.id) ?? 0) === rank,
+      );
+      const allows = peers.every((peer) =>
+        leftToRight
+          ? (order.get(peer.id) ?? 0) <= (order.get(node.id) ?? 0)
+          : (order.get(peer.id) ?? 0) >= (order.get(node.id) ?? 0),
+      );
+      if (!allows) continue;
+      const nextPeers = input.graph.nodes.filter(
+        (candidate) => (ranks.get(candidate.id) ?? 0) === next,
+      );
+      if (
+        !nextPeers.some((peer) =>
+          leftToRight
+            ? (order.get(peer.id) ?? 0) < (order.get(node.id) ?? 0)
+            : (order.get(peer.id) ?? 0) > (order.get(node.id) ?? 0),
+        )
+      )
+        continue;
+      const candidate = new Map(ranks).set(node.id, next);
+      if (
+        edges.every(
+          ([source, target]) => (candidate.get(source) ?? 0) < (candidate.get(target) ?? 0),
+        )
+      ) {
+        ranks.set(node.id, next);
+        changed = true;
+      }
+    }
+  }
+  normalize(ranks);
+  return { layerByNodeId: ranks };
+}

package/src/layered/spacing.ts

@@ -0,0 +1,37 @@
+import type { LayeredPhaseInput } from "./types";
+
+export type IndividualSpacing = Readonly<Record<string, number>>;
+
+/** ELK resolves local spacing as the maximum override on either graph element. */
+export function nodeNodeSpacing(
+  input: LayeredPhaseInput,
+  firstId: string,
+  secondId: string,
+): number {
+  const firstBreakingPoint = firstId.startsWith("__layout_breaking:");
+  const secondBreakingPoint = secondId.startsWith("__layout_breaking:");
+  const firstDummy = firstId.startsWith("__layout_dummy:") || firstBreakingPoint;
+  const secondDummy = secondId.startsWith("__layout_dummy:") || secondBreakingPoint;
+  const spacingName =
+    firstDummy && secondDummy && firstBreakingPoint === secondBreakingPoint
+      ? "spacing.edgeEdge"
+      : firstDummy || secondDummy
+        ? "spacing.edgeNode"
+        : "spacing.node";
+  let spacing =
+    spacingName === "spacing.edgeEdge"
+      ? Number(input.settings["spacing.edgeEdge"] ?? 10)
+      : spacingName === "spacing.edgeNode"
+        ? Number(input.settings["spacing.edgeNode"] ?? 10)
+        : input.spacing.node;
+  for (const id of [firstId, secondId]) {
+    const node = input.graph.nodes.find((candidate) => candidate.id === id);
+    if (!node) continue;
+    const individual = input.nodeSettings?.(node)?.["spacing.individual"];
+    if (individual && typeof individual === "object") {
+      const value = (individual as IndividualSpacing)[spacingName];
+      if (typeof value === "number" && Number.isFinite(value)) spacing = Math.max(spacing, value);
+    }
+  }
+  return spacing;
+}

package/src/layered/spline-bezier.ts

@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * Copyright (c) 2014, 2018 Kiel University and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { Point } from "@statelyai/graph";
+
+function interpolate(left: Point, right: Point, ratio: number): Point {
+  return {
+    x: (1 - ratio) * left.x + ratio * right.x,
+    y: (1 - ratio) * left.y + ratio * right.y,
+  };
+}
+
+/** Convert ELK's clamped uniform cubic NUB spline to equivalent Bezier control points. */
+export function uniformCubicSplineToBezier(values: readonly Point[]): Point[] {
+  const points = values.map((point) => ({ ...point }));
+  while (points.length < 4) points.unshift({ ...points[0]! });
+  const degree = 3;
+  const segmentCount = points.length - degree;
+  let knots = [
+    ...Array.from({ length: degree + 1 }, () => 0),
+    ...Array.from(
+      { length: Math.max(0, segmentCount - 1) },
+      (_, index) => (index + 1) / segmentCount,
+    ),
+    ...Array.from({ length: degree + 1 }, () => 1),
+  ];
+
+  const insertKnot = (knot: number) => {
+    const nodeCount = points.length - 1;
+    let span = nodeCount;
+    for (let index = degree; index <= nodeCount; index++) {
+      if (knot >= knots[index]! && knot < knots[index + 1]!) {
+        span = index;
+        break;
+      }
+    }
+    const multiplicity = knots.filter((candidate) => Math.abs(candidate - knot) < 1e-6).length;
+    const next = Array.from({ length: points.length + 1 }, () => ({ x: 0, y: 0 }));
+    for (let index = 0; index <= span - degree; index++) next[index] = points[index]!;
+    for (let index = span - multiplicity; index <= nodeCount; index++) {
+      next[index + 1] = points[index]!;
+    }
+    for (let index = span - degree + 1; index <= span - multiplicity; index++) {
+      const ratio = (knot - knots[index]!) / (knots[index + degree]! - knots[index]!);
+      next[index] = interpolate(points[index - 1]!, points[index]!, ratio);
+    }
+    points.splice(0, points.length, ...next);
+    knots = [...knots.slice(0, span + 1), knot, ...knots.slice(span + 1)];
+  };
+
+  for (let segment = 1; segment < segmentCount; segment++) {
+    const knot = segment / segmentCount;
+    for (let insertion = 1; insertion < degree; insertion++) insertKnot(knot);
+  }
+  return points;
+}
+
+function absMin(first: number, second: number): number {
+  return Math.abs(first) < Math.abs(second) ? first : second;
+}
+
+export function conservativeSpline(
+  start: Point,
+  end: Point,
+  track: number,
+  horizontal: boolean,
+  softenNodeAttachments: boolean,
+): Point[] {
+  const sourceCross = horizontal ? start.y : start.x;
+  const targetCross = horizontal ? end.y : end.x;
+  const straight = Math.abs(sourceCross - targetCross) < 1e-6;
+  const controlPoints = straight
+    ? [{ ...start }, { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 }, { ...end }]
+    : [
+        { ...start },
+        { ...start },
+        horizontal ? { x: track, y: start.y } : { x: start.x, y: track },
+        horizontal ? { x: track, y: end.y } : { x: end.x, y: track },
+        { ...end },
+        { ...end },
+      ];
+  if (!softenNodeAttachments) {
+    const flowSign = Math.sign(horizontal ? end.x - start.x : end.y - start.y) || 1;
+    const second = controlPoints[1]!;
+    controlPoints.splice(1, 0, {
+      x: start.x + absMin(horizontal ? flowSign * 5 : 0, second.x - start.x),
+      y: start.y + absMin(horizontal ? 0 : flowSign * 5, second.y - start.y),
+    });
+    const secondLast = controlPoints.at(-2)!;
+    controlPoints.splice(-1, 0, {
+      x: end.x + absMin(horizontal ? -flowSign * 5 : 0, secondLast.x - end.x),
+      y: end.y + absMin(horizontal ? 0 : -flowSign * 5, secondLast.y - end.y),
+    });
+  }
+  return uniformCubicSplineToBezier(controlPoints);
+}