@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/styles/scrollbar.styles.d.ts

@@ -1,6 +1,6 @@
 /**
  * Global, not scoped. The ::-webkit-scrollbar* pseudo elements have no element of their own to
- * hang a component class on, and .scrollbar is a hook class seven components opt into by
+ * hang a component class on, and .scrollbar is a hook class the scrolling panels opt into by
  * literal name (class=${['scrollbar', ...]}) — scoping it would rename it out from under them.
  */
 export declare const scrollbarStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/themes/radix-ui-theme.d.ts

@@ -1744,6 +1744,10 @@ export declare const Appearance: {
 };
 export type Appearance = ValuesType<typeof Appearance>;
 export declare const AppearanceList: ("dark" | "light")[];
+/** The theme builder's third appearance: the light or dark the system shows. */
+export declare const SYSTEM_APPEARANCE = "system";
+export type AppearanceOption = Appearance | typeof SYSTEM_APPEARANCE;
+export declare const AppearanceOptionList: ReadonlyArray<AppearanceOption>;
 export declare const GrayColor: {
     readonly gray: "gray";
     readonly mauve: "mauve";
@@ -1783,11 +1787,15 @@ export declare const AccentColor: {
     readonly sky: "sky";
 };
 export type AccentColor = ValuesType<typeof AccentColor>;
-export declare const AccentColorList: ("ruby" | "gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky")[];
+export declare const AccentColorList: ("ruby" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "pink" | "gray" | "gold" | "bronze" | "brown" | "tomato" | "crimson" | "plum" | "iris" | "jade" | "grass" | "mint")[];
 export type ThemeOptions = {
-    appearance: Appearance;
+    appearance: AppearanceOption;
     grayColor: GrayColor;
     accentColor: AccentColor;
 };
-export declare const createTheme: ({ grayColor, accentColor, appearance, }: ThemeOptions) => Theme;
+/** Theme options with system resolved to the light or dark a theme is built for. */
+export type ResolvedThemeOptions = Omit<ThemeOptions, 'appearance'> & {
+    appearance: Appearance;
+};
+export declare const createTheme: ({ grayColor, accentColor, appearance, }: ResolvedThemeOptions) => Theme;
 //# sourceMappingURL=radix-ui-theme.d.ts.map

package/dist/themes/tokens.d.ts

@@ -30,6 +30,9 @@ export type Theme = {
     tableSelect: string;
     tableBorder: string;
     tableShadow: string;
+    tableGroupHeaderBackground: string;
+    tableGroupBackground: string;
+    tableGroupBorder: string;
     memoBackground: string;
     memoSelect: string;
     memoBorder: string;
@@ -52,6 +55,12 @@ export type Theme = {
     minimapViewportBorderHover: string;
     toastBackground: string;
     toastBorder: string;
+    toastSuccess: string;
+    toastError: string;
+    findReplaceError: string;
+    mapColumnsError: string;
+    schemaSqlWarningBackground: string;
+    schemaSqlWarningForeground: string;
     dragSelectBackground: string;
     dragSelectBorder: string;
     scrollbarTrack: string;
@@ -65,12 +74,17 @@ export type Theme = {
     keyPK: string;
     keyFK: string;
     keyPFK: string;
-    diffInsertBackground: string;
-    diffDeleteBackground: string;
-    diffCrossBackground: string;
+    treeBackground: string;
+    treeRowHover: string;
+    treeRowCurrent: string;
+    treeMuted: string;
+    treeMatch: string;
+    explorerBackground: string;
+    explorerBorder: string;
     diffInsertForeground: string;
     diffDeleteForeground: string;
-    diffCrossForeground: string;
+    diffModifyForeground: string;
+    diffRenameForeground: string;
 };
 export declare const ThemeTokens: ReadonlyArray<keyof Theme>;
 /** The custom property one token is published under on :host. */

package/dist/utils/calcTable.d.ts

@@ -3,6 +3,15 @@ import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
 import { GeometrySource } from './draw-relationship/geometrySource';
 export declare function getWidthGeneration(): number;
+/**
+ * Reads the generation through the observable, so the render calling it runs
+ * again whenever any table's widths may have changed.
+ *
+ * @example
+ * trackTableWidths();
+ * const rect = getTableRect(state, member);
+ */
+export declare function trackTableWidths(): number;
 /**
  * Invalidates every cached table size. Called from recalculateTableWidth,
  * which rewrites widths without dispatching an action, and from the

package/dist/utils/clipboard.d.ts

@@ -1,2 +1,11 @@
 export declare function copyToClipboard(value: string): Promise<void>;
+/**
+ * Puts a png on the clipboard, writing at once inside the click with the image
+ * still to come: Safari refuses a write made after an await has spent the
+ * click. A host with no image clipboard refuses before the image is asked for.
+ *
+ * @example
+ * await copyImageToClipboard(() => createDocumentPng(options));
+ */
+export declare function copyImageToClipboard(createPng: () => Promise<Blob>): Promise<void>;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/utils/collection/tableGroup.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, TableGroup } from '../../internal-types';
+export declare const createTableGroup: (value?: DeepPartial<TableGroup>) => TableGroup;
+//# sourceMappingURL=tableGroup.entity.d.ts.map

package/dist/utils/contrastText.d.ts

@@ -0,0 +1,21 @@
+/** The dark text a light background takes. */
+export declare const CONTRAST_BLACK = "#000000";
+/** The light text a dark background takes. */
+export declare const CONTRAST_WHITE = "#ffffff";
+/**
+ * A color's WCAG 2 relative luminance, from 0 for black to 1 for white, any
+ * alpha dropped; null for a color toOpaqueHex cannot read.
+ */
+export declare function relativeLuminance(color: string): number | null;
+/** The WCAG 2 contrast ratio of two relative luminances, from 1 to 21 in either order. */
+export declare function contrastRatio(a: number, b: number): number;
+/**
+ * White, unless black's WCAG 2 contrast ratio against the background beats
+ * white's by more than 4, so white is never under 3 and black never under 7.
+ * Null for a background toOpaqueHex cannot read, which keeps its colors.
+ *
+ * @example
+ * contrastTextColor('#3b82f6'); // '#ffffff'
+ */
+export declare function contrastTextColor(background: string): string | null;
+//# sourceMappingURL=contrastText.d.ts.map

package/dist/utils/deepMerge.d.ts

@@ -0,0 +1,8 @@
+import { DeepPartial } from '../internal-types';
+/**
+ * Merges source over a deep copy of target: objects key by key, arrays target
+ * first then source, every object and array in the result a fresh copy, and a
+ * key source holds as undefined overwriting target's.
+ */
+export declare function deepMerge<T extends object>(target: T, source: DeepPartial<T>): T;
+//# sourceMappingURL=deepMerge.d.ts.map

package/dist/utils/device-detect/index.d.ts

@@ -1,9 +1,5 @@
+/** macOS or iOS, where $mod is Cmd rather than Ctrl. */
 export declare const hasAppleDevice: () => boolean;
-export declare const hasMacintosh: () => boolean;
-export declare const hasIOS: () => boolean;
-export declare const hasAndroid: () => boolean;
+/** Windows, whose browsers all name it Win32 and where AltGr is Ctrl and Alt held. */
 export declare const hasWindows: () => boolean;
-export declare const hasChrome: () => boolean;
-export declare const hasSafari: () => boolean;
-export declare const hasFirefox: () => boolean;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/diff/compareEntities.d.ts

@@ -0,0 +1,39 @@
+import { RootState } from '../../engine/state';
+import { Column, Index, Memo, Relationship, Table, TableGroup } from '../../internal-types';
+import { Pairing } from './pairEntities';
+import { DiffChange } from './types';
+/** Both documents and what pairs across them, which every comparison reads. */
+export type DiffContext = {
+    prev: RootState;
+    next: RootState;
+    tables: Pairing;
+    columns: Pairing;
+    tableGroups: Pairing;
+};
+/** Name, comment, the group it is in, where it stands and its colour; never its z-index or the widths its text gives it. */
+export declare function compareTables(ctx: DiffContext, prev: Table, next: Table): DiffChange[];
+/**
+ * Name, comment, type, default and the four options, and its place among the
+ * columns once it moved, given as where it stood and stands, counted from one.
+ */
+export declare function compareColumns(prev: Column, next: Column, moved: {
+    before: number;
+    after: number;
+} | null): DiffChange[];
+/** The columns of an index in key order, each as the current column it pairs with and its direction. */
+export declare function indexKeyOf(ctx: DiffContext, index: Index, side: 'prev' | 'next'): string;
+/** Name, UNIQUE, and the columns in their order and direction, each column by the one it pairs with. */
+export declare function compareIndexes(ctx: DiffContext, prev: Index, next: Index): DiffChange[];
+/** A foreign key as it reads: its columns, the parent and the parent's columns. */
+export declare function foreignKeyText(state: RootState, relationship: Relationship): string;
+/** The column pairs of a foreign key, child to parent, as the current columns they pair with. */
+export declare function foreignKeyPairsOf(ctx: DiffContext, relationship: Relationship, side: 'prev' | 'next'): string;
+/** Its column pairs, its kind and what ON DELETE and ON UPDATE do; never where its ends are anchored. */
+export declare function compareForeignKeys(ctx: DiffContext, prev: Relationship, next: Relationship): DiffChange[];
+/** What it says, where it stands, its size and its colour; never its z-index. */
+export declare function compareMemos(prev: Memo, next: Memo): DiffChange[];
+/** The tables a group holds, each as the current table it pairs with. */
+export declare function groupMembersOf(ctx: DiffContext, group: TableGroup, side: 'prev' | 'next'): string[];
+/** Name, the tables it holds, its colour and the box it keeps; never its z-index. */
+export declare function compareTableGroups(ctx: DiffContext, prev: TableGroup, next: TableGroup): DiffChange[];
+//# sourceMappingURL=compareEntities.d.ts.map

package/dist/utils/diff/diffDocuments.d.ts

@@ -0,0 +1,12 @@
+import { RootState } from '../../engine/state';
+import { DocumentDiff } from './types';
+/**
+ * What changed from a saved document to the current one: the entries the diff
+ * tree lists and the marks each pane draws, which say the same thing. An entity
+ * pairs by id, then one to one by a name it keeps (src/components/erd/AGENTS.md).
+ *
+ * @example
+ * const { entries, prev, next } = diffDocuments(savedStore.state, store.state);
+ */
+export declare function diffDocuments(prev: RootState, next: RootState): DocumentDiff;
+//# sourceMappingURL=diffDocuments.d.ts.map

package/dist/utils/diff/index.d.ts

@@ -0,0 +1,5 @@
+export * from './compareEntities';
+export * from './diffDocuments';
+export * from './pairEntities';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/diff/pairEntities.d.ts

@@ -0,0 +1,41 @@
+/** Which entity of the saved document stands for which of the current one, both ways. */
+export type Pairing = {
+    /** A saved id to the current id it pairs with. */
+    toNext: Map<string, string>;
+    /** A current id to the saved id it pairs with. */
+    toPrev: Map<string, string>;
+};
+export declare const emptyPairing: () => Pairing;
+/** An id as the current one it stands for: a saved id as the one it pairs with, or one no current id can equal. */
+export declare function asNextId(pairing: Pairing, id: string, side: 'prev' | 'next'): string;
+/**
+ * A key two entities pair on, read on either side: a saved entity spells the
+ * ids it refers to as the current ones they pair with, so equal keys mean the
+ * same thing. Null for an entity the key cannot pair, an unnamed one say.
+ */
+export type PairKey<T> = (item: T, side: 'prev' | 'next') => string | null;
+/**
+ * Pairs two lists one to one: by id first, then by each key in turn, the
+ * saved entities taken in document order each pairing with the first current
+ * one left that has its key, so a rerun pairs the same way.
+ *
+ * @example
+ * pairEntities(prevTables, nextTables, [table => table.name.trim() ? table.name : null]);
+ */
+export declare function pairEntities<T extends {
+    id: string;
+}>(prev: ReadonlyArray<T>, next: ReadonlyArray<T>, keys?: ReadonlyArray<PairKey<T>>): Pairing;
+/**
+ * Pairs what is left by the most members two entities share, for those a key
+ * cannot name, such as table groups with no name: the saved ones in document
+ * order, each taking the current one it shares the most with, ties the first.
+ */
+export declare function pairByOverlap<T extends {
+    id: string;
+}>(pairing: Pairing, prev: ReadonlyArray<T>, next: ReadonlyArray<T>, membersOf: (item: T, side: 'prev' | 'next') => ReadonlyArray<string>): void;
+/**
+ * The positions of the longest run two sequences share in order, as the
+ * indexes of the second one, so an entry outside it is one that moved.
+ */
+export declare function longestCommonIndexes(a: ReadonlyArray<string>, b: ReadonlyArray<string>): Set<number>;
+//# sourceMappingURL=pairEntities.d.ts.map

package/dist/utils/diff/types.d.ts

@@ -0,0 +1,77 @@
+import { DiffMap } from '../../components/erd/diff-viewer/diff';
+import { ValuesType } from '../../internal-types';
+export declare const DiffKind: {
+    readonly table: "table";
+    readonly column: "column";
+    readonly index: "index";
+    readonly foreignKey: "foreignKey";
+    readonly memo: "memo";
+    readonly tableGroup: "tableGroup";
+};
+export type DiffKind = ValuesType<typeof DiffKind>;
+export declare const DiffStatus: {
+    readonly added: "added";
+    readonly modified: "modified";
+    readonly deleted: "deleted";
+    readonly renamed: "renamed";
+};
+export type DiffStatus = ValuesType<typeof DiffStatus>;
+/** What of an entity changed, each the name of a tooltip line. */
+export declare const DiffField: {
+    readonly name: "name";
+    readonly comment: "comment";
+    readonly dataType: "dataType";
+    readonly default: "default";
+    readonly autoIncrement: "autoIncrement";
+    readonly primaryKey: "primaryKey";
+    readonly unique: "unique";
+    readonly notNull: "notNull";
+    readonly order: "order";
+    readonly tableGroup: "tableGroup";
+    readonly position: "position";
+    readonly size: "size";
+    readonly color: "color";
+    readonly members: "members";
+    readonly columns: "columns";
+    readonly relationshipType: "relationshipType";
+    readonly onDelete: "onDelete";
+    readonly onUpdate: "onUpdate";
+    readonly value: "value";
+};
+export type DiffField = ValuesType<typeof DiffField>;
+/** A value as the saved or the current document holds it, before any wording. */
+export type DiffValue = string | number | boolean;
+export type DiffChange = {
+    field: DiffField;
+    before: DiffValue;
+    after: DiffValue;
+};
+/**
+ * One entity the two documents differ on, or that holds one that does. Its
+ * status is null for a table listed only for what changed inside it.
+ */
+export type DiffEntry = {
+    kind: DiffKind;
+    status: DiffStatus | null;
+    prevId: string | null;
+    nextId: string | null;
+    /** What the current document calls it, or the saved one where it is gone. */
+    name: string;
+    /** What the saved document calls it, the same as name unless renamed or added. */
+    prevName: string;
+    changes: DiffChange[];
+    /** A table's columns, indexes and foreign keys, in that order. */
+    children: DiffEntry[];
+};
+export type DiffEntries = {
+    tables: DiffEntry[];
+    tableGroups: DiffEntry[];
+    memos: DiffEntry[];
+};
+/** The entries for the tree and what each pane marks, which say the same thing. */
+export type DocumentDiff = {
+    entries: DiffEntries;
+    prev: DiffMap;
+    next: DiffMap;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/domEvent.d.ts

@@ -4,8 +4,26 @@ export declare function onStop(event: Event): void;
 export declare function onStopImmediate(event: Event): void;
 export declare function isMouseEvent(event: Event): event is MouseEvent;
 export declare function isTouchEvent(event: Event): event is TouchEvent;
+/**
+ * A press of the secondary mouse button alone. A macOS Ctrl+click reports the
+ * main button with ctrlKey and stays a main press, and a touch has no button.
+ */
+export declare function isSecondaryButtonPress(event: Event): boolean;
 /** A touch that puts a finger down beside another: a pinch, never a press of its own. */
 export declare function isMultiTouch(event: Event): boolean;
+/** A press that may carry what it lands on: a touch, or the main mouse button. */
+export declare function isMainButtonPress(event: Event): boolean;
+/** A press of the middle mouse button. */
+export declare function isMiddleButtonPress(event: Event): event is MouseEvent;
+/**
+ * Prevents the next middle lift wherever it lands, heard on the window ahead of
+ * the listener that ends a pan, since Chromium on Linux pastes the selection on
+ * a lift left unprevented. The returned remover drops it when no lift came.
+ *
+ * @example
+ * drag$.subscribe(handleMove).add(preventMiddleLift());
+ */
+export declare function preventMiddleLift(): () => void;
 /**
  * The editor root, which is where a pan has to take the selection off: the top
  * toolbar is a sibling of the scene that pans, so suppressing it any lower

package/dist/utils/dragSelect.d.ts

@@ -10,6 +10,8 @@ export type Rect = {
     w: number;
     h: number;
 };
+/** Whether the rect lies wholly inside the drag rect, its edges included. */
+export declare function isInsideDragRect(dragRect: Rect, rect: Rect): boolean;
 export declare function isOverlapPosition(dragRect: Rect, rect: Rect): boolean;
 export declare function getOverlapPosition(dragRect: Rect, rect: Rect): PointToPoint | null;
 export {};

package/dist/utils/draw-relationship/bezier.d.ts

@@ -29,4 +29,6 @@ export declare function bezierControls(from: Point, fromOutward: Point, to: Poin
  * the particle measurement and the route box all stay as they were.
  */
 export declare function bezierPolyline(from: Point, fromOutward: Point, to: Point, toOutward: Point, segments?: number): Point[];
+/** A cubic between two ends and its two control points, as that many chords. */
+export declare function cubicPolyline(from: Point, first: Point, second: Point, to: Point, segments: number): Point[];
 //# sourceMappingURL=bezier.d.ts.map

package/dist/utils/draw-relationship/corner.d.ts

@@ -0,0 +1,9 @@
+import { Point } from '../../internal-types';
+/**
+ * How many chords a full-radius corner is flattened into. A chord strays from the
+ * arc by about a tenth of a pixel at the canvas's closest zoom, so the turn still
+ * reads as a curve there; a smaller corner takes one chord per pixel of radius.
+ */
+export declare const ROUTE_CORNER_SEGMENTS = 6;
+export declare function roundPolyline(points: Point[], radius: number): Point[];
+//# sourceMappingURL=corner.d.ts.map

package/dist/utils/draw-relationship/index.d.ts

@@ -92,24 +92,24 @@ export type ObjectPoint = {
     rb: Point;
 };
 export declare const isDirection: (value: string) => boolean;
-export declare const PATH_HEIGHT = 30;
-export declare const PATH_END_HEIGHT: number;
+/** The stub of a side's first slot: as short as the decoration lets it be. */
+export declare const PATH_END_HEIGHT = 24;
 /**
- * The cardinality decoration, measured outward from the anchor. The four are one
- * shape and cannot be set independently: the ring shares a centre with the
- * second tick and has to clear both the first tick and the guide line.
+ * The cardinality decoration, measured outward from the anchor, at the size other
+ * ERD tools draw it, clear down to the lowest zoom a table shows its rows. The
+ * ring shares the second tick's centre and clears the first and the guide.
  */
-export declare const LINE_SIZE = 7;
-export declare const LINE_HEIGHT = 11;
+export declare const LINE_SIZE = 6;
+export declare const LINE_HEIGHT = 9;
 export declare const CIRCLE_HEIGHT: number;
-export declare const CIRCLE_RADIUS = 6;
+export declare const CIRCLE_RADIUS = 5;
 export declare const PATH_LINE_HEIGHT: number;
 /**
  * How far apart the corridors of two relationships leaving the same table side
- * sit. Without it every path on a side turns at the same coordinate and their
- * first segments run down one another however far the anchors are spread.
+ * sit, one hit band at full zoom. Without it every path on a side turns at the
+ * same coordinate and their first segments run down one another.
  */
-export declare const STUB_STEP = 12;
+export declare const STUB_STEP = 8;
 /**
  * Corridors repeat every fourth slot. An unbounded stub walks a busy side's
  * paths ever further from the table; wrapping caps the longest one and still
@@ -118,10 +118,10 @@ export declare const STUB_STEP = 12;
 export declare const STUB_CYCLE = 4;
 /**
  * The shortest a stub may be clamped to. It has to clear PATH_LINE_HEIGHT or the
- * guide line is drawn backwards, but it is not derived from it: this is where
- * the routing was measured, and following the decorations down cost overlap.
+ * guide line is drawn backwards; just past it, two facing tables about 50px
+ * apart still join in one straight run, where a longer floor sends it around.
  */
-export declare const MIN_STUB = 36;
+export declare const MIN_STUB = 24;
 /**
  * The widest gap allowed between two anchors on the same table side. Capping the
  * pitch keeps a side's anchors together as a group, so a tall table's edge is
@@ -131,11 +131,11 @@ export declare const ANCHOR_MAX_PITCH = 120;
 /** Keeps the outermost anchor of a side clear of the table's corners. */
 export declare const ANCHOR_EDGE_INSET = 12;
 /**
- * How far back from a corner a connector turns when the corner is cut to 45
- * degrees. A ceiling rather than a length: each cut is clamped to half the
- * shorter run it touches, so a short run keeps its right angle.
+ * The radius of the quarter circle a connector turns on at a corner. A ceiling
+ * rather than a length: each corner is clamped to half the shorter run it
+ * touches, so a short run keeps its right angle.
  */
-export declare const ROUTE_CHAMFER = 8;
+export declare const ROUTE_CORNER_RADIUS = 8;
 /** One end of a connector as the geometry reads it: which table, where on it, and which way out. */
 export type Anchor = Pick<RelationshipPoint, 'x' | 'y' | 'direction'> & {
     tableId: string;

package/dist/utils/draw-relationship/loop.d.ts

@@ -0,0 +1,29 @@
+import { Point } from '../../internal-types';
+/**
+ * How far a loop's stubs run, as a multiple of how far its anchors sit from the
+ * table corner: the first loop's 20px gives the 24px every other stub starts at.
+ */
+export declare const LOOP_STUB_RATIO = 1.2;
+/**
+ * How far a loop's control points reach past its stubs, as the same multiple.
+ * With both scaled by the offset, a table's loops are one shape at nested sizes.
+ */
+export declare const LOOP_CURVATURE = 1.25;
+/**
+ * How many chords a loop is flattened into. Even a fourth loop's chords stray from
+ * the curve by under a quarter of a pixel at the canvas's closest zoom.
+ */
+export declare const LOOP_SEGMENTS = 48;
+/** How far a loop's anchors sit from the table corner, along either side. */
+export declare function loopOffset(start: Point, end: Point): number;
+/** The stub both ends of a loop run out on. */
+export declare function loopStub(start: Point, end: Point): number;
+/** How far past its anchors a loop is drawn at most, for the route box. */
+export declare function loopReach(start: Point, end: Point): number;
+/**
+ * A loop between its two turning points: a cubic leaving each straight out along
+ * its stub, so it meets both without a corner and turns round the table's corner
+ * clear of it.
+ */
+export declare function loopPolyline(from: Point, fromOutward: Point, to: Point, toOutward: Point, offset: number): Point[];
+//# sourceMappingURL=loop.d.ts.map

package/dist/utils/draw-relationship/pathFinding.d.ts

@@ -4,7 +4,7 @@ import { GeometrySource } from './geometrySource';
 export declare function getRelationshipPath(relationship: Relationship, source?: GeometrySource): RelationshipPath;
 /**
  * The routing polyline as one d, so a connector is a single element whatever the
- * router and the corner cuts made of it. The segments are contiguous by
+ * router and the rounded corners made of it. The segments are contiguous by
  * construction, so each contributes its far end and nothing else.
  */
 export declare function toPathD(segments: Array<[Point, Point]>): string;

package/dist/utils/draw-relationship/sort.d.ts

@@ -1,4 +1,11 @@
 import { RootState } from '../../engine/state';
 import { GeometrySource } from './geometrySource';
-export declare function relationshipSort(state: RootState, source?: GeometrySource): void;
+/**
+ * Places each relationship's anchors and slots on the source's channel, and on
+ * the document's routes every connector too, unless route is false, as in a
+ * store that draws nothing, where a route is never read.
+ */
+export declare function relationshipSort(state: RootState, source?: GeometrySource, { route }?: {
+    route?: boolean;
+}): void;
 //# sourceMappingURL=sort.d.ts.map

package/dist/utils/draw-relationship/stub.d.ts

@@ -1,8 +1,9 @@
 import { Point } from '../../internal-types';
 import { Anchor, Anchors } from '.';
 /**
- * Slot zero keeps the historical PATH_END_HEIGHT, so a relationship that never
- * went through relationshipSort draws exactly as it did before.
+ * Slot zero runs at PATH_END_HEIGHT, the stub a relationship that never went
+ * through relationshipSort is drawn with, so a side's first connector keeps its
+ * stub through a sort.
  */
 export declare function stubFor(slot: number): number;
 /**
@@ -25,7 +26,7 @@ export type StubEnds = {
     startStub: number;
     endStub: number;
 };
-export declare function isHorizontal(direction: number): direction is 1 | 2;
+export declare function isHorizontal(direction: number): direction is 2 | 1;
 /** +1 when the anchor's outward normal points right or down. */
 export declare function outwardSign(direction: number): 1 | -1;
 /**