@statelyai/layout 0.0.0 → 0.0.2

package/src/spore.ts

@@ -0,0 +1,103 @@
+import type { Graph, VisualGraph, VisualNode } from "@statelyai/graph";
+import { getNodeSize, type LayoutOptions } from "@statelyai/graph/layout";
+import { getFixedLayout } from "./fixed";
+import type { LayoutPadding } from "./layered";
+import type { LayoutAlgorithm } from "./types";
+
+export interface SporeLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {
+  spacing?: number;
+  padding?: number | Partial<LayoutPadding>;
+}
+
+function getPadding(value: SporeLayoutOptions["padding"]): LayoutPadding {
+  if (typeof value === "number") {
+    return { top: value, right: value, bottom: value, left: value };
+  }
+  return {
+    top: value?.top ?? 0,
+    right: value?.right ?? 0,
+    bottom: value?.bottom ?? 0,
+    left: value?.left ?? 0,
+  };
+}
+
+function getSporeLayout<N, E, G, P>(
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>,
+  options: SporeLayoutOptions,
+  compact: boolean,
+): VisualGraph<N, E, G, P> {
+  const spacing = options.spacing ?? 20;
+  const padding = getPadding(options.padding);
+  const nodes: VisualNode<N, P>[] = [];
+
+  graph.nodes.forEach((node, index) => {
+    const size = getNodeSize(node, options);
+    const previous = graph.nodes[index - 1];
+    const placedPrevious = nodes[index - 1];
+    if (!previous || !placedPrevious) {
+      nodes.push({
+        ...node,
+        x: padding.left,
+        y: padding.top,
+        ...size,
+      } as VisualNode<N, P>);
+      return;
+    }
+    const deltaX = (node.x ?? 0) - (previous.x ?? 0);
+    const deltaY = (node.y ?? 0) - (previous.y ?? 0);
+    const requiredX = placedPrevious.width + spacing;
+    const requiredY = placedPrevious.height + spacing;
+    const distance = (delta: number, required: number): number => {
+      if (delta === 0) return 0;
+      const magnitude = compact ? required : Math.max(Math.abs(delta), required);
+      return Math.sign(delta) * magnitude;
+    };
+    nodes.push({
+      ...node,
+      x: placedPrevious.x + distance(deltaX, requiredX),
+      y: placedPrevious.y + distance(deltaY, requiredY),
+      ...size,
+    } as VisualNode<N, P>);
+  });
+
+  return getFixedLayout({ ...graph, nodes }, { direction: options.direction ?? graph.direction });
+}
+
+/** Compact an existing layout while preserving its relative directions. */
+export function getSporeCompactionLayout<N, E, G, P>(
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>,
+  options: SporeLayoutOptions = {},
+): VisualGraph<N, E, G, P> {
+  return getSporeLayout(graph, options, true);
+}
+
+/** Remove overlap while preserving existing distances that already fit. */
+export function getSporeOverlapRemovalLayout<N, E, G, P>(
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>,
+  options: SporeLayoutOptions = {},
+): VisualGraph<N, E, G, P> {
+  return getSporeLayout(graph, options, false);
+}
+
+function algorithm(
+  id: "sporeCompaction" | "sporeOverlap",
+  compact: boolean,
+): LayoutAlgorithm<SporeLayoutOptions> {
+  return {
+    id,
+    capabilities: {
+      full: true,
+      incremental: false,
+      partial: false,
+      routeOnly: false,
+      hierarchy: false,
+      ports: true,
+    },
+    layout(graph, options) {
+      return getSporeLayout(graph, options ?? {}, compact);
+    },
+  };
+}
+
+export const sporeCompactionAlgorithm = algorithm("sporeCompaction", true);
+export const sporeOverlapRemovalAlgorithm = algorithm("sporeOverlap", false);

package/src/types.ts

@@ -0,0 +1,84 @@
+import type { Graph, GraphPatch, VisualGraph } from "@statelyai/graph";
+
+export type AnyGraph = Graph<unknown, unknown, unknown, unknown>;
+
+export type LayoutDirection = "up" | "down" | "left" | "right";
+
+export type LayoutScope =
+  | { mode: "full" }
+  | {
+      mode: "incremental";
+      previous: VisualGraph;
+    }
+  | {
+      mode: "partial";
+      previous: VisualGraph;
+      nodeIds: readonly string[];
+    }
+  | {
+      mode: "route-only";
+      previous: VisualGraph;
+      edgeIds?: readonly string[];
+    };
+
+export interface LayoutDiagnostic {
+  severity: "info" | "warning" | "error";
+  code: string;
+  message: string;
+  entityIds?: readonly string[];
+  phase?: string;
+}
+
+export interface LayoutPhaseMetrics {
+  id: string;
+  durationMs: number;
+}
+
+export interface LayoutMetrics {
+  durationMs: number;
+  nodeCount: number;
+  edgeCount: number;
+  phases: readonly LayoutPhaseMetrics[];
+}
+
+export interface LayoutCapabilities {
+  full: boolean;
+  incremental: boolean;
+  partial: boolean;
+  routeOnly: boolean;
+  hierarchy: boolean;
+  ports: boolean;
+}
+
+export interface LayoutAlgorithm<Options = unknown> {
+  readonly id: string;
+  readonly capabilities: LayoutCapabilities;
+  layout<N, E, G, P>(
+    graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>,
+    options: Options,
+    context: LayoutExecutionContext,
+  ): VisualGraph<N, E, G, P> | Promise<VisualGraph<N, E, G, P>>;
+}
+
+export interface LayoutExecutionContext {
+  readonly scope: LayoutScope;
+  readonly signal?: AbortSignal;
+  readonly diagnostics: LayoutDiagnostic[];
+  measurePhase<T>(id: string, run: () => T): T;
+  throwIfAborted(): void;
+}
+
+export interface LayoutRequest<N = unknown, E = unknown, G = unknown, P = unknown, O = unknown> {
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>;
+  algorithm?: string | LayoutAlgorithm<O>;
+  options?: O;
+  scope?: LayoutScope;
+  signal?: AbortSignal;
+}
+
+export interface LayoutResult<N = unknown, E = unknown, G = unknown, P = unknown> {
+  graph: VisualGraph<N, E, G, P>;
+  patches: readonly GraphPatch<N, E>[];
+  diagnostics: readonly LayoutDiagnostic[];
+  metrics: LayoutMetrics;
+}

package/dist/index-v0P1Ake8.d.mts

@@ -1,149 +0,0 @@
-import { LayoutConstraints } from "@statelyai/graph/layout";
-import { EntityRect, Graph, GraphNode, GraphPatch, Point, VisualGraph } from "@statelyai/graph";
-
-//#region src/types.d.ts
-type AnyGraph = Graph<unknown, unknown, unknown, unknown>;
-type LayoutDirection = "up" | "down" | "left" | "right";
-type LayoutScope = {
-  mode: "full";
-} | {
-  mode: "incremental";
-  previous: VisualGraph;
-} | {
-  mode: "partial";
-  previous: VisualGraph;
-  nodeIds: readonly string[];
-} | {
-  mode: "route-only";
-  previous: VisualGraph;
-  edgeIds?: readonly string[];
-};
-interface LayoutDiagnostic {
-  severity: "info" | "warning" | "error";
-  code: string;
-  message: string;
-  entityIds?: readonly string[];
-  phase?: string;
-}
-interface LayoutPhaseMetrics {
-  id: string;
-  durationMs: number;
-}
-interface LayoutMetrics {
-  durationMs: number;
-  nodeCount: number;
-  edgeCount: number;
-  phases: readonly LayoutPhaseMetrics[];
-}
-interface LayoutCapabilities {
-  full: boolean;
-  incremental: boolean;
-  partial: boolean;
-  routeOnly: boolean;
-  hierarchy: boolean;
-  ports: boolean;
-}
-interface LayoutAlgorithm<Options = unknown> {
-  readonly id: string;
-  readonly capabilities: LayoutCapabilities;
-  layout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options: Options, context: LayoutExecutionContext): VisualGraph<N, E, G, P> | Promise<VisualGraph<N, E, G, P>>;
-}
-interface LayoutExecutionContext {
-  readonly scope: LayoutScope;
-  readonly signal?: AbortSignal;
-  readonly diagnostics: LayoutDiagnostic[];
-  measurePhase<T>(id: string, run: () => T): T;
-  throwIfAborted(): void;
-}
-interface LayoutRequest<N = unknown, E = unknown, G = unknown, P = unknown, O = unknown> {
-  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>;
-  algorithm?: string | LayoutAlgorithm<O>;
-  options?: O;
-  scope?: LayoutScope;
-  signal?: AbortSignal;
-}
-interface LayoutResult<N = unknown, E = unknown, G = unknown, P = unknown> {
-  graph: VisualGraph<N, E, G, P>;
-  patches: readonly GraphPatch<N, E>[];
-  diagnostics: readonly LayoutDiagnostic[];
-  metrics: LayoutMetrics;
-}
-//#endregion
-//#region src/layered/types.d.ts
-interface NodeSize {
-  width: number;
-  height: number;
-}
-interface LayeredSpacing {
-  node: number;
-  layer: number;
-}
-interface LayoutPadding {
-  top: number;
-  right: number;
-  bottom: number;
-  left: number;
-}
-interface LayeredPhaseInput {
-  graph: Graph<unknown, unknown, unknown, unknown>;
-  sizes: ReadonlyMap<string, NodeSize>;
-  direction: LayoutDirection;
-  spacing: LayeredSpacing;
-  padding: LayoutPadding;
-  constrainedLayerByNodeId: ReadonlyMap<string, number>;
-}
-interface AcyclicOrientation {
-  reversedEdgeIds: ReadonlySet<string>;
-}
-interface LayerAssignment {
-  layerByNodeId: ReadonlyMap<string, number>;
-}
-interface LayerOrder {
-  layers: readonly (readonly string[])[];
-}
-interface NodePlacement {
-  rectByNodeId: ReadonlyMap<string, EntityRect>;
-}
-interface EdgeRoutes {
-  pointsByEdgeId: ReadonlyMap<string, readonly Point[]>;
-}
-type CycleBreaker = (input: LayeredPhaseInput) => AcyclicOrientation;
-type LayerAssigner = (input: LayeredPhaseInput, orientation: AcyclicOrientation) => LayerAssignment;
-type CrossingMinimizer = (input: LayeredPhaseInput, orientation: AcyclicOrientation, assignment: LayerAssignment) => LayerOrder;
-type NodePlacer = (input: LayeredPhaseInput, order: LayerOrder) => NodePlacement;
-type EdgeRouter = (input: LayeredPhaseInput, orientation: AcyclicOrientation, placement: NodePlacement) => EdgeRoutes;
-interface LayeredStrategies {
-  breakCycles?: CycleBreaker;
-  assignLayers?: LayerAssigner;
-  minimizeCrossings?: CrossingMinimizer;
-  placeNodes?: NodePlacer;
-  routeEdges?: EdgeRouter;
-}
-interface LayeredLayoutOptions {
-  direction?: LayoutDirection;
-  spacing?: Partial<LayeredSpacing>;
-  padding?: number | Partial<LayoutPadding>;
-  constraints?: LayoutConstraints;
-  measure?: (node: GraphNode) => NodeSize;
-  crossingSweeps?: number;
-  strategies?: LayeredStrategies;
-}
-//#endregion
-//#region src/layered/strategies.d.ts
-declare const breakCyclesWithDepthFirstSearch: CycleBreaker;
-declare const assignLayersByLongestPath: LayerAssigner;
-declare function minimizeCrossingsWithBarycenter(sweeps?: number): CrossingMinimizer;
-declare const placeNodesInLayers: NodePlacer;
-declare const routeEdgesOrthogonally: EdgeRouter;
-//#endregion
-//#region src/layered/index.d.ts
-/**
- * Deterministic native layered layout for an `@statelyai/graph` graph.
- *
- * This initial vertical slice supports flat graphs, cycles, ports, self-loops,
- * four directions, custom phase strategies, and orthogonal routes.
- */
-declare function getLayeredLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: LayeredLayoutOptions): VisualGraph<N, E, G, P>;
-declare const layeredAlgorithm: LayoutAlgorithm<LayeredLayoutOptions>;
-//#endregion
-export { LayoutMetrics as A, NodeSize as C, LayoutDiagnostic as D, LayoutCapabilities as E, LayoutRequest as M, LayoutResult as N, LayoutDirection as O, LayoutScope as P, NodePlacer as S, LayoutAlgorithm as T, LayeredPhaseInput as _, minimizeCrossingsWithBarycenter as a, LayoutPadding as b, AcyclicOrientation as c, EdgeRouter as d, EdgeRoutes as f, LayeredLayoutOptions as g, LayerOrder as h, breakCyclesWithDepthFirstSearch as i, LayoutPhaseMetrics as j, LayoutExecutionContext as k, CrossingMinimizer as l, LayerAssignment as m, layeredAlgorithm as n, placeNodesInLayers as o, LayerAssigner as p, assignLayersByLongestPath as r, routeEdgesOrthogonally as s, getLayeredLayout as t, CycleBreaker as u, LayeredSpacing as v, AnyGraph as w, NodePlacement as x, LayeredStrategies as y };