@statelyai/layout 0.0.1 → 0.0.3

package/src/elkjs/types.ts

@@ -0,0 +1,103 @@
+export type ElkId = string | number;
+
+export interface ElkGraphElement {
+  id?: ElkId;
+  layoutOptions?: Record<string, unknown>;
+  properties?: Record<string, unknown>;
+}
+
+export interface ElkPoint {
+  x: number;
+  y: number;
+}
+
+export interface ElkShape extends ElkGraphElement {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+}
+
+export interface ElkLabel extends ElkShape {
+  text?: string;
+}
+
+export interface ElkPort extends ElkShape {
+  labels?: ElkLabel[];
+}
+
+export interface ElkEdgeSection extends ElkGraphElement {
+  startPoint: ElkPoint;
+  endPoint: ElkPoint;
+  bendPoints?: ElkPoint[];
+  incomingShape?: ElkId;
+  outgoingShape?: ElkId;
+}
+
+export interface ElkEdge extends ElkGraphElement {
+  sources?: ElkId[];
+  targets?: ElkId[];
+  source?: ElkId;
+  target?: ElkId;
+  sourcePort?: ElkId;
+  targetPort?: ElkId;
+  labels?: ElkLabel[];
+  sections?: ElkEdgeSection[];
+  junctionPoints?: ElkPoint[];
+}
+
+export interface ElkNode extends ElkShape {
+  labels?: ElkLabel[];
+  ports?: ElkPort[];
+  children?: ElkNode[];
+  edges?: ElkEdge[];
+  logging?: ElkLogging;
+}
+
+export interface ElkLogging {
+  name?: string;
+  executionTime?: number;
+  logs?: string[];
+  children?: ElkLogging[];
+}
+
+export interface ElkLayoutArguments {
+  layoutOptions?: Record<string, unknown>;
+  logging?: boolean;
+  measureExecutionTime?: boolean;
+}
+
+export interface ElkConstructorArguments {
+  defaultLayoutOptions?: Record<string, unknown>;
+  algorithms?: string[];
+  workerUrl?: string;
+  workerFactory?: (url?: string) => unknown;
+}
+
+export interface ElkCommonDescription {
+  id?: string;
+  name?: string;
+  description?: string;
+}
+
+export interface ElkLayoutAlgorithmDescription extends ElkCommonDescription {
+  category?: string;
+  knownOptions?: string[];
+  supportedFeatures?: string[];
+}
+
+export interface ElkLayoutOptionDescription extends ElkCommonDescription {
+  group?: string;
+  type?: string;
+  targets?: string[];
+}
+
+export interface ElkLayoutCategoryDescription extends ElkCommonDescription {
+  knownLayouters?: string[];
+}
+
+export type LaidOutElkNode<T extends ElkNode> = Omit<T, "children" | "edges"> &
+  Omit<ElkNode, "children" | "edges"> & {
+    children?: Array<NonNullable<T["children"]>[number] & ElkNode>;
+    edges?: Array<NonNullable<T["edges"]>[number] & ElkEdge>;
+  };

package/src/errors.ts

@@ -0,0 +1,16 @@
+export class LayoutError extends Error {
+  constructor(
+    message: string,
+    readonly code: string,
+  ) {
+    super(message);
+    this.name = "LayoutError";
+  }
+}
+
+export class UnsupportedLayoutError extends LayoutError {
+  constructor(message: string) {
+    super(message, "UNSUPPORTED_LAYOUT");
+    this.name = "UnsupportedLayoutError";
+  }
+}

package/src/fixed.ts

@@ -0,0 +1,80 @@
+import type { Graph, Point, VisualGraph, VisualNode } from "@statelyai/graph";
+import { getNodeSize, type LayoutOptions } from "@statelyai/graph/layout";
+import { getPolylineMidpoint, placePorts } from "./layered/strategies";
+import type { LayoutAlgorithm } from "./types";
+
+export interface FixedLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {}
+
+function defaultRoute(source: VisualNode, target: VisualNode): Point[] {
+  return [
+    {
+      x: source.x + source.width / 2,
+      y: source.y + source.height / 2,
+    },
+    {
+      x: target.x + target.width / 2,
+      y: target.y + target.height / 2,
+    },
+  ];
+}
+
+/** Preserve authored positions and routes while completing visual geometry. */
+export function getFixedLayout<N, E, G, P>(
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>,
+  options: FixedLayoutOptions = {},
+): VisualGraph<N, E, G, P> {
+  const direction = options.direction ?? graph.direction ?? "down";
+  const nodes = graph.nodes.map((node): VisualNode<N, P> => {
+    const size = getNodeSize(node, options);
+    const rect = {
+      x: node.x ?? 0,
+      y: node.y ?? 0,
+      ...size,
+    };
+    const ports = placePorts(node.ports, rect, direction);
+    return {
+      ...node,
+      ...rect,
+      ...(ports === undefined ? {} : { ports }),
+    } as VisualNode<N, P>;
+  });
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const edges = graph.edges.map((edge) => {
+    const source = nodeById.get(edge.sourceId);
+    const target = nodeById.get(edge.targetId);
+    const points = edge.points
+      ? [...edge.points]
+      : source && target
+        ? defaultRoute(source, target)
+        : [];
+    const midpoint = getPolylineMidpoint(points);
+    const width = edge.width ?? 0;
+    const height = edge.height ?? 0;
+    return {
+      ...edge,
+      x: edge.x ?? midpoint.x - width / 2,
+      y: edge.y ?? midpoint.y - height / 2,
+      width,
+      height,
+      points,
+      routing: edge.routing ?? ("polyline" as const),
+    };
+  });
+
+  return { ...graph, direction, nodes, edges };
+}
+
+export const fixedAlgorithm: LayoutAlgorithm<FixedLayoutOptions> = {
+  id: "fixed",
+  capabilities: {
+    full: true,
+    incremental: false,
+    partial: false,
+    routeOnly: false,
+    hierarchy: true,
+    ports: true,
+  },
+  layout(graph, options) {
+    return getFixedLayout(graph, options ?? {});
+  },
+};

package/src/index.ts

@@ -0,0 +1,92 @@
+export { LayoutError, UnsupportedLayoutError } from "./errors";
+export { boxAlgorithm, getBoxLayout } from "./box";
+export type { BoxLayoutOptions } from "./box";
+export { fixedAlgorithm, getFixedLayout } from "./fixed";
+export type { FixedLayoutOptions } from "./fixed";
+export { getRectanglePackingLayout, rectanglePackingAlgorithm } from "./packing";
+export type { RectanglePackingLayoutOptions } from "./packing";
+export { getRandomLayout, randomAlgorithm } from "./random";
+export type { RandomLayoutOptions } from "./random";
+export {
+  getSporeCompactionLayout,
+  getSporeOverlapRemovalLayout,
+  sporeCompactionAlgorithm,
+  sporeOverlapRemovalAlgorithm,
+} from "./spore";
+export type { SporeLayoutOptions } from "./spore";
+export { getLayout, getLayoutAlgorithm, registerLayoutAlgorithm } from "./layout";
+export {
+  assignLayersByLongestPath,
+  assignLayersByLongestPathToSink,
+  assignLayersByBreadthFirstModelOrder,
+  assignLayersByDepthFirstModelOrder,
+  assignLayersInteractively,
+  assignLayersWithCoffmanGraham,
+  assignLayersWithNetworkSimplex,
+  assignLayersWithMinWidth,
+  assignLayersWithStretchWidth,
+  breakCyclesByModelOrder,
+  breakCyclesByStronglyConnectedConnectivity,
+  breakCyclesByStronglyConnectedNodeType,
+  breakCyclesWithDepthFirstSearch,
+  breakCyclesGreedily,
+  breakCyclesGreedilyByModelOrder,
+  breakCyclesInteractively,
+  breakCyclesWithModelOrderDepthFirstSearch,
+  breakCyclesWithModelOrderBreadthFirstSearch,
+  getLayeredLayout,
+  layeredAlgorithm,
+  minimizeCrossingsWithBarycenter,
+  minimizeCrossingsWithMedian,
+  minimizeCrossingsInteractively,
+  minimizeCrossingsWithModelOrder,
+  placeNodesInLayers,
+  placeNodesInteractively,
+  routeEdgesOrthogonally,
+  routeEdgesWithPolylines,
+  routeEdgesWithSplines,
+  elkLayeredEnumValues,
+  elkLayeredOptionDefinitions,
+  fromElkLayeredOptionId,
+  toElkLayeredOptions,
+} from "./layered";
+export type {
+  AnyGraph,
+  LayoutAlgorithm,
+  LayoutCapabilities,
+  LayoutDiagnostic,
+  LayoutDirection,
+  LayoutExecutionContext,
+  LayoutMetrics,
+  LayoutPhaseMetrics,
+  LayoutRequest,
+  LayoutResult,
+  LayoutScope,
+} from "./types";
+export type {
+  AcyclicOrientation,
+  CrossingMinimizer,
+  CycleBreaker,
+  EdgeRouter,
+  EdgeRoutes,
+  LayerAssigner,
+  LayerAssignment,
+  LayeredLayoutOptions,
+  LayeredAdvancedOptions,
+  ElkLayeredOptionId,
+  ElkLayeredOptionName,
+  ElkLayeredOptionValueByName,
+  CycleBreakingStrategy,
+  CrossingMinimizationStrategy,
+  EdgeRoutingStyle,
+  LayeringStrategy,
+  NodePlacementStrategy,
+  LayeredPhaseInput,
+  LayeredSpacing,
+  LayeredStrategies,
+  LayoutPadding,
+  LayerOrder,
+  NodePlacement,
+  NodePlacer,
+  NodeSize,
+} from "./layered";

package/src/java-random.ts

@@ -0,0 +1,46 @@
+/** Java's 48-bit `java.util.Random`, used by ELK for seeded tie-breaking. */
+export class JavaRandom {
+  static readonly #multiplier = 0x5deece66dn;
+  static readonly #addend = 0xbn;
+  static readonly #mask = (1n << 48n) - 1n;
+  #seed: bigint;
+
+  constructor(seed: number | bigint) {
+    this.#seed = (BigInt(seed) ^ JavaRandom.#multiplier) & JavaRandom.#mask;
+  }
+
+  #next(bits: number): number {
+    this.#seed = (this.#seed * JavaRandom.#multiplier + JavaRandom.#addend) & JavaRandom.#mask;
+    return Number(this.#seed >> BigInt(48 - bits));
+  }
+
+  nextDouble(): number {
+    return (this.#next(26) * 2 ** 27 + this.#next(27)) / 2 ** 53;
+  }
+
+  nextFloat(): number {
+    return this.#next(24) / 2 ** 24;
+  }
+
+  nextBoolean(): boolean {
+    return this.#next(1) !== 0;
+  }
+
+  nextLong(): bigint {
+    const high = BigInt.asIntN(32, BigInt(this.#next(32)));
+    const low = BigInt.asIntN(32, BigInt(this.#next(32)));
+    return BigInt.asIntN(64, (high << 32n) + low);
+  }
+
+  nextInt(bound: number): number {
+    if (bound <= 0) throw new RangeError("bound must be positive");
+    if ((bound & -bound) === bound) return Math.floor((bound * this.#next(31)) / 2 ** 31);
+    let bits: number;
+    let value: number;
+    do {
+      bits = this.#next(31);
+      value = bits % bound;
+    } while (bits - value + (bound - 1) >= 2 ** 31);
+    return value;
+  }
+}