@kekonic/diagrams-routing 1.0.0-rc.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kekonic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# @kekonic/diagrams-routing
+
+Post-layout edge finishing for KDiagram: route-style refinement, crossing treatment, endpoint trim, and label placement types.
+
+## Scope
+
+- Route styles: `metro` / `rounded` / `bezier` refine the laid-out corridor into
+  organic cubics (port ease + curved avoidance); `orthogonal` keeps sharp corners;
+  `straight` shortcuts a clear corridor
+- Crossing modes: `none` / `gaps` / `jumps` / `smart`
+- Arrowhead / crow's-foot endpoint insets
+- Shared `RoutedEdge` / `TreatedEdge` / `EdgeLabelPlacement` types
+
+Orthogonal corridors normally come from ELK (or region-arrange stubs). This package does **not** search a new route grid; it shortens or smooths the corridor it was given.
+
+## Install
+
+```bash
+pnpm add @kekonic/diagrams-routing
+```
+
+Prefer the meta package `@kekonic/diagrams` for the full pipeline.
+
+## Related
+
+- Layout: `@kekonic/diagrams-layout`
+- Pipeline boundaries: [`docs/architecture/pipeline.md`](../../docs/architecture/pipeline.md)

package/dist/index.d.mts

@@ -0,0 +1,162 @@
+import { PerimeterAttachInput, attachPointOnPerimeter } from "@kekonic/diagrams-geometry";
+import { CrossingMode, Diagnostic, EdgeArrows, EdgeKind, Point, Rect, RouteMode } from "@kekonic/diagrams-core";
+//#region src/routing/path-style.d.ts
+type CubicBezier = {
+  from: Point;
+  c1: Point;
+  c2: Point;
+  to: Point;
+};
+type RouteStyleEdge = {
+  edgeId: string;
+  fromId: string;
+  toId: string;
+  points: Point[];
+};
+type RouteStyleObstacle = {
+  id: string;
+  bounds: Rect;
+};
+type RefinedRoute = {
+  edgeId: string;
+  points: Point[];
+  cubics?: CubicBezier[];
+};
+type OrganicRouteOptions = {
+  mode?: "metro" | "rounded" | "bezier";
+  t0?: Point;
+  t1?: Point;
+  cornerRadius?: number;
+};
+export declare function collapseColinear(points: Point[], eps?: number): Point[];
+/**
+ * True when the open segment stabs the open interior of `box`.
+ * Grazing a face does not count — attach points sit on silhouettes.
+ */
+export declare function segmentHitsAabb(a: Point, b: Point, box: Rect): boolean;
+/**
+ * Keep original waypoints, skipping any that the chord can see around.
+ * Clear line of sight → `[start, end]`. Otherwise a minimal dogleg from the
+ * existing corridor — never a silent punch through a third-party node.
+ */
+export declare function shortcutStraight(points: Point[], obstacles: Rect[]): Point[];
+export declare function sampleCubics(cubics: CubicBezier[], steps?: number): Point[];
+/**
+ * Outward unit normal of the silhouette face `point` sits on.
+ * Corner ties prefer `fallback` (usually the corridor stub).
+ */
+export declare function silhouetteNormal(point: Point, box: Rect, fallback: Point): Point;
+/**
+ * Obstacle-aware cubic spline along an orthogonal channel.
+ *
+ * Clear line of sight → one cubic with port-normal handles (ease out of the
+ * source, ease into the target). Otherwise each corridor elbow becomes its own
+ * curved section — not a sharp Manhattan stair.
+ */
+export declare function fitOrganicRoute(points: Point[], obstacles: Rect[], options?: OrganicRouteOptions): CubicBezier[];
+/** Smart-bezier: organic cubics with the bezier handle profile. */
+export declare function fitSmartBezier(points: Point[], obstacles: Rect[], ports?: {
+  t0?: Point;
+  t1?: Point;
+}): CubicBezier[];
+export declare function cubicsToPath(cubics: CubicBezier[]): string;
+/**
+ * Refine laid-out orthogonal polylines for the requested route mode.
+ * `orthogonal` stays a sharp polyline. Metro / rounded / bezier become organic
+ * cubics (port ease + curved avoidance). Straight still shortcuts the corridor.
+ */
+export declare function refineRouteStyle(edges: RouteStyleEdge[], obstacles: RouteStyleObstacle[], mode: RouteMode | undefined, parallel?: "separate" | "shared", cornerRadius?: number): RefinedRoute[];
+//#endregion
+//#region src/routing/types.d.ts
+type RoutedEdge = {
+  edgeId: string;
+  points: Point[];
+  segments: Array<{
+    from: Point;
+    to: Point;
+  }>;
+  /** Organic cubics for metro / rounded / bezier. Crossing treatment may flatten these. */
+  cubics?: CubicBezier[];
+};
+/** Post-ELK edge geometry after label placement and endpoint trim. */
+type RoutingResult = {
+  edges: RoutedEdge[];
+  algorithmVersion: string;
+  routeMs: number;
+  diagnostics: Diagnostic[];
+};
+//#endregion
+//#region src/crossings/treat.d.ts
+/** Tip extends past the path end (toward the node) by this much. */
+export declare const ARROW_MARKER_TIP_OVERHANG: number;
+/** Target trim: tip lands on the outer node stroke; dash/solid stop at the arrow base. */
+export declare const ARROW_ENDPOINT_INSET: number;
+type FlowArrowEnds = {
+  start: boolean;
+  end: boolean;
+};
+/** Whether an edge paints flow arrowheads at the path start and/or end. */
+export declare function flowArrowEnds(edge: {
+  kind: EdgeKind;
+  arrows?: EdgeArrows;
+} | undefined, showArrowheads: boolean): FlowArrowEnds;
+/**
+ * Crow's-foot tip sits on the path endpoint (marker refX), unlike arrows whose tip
+ * overhangs past refX. Keep only a hairline gap so the tip kisses the table stroke.
+ */
+export declare const CARDINALITY_ENDPOINT_INSET: number;
+/** Small inset for edges without arrowheads — clears node stroke at connection. */
+export declare const EDGE_ENDPOINT_INSET = 1;
+type RenderedEdgeSegment = {
+  type: "line";
+  from: Point;
+  to: Point;
+} | {
+  type: "cubic";
+  from: Point;
+  c1: Point;
+  c2: Point;
+  to: Point;
+} | {
+  type: "gap";
+  from: Point;
+  to: Point;
+} | {
+  type: "jump";
+  from: Point;
+  to: Point;
+  radius: number;
+};
+type TreatedEdge = {
+  edgeId: string;
+  segments: RenderedEdgeSegment[];
+};
+export declare function applyCrossingTreatment(edges: RoutedEdge[], mode: CrossingMode): TreatedEdge[];
+/** Crossing points between distinct edge segments (for label scoring). */
+export declare function detectCrossingPoints(edges: RoutedEdge[]): Point[];
+type TrimEdgeEndpointsOptions = {
+  /** Uniform source inset, or per-edge via callback. */
+  sourceInset?: number | ((edgeId: string) => number);
+  /** Uniform target inset, or per-edge via callback. */
+  targetInset?: number | ((edgeId: string) => number);
+};
+/** Shorten first/last strokes so arrowheads stop on the outer node stroke. */
+export declare function trimEdgeEndpoints(edges: TreatedEdge[], options?: TrimEdgeEndpointsOptions): TreatedEdge[];
+//#endregion
+//#region src/labels/types.d.ts
+/** Edge label bounds produced by ELK and painted by the SVG renderer. */
+type EdgeLabelPlacement = {
+  edgeId: string;
+  text: string;
+  bounds: Rect;
+  anchor: Point;
+};
+/** Icon size inside an edge-label pill (logical units). Keep in sync with SVG paint. */
+export declare const EDGE_LABEL_ICON = 12;
+/** Gap between edge-label icon and text. */
+export declare const EDGE_LABEL_ICON_GAP = 4;
+/** Horizontal padding inside the edge-label pill. */
+export declare const EDGE_LABEL_PAD_X = 8;
+//#endregion
+export { type CubicBezier, type EdgeLabelPlacement, type FlowArrowEnds, type OrganicRouteOptions, type PerimeterAttachInput, type RefinedRoute, type RenderedEdgeSegment, type RouteStyleEdge, type RouteStyleObstacle, type RoutedEdge, type RoutingResult, type TreatedEdge, attachPointOnPerimeter };
+//# sourceMappingURL=index.d.mts.map