@statelyai/layout 0.1.3 → 0.3.0

package/dist/index-BEA_pzeT.d.cts

@@ -0,0 +1,72 @@
+import { a as RouteBounds, c as RoutePath, l as RoutePoint, n as NativeRoutingStrategy, r as Route, s as RoutePatch } from "./types-uxPlGRof.cjs";
+import { GraphPatch, VisualGraph } from "@statelyai/graph";
+
+//#region src/routing/engine.d.ts
+declare function applyRoutePatches(routes: ReadonlyMap<string, Route>, patches: readonly RoutePatch[]): ReadonlyMap<string, Route>;
+//#endregion
+//#region src/routing/path.d.ts
+declare function pathFromPoints(points: readonly RoutePoint[]): RoutePath;
+interface FlattenPathOptions {
+  readonly tolerance?: number;
+  readonly maxSegments?: number;
+}
+/** Adaptive, bounded-error polyline approximation. Throws rather than silently exceeding tolerance. */
+declare function flattenPath(path: RoutePath, options?: FlattenPathOptions): RoutePoint[];
+/** Conservative bounds: control hulls and full ellipse envelopes contain every curve. */
+declare function getPathBounds(path: RoutePath): RouteBounds;
+declare function getPathLength(path: RoutePath, options?: FlattenPathOptions): number;
+declare function getPointAtLength(path: RoutePath, length: number, options?: FlattenPathOptions): RoutePoint;
+declare function getTangentAtLength(path: RoutePath, length: number, options?: FlattenPathOptions): RoutePoint;
+/** Round line-to-line corners only; existing curves and path endpoints are retained. */
+declare function roundCorners(path: RoutePath, options: {
+  readonly radius: number;
+}): RoutePath;
+declare function toSvgPath(path: RoutePath, options?: {
+  readonly radius?: number;
+  readonly precision?: number;
+}): string;
+//#endregion
+//#region src/routing/adapters.d.ts
+/** ELK/native spline output: start, then repeating control1/control2/end triples. */
+declare function pathFromSplinePoints(points: readonly RoutePoint[]): RoutePath;
+/** Normalize routes from any native layout algorithm, without running layout again. */
+declare function getLayoutRoutes(graph: VisualGraph): ReadonlyMap<string, Route>;
+/** One polyline per section preserves label gaps and branching for simple renderers. */
+declare function routeToPolylines(route: Route, options?: {
+  readonly tolerance?: number;
+}): readonly (readonly RoutePoint[])[];
+/** Compatibility for single-section native consumers. Refuses to erase gaps or topology. */
+declare function routeToGraphPatch(route: Route, options?: {
+  readonly tolerance?: number;
+  readonly offset?: RoutePoint;
+}): GraphPatch;
+//#endregion
+//#region src/routing/index.d.ts
+declare const straightRouting: NativeRoutingStrategy;
+declare const bezierRouting: NativeRoutingStrategy;
+declare const orthogonalRouting: NativeRoutingStrategy;
+declare const polylineRouting: NativeRoutingStrategy;
+declare const octilinearRouting: NativeRoutingStrategy;
+declare const curvedRouting: NativeRoutingStrategy;
+declare const organicRouting: NativeRoutingStrategy;
+declare const parallelRouting: NativeRoutingStrategy;
+declare const selfLoopRouting: NativeRoutingStrategy;
+declare const fanRouting: NativeRoutingStrategy;
+declare const busRouting: NativeRoutingStrategy;
+declare const bundleRouting: NativeRoutingStrategy;
+declare const routingStrategies: Readonly<{
+  straight: NativeRoutingStrategy;
+  bezier: NativeRoutingStrategy;
+  orthogonal: NativeRoutingStrategy;
+  polyline: NativeRoutingStrategy;
+  octilinear: NativeRoutingStrategy;
+  curved: NativeRoutingStrategy;
+  organic: NativeRoutingStrategy;
+  parallel: NativeRoutingStrategy;
+  "self-loop": NativeRoutingStrategy;
+  fan: NativeRoutingStrategy;
+  bus: NativeRoutingStrategy;
+  bundle: NativeRoutingStrategy;
+}>;
+//#endregion
+export { getTangentAtLength as C, applyRoutePatches as D, toSvgPath as E, getPointAtLength as S, roundCorners as T, routeToPolylines as _, fanRouting as a, getPathBounds as b, orthogonalRouting as c, routingStrategies as d, selfLoopRouting as f, routeToGraphPatch as g, pathFromSplinePoints as h, curvedRouting as i, parallelRouting as l, getLayoutRoutes as m, bundleRouting as n, octilinearRouting as o, straightRouting as p, busRouting as r, organicRouting as s, bezierRouting as t, polylineRouting as u, FlattenPathOptions as v, pathFromPoints as w, getPathLength as x, flattenPath as y };

package/dist/{index-8xYkohbz.d.mts → index-D9dhxrRl.d.cts}

@@ -1,6 +1,67 @@
-import { LayoutConstraints } from "@statelyai/graph/layout";
+import { r as Route } from "./types-uxPlGRof.cjs";
 import { EntityRect, Graph, GraphEdge, GraphNode, GraphPatch, GraphPort, Point, VisualGraph } from "@statelyai/graph";
+import { LayoutConstraints } from "@statelyai/graph/layout";
 
+//#region src/constraints.d.ts
+type GeometryReference = {
+  nodeId: string;
+} | {
+  edgeId: string;
+  part: "label";
+};
+type ConstraintStrength = "required" | "strong" | "medium" | "weak";
+type GeometryAttribute = "x" | "y" | "centerX" | "centerY" | "right" | "bottom";
+interface ConstraintBase {
+  id: string;
+  strength?: ConstraintStrength;
+}
+interface AlignConstraint extends ConstraintBase {
+  kind: "align";
+  entities: readonly GeometryReference[];
+  axis: "x" | "y";
+  anchor?: "start" | "center" | "end";
+}
+interface DistributeConstraint extends ConstraintBase {
+  kind: "distribute";
+  entities: readonly GeometryReference[];
+  axis: "x" | "y";
+  spacing?: "gaps" | "centers";
+  gap?: number;
+}
+interface PinConstraint extends ConstraintBase {
+  kind: "pin";
+  entity: GeometryReference;
+  x?: number;
+  y?: number;
+}
+interface LinearConstraint extends ConstraintBase {
+  kind: "linear";
+  terms: readonly {
+    entity: GeometryReference;
+    attribute: GeometryAttribute;
+    coefficient: number;
+  }[];
+  relation: "eq" | "le" | "ge";
+  value: number;
+}
+interface WaypointConstraint extends ConstraintBase {
+  kind: "waypoint";
+  edgeId: string;
+  point: {
+    x: number;
+    y: number;
+  };
+}
+type LayoutConstraint = AlignConstraint | DistributeConstraint | PinConstraint | LinearConstraint | WaypointConstraint;
+/** Serializable constraint constructors; graph geometry stays in @statelyai/graph. */
+declare const c: {
+  align: (value: Omit<AlignConstraint, "kind">) => AlignConstraint;
+  distribute: (value: Omit<DistributeConstraint, "kind">) => DistributeConstraint;
+  pin: (value: Omit<PinConstraint, "kind">) => PinConstraint;
+  linear: (value: Omit<LinearConstraint, "kind">) => LinearConstraint;
+  waypoint: (value: Omit<WaypointConstraint, "kind">) => WaypointConstraint;
+};
+//#endregion
 //#region src/types.d.ts
 type AnyGraph = Graph<unknown, unknown, unknown, unknown>;
 type LayoutDirection = "up" | "down" | "left" | "right";
@@ -11,8 +72,16 @@ type LayoutScope = {
   previous: VisualGraph;
 } | {
   mode: "partial";
-  previous: VisualGraph;
-  nodeIds: readonly string[];
+  /** Missing current geometry falls back to these matching entity IDs. */
+  previous?: VisualGraph;
+  /** Position permission only. Omitted or empty selects no nodes. */
+  nodeIds?: readonly string[];
+  /** Edge selection never grants permission to move endpoints. */
+  edgeIds?: readonly string[];
+  /** Defaults to affected; automatic changes obey edgeGeometry. */
+  routing?: "selected" | "affected";
+  /** Defaults to both; dimensions remain fixed. */
+  edgeGeometry?: "routes" | "labels" | "both";
 } | {
   mode: "route-only";
   previous: VisualGraph;
@@ -24,6 +93,8 @@ interface LayoutDiagnostic {
   message: string;
   entityIds?: readonly string[];
   phase?: string;
+  constraintIds?: readonly string[];
+  geometry?: "node" | "routes" | "labels";
 }
 interface LayoutPhaseMetrics {
   id: string;
@@ -36,6 +107,8 @@ interface LayoutMetrics {
   phases: readonly LayoutPhaseMetrics[];
 }
 interface LayoutCapabilities {
+  /** Common geometry constraints; absent means unsupported. */
+  constraints?: boolean;
   full: boolean;
   incremental: boolean;
   partial: boolean;
@@ -50,6 +123,7 @@ interface LayoutAlgorithm<Options = unknown> {
 }
 interface LayoutExecutionContext {
   readonly scope: LayoutScope;
+  readonly constraints?: readonly LayoutConstraint[];
   readonly signal?: AbortSignal;
   readonly diagnostics: LayoutDiagnostic[];
   measurePhase<T>(id: string, run: () => T): T;
@@ -60,6 +134,7 @@ interface LayoutRequest<N = unknown, E = unknown, G = unknown, P = unknown, O =
   algorithm?: string | LayoutAlgorithm<O>;
   options?: O;
   scope?: LayoutScope;
+  constraints?: readonly LayoutConstraint[];
   signal?: AbortSignal;
 }
 interface LayoutResult<N = unknown, E = unknown, G = unknown, P = unknown> {
@@ -1125,8 +1200,30 @@ interface LayeredStrategies {
   placeNodes?: NodePlacer;
   routeEdges?: EdgeRouter;
 }
+/** Geometry reserved while laying out a compound, before its ancestors. */
+interface CompoundLayoutOptions {
+  padding?: number | Partial<LayoutPadding>;
+  direction?: LayoutDirection;
+  header?: NodeSize & {
+    side?: "top" | "right" | "bottom" | "left";
+  };
+  minContentSize?: Partial<NodeSize>;
+}
+interface CompoundLayoutGeometry {
+  /** Parent-relative outer rectangle; header/content are relative to this rectangle. */
+  bounds: EntityRect;
+  header?: EntityRect;
+  content: EntityRect;
+}
+interface CompoundEdgeAttachment {
+  /** Content attachments leave toward the interior; outer attachments leave outward. */
+  source?: "content" | "outer";
+  target?: "content" | "outer";
+}
 interface LayeredLayoutOptions {
   direction?: LayoutDirection;
+  compound?: (node: GraphNode) => CompoundLayoutOptions | undefined;
+  edgeAttachment?: (edge: GraphEdge) => CompoundEdgeAttachment | undefined;
   spacing?: Partial<LayeredSpacing>;
   padding?: number | Partial<LayoutPadding>;
   constraints?: LayoutConstraints;
@@ -1143,6 +1240,15 @@ interface LayeredLayoutOptions {
   portSettings?: (port: GraphPort, node: GraphNode) => ElkLayeredOptionValueByName | undefined;
 }
 //#endregion
+//#region src/layered/compound.d.ts
+type CompoundVisualGraph<N = unknown, E = unknown, G = unknown, P = unknown> = VisualGraph<N, E, G, P> & {
+  /** Nodes remain parent-relative; edge rectangles and points are world-space. */
+  readonly edgeCoordinateSpace?: "world";
+  readonly compoundGeometry: ReadonlyMap<string, CompoundLayoutGeometry>;
+  /** World-space route sections preserve label gaps and fallback diagnostics. */
+  readonly compoundRoutes: ReadonlyMap<string, Route>;
+};
+//#endregion
 //#region src/layered/strategies.d.ts
 declare const breakCyclesWithDepthFirstSearch: CycleBreaker;
 declare const breakCyclesGreedily: CycleBreaker;
@@ -1206,7 +1312,7 @@ declare function placeNodesWithNetworkSimplex(input: LayeredPhaseInput, order: L
  * Supports flat and nested graphs, cycles, ports, self-loops, four directions,
  * custom phase strategies, and all layered edge-routing styles.
  */
-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 function getLayeredLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: LayeredLayoutOptions): CompoundVisualGraph<N, E, G, P>;
 declare const layeredAlgorithm: LayoutAlgorithm<LayeredLayoutOptions>;
 //#endregion
-export { LayeringStrategy as $, routeEdgesOrthogonally as A, LayerOrder as B, breakCyclesWithModelOrderDepthFirstSearch as C, minimizeCrossingsWithModelOrder as D, minimizeCrossingsWithMedian as E, CycleBreaker as F, LayoutPadding as G, LayeredPhaseInput as H, EdgeRouter as I, NodeSize as J, NodePlacement as K, EdgeRoutes as L, routeEdgesWithSplines as M, AcyclicOrientation as N, placeNodesInLayers as O, CrossingMinimizer as P, LayeredAdvancedOptions as Q, LayerAssigner as R, breakCyclesWithModelOrderBreadthFirstSearch as S, minimizeCrossingsWithBarycenter as T, LayeredSpacing as U, LayeredLayoutOptions as V, LayeredStrategies as W, CycleBreakingStrategy as X, CrossingMinimizationStrategy as Y, EdgeRoutingStyle as Z, breakCyclesByStronglyConnectedNodeType as _, LayoutResult as _t, placeNodesWithBrandesKoepf as a, ElkLayeredOptionName as at, breakCyclesInteractively as b, assignLayersWithNetworkSimplex as c, AnyGraph as ct, assignLayersByLongestPath as d, LayoutDiagnostic as dt, NodePlacementStrategy as et, assignLayersByLongestPathToSink as f, LayoutDirection as ft, breakCyclesByStronglyConnectedConnectivity as g, LayoutRequest as gt, breakCyclesByModelOrder as h, LayoutPhaseMetrics as ht, placeNodesWithLinearSegments as i, ElkLayeredOptionId as it, routeEdgesWithPolylines as j, placeNodesInteractively as k, assignLayersByBreadthFirstModelOrder as l, LayoutAlgorithm as lt, assignLayersWithCoffmanGraham as m, LayoutMetrics as mt, layeredAlgorithm as n, toElkLayeredOptions as nt, assignLayersWithStretchWidth as o, ElkLayeredOptionValueByName as ot, assignLayersInteractively as p, LayoutExecutionContext as pt, NodePlacer as q, placeNodesWithNetworkSimplex as r, elkLayeredEnumValues as rt, assignLayersWithMinWidth as s, elkLayeredOptionDefinitions as st, getLayeredLayout as t, fromElkLayeredOptionId as tt, assignLayersByDepthFirstModelOrder as u, LayoutCapabilities as ut, breakCyclesGreedily as v, LayoutScope as vt, minimizeCrossingsInteractively as w, breakCyclesWithDepthFirstSearch as x, breakCyclesGreedilyByModelOrder as y, LayerAssignment as z };
+export { CrossingMinimizationStrategy as $, routeEdgesOrthogonally as A, PinConstraint as At, EdgeRouter as B, breakCyclesWithModelOrderDepthFirstSearch as C, AlignConstraint as Ct, minimizeCrossingsWithModelOrder as D, GeometryReference as Dt, minimizeCrossingsWithMedian as E, GeometryAttribute as Et, CompoundEdgeAttachment as F, LayeredLayoutOptions as G, LayerAssigner as H, CompoundLayoutGeometry as I, LayeredStrategies as J, LayeredPhaseInput as K, CompoundLayoutOptions as L, routeEdgesWithSplines as M, c as Mt, CompoundVisualGraph as N, placeNodesInLayers as O, LayoutConstraint as Ot, AcyclicOrientation as P, NodeSize as Q, CrossingMinimizer as R, breakCyclesWithModelOrderBreadthFirstSearch as S, LayoutScope as St, minimizeCrossingsWithBarycenter as T, DistributeConstraint as Tt, LayerAssignment as U, EdgeRoutes as V, LayerOrder as W, NodePlacement as X, LayoutPadding as Y, NodePlacer as Z, breakCyclesByStronglyConnectedNodeType as _, LayoutExecutionContext as _t, placeNodesWithBrandesKoepf as a, fromElkLayeredOptionId as at, breakCyclesInteractively as b, LayoutRequest as bt, assignLayersWithNetworkSimplex as c, ElkLayeredOptionId as ct, assignLayersByLongestPath as d, elkLayeredOptionDefinitions as dt, CycleBreakingStrategy as et, assignLayersByLongestPathToSink as f, AnyGraph as ft, breakCyclesByStronglyConnectedConnectivity as g, LayoutDirection as gt, breakCyclesByModelOrder as h, LayoutDiagnostic as ht, placeNodesWithLinearSegments as i, NodePlacementStrategy as it, routeEdgesWithPolylines as j, WaypointConstraint as jt, placeNodesInteractively as k, LinearConstraint as kt, assignLayersByBreadthFirstModelOrder as l, ElkLayeredOptionName as lt, assignLayersWithCoffmanGraham as m, LayoutCapabilities as mt, layeredAlgorithm as n, LayeredAdvancedOptions as nt, assignLayersWithStretchWidth as o, toElkLayeredOptions as ot, assignLayersInteractively as p, LayoutAlgorithm as pt, LayeredSpacing as q, placeNodesWithNetworkSimplex as r, LayeringStrategy as rt, assignLayersWithMinWidth as s, elkLayeredEnumValues as st, getLayeredLayout as t, EdgeRoutingStyle as tt, assignLayersByDepthFirstModelOrder as u, ElkLayeredOptionValueByName as ut, breakCyclesGreedily as v, LayoutMetrics as vt, minimizeCrossingsInteractively as w, ConstraintStrength as wt, breakCyclesWithDepthFirstSearch as x, LayoutResult as xt, breakCyclesGreedilyByModelOrder as y, LayoutPhaseMetrics as yt, CycleBreaker as z };

package/dist/index-DNTLRsDl.d.mts

@@ -0,0 +1,72 @@
+import { a as RouteBounds, c as RoutePath, l as RoutePoint, n as NativeRoutingStrategy, r as Route, s as RoutePatch } from "./types-CT2akdK0.mjs";
+import { GraphPatch, VisualGraph } from "@statelyai/graph";
+
+//#region src/routing/engine.d.ts
+declare function applyRoutePatches(routes: ReadonlyMap<string, Route>, patches: readonly RoutePatch[]): ReadonlyMap<string, Route>;
+//#endregion
+//#region src/routing/path.d.ts
+declare function pathFromPoints(points: readonly RoutePoint[]): RoutePath;
+interface FlattenPathOptions {
+  readonly tolerance?: number;
+  readonly maxSegments?: number;
+}
+/** Adaptive, bounded-error polyline approximation. Throws rather than silently exceeding tolerance. */
+declare function flattenPath(path: RoutePath, options?: FlattenPathOptions): RoutePoint[];
+/** Conservative bounds: control hulls and full ellipse envelopes contain every curve. */
+declare function getPathBounds(path: RoutePath): RouteBounds;
+declare function getPathLength(path: RoutePath, options?: FlattenPathOptions): number;
+declare function getPointAtLength(path: RoutePath, length: number, options?: FlattenPathOptions): RoutePoint;
+declare function getTangentAtLength(path: RoutePath, length: number, options?: FlattenPathOptions): RoutePoint;
+/** Round line-to-line corners only; existing curves and path endpoints are retained. */
+declare function roundCorners(path: RoutePath, options: {
+  readonly radius: number;
+}): RoutePath;
+declare function toSvgPath(path: RoutePath, options?: {
+  readonly radius?: number;
+  readonly precision?: number;
+}): string;
+//#endregion
+//#region src/routing/adapters.d.ts
+/** ELK/native spline output: start, then repeating control1/control2/end triples. */
+declare function pathFromSplinePoints(points: readonly RoutePoint[]): RoutePath;
+/** Normalize routes from any native layout algorithm, without running layout again. */
+declare function getLayoutRoutes(graph: VisualGraph): ReadonlyMap<string, Route>;
+/** One polyline per section preserves label gaps and branching for simple renderers. */
+declare function routeToPolylines(route: Route, options?: {
+  readonly tolerance?: number;
+}): readonly (readonly RoutePoint[])[];
+/** Compatibility for single-section native consumers. Refuses to erase gaps or topology. */
+declare function routeToGraphPatch(route: Route, options?: {
+  readonly tolerance?: number;
+  readonly offset?: RoutePoint;
+}): GraphPatch;
+//#endregion
+//#region src/routing/index.d.ts
+declare const straightRouting: NativeRoutingStrategy;
+declare const bezierRouting: NativeRoutingStrategy;
+declare const orthogonalRouting: NativeRoutingStrategy;
+declare const polylineRouting: NativeRoutingStrategy;
+declare const octilinearRouting: NativeRoutingStrategy;
+declare const curvedRouting: NativeRoutingStrategy;
+declare const organicRouting: NativeRoutingStrategy;
+declare const parallelRouting: NativeRoutingStrategy;
+declare const selfLoopRouting: NativeRoutingStrategy;
+declare const fanRouting: NativeRoutingStrategy;
+declare const busRouting: NativeRoutingStrategy;
+declare const bundleRouting: NativeRoutingStrategy;
+declare const routingStrategies: Readonly<{
+  straight: NativeRoutingStrategy;
+  bezier: NativeRoutingStrategy;
+  orthogonal: NativeRoutingStrategy;
+  polyline: NativeRoutingStrategy;
+  octilinear: NativeRoutingStrategy;
+  curved: NativeRoutingStrategy;
+  organic: NativeRoutingStrategy;
+  parallel: NativeRoutingStrategy;
+  "self-loop": NativeRoutingStrategy;
+  fan: NativeRoutingStrategy;
+  bus: NativeRoutingStrategy;
+  bundle: NativeRoutingStrategy;
+}>;
+//#endregion
+export { getTangentAtLength as C, applyRoutePatches as D, toSvgPath as E, getPointAtLength as S, roundCorners as T, routeToPolylines as _, fanRouting as a, getPathBounds as b, orthogonalRouting as c, routingStrategies as d, selfLoopRouting as f, routeToGraphPatch as g, pathFromSplinePoints as h, curvedRouting as i, parallelRouting as l, getLayoutRoutes as m, bundleRouting as n, octilinearRouting as o, straightRouting as p, busRouting as r, organicRouting as s, bezierRouting as t, polylineRouting as u, FlattenPathOptions as v, pathFromPoints as w, getPathLength as x, flattenPath as y };