ooxml-ui 0.30.1 → 0.31.0

package/dist/pptx/render/connector-elbow-geometry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * OOXML preset bend geometry for multi-segment elbow connectors
+ * (`bentConnector3/4/5`, `curvedConnector3/4/5`).
+ *
+ * PowerPoint's elbow connectors do NOT avoid obstacles (obstacle-avoiding A*
+ * routing lives in `connector-router.ts` and is applied separately by
+ * `connector-path.ts`, only when a binding supplies an obstacle list; that is
+ * out of scope here). The ECMA-376 `bentConnector3/4/5` and
+ * `curvedConnector3/4/5` paths are always authored horizontal-first against
+ * their local box. `a:xfrm/@flipH` and `@flipV` orient that stored path; the
+ * bounding-box aspect ratio does not transpose its axes.
+ *
+ * No framework imports.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { RouterPoint } from './connector-router-types.js';
+/** Segment counts implied by the `bentConnector*` / `curvedConnector*` preset names. */
+export type ElbowSegments = 3 | 4 | 5;
+/**
+ * Normalise one of a connector's OOXML adjustment values (`adj1`/`adj2`/`adj3`,
+ * falling back to the generic `adj`) to a 0..1 fraction that positions an
+ * elbow bend line or curve control point. OOXML stores these in 1000ths of a
+ * percent (0..100000); values already in 0..1 are passed through. Defaults to
+ * `fallback` (the spec midpoint, `0.5`) when no usable adjustment is present,
+ * so an explicitly authored `adj1`/`adj2`/`adj3` always wins over the
+ * auto-computed default.
+ */
+export declare function connectorAdjustmentFraction(element: PptxElement, key: string, fallback?: number): number;
+/**
+ * Normalise a connector's first adjustment value (`adj1`/`adj`) to a 0..1
+ * fraction. Kept as a named entry point for `adj1` specifically (the only
+ * adjustment a `bentConnector3`/`curvedConnector3` elbow uses); see
+ * {@link connectorAdjustmentFraction} for `adj2`/`adj3`.
+ */
+export declare function connectorBendFraction(element: PptxElement): number;
+/**
+ * Segment count implied by a lower-cased `bentConnector*` / `curvedConnector*`
+ * shape type (`bentConnector2`/`curvedConnector2` are handled by their own
+ * fixed-shape branch in `connector-path.ts` before this is consulted).
+ * Unknown/missing suffixes fall back to `3` (the Z-shape), matching the
+ * historical behaviour for a bare `"bentConnector"` / `"curvedConnector"`.
+ */
+export declare function elbowSegmentCount(lowerShapeType: string): ElbowSegments;
+/**
+ * OOXML connector preset paths always use x as their primary bend axis.
+ */
+export declare function isHorizontalPrimary(_x1: number, _y1: number, _x2: number, _y2: number): boolean;
+/**
+ * Compute the bend waypoints (including the two endpoints) for a
+ * `segments`-segment orthogonal elbow between `(x1,y1)` and `(x2,y2)`,
+ * honouring `adj1`/`adj2`/`adj3` fractions (already normalised to 0..1 by
+ * `connectorAdjustmentFraction`; explicit authored values win, 0.5 is the
+ * spec default when absent).
+ *
+ * Segment counts mirror the OOXML presets:
+ * - `3` (`bentConnector3`, Z-shape): one bend line, positioned by `adj1`.
+ * - `4` (`bentConnector4`): a staircase through `adj1` (primary axis) and
+ *   `adj2` (secondary axis).
+ * - `5` (`bentConnector5`): a staircase with two primary-axis bend lines
+ *   (`adj1`, `adj3`) joined by one secondary-axis crossing (`adj2`).
+ */
+export declare function elbowWaypoints(x1: number, y1: number, x2: number, y2: number, segments: ElbowSegments, adj1: number, adj2: number, adj3: number): RouterPoint[];
+/**
+ * Render the same `segments`-segment elbow as a smooth path: cubic Beziers
+ * whose control points sit on the elbow's own corners, so curved connectors
+ * get the same horizontal-first, segment-count-aware routing as
+ * {@link elbowWaypoints} while never producing a sharp corner.
+ *
+ * `segments === 3` emits a single cubic Bezier through the two corner points
+ * (already smooth on its own, no interior breakpoint needed). `4` and `5`
+ * each insert one extra breakpoint per interior corner (halfway along the
+ * secondary axis) so the curve visibly bends near the corner instead of
+ * overshooting it, mirroring the multi-segment cubic construction
+ * `ooxml-core/src/pptx/core/geometry/connector-geometry.ts` uses for
+ * `curvedConnector4`/`curvedConnector5`.
+ */
+export declare function curvedElbowPathD(x1: number, y1: number, x2: number, y2: number, segments: ElbowSegments, adj1: number, adj2: number, adj3: number): string;
+//# sourceMappingURL=connector-elbow-geometry.d.ts.map

package/dist/pptx/render/connector-elbow-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-elbow-geometry.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-elbow-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,wFAAwF;AACxF,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtC;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,MAAM,EACX,QAAQ,SAAM,GACZ,MAAM,CAQR;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAQvE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/F;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,WAAW,EAAE,CAqBf;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC/B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,MAAM,CAwCR"}

package/dist/pptx/render/connector-endpoints.d.ts

@@ -0,0 +1,105 @@
+/**
+ * `connector-endpoints`: attaching and detaching a connector's ends on canvas.
+ *
+ * `connector-reroute` keeps a BOUND connector following its shapes and
+ * `connector-authoring` turns a site-to-site drag into a new connector. Neither
+ * lets the user change an existing connector's bindings, which is what
+ * PowerPoint's two endpoint handles do: drag one onto a shape and it gains an
+ * `a:stCxn` / `a:endCxn` and starts following that shape; drag it onto empty
+ * canvas and the binding is removed and the end stays where it is dropped.
+ *
+ * That was implemented in no binding at all. React shipped a `ConnectorOverlay`
+ * for the site-to-site creation gesture, but nothing ever passed the
+ * `connectorCreationMode` / `onCreateConnector` props that mount it, so the
+ * whole path was unreachable; the other four had no overlay in the first place.
+ *
+ * Everything here is slide-pixel space and free of framework imports: a binding
+ * supplies pointer positions already converted out of screen space, and applies
+ * the returned descriptor.
+ *
+ * @module render/connector-endpoints
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** Which end of a connector a gesture is moving. */
+export type ConnectorEndpointKind = 'start' | 'end';
+/** One draggable endpoint of a selected connector, in slide px. */
+export interface ConnectorEndpointHandle {
+    kind: ConnectorEndpointKind;
+    x: number;
+    y: number;
+    /** True when the end carries an `a:stCxn` / `a:endCxn` binding. */
+    attached: boolean;
+}
+/** A connection site a dragged endpoint can be dropped onto, in slide px. */
+export interface ConnectorSiteCandidate {
+    /** The target element's model id (what a canvas has in hand). */
+    elementId: string;
+    /** The id the binding must reference: `p:cNvPr/@id` when the deck has one. */
+    shapeId: string;
+    siteIndex: number;
+    x: number;
+    y: number;
+}
+/** Default snap radius in slide px, matching the site dot's own hit area. */
+export declare const CONNECTOR_SITE_SNAP_PX = 14;
+/**
+ * The two endpoints of `connector`, in slide px.
+ *
+ * The flip flags decide which corner of the bounding box each end sits on:
+ * `getConnectorPathGeometry` derives the line's direction from them, so a
+ * connector drawn right-to-left has its START at `x + width`. Reading the
+ * corners any other way puts the handles on the wrong ends and an endpoint drag
+ * silently reverses the arrowhead.
+ */
+export declare function getConnectorEndpointHandles(connector: PptxElement): ConnectorEndpointHandle[];
+/**
+ * Every connection site on the slide a connector end could bind to.
+ *
+ * Resolved through `getShapeConnectionSites`, the SAME list the reroute reads,
+ * so a site dot is drawn exactly where the connector will land. React's overlay
+ * used the four-edge-midpoint fallback instead, which meant that on any shape
+ * carrying a real `a:cxnLst` the dots were drawn in one place and the connector
+ * jumped to another the first time the shape moved.
+ */
+export declare function collectConnectorSiteCandidates(elements: readonly PptxElement[]): ConnectorSiteCandidate[];
+/** The nearest candidate within `radius` slide px of the point, or `null`. */
+export declare function findConnectorSiteNear(candidates: readonly ConnectorSiteCandidate[], x: number, y: number, radius?: number): ConnectorSiteCandidate | null;
+/** The geometry + bindings a connector takes after one of its ends is moved. */
+export interface ConnectorEndpointUpdate {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    /** `undefined` means DETACHED: the binding must be removed, not kept. */
+    startConnection?: {
+        shapeId: string;
+        connectionSiteIndex: number;
+    };
+    endConnection?: {
+        shapeId: string;
+        connectionSiteIndex: number;
+    };
+}
+/**
+ * The connector that results from dropping `kind` at `point`.
+ *
+ * `target` is the connection site the drop snapped to, or `null` for a drop on
+ * empty canvas, which DETACHES that end: the returned update omits the binding
+ * so the caller deletes it rather than leaving a stale `a:stCxn` pointing at a
+ * shape the line no longer touches.
+ */
+export declare function resolveConnectorEndpointUpdate(connector: PptxElement, elements: readonly PptxElement[], kind: ConnectorEndpointKind, point: {
+    x: number;
+    y: number;
+}, target: ConnectorSiteCandidate | null): ConnectorEndpointUpdate;
+/**
+ * `connector` with an endpoint update applied.
+ *
+ * Shared so no binding re-implements the spread, and so a DETACHED end really
+ * loses its `connectorStartConnection` / `connectorEndConnection` key instead of
+ * keeping an undefined one that later code would treat as still bound.
+ */
+export declare function withConnectorEndpointUpdate(connector: PptxElement, update: ConnectorEndpointUpdate): PptxElement;
+//# sourceMappingURL=connector-endpoints.d.ts.map

package/dist/pptx/render/connector-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-endpoints.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-endpoints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,oDAAoD;AACpD,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,KAAK,CAAC;AAEpD,mEAAmE;AACnE,MAAM,WAAW,uBAAuB;IACvC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACtC,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAQD,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAQzC;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,WAAW,GAAG,uBAAuB,EAAE,CAsB7F;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC7C,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC9B,sBAAsB,EAAE,CAiB1B;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CACpC,UAAU,EAAE,SAAS,sBAAsB,EAAE,EAC7C,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,GAAE,MAA+B,GACrC,sBAAsB,GAAG,IAAI,CAW/B;AAED,gFAAgF;AAChF,MAAM,WAAW,uBAAuB;IACvC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,yEAAyE;IACzE,eAAe,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;IACnE,aAAa,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;CACjE;AAwBD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC7C,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,IAAI,EAAE,qBAAqB,EAC3B,KAAK,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/B,MAAM,EAAE,sBAAsB,GAAG,IAAI,GACnC,uBAAuB,CA2BzB;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,uBAAuB,GAC7B,WAAW,CAwBb"}

package/dist/pptx/render/connector-hit-target.d.ts

@@ -0,0 +1,36 @@
+/**
+ * connector-hit-target.ts: how wide a connector's pointer target has to be.
+ *
+ * WHY this exists at all: a connector's wrapper is `pointer-events: none`, so
+ * an empty bounding box (connectors are usually large and mostly empty) never
+ * swallows clicks meant for the shapes it spans. That also left the LINE
+ * unclickable, so no pointer route reached a connector and the inspector's
+ * connector card could only be opened from the Elements list. Every binding
+ * therefore paints a transparent stroke along the path that opts back INTO hit
+ * testing with `pointer-events: stroke`, keeping the target on the line and off
+ * the box.
+ *
+ * WHY its own module: `buildConnectorGeometry` hands the width to the three
+ * bindings that consume the geometry object, but Vanilla renders a connector
+ * without ever building one, so it needs the rule and nothing else. Four
+ * bindings agreeing on a magic number by copying it is how they drifted the
+ * first time.
+ *
+ * @module render/connector-hit-target
+ */
+/**
+ * Narrowest a connector's pointer target may be, in px.
+ *
+ * WHY a floor: a hairline connector is one or two px of ink, and a target that
+ * thin cannot be hit with a mouse, never mind a finger. PowerPoint shows the
+ * same generosity around a line.
+ */
+export declare const CONNECTOR_HIT_MIN_WIDTH = 14;
+/**
+ * Width of the transparent stroke that makes a connector clickable.
+ *
+ * WHY 3x: the target has to be comfortably wider than the ink so a near miss
+ * still lands, while staying proportional for a thick line.
+ */
+export declare function connectorHitStrokeWidth(strokeWidth: number): number;
+//# sourceMappingURL=connector-hit-target.d.ts.map

package/dist/pptx/render/connector-hit-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-hit-target.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-hit-target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/pptx/render/connector-markers.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Arrow-head marker shapes for connectors.
+ *
+ * A connector's line geometry and its end decorations are independent concerns:
+ * routing answers "where does the line go", this module answers "what is drawn
+ * at each end and how big is it". Splitting them keeps `connector-path.ts`
+ * within the file-size rule and gives the arrow-size mapping a home of its own,
+ * since it is the part users actually configure (the inspector's six arrowhead
+ * controls all resolve to values consumed here).
+ *
+ * Pure and framework-agnostic: the `<marker>` element itself is emitted by each
+ * binding's view layer from the {@link MarkerShape} returned here.
+ */
+import type { ConnectorArrowType } from 'ooxml-core/pptx';
+/** Arrow head size token (`a:ln/a:headEnd|tailEnd/@w|@len`). */
+export type ArrowSize = 'sm' | 'med' | 'lg';
+/** Shape description for a SVG `<marker>` element (viewBox 0 0 10 10). */
+export interface MarkerShape {
+    shape: 'path' | 'circle';
+    d?: string;
+    /**
+     * Suggested `markerWidth` (along the line: arrow *length*). Derived from the
+     * connector's `@len` size token. Bindings should apply this instead of a
+     * hard-coded value so `sm`/`lg` arrows scale. Defaults to the historical `4`.
+     */
+    markerWidth: number;
+    /** Suggested `markerHeight` (perpendicular: arrow *width*, from `@w`). */
+    markerHeight: number;
+    /**
+     * True for a stroke-only (open, unfilled) marker path, i.e. the `'arrow'`
+     * open chevron. A binding should render this path with `fill="none"` and
+     * `stroke={strokeColor}` instead of the default solid `fill={strokeColor}`
+     * it uses for every other shape; a chevron rendered with a solid fill draws
+     * as a filled wedge, indistinguishable from `'triangle'`.
+     */
+    strokeOnly?: boolean;
+}
+/**
+ * Map a `ConnectorArrowType` value to its SVG marker shape, scaling the marker
+ * box by the arrow's width (`@w`) and length (`@len`) size tokens.
+ *
+ * The `<marker>` viewBox stays `0 0 10 10`; the returned {@link MarkerShape}
+ * carries `markerWidth` (length, along the line) and `markerHeight` (width,
+ * perpendicular) so bindings render `sm`/`med`/`lg` arrows at the right size
+ * instead of a single fixed dimension.
+ *
+ * @param type        Arrow head shape.
+ * @param arrowWidth  `@w` size token (perpendicular thickness). Defaults `med`.
+ * @param arrowLength `@len` size token (length along the line). Defaults `med`.
+ */
+export declare function markerPath(type: ConnectorArrowType, arrowWidth?: ArrowSize, arrowLength?: ArrowSize): MarkerShape;
+/** Normalise a raw arrow type value: coerce `"none"` / `undefined` to `undefined`. */
+export declare function normalizeArrow(a: ConnectorArrowType | undefined): ConnectorArrowType | undefined;
+//# sourceMappingURL=connector-markers.d.ts.map

package/dist/pptx/render/connector-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-markers.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-markers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,gEAAgE;AAChE,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,CAAC;AAE5C,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AASD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,kBAAkB,EACxB,UAAU,CAAC,EAAE,SAAS,EACtB,WAAW,CAAC,EAAE,SAAS,GACrB,WAAW,CAoBb;AAED,sFAAsF;AACtF,wBAAgB,cAAc,CAAC,CAAC,EAAE,kBAAkB,GAAG,SAAS,GAAG,kBAAkB,GAAG,SAAS,CAEhG"}

package/dist/pptx/render/connector-path.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Pure, framework-agnostic connector-geometry helpers shared across bindings.
+ *
+ * Derives the full set of SVG rendering values for a connector `PptxElement`:
+ * stroke style, flip-adjusted endpoints, bent/curved path data (with optional
+ * obstacle-avoiding A* routing), and arrow `<marker>` shapes. No framework
+ * imports; the actual `<svg>`/`<marker>`/`<path>` emission stays in each
+ * binding's view layer.
+ *
+ * Connector-family classification (`connectorKind` / `ConnectorKind`) lives in
+ * `connector-style.ts` and is re-used here rather than re-declared.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { MarkerShape } from './connector-markers.js';
+import type { RouterRect } from './connector-router.js';
+export { CONNECTOR_HIT_MIN_WIDTH, connectorHitStrokeWidth } from './connector-hit-target.js';
+export { markerPath, normalizeArrow } from './connector-markers.js';
+export type { ArrowSize, MarkerShape } from './connector-markers.js';
+export { buildDashArray } from './connector-dash.js';
+export type { DashSegment } from './connector-dash.js';
+export { connectorAdjustmentFraction, connectorBendFraction } from './connector-elbow-geometry.js';
+export type { ElbowSegments } from './connector-elbow-geometry.js';
+/**
+ * Optional obstacle-avoidance routing context for bent connectors. When
+ * supplied with a non-empty obstacle list, a bent connector's elbow path is
+ * replaced by an A* orthogonal route that detours around the obstacle rects
+ * (absolute slide coordinates). Straight/curved connectors ignore this.
+ */
+export interface ConnectorRouting {
+    obstacles: ReadonlyArray<RouterRect>;
+    canvasWidth: number;
+    canvasHeight: number;
+}
+/** All derived connector rendering values, computed from a `PptxElement`. */
+export interface ConnectorGeometry {
+    strokeWidth: number;
+    strokeColor: string;
+    strokeOpacity: number;
+    dashArray: string | undefined;
+    /** SVG `stroke-linecap`, derived from the connector's `a:ln/@cap`. */
+    strokeLinecap: 'butt' | 'round' | 'square';
+    /**
+     * Perpendicular offsets (px) for each parallel strand of a compound
+     * (double/triple) line. A single line yields `[0]`. Strands render the same
+     * path/line translated vertically by each offset.
+     */
+    compoundOffsets: number[];
+    /** Per-strand stroke widths, index-aligned with {@link compoundOffsets}. */
+    compoundWidths: number[];
+    /** SVG width (clamped to at least 1). */
+    svgW: number;
+    /** SVG height (clamped to at least 1). */
+    svgH: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    /**
+     * SVG `path` data for bent / curved connectors. `undefined` for straight
+     * connectors, in which case the component renders a `<line>` from
+     * `(x1,y1)` to `(x2,y2)` instead.
+     */
+    pathD: string | undefined;
+    startMarkerId: string;
+    endMarkerId: string;
+    startMarker: MarkerShape | null;
+    endMarker: MarkerShape | null;
+    startMarkerRef: string | null;
+    endMarkerRef: string | null;
+    /**
+     * `path` data for the invisible pointer target that runs along the stroke.
+     * Always set: it is {@link pathD} for a bent/curved connector, and the
+     * straight `(x1,y1) -> (x2,y2)` segment otherwise, so a binding can emit one
+     * `<path>` for the hit target regardless of which shape it paints.
+     */
+    hitPathD: string;
+    /** `stroke-width` for the hit target. See {@link connectorHitStrokeWidth}. */
+    hitStrokeWidth: number;
+    /** Inline `style` string for the wrapper `<div>`. */
+    wrapperStyle: string;
+}
+/**
+ * Derive all rendering geometry for a connector element.
+ *
+ * This is a pure function: no side-effects, no framework imports. The component
+ * calls this once per change-detection cycle inside a `computed()`.
+ */
+export declare function buildConnectorGeometry(element: PptxElement, zIndex: number, routing?: ConnectorRouting): ConnectorGeometry;
+/**
+ * Build the SVG `path` data for a bent or curved connector, or `undefined`
+ * for straight connectors (which render as a `<line>`). Endpoints are already
+ * flip-adjusted by the caller.
+ *
+ * PowerPoint's elbow connectors do not avoid obstacles (that A* routing is
+ * applied separately by {@link buildConnectorGeometry} when a binding
+ * supplies an obstacle list). These fallback helpers keep the stored
+ * horizontal-first axis and preserve each preset's segment count and
+ * adjustments. The main renderer delegates to core's normative preset path
+ * evaluator in {@link buildConnectorGeometry}.
+ *  - **bent**: orthogonal elbow polyline. `bentConnector2` is a single L-bend;
+ *    `bentConnector3` is a 2-bend Z routed through one adjustment (`adj1`);
+ *    `bentConnector4` is a 3-bend staircase (`adj1`, `adj2`); `bentConnector5`
+ *    is a 4-bend staircase (`adj1`, `adj2`, `adj3`).
+ *  - **curved**: fallback Bezier approximations for callers that build paths
+ *    directly rather than through {@link buildConnectorGeometry}.
+ *
+ * `bend2`/`bend3` are optional so existing 6-argument call sites (which only
+ * ever needed `bentConnector2/3` / `curvedConnector2/3`) keep compiling and
+ * producing identical output; they default to the spec midpoint (`0.5`).
+ */
+export declare function buildConnectorPathD(shapeType: string | undefined, x1: number, y1: number, x2: number, y2: number, bend: number, bend2?: number, bend3?: number): string | undefined;
+/**
+ * The connector wrapper's CSS `transform` value: rotation only, never flip.
+ *
+ * A connector's `flipHorizontal`/`flipVertical` is already baked into its
+ * endpoints (`buildConnectorGeometry`'s `x1/y1/x2/y2`, which swap per flip
+ * flag), so re-applying the flip as a `scaleX(-1)`/`scaleY(-1)` on the
+ * wrapper would cancel it back out. Every binding must build its wrapper
+ * transform through this one function rather than the general-purpose
+ * `getElementTransform` (which DOES include flip, for every other element
+ * type) or the flip cancels silently; see CLAUDE.md Rule 2 and the G0 fix in
+ * the OpenXML parity audit.
+ */
+export declare function connectorWrapperTransform(element: PptxElement): string | undefined;
+/**
+ * Build the inline `style` string for the connector wrapper `<div>`.
+ * Position, size, z-index, rotation, opacity, and visibility.
+ */
+export declare function buildWrapperStyle(element: PptxElement, zIndex: number): string;
+//# sourceMappingURL=connector-path.d.ts.map

package/dist/pptx/render/connector-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-path.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-path.ts"],"names":[],"mappings":"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"}

package/dist/pptx/render/connector-reroute.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Connector dynamic rerouting: recalculates connector endpoints when
+ * connected shapes are moved or resized. Pure (no framework imports).
+ *
+ * Connectors reference shapes via `shapeStyle.connectorStartConnection` and
+ * `shapeStyle.connectorEndConnection`, each containing a `shapeId` and a
+ * `connectionSiteIndex`. When the referenced shape moves or resizes, the
+ * connector's position and dimensions must be updated to follow.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+export { getConnectionSites, getShapeConnectionSites, getUnrotatedShapeConnectionSites, transformConnectionSite, } from './connector-sites.js';
+export type { ConnectionSite, ConnectionSiteFrame } from './connector-sites.js';
+/** Describes the updated geometry for a connector after rerouting. */
+export interface ReroutedConnector {
+    /** The connector element ID. */
+    id: string;
+    /** New x position. */
+    x: number;
+    /** New y position. */
+    y: number;
+    /** New width. */
+    width: number;
+    /** New height. */
+    height: number;
+    /**
+     * Recomputed horizontal flip flag. True when the resolved end point is to
+     * the left of the start point, matching how `getConnectorPathGeometry`
+     * derives the start/end corners (and thus arrowhead direction) from the
+     * flip flags. Omitted only when produced outside {@link computeConnectorGeometry}.
+     */
+    flipHorizontal?: boolean;
+    /** Recomputed vertical flip flag. True when the end point is above the start. */
+    flipVertical?: boolean;
+}
+/** A connection reference (shape + site index) on a connector endpoint. */
+export interface ConnectorConnectionRef {
+    shapeId?: string;
+    connectionSiteIndex?: number;
+}
+/**
+ * Index the slide's elements by every id a connector may reference them with.
+ *
+ * `a:stCxn/@id` is the OOXML `p:cNvPr/@id` of the target shape ("2"), which the
+ * parser keeps on the element as `shapeId`; the element's own `id` is a
+ * synthetic part-scoped key ("ppt/slides/slide1.xml-shape-0"). A connector the
+ * USER draws in the viewer instead stores the model id, because that is what
+ * the canvas has in hand. Both spellings therefore occur in one deck, and a
+ * lookup that honoured only the model id silently skipped every connector that
+ * came out of a real `.pptx` - which is why "connectors follow their shape"
+ * looked implemented while never firing on an authored deck.
+ *
+ * Model ids are written last so they win any collision with a raw id.
+ */
+export declare function buildConnectorElementLookup(elements: PptxElement[]): Map<string, PptxElement>;
+/**
+ * Find all connectors on the slide that reference any of the given element IDs
+ * via `connectorStartConnection`/`connectorEndConnection`, and recalculate
+ * their positions based on the current shape positions.
+ *
+ * @param elements - All elements on the current slide (after moves applied).
+ * @param movedElementIds - Set of element IDs that were moved or resized.
+ * @returns Array of rerouted connector descriptors with updated geometry.
+ */
+export declare function rerouteConnectorsForMovedElements(elements: PptxElement[], movedElementIds: Set<string>): ReroutedConnector[];
+/**
+ * Compute the new geometry for a single connector given its connection
+ * references and the current element positions. Returns null if a referenced
+ * shape cannot be found.
+ */
+export declare function computeConnectorGeometry(connector: PptxElement, startConn: ConnectorConnectionRef | undefined, endConn: ConnectorConnectionRef | undefined, elementMap: Map<string, PptxElement>): ReroutedConnector | null;
+/**
+ * Apply rerouted connector positions to a slide's element array.
+ * Returns a new array with updated connector positions (or the same reference
+ * when there is nothing to apply).
+ */
+export declare function applyReroutedConnectors(elements: PptxElement[], rerouted: ReroutedConnector[]): PptxElement[];
+//# sourceMappingURL=connector-reroute.d.ts.map

package/dist/pptx/render/connector-reroute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-reroute.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-reroute.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,EACN,kBAAkB,EAClB,uBAAuB,EACvB,gCAAgC,EAChC,uBAAuB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7E,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IACjC,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,sBAAsB;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,iBAAiB;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,kBAAkB;IAClB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iFAAiF;IACjF,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,2EAA2E;AAC3E,MAAM,WAAW,sBAAsB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAW7F;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAChD,QAAQ,EAAE,WAAW,EAAE,EACvB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,iBAAiB,EAAE,CA6CrB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,sBAAsB,GAAG,SAAS,EAC7C,OAAO,EAAE,sBAAsB,GAAG,SAAS,EAC3C,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAClC,iBAAiB,GAAG,IAAI,CA0D1B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,WAAW,EAAE,EACvB,QAAQ,EAAE,iBAAiB,EAAE,GAC3B,WAAW,EAAE,CAiCf"}

package/dist/pptx/render/connector-router-astar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A*-based orthogonal path search and path simplification.
+ *
+ * Pure (no framework imports). Deterministic  -  no Math.random / Date.
+ */
+import type { RouterPoint, RouterRect } from './connector-router-types.js';
+/**
+ * Run A* over the navigation graph to find the shortest orthogonal path from
+ * `start` to `end` that avoids all `inflated` obstacle rectangles.
+ *
+ * Returns an array of waypoints (possibly including intermediate bend points
+ * when L-shaped edges are taken). Falls back to `[start, end]` when no path is
+ * found within {@link MAX_ASTAR_ITERATIONS}.
+ */
+export declare function aStarOrthogonal(nodes: ReadonlyArray<RouterPoint>, start: RouterPoint, end: RouterPoint, inflated: ReadonlyArray<RouterRect>): RouterPoint[];
+/**
+ * Remove collinear intermediate waypoints from a path.
+ *
+ * A waypoint is dropped when the previous and next waypoints are collinear on
+ * both axes with it (three consecutive collinear points). Every directional
+ * change is preserved.
+ */
+export declare function simplifyPath(points: ReadonlyArray<RouterPoint>): RouterPoint[];
+//# sourceMappingURL=connector-router-astar.d.ts.map

package/dist/pptx/render/connector-router-astar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-router-astar.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-router-astar.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAKxE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,EACjC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,GACjC,WAAW,EAAE,CAkKf;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,CAuB9E"}

package/dist/pptx/render/connector-router-graph.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Graph-building helpers for the orthogonal connector router.
+ *
+ * Provides geometry primitives, collision detection, and navigation-graph
+ * construction used by the A* search. Pure (no framework imports).
+ */
+import type { RouterPoint, RouterRect } from './connector-router-types.js';
+export { PADDING_DEFAULT } from './connector-router-types.js';
+/** Expand a rect by `pad` pixels on every side. Returns a new rect. */
+export declare function inflateRect(r: RouterRect, pad: number): RouterRect;
+/** Return true when point `p` lies inside (or on the border of) `r`. */
+export declare function pointInRect(p: RouterPoint, r: RouterRect): boolean;
+/**
+ * Return true when the axis-aligned segment `a→b` intersects rectangle `r`.
+ *
+ * Only horizontal and vertical segments are handled exactly; diagonal segments
+ * are treated as intersecting (safe / conservative fallback).
+ */
+export declare function segmentIntersectsRect(a: RouterPoint, b: RouterPoint, r: RouterRect): boolean;
+/**
+ * Return true when the direct segment `start→end` is clear of all inflated
+ * obstacle rectangles.
+ */
+export declare function directPathClear(start: RouterPoint, end: RouterPoint, inflated: ReadonlyArray<RouterRect>): boolean;
+/** Manhattan-distance heuristic for A*. */
+export declare function heuristic(a: RouterPoint, b: RouterPoint): number;
+/** Stable string key for a point (rounded to nearest pixel). Used as Map keys. */
+export declare function pointKey(p: RouterPoint): string;
+/**
+ * Build the set of candidate navigation nodes for A*:
+ * - Start and end points.
+ * - Corners of each inflated obstacle (with a small clearance margin).
+ * - Orthogonal projections of every node onto start/end rows and columns.
+ *
+ * Nodes that fall inside an obstacle or outside the canvas are discarded.
+ */
+export declare function buildGraphNodes(start: RouterPoint, end: RouterPoint, inflated: ReadonlyArray<RouterRect>, canvasWidth: number, canvasHeight: number): RouterPoint[];
+//# sourceMappingURL=connector-router-graph.d.ts.map

package/dist/pptx/render/connector-router-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-router-graph.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-router-graph.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAExE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAM3D,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAOlE;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAyB5F;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,GACjC,OAAO,CAOT;AAED,2CAA2C;AAC3C,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAEhE;AAED,kFAAkF;AAClF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAE/C;AAMD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,EACnC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GAClB,WAAW,EAAE,CAqDf"}

package/dist/pptx/render/connector-router-types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Types for the orthogonal connector router (shared across bindings).
+ *
+ * Two naming conventions are exported for the same underlying shapes so that
+ * the React (`RouterPoint`/`RouterRect`) and Angular (`Point`/`Rect`) consumers
+ * keep their exact import surface unchanged.
+ */
+/** A 2-D point in pixel space. */
+export interface RouterPoint {
+    x: number;
+    y: number;
+}
+/** An axis-aligned bounding rectangle in pixel space. */
+export interface RouterRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Alias of {@link RouterPoint} (Angular naming). */
+export type Point = RouterPoint;
+/** Alias of {@link RouterRect} (Angular naming). */
+export type Rect = RouterRect;
+/**
+ * Options for {@link routeConnector} (React-style options object).
+ */
+export interface ConnectorRouterOptions {
+    start: RouterPoint;
+    end: RouterPoint;
+    obstacles: ReadonlyArray<RouterRect>;
+    canvasWidth: number;
+    canvasHeight: number;
+    /** Padding around obstacles (px). Default 12. */
+    padding?: number;
+    /** When true, only produce axis-aligned segments. Default true. */
+    orthogonal?: boolean;
+}
+/** Options for {@link routeOrthogonalConnector} (Angular naming). */
+export interface OrthogonalRouterOptions {
+    /** Start point (absolute pixel coordinates). */
+    start: RouterPoint;
+    /** End point (absolute pixel coordinates). */
+    end: RouterPoint;
+    /** Obstacle bounding boxes the path must avoid. */
+    obstacles: ReadonlyArray<RouterRect>;
+    /** Width of the routing canvas. Defaults to a large sentinel when omitted. */
+    canvasWidth?: number;
+    /** Height of the routing canvas. Defaults to a large sentinel when omitted. */
+    canvasHeight?: number;
+    /** Padding (px) expanded around each obstacle. Default {@link PADDING_DEFAULT}. */
+    padding?: number;
+}
+/** Default obstacle padding in pixels (React naming). */
+export declare const PADDING_DEFAULT = 12;
+/** Default obstacle padding in pixels (Angular naming). Same value. */
+export declare const ROUTING_PADDING_DEFAULT = 12;
+/** Sentinel canvas size when a caller does not supply one. */
+export declare const CANVAS_SENTINEL = 100000;
+//# sourceMappingURL=connector-router-types.d.ts.map