reladraw 0.16.0 → 0.17.0

package/dist/lines.d.ts

@@ -0,0 +1,96 @@
+import type { Layout, LayoutEdge, LayoutNode } from './model.js';
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A rectangle as drawn: the node's face, which differs from its box only for a deck. */
+export interface Face {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** A circle is drawn in this square, so a line meets the circle. */
+    round: boolean;
+}
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+/** One piece of a drawn line, from where the last one ended: straight, or a cubic. */
+export type Piece = {
+    to: Point;
+} | {
+    c1: Point;
+    c2: Point;
+    to: Point;
+};
+/** One line, worked out. */
+export interface Route {
+    edge: LayoutEdge;
+    /** Where the line starts; each piece runs on from the end of the one before. */
+    start: Point;
+    pieces: Piece[];
+    /**
+     * The line's corners, ends included: two points for a straight line, the
+     * square route's corners for a square one, and for a curved one the points
+     * the curve passes through.
+     */
+    points: Point[];
+    /** Each named leg, as drawn, in the direction the line travels. */
+    legs: Map<string, Point[]>;
+    /** Each stop the line passes, as written, and the points it put on the line: `req b top` finds its run here (4.6). */
+    stops: {
+        written: string;
+        points: Point[];
+    }[];
+    /**
+     * Pieces not drawn, as [first, past the last]: a member's way along a
+     * collapsed bundle, which the bus draws once (6.6). The line still travels
+     * there, so the trace and every finding include them.
+     */
+    hidden?: [number, number][];
+}
+/** Where every line in the layout goes. */
+export declare function planLines(layout: Layout): Map<LayoutEdge, Route>;
+/** The ends sharing one side of one box, in their order along it. */
+export interface SideEnds {
+    node: LayoutNode;
+    side: Side;
+    /** Where each end landed, in order along the side, the line it belongs to, and which of the line's ends it is. */
+    ends: {
+        at: Point;
+        edge: LayoutEdge;
+        which: 'from' | 'to';
+    }[];
+}
+/** Every line, and every side two or more ends share, for the findings to measure. */
+export declare function planSides(layout: Layout): {
+    routes: Map<LayoutEdge, Route>;
+    sides: SideEnds[];
+};
+/** The drawn rectangle of a node. */
+export declare function faceOfNode(node: LayoutNode): Face;
+/** The point a share of the way along a polyline, bends included, or its start or end. */
+export declare function alongLength(trace: Point[], at: number | 'start' | 'end'): Point;
+export declare function centerOf(face: Face): Point;
+/** The points with repeats and points in line with both neighbors dropped. */
+export declare function tidyCorners(points: Point[]): Point[];
+/** The line as drawn, as a polyline: curves flattened, everything else its own points. */
+export declare function traceRoute(route: Route): Point[];
+/** A line's pieces with those along a collapsed bundle left out, as the runs either side of each. */
+export declare function visibleRuns(route: Route): {
+    start: Point;
+    pieces: Route['pieces'];
+}[];
+/** The line as drawn, as polylines: its trace with any stretch along a collapsed bundle left out. */
+export declare function traceVisible(route: Route): Point[][];
+/**
+ * Where two drawn lines cross, with the way each runs there. Lines that only
+ * touch or run together don't cross, and nor do two lines nearer than `clear`
+ * to an end of either: that is two lines meeting at a box, not passing each
+ * other. The renderer jumps these and the `edge-crossings` finding counts
+ * them, so the two agree.
+ */
+export declare function crossingPoints(a: Point[], b: Point[], clear: number): {
+    at: Point;
+    along: Point;
+    other: Point;
+}[];
+export declare function describeEdge(edge: LayoutEdge): string;