@univerjs-pro/engine-shape 0.15.3-insiders.20260131-cbd5fac

package/lib/types/index.d.ts

@@ -0,0 +1,200 @@
+export { BasicShapeModel as ShapeModel } from '../src/model/shape-model';
+export { LineShapeRenderModel } from '../src/render-engine/line-shape-render-model';
+export { BaseShapeRenderModel } from '../src/render-engine/shape-render-model';
+export { BasicShapeEnum, ShapeArrowSizeEnum, ShapeArrowTypeEnum, ShapeFillEnum, ShapeGradientTypeEnum, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeLineTypeEnum, ShapeOperatorEnum, ShapeRenderModeEnum, ShapeTypeEnum } from '../src/shape-enum';
+export type { IConnectorLayoutResult, IConnectorRouteLayoutResult, IConnectPointInfo, ICustomShapeTextData, ICxnShapeData, IDrawingRect, IGdContext, IGdContextBase, ILineType, IPathCommand, IPresetShapeConfig, IShapeAdjustItem, IShapeAdjustItemResolved, IShapeContextOptions, IBasicShapeData as IShapeData, IShapeHitTestResult, IShapeJSONData, IShapeLineStyle, IShapeModel, IShapePath, IShapePoint, IShapePointWithAdjName, IShapeRect, IShapeRelation, IShapeRelationItem, IShapeRenderParameters, IShapeText, ShapeAdjustHandleTypeEnum, ShapeHitTestHitTypeEnum, } from '../src/shape-type';
+export { AccentBorderCallout1Shape } from '../src/shapes/accent-border-callout1-shape';
+export { AccentBorderCallout2Shape } from '../src/shapes/accent-border-callout2-shape';
+export { AccentBorderCallout3Shape } from '../src/shapes/accent-border-callout3-shape';
+export { AccentCallout1Shape } from '../src/shapes/accent-callout1-shape';
+export { AccentCallout2Shape } from '../src/shapes/accent-callout2-shape';
+export { AccentCallout3Shape } from '../src/shapes/accent-callout3-shape';
+export { ActionButtonBackPreviousShape } from '../src/shapes/action-button-back-previous-shape';
+export { ActionButtonBeginningShape } from '../src/shapes/action-button-beginning-shape';
+export { ActionButtonBlankShape } from '../src/shapes/action-button-blank-shape';
+export { ActionButtonDocumentShape } from '../src/shapes/action-button-document-shape';
+export { ActionButtonEndShape } from '../src/shapes/action-button-end-shape';
+export { ActionButtonForwardNextShape } from '../src/shapes/action-button-forward-next-shape';
+export { ActionButtonHelpShape } from '../src/shapes/action-button-help-shape';
+export { ActionButtonHomeShape } from '../src/shapes/action-button-home-shape';
+export { ActionButtonInformationShape } from '../src/shapes/action-button-information-shape';
+export { ActionButtonMovieShape } from '../src/shapes/action-button-movie-shape';
+export { ActionButtonReturnShape } from '../src/shapes/action-button-return-shape';
+export { ActionButtonSoundShape } from '../src/shapes/action-button-sound-shape';
+export { ArcShape } from '../src/shapes/arc-shape';
+export { BentArrowShape } from '../src/shapes/bent-arrow-shape';
+export { BentConnector2Shape } from '../src/shapes/bent-connector2-shape';
+export { BentConnector3Shape } from '../src/shapes/bent-connector3-shape';
+export { BentConnector4Shape } from '../src/shapes/bent-connector4-shape';
+export { BentConnector5Shape } from '../src/shapes/bent-connector5-shape';
+export { BentUpArrowShape } from '../src/shapes/bent-up-arrow-shape';
+export { BevelShape } from '../src/shapes/bevel-shape';
+export { BlockArcShape } from '../src/shapes/block-arc-shape';
+export { BorderCallout1Shape } from '../src/shapes/border-callout1-shape';
+export { BorderCallout2Shape } from '../src/shapes/border-callout2-shape';
+export { BorderCallout3Shape } from '../src/shapes/border-callout3-shape';
+export { BracePairShape } from '../src/shapes/brace-pair-shape';
+export { BracketPairShape } from '../src/shapes/bracket-pair-shape';
+export { Callout1Shape } from '../src/shapes/callout1-shape';
+export { Callout2Shape } from '../src/shapes/callout2-shape';
+export { Callout3Shape } from '../src/shapes/callout3-shape';
+export { CanShape } from '../src/shapes/can-shape';
+export { ChartPlusShape } from '../src/shapes/chart-plus-shape';
+export { ChartStarShape } from '../src/shapes/chart-star-shape';
+export { ChartXShape } from '../src/shapes/chart-x-shape';
+export { ChevronShape } from '../src/shapes/chevron-shape';
+export { ChordShape } from '../src/shapes/chord-shape';
+export { CircleShape } from '../src/shapes/circle-shape';
+export { CircularArrowShape } from '../src/shapes/circular-arrow-shape';
+export { CloudCalloutShape } from '../src/shapes/cloud-callout-shape';
+export { CloudShape } from '../src/shapes/cloud-shape';
+export { CornerShape } from '../src/shapes/corner-shape';
+export { CornerTabsShape } from '../src/shapes/corner-tabs-shape';
+export { CubeShape } from '../src/shapes/cube-shape';
+export { CurvedConnector2Shape } from '../src/shapes/curved-connector2-shape';
+export { CurvedConnector3Shape } from '../src/shapes/curved-connector3-shape';
+export { CurvedConnector4Shape } from '../src/shapes/curved-connector4-shape';
+export { CurvedConnector5Shape } from '../src/shapes/curved-connector5-shape';
+export { CurvedDownArrowShape } from '../src/shapes/curved-down-arrow-shape';
+export { CurvedLeftArrowShape } from '../src/shapes/curved-left-arrow-shape';
+export { CurvedRightArrowShape } from '../src/shapes/curved-right-arrow-shape';
+export { CurvedUpArrowShape } from '../src/shapes/curved-up-arrow-shape';
+export { DecagonShape } from '../src/shapes/decagon-shape';
+export { DiagStripeShape } from '../src/shapes/diagonal-stripe-shape';
+export { DiamondShape } from '../src/shapes/diamond-shape';
+export { DodecagonShape } from '../src/shapes/dodecagon-shape';
+export { DonutShape } from '../src/shapes/donut-shape';
+export { DoubleWaveShape } from '../src/shapes/double-wave-shape';
+export { DownArrowCalloutShape } from '../src/shapes/down-arrow-callout-shape';
+export { DownArrowShape } from '../src/shapes/down-arrow-shape';
+export { EllipseRibbon2Shape } from '../src/shapes/ellipse-ribbon2-shape';
+export { EllipseRibbonShape } from '../src/shapes/ellipse-ribbon-shape';
+export { EllipseShape } from '../src/shapes/ellipse-shape';
+export { FlowChartOfflineStorageShape } from '../src/shapes/flow-chart-offline-storage-shape';
+export { FlowchartAlternateProcessShape } from '../src/shapes/flowchart-alternate-process-shape';
+export { FlowchartCollateShape } from '../src/shapes/flowchart-collate-shape';
+export { FlowchartConnectorShape } from '../src/shapes/flowchart-connector-shape';
+export { FlowChartInputOutputShape } from '../src/shapes/flowchart-data-shape';
+export { FlowchartDecisionShape } from '../src/shapes/flowchart-decision-shape';
+export { FlowchartDelayShape } from '../src/shapes/flowchart-delay-shape';
+export { FlowchartDisplayShape } from '../src/shapes/flowchart-display-shape';
+export { FlowchartDocumentShape } from '../src/shapes/flowchart-document-shape';
+export { FlowchartExtractShape } from '../src/shapes/flowchart-extract-shape';
+export { FlowchartInternalStorageShape } from '../src/shapes/flowchart-internal-storage-shape';
+export { FlowchartMagneticDiskShape } from '../src/shapes/flowchart-magnetic-disk-shape';
+export { FlowchartMagneticDrumShape } from '../src/shapes/flowchart-magnetic-drum-shape';
+export { FlowchartMagneticTapeShape } from '../src/shapes/flowchart-magnetic-tape-shape';
+export { FlowchartManualInputShape } from '../src/shapes/flowchart-manual-input-shape';
+export { FlowchartManualOperationShape } from '../src/shapes/flowchart-manual-operation-shape';
+export { FlowchartMergeShape } from '../src/shapes/flowchart-merge-shape';
+export { FlowchartMultiDocumentShape } from '../src/shapes/flowchart-multidocument-shape';
+export { FlowchartOffPageConnectorShape } from '../src/shapes/flowchart-offpage-connector-shape';
+export { FlowchartOnlineStorageShape } from '../src/shapes/flowchart-online-storage-shape';
+export { FlowchartOrShape } from '../src/shapes/flowchart-or-shape';
+export { FlowchartPredefinedProcessShape } from '../src/shapes/flowchart-predefined-process-shape';
+export { FlowchartPreparationShape } from '../src/shapes/flowchart-preparation-shape';
+export { FlowchartProcessShape } from '../src/shapes/flowchart-process-shape';
+export { FlowchartPunchedCardShape } from '../src/shapes/flowchart-punched-card-shape';
+export { FlowchartPunchedTapeShape } from '../src/shapes/flowchart-punched-tape-shape';
+export { FlowchartSortShape } from '../src/shapes/flowchart-sort-shape';
+export { FlowchartSummingJunctionShape } from '../src/shapes/flowchart-summing-junction-shape';
+export { FlowchartTerminatorShape } from '../src/shapes/flowchart-terminator-shape';
+export { FoldedCornerShape } from '../src/shapes/folded-corner-shape';
+export { FrameShape } from '../src/shapes/frame-shape';
+export { FunnelShape } from '../src/shapes/funnel-shape';
+export { Gear6Shape } from '../src/shapes/gear6-shape';
+export { Gear9Shape } from '../src/shapes/gear9-shape';
+export { HalfFrameShape } from '../src/shapes/half-frame-shape';
+export { HeartShape } from '../src/shapes/heart-shape';
+export { HeptagonShape } from '../src/shapes/heptagon-shape';
+export { HexagonShape } from '../src/shapes/hexagon-shape';
+export { HomePlateShape } from '../src/shapes/home-plate-shape';
+export { HorizontalScrollShape } from '../src/shapes/horizontal-scroll-shape';
+export { IrregularSeal1Shape } from '../src/shapes/irregular-seal1-shape';
+export { IrregularSeal2Shape } from '../src/shapes/irregular-seal2-shape';
+export { LeftArrowCalloutShape } from '../src/shapes/left-arrow-callout-shape';
+export { LeftArrowShape } from '../src/shapes/left-arrow-shape';
+export { LeftBraceShape } from '../src/shapes/left-brace-shape';
+export { LeftBracketShape } from '../src/shapes/left-bracket-shape';
+export { LeftCircularArrowShape } from '../src/shapes/left-circular-arrow-shape';
+export { LeftRightArrowCalloutShape } from '../src/shapes/left-right-arrow-callout-shape';
+export { LeftRightArrowShape } from '../src/shapes/left-right-arrow-shape';
+export { LeftRightCircularArrowShape } from '../src/shapes/left-right-circular-arrow-shape';
+export { LeftRightRibbonShape } from '../src/shapes/left-right-ribbon-shape';
+export { LeftRightUpArrowShape } from '../src/shapes/left-right-up-arrow-shape';
+export { LeftUpArrowShape } from '../src/shapes/left-up-arrow-shape';
+export { LightningBoltShape } from '../src/shapes/lightning-bolt-shape';
+export { LineInvShape } from '../src/shapes/line-lnv-shape';
+export { LineShape } from '../src/shapes/line-shape';
+export { MathDivideShape } from '../src/shapes/math-divide-shape';
+export { MathEqualShape } from '../src/shapes/math-equal-shape';
+export { MathMinusShape } from '../src/shapes/math-minus-shape';
+export { MathMultiplyShape } from '../src/shapes/math-multiply-shape';
+export { MathNotEqualShape } from '../src/shapes/math-not-equal-shape';
+export { MathPlusShape } from '../src/shapes/math-plus-shape';
+export { MoonShape } from '../src/shapes/moon-shape';
+export { NoSmokingShape } from '../src/shapes/no-smoking-shape';
+export { NonIsoscelesTrapezoidShape } from '../src/shapes/non-isosceles-trapezoid';
+export { NotchedRightArrowShape } from '../src/shapes/notched-right-arrow-shape';
+export { OctagonShape } from '../src/shapes/octagon-shape';
+export { ParallelogramShape } from '../src/shapes/parallelogram-shape';
+export { PentagonShape } from '../src/shapes/pentagon-shape';
+export { PieShape } from '../src/shapes/pie-shape';
+export { PieWedgeShape } from '../src/shapes/pie-wedge-shape';
+export { PlaqueShape } from '../src/shapes/plaque-shape';
+export { PlaqueTabsShape } from '../src/shapes/plaque-tabs-shape';
+export { PlusShape } from '../src/shapes/plus-shape';
+export { QuadArrowCalloutShape } from '../src/shapes/quad-arrow-callout-shape';
+export { QuadArrowShape } from '../src/shapes/quad-arrow-shape';
+export { RectangleShape } from '../src/shapes/rectangle-shape';
+export { Ribbon2Shape } from '../src/shapes/ribbon2-shape';
+export { RibbonShape } from '../src/shapes/ribbon-shape';
+export { RightArrowCalloutShape } from '../src/shapes/right-arrow-callout-shape';
+export { RightArrowShape } from '../src/shapes/right-arrow-shape';
+export { RightBraceShape } from '../src/shapes/right-brace-shape';
+export { RightBracketShape } from '../src/shapes/right-bracket-shape';
+export { RightTriangleShape } from '../src/shapes/right-triangle-shape';
+export { Round1RectShape } from '../src/shapes/round-rectangle1-shape';
+export { Round2DiagRectShape } from '../src/shapes/round-rectangle2-diagonal-shape';
+export { Round2SameRectShape } from '../src/shapes/round-rectangle2-shape';
+export { RoundRectangleShape } from '../src/shapes/round-rectangle-shape';
+export { SmileyFaceShape } from '../src/shapes/smiley-face-shape';
+export { SnipRectangle1Shape } from '../src/shapes/snip-rectangle1-shape';
+export { SnipRectangle2DiagonalShape } from '../src/shapes/snip-rectangle2-diagonal-shape';
+export { SnipRectangle2SameShape } from '../src/shapes/snip-rectangle2-same-shape';
+export { SnipRoundRectangle1Shape } from '../src/shapes/snip-round-rectangle1-shape';
+export { SquareTabsShape } from '../src/shapes/square-tabs-shape';
+export { Star4Shape } from '../src/shapes/star4-shape';
+export { Star5Shape } from '../src/shapes/star5-shape';
+export { Star6Shape } from '../src/shapes/star6-shape';
+export { Star7Shape } from '../src/shapes/star7-shape';
+export { Star8Shape } from '../src/shapes/star8-shape';
+export { Star10Shape } from '../src/shapes/star10-shape';
+export { Star12Shape } from '../src/shapes/star12-shape';
+export { Star16Shape } from '../src/shapes/star16-shape';
+export { Star24Shape } from '../src/shapes/star24-shape';
+export { Star32Shape } from '../src/shapes/star32-shape';
+export { StraightConnector1Shape } from '../src/shapes/straight-connector1-shape';
+export { StripedRightArrowShape } from '../src/shapes/striped-right-arrow-shape';
+export { SunShape } from '../src/shapes/sun-shape';
+export { SwooshArrowShape } from '../src/shapes/swoosh-arrow-shape';
+export { TeardropShape } from '../src/shapes/teardrop-shape';
+export { TextBoxShape } from '../src/shapes/text-box-shape';
+export { TrapezoidShape } from '../src/shapes/trapezoid-shape';
+export { TriangleShape } from '../src/shapes/triangle-shape';
+export { UpArrowCalloutShape } from '../src/shapes/up-arrow-callout-shape';
+export { UpArrowShape } from '../src/shapes/up-arrow-shape';
+export { UpDownArrowCalloutShape } from '../src/shapes/up-down-arrow-callout-shape';
+export { UpDownArrowShape } from '../src/shapes/up-down-arrow-shape';
+export { UturnArrowShape } from '../src/shapes/uturn-arrow-shape';
+export { VerticalScrollShape } from '../src/shapes/vertical-scroll-shape';
+export { WaveShape } from '../src/shapes/wave-shape';
+export { WedgeEllipseCalloutShape } from '../src/shapes/wedge-ellipse-callout-shape';
+export { WedgeRectCalloutShape } from '../src/shapes/wedge-rect-callout-shape';
+export { WedgeRoundRectCalloutShape } from '../src/shapes/wedge-round-rect-callout-shape';
+export { computeConnectorRouteLayout, getBasicShapeRotateBound, rotatePointAroundCenter, routeConnectorLineShape } from './render-engine/connector-points-util';
+export { ShapeDefaultConfig } from './shape-default';
+export { freeRouteBentConnectorLinePoints } from './util/connector-points-util';
+export type { IBentConnectorResult } from './util/connector-points-util';
+export { ConnectorCoordinateTransform } from './util/connector-transform';
+export { isConnectorShape, isCurvedConnectorShape } from './util/shape-util';

package/lib/types/model/shape-model.d.ts

@@ -0,0 +1,107 @@
+import { ShapeTypeEnum, BasicShapeEnum } from '../shape-enum';
+import { IBasicShapeData, ICustomShapeTextData, IGdContext, IPresetShapeConfig, IShapeAdjustItemResolved, IShapeContextOptions, IShapeJSONData, IShapeModel, IShapePoint, IShapePointWithAdjName, IShapeRect, IShapeRelation, IShapeRelationItem, IShapeRenderParameters, IShapeText } from '../shape-type';
+export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+export declare class BasicShapeModel implements IShapeModel {
+    protected _shapeType: ShapeTypeEnum;
+    private readonly _id;
+    protected _shapeData: IBasicShapeData;
+    /**
+     * this property is only used for LineShapeRenderModel to indicate whether to render line points for routing
+     */
+    private _isRenderLinePointsMode;
+    private _context;
+    private _renderModel;
+    private _adjustNameMap;
+    constructor(shapeType: ShapeTypeEnum, id: string, shapeData?: IBasicShapeData);
+    changeShapeType(shapeType: ShapeTypeEnum, shapeData?: IBasicShapeData): void;
+    getShapeType(): ShapeTypeEnum;
+    getShapeRelation(): IShapeRelation | undefined;
+    getBasicShapeType(): BasicShapeEnum;
+    getId(): string;
+    /**
+     * get shape text data
+     * @returns The shape text data
+     */
+    getShapeTextData(): IShapeText | ICustomShapeTextData;
+    /**
+     * set shape text data
+     * @param shapeText The shape text data
+     */
+    setShapeTextData(shapeText: IShapeText | ICustomShapeTextData): void;
+    /**
+     * get shape text rect, the shape text rect is defined in shape preset config, if not exist, return the whole shape rect, we will add padding in render model
+     * @param rect The drawing rect, define the position and size of the shape
+     * @returns {IShapeRect} The shape text rect, the position is relative to the shape rect
+     */
+    getShapeTextRect(rect: IShapeRect): IShapeRect;
+    setShapeType(shapeType: ShapeTypeEnum, shapeData?: IBasicShapeData): void;
+    getShapeData(): IBasicShapeData;
+    setShapeData(shapeData: IBasicShapeData, merge?: boolean): void;
+    getPresetShapeConfig(): IPresetShapeConfig;
+    getAdjustNames(): string[];
+    /**
+     * Only for connector shape, get the start connection info
+     * @returns {IShapeRelationItem | undefined} The start connection info
+     */
+    getStartConnectInfo(): IShapeRelationItem | undefined;
+    /**
+     * Only for connector shape, get the end connection info
+     * @returns {IShapeRelationItem | undefined} The end connection info
+     */
+    getEndConnectInfo(): IShapeRelationItem | undefined;
+    getConnectorLinePoints(): IShapePoint[];
+    /**
+     * Get all connection sites (cxnLst) for this shape.
+     * Connection sites are the points where connectors can attach to the shape.
+     * @returns Array of connection site points with their index and resolved coordinates
+     */
+    getConnectionSiteList(): Array<{
+        x: number;
+        y: number;
+        index: number;
+        ang: number;
+    }>;
+    getAdjustInfoByName(adjName: string): IShapeAdjustItemResolved | undefined;
+    getAdjustInfo(index: number): IShapeAdjustItemResolved | undefined;
+    private _getAdjustIndexByName;
+    private _getAdjScope;
+    private _setAdjustValue;
+    clearAdjustValue(): void;
+    /**
+     * et adjust value by adj name
+     * @param {string} adjName The name of adj point
+     * @param {number} value The set val of adj point
+     * @returns {number} The actual set val of adj point, it will consider about max min value
+     */
+    setAdjustValueByName(adjName: string, value: number): number;
+    getAdjustValueByName(adjName: string): number | undefined;
+    updateContext(options: IShapeContextOptions): void;
+    getGdRecord(): Partial<IGdContext>;
+    updateLinePoints(points: IShapePoint[]): void;
+    get isRenderLinePointsMode(): boolean;
+    removeLinePoints(): void;
+    /**
+     * Check if this is a line shape.
+     * @returns true if this is a line shape (connector, line, etc.)
+     */
+    isLineShape(): boolean;
+    /**
+     * Test if a point hits the line shape.
+     * This method should only be called for line shapes.
+     * It checks if the point is within the hit tolerance of any line segment or curve.
+     *
+     * @param pointX The x-coordinate of the point to test (in local coordinates, centered)
+     * @param pointY The y-coordinate of the point to test (in local coordinates, centered)
+     * @param width The width of the shape
+     * @param height The height of the shape
+     * @param tolerance The hit tolerance in pixels (default: 8)
+     * @returns true if the point hits the line shape
+     */
+    isHitLine(pointX: number, pointY: number, width: number, height: number, tolerance?: number): boolean;
+    render(canvasContext: CanvasRenderingContext2D, rect: IShapeRect, renderOption: IShapeRenderParameters): void;
+    getDrawingPoints(): IShapePointWithAdjName[];
+    calcAdjValue(rect: IShapeRect, point: IShapePoint, adjustInfo: IShapeAdjustItemResolved, isFlipH: boolean, isFlipV: boolean): number;
+    dispose(): void;
+    toJSON(): IShapeJSONData;
+    fromJSON(json: IShapeJSONData): void;
+}

package/lib/types/perset-shape-config.d.ts

@@ -0,0 +1,2 @@
+import { IPresetShapeConfigMap } from './shape-type';
+export declare const PresetShapeConfig: IPresetShapeConfigMap;

package/lib/types/render-engine/base-shape-context.d.ts

@@ -0,0 +1,9 @@
+import { IBasicShapeData, IGdContext, IPresetShapeConfig, IShapeContextOptions } from '../shape-type';
+export declare class BaseShapeContext {
+    private _gdRecord;
+    getGdRecord(): Partial<IGdContext>;
+    reset(): void;
+    private _transformAgValueToNumber;
+    private _calcAdValueByOperator;
+    buildGdRecord(options: IShapeContextOptions, presetShapeConfig: IPresetShapeConfig, shapeDataConfig?: IBasicShapeData): void;
+}

package/lib/types/render-engine/bent-connector-router-util.d.ts

@@ -0,0 +1,48 @@
+import { IBentConnectorResult, IShapePoint, IShapeRect } from '../shape-type';
+import { ShapeDirectionEnum } from '../shape-enum';
+/**
+ * Route a free-free bent connector line (Excel-like behavior).
+ *
+ * 根据 Excel 的行为，对首尾都为自由点的 bent 连接线进行布点计算。
+ * 该方法不涉及自动 routing、障碍规避或连接点约束，
+ * 仅依据 start / end 构成的矩形关系生成折线路径。
+ *
+ * Core rules / 核心规则：
+ *
+ * 1. Start point and end point define a local bounding rectangle.
+ *    If the width (end.x - start.x) is negative, the width is stored
+ *    as an absolute value and flipH is set to true.
+ *    The same rule applies to height (flipV) in the vertical direction.
+ *
+ *    起点和终点共同定义一个局部矩形。
+ *    如果 end.x - start.x < 0，则使用 width = abs(width)，
+ *    同时记录 flipH = true。
+ *    垂直方向同理，记录 flipV。
+ *
+ * 2. The absolute width and height determine the bend orientation.
+ *    If |width| >= |height|, points are generated in
+ *    horizontal-first then vertical order (H → V).
+ *    Otherwise, points are generated in vertical-first
+ *    then horizontal order (V → H).
+ *
+ *    通过宽高绝对值决定折线方向：
+ *    - |width| >= |height|：先横后竖
+ *    - |width| <  |height|：先竖后横
+ *
+ * 3. The returned points are always generated in a normalized
+ *    (non-flipped) coordinate space. The actual visual direction
+ *    is determined by flipH / flipV.
+ *
+ *    返回的点始终基于“未翻转”的规范坐标系生成，
+ *    实际方向由 flipH / flipV 决定。
+ */
+export declare function freeRouteBentConnectorLinePoints(startPoint: IShapePoint, endPoint: IShapePoint): IBentConnectorResult;
+/**
+ * Simplified route connector for normalized inputs.
+ * Assumes: logicalStart.x <= logicalEnd.x (start is to the left or same x as end)
+ * This reduces the number of cases we need to handle.
+ *
+ * startDir: direction we're going OUT from start (0=right, 90=down, 180=left, 270=up)
+ * endDir: direction we need to ENTER end from (0=right means line approaches from right)
+ */
+export declare function routeByDirectionsNormalized(points: IShapePoint[], exitPoint: IShapePoint, approachPoint: IShapePoint, startDir: ShapeDirectionEnum, endDir: ShapeDirectionEnum, startBounds: IShapeRect, endBounds: IShapeRect): void;

package/lib/types/render-engine/connector-points-util.d.ts

@@ -0,0 +1,44 @@
+import { IConnectorRouteLayoutResult, IConnectPointInfo, ILineType, IShapePoint, IShapeRect } from '../shape-type';
+export declare const BENT_CONNECTOR_HANDLE_OFFSET = 40;
+export declare function routeConnectorLineShape(startInfo: IConnectPointInfo, endInfo: IConnectPointInfo, lineType: ILineType): IShapePoint[];
+/**
+ * Rotate a point around a center point by a given angle.
+ * Positive angle = counter-clockwise rotation.
+ * Used to de-rotate points before calculating adjust values.
+ */
+export declare function rotatePointAroundCenter(point: IShapePoint, center: IShapePoint, angleInDegrees: number): IShapePoint;
+/**
+ * In excel, the basic shape with rotate bound use major axis switch, xis-aligned bound will bu used.
+ * 在excel中，基本形状的旋转边界使用主轴切换，将使用轴对齐边界。也就是说，一个shape旋转了44度的时候，接近他的是0度，因此他的bound也是0度的bound
+ * 如果旋转到了45度，则接近他的就是90度，因此他的bound就是90度的bound
+ * [-45°, 45°) -> 0° 横向
+ * [45°, 135°) -> 90° 纵向
+ * [135°, 225°) -> 180° 横向
+ * [225°, 315°) -> 270° 纵向
+ * @param bound The original axis-aligned bound
+ * @param angle The rotation angle in degrees
+ * @return {IShapeRect} The axis-aligned bound after rotation
+ */
+export declare function getBasicShapeRotateBound(bound: IShapeRect, angle: number): IShapeRect;
+export declare function computeStraightConnectorRouteLayout(routedPoints: IShapePoint[], originalLineType: ILineType): IConnectorRouteLayoutResult;
+export declare function computeConnectorRouteLayout(routedPoints: IShapePoint[], originalLineType: ILineType): IConnectorRouteLayoutResult;
+/**
+ * Route a bent connector line between two connected shapes.
+ *
+ * This algorithm generates a polyline path that:
+ * 1. Exits the start shape in the direction specified by startInfo.angle
+ * 2. Routes around shapes to avoid overlap
+ * 3. Enters the end shape from the direction specified by endInfo.angle
+ *
+ * Optimization: To reduce complexity, we normalize the input so that the
+ * "logical start" is always at the top-left relative to the "logical end".
+ * If needed, we swap the inputs and reverse the result at the end.
+ *
+ * The algorithm considers all 16 combinations of the 4 cardinal directions:
+ * - 0° = right, 90° = down, 180° = left, 270° = up
+ *
+ * @param startInfo - Connection point info for the start shape
+ * @param endInfo - Connection point info for the end shape
+ * @returns Array of points forming the bent connector path
+ */
+export declare function routeBentConnectorLineShape(startInfo: IConnectPointInfo, endInfo: IConnectPointInfo): IShapePoint[];

package/lib/types/render-engine/line-shape-render-model.d.ts

@@ -0,0 +1,135 @@
+import { IShapeData, IShapePoint, IShapeRect, IShapeRenderParameters } from '../shape-type';
+import { BaseShapeContext } from './base-shape-context';
+import { BaseShapeRenderModel } from './shape-render-model';
+/**
+ * Base class for line-type shapes (connectors, lines).
+ *
+ * This class provides specialized hit testing for line shapes.
+ * Instead of using the bounding rectangle for hit detection,
+ * it checks if the point is within a certain distance of the actual line segments.
+ *
+ * All connector shapes (BentConnector2-5, CurvedConnector2-5, StraightConnector1, Line)
+ * should extend this class to get proper line hit testing behavior.
+ */
+export declare abstract class LineShapeRenderModel extends BaseShapeRenderModel {
+    protected _isLineShape: boolean;
+    /**
+     * Check if a point is near a line segment.
+     *
+     * @param point The point to test
+     * @param lineStart Start point of the line segment
+     * @param lineEnd End point of the line segment
+     * @param tolerance Maximum distance from the line to be considered "near"
+     * @returns true if the point is within tolerance distance of the line segment
+     */
+    protected _isPointNearLineSegment(point: IShapePoint, lineStart: IShapePoint, lineEnd: IShapePoint, tolerance?: number): boolean;
+    /**
+     * Check if a point is near a quadratic Bezier curve.
+     *
+     * @param point The point to test
+     * @param p0 Start point
+     * @param p1 Control point
+     * @param p2 End point
+     * @param tolerance Maximum distance from the curve to be considered "near"
+     * @param samples Number of samples to take along the curve
+     * @returns true if the point is within tolerance distance of the curve
+     */
+    protected _isPointNearQuadraticBezier(point: IShapePoint, p0: IShapePoint, p1: IShapePoint, p2: IShapePoint, tolerance?: number, samples?: number): boolean;
+    /**
+     * Check if a point is near a cubic Bezier curve.
+     *
+     * @param point The point to test
+     * @param p0 Start point
+     * @param p1 First control point
+     * @param p2 Second control point
+     * @param p3 End point
+     * @param tolerance Maximum distance from the curve to be considered "near"
+     * @param samples Number of samples to take along the curve
+     * @returns true if the point is within tolerance distance of the curve
+     */
+    protected _isPointNearCubicBezier(point: IShapePoint, p0: IShapePoint, p1: IShapePoint, p2: IShapePoint, p3: IShapePoint, tolerance?: number, samples?: number): boolean;
+    /**
+     * Process a single path command and check if the point is near it.
+     *
+     * @returns Object with hit result and updated current/start points
+     */
+    private _processPathCommand;
+    private _handleMoveTo;
+    private _handleLineTo;
+    private _handleQuadraticBezier;
+    private _handleCubicBezier;
+    private _handleClosePath;
+    /**
+     * Test if a point hits the line shape.
+     *
+     * This method checks if the point is within the hit tolerance of any
+     * line segment or curve in the shape's path.
+     *
+     * @param pointX The x-coordinate of the point to test (in local coordinates)
+     * @param pointY The y-coordinate of the point to test (in local coordinates)
+     * @param shapeContext The shape context containing gd values
+     * @param tolerance The hit tolerance in pixels
+     * @returns true if the point hits the line shape
+     */
+    isHitLine(pointX: number, pointY: number, shapeContext: BaseShapeContext, tolerance?: number): boolean;
+    /**
+     * Get a value from the gdRecord, handling both number and string keys.
+     */
+    private _getGdValue;
+    renderWithPoints(canvasContext: CanvasRenderingContext2D, shapeContext: BaseShapeContext, shapeData: IShapeData, renderOption: IShapeRenderParameters): void;
+    /**
+     * Override render method to handle line shapes with arrows
+     * This preserves bezier curve structure when adjusting endpoints for arrows
+     */
+    render(canvasContext: CanvasRenderingContext2D, rect: IShapeRect, shapeContext: BaseShapeContext, shapeData: IShapeData, renderOption: IShapeRenderParameters): void;
+    private _scalePoints;
+    private _executePathCommand;
+    private _applyFill;
+    private _applyStrokeWithArrows;
+    /**
+     * Extract start and end points with tangent direction points for arrow rendering
+     * For bezier curves, uses control points to get correct tangent direction
+     */
+    private _extractEndpointsWithTangents;
+    /**
+     * Get the end point coordinates from a path command
+     */
+    private _getCommandEndPoint;
+    /**
+     * Get the first control/target point from a path command for direction calculation
+     */
+    private _getCommandFirstPoint;
+    /**
+     * Adjust start point of path commands for arrow
+     */
+    private _adjustStartPointForArrow;
+    /**
+     * Adjust end point of path commands for arrow
+     */
+    private _adjustEndPointForArrow;
+    private _adjustEndPointByCommand;
+    private _adjustCubicBezierEndPoint;
+    private _adjustQuadraticBezierEndPoint;
+    private _adjustLineEndPoint;
+    /**
+     * Get adjusted line path commands with endpoints moved inward to avoid overlap with arrows
+     */
+    private _getAdjustedLinePathCommands;
+    private _drawLineExtends;
+    private _calculateAngle;
+    private _getArrowDimensions;
+    private _drawArrow;
+    private _drawFilledArrow;
+    private _drawOpenArrow;
+    private _drawDiamondArrow;
+    private _drawStealthArrow;
+    private _drawOvalArrow;
+    private _getLineFillStyle;
+    private _getLineStrokeStyle;
+    private _getLineDashType;
+    private _getLineCapType;
+    private _getLineJoinType;
+    private _createLineGradient;
+    private _renderCxnPointsForLine;
+    private _renderAdjustHandlesForLine;
+}

package/lib/types/render-engine/point-to-shape-transform.d.ts

@@ -0,0 +1,13 @@
+import { IShapePoint } from '../shape-type';
+interface Point {
+    x: number;
+    y: number;
+}
+interface TransformResult {
+    rotation: 0 | 90 | 180 | 270;
+    flipH: boolean;
+    flipV: boolean;
+    restorePoints: IShapePoint[];
+}
+export declare function resolveTransform(points: Point[]): TransformResult;
+export {};

package/lib/types/render-engine/shape-context-operator.d.ts

@@ -0,0 +1,19 @@
+export declare class ShapeContextStaticOperator {
+    static val(value: number): number;
+    static pin(value: number, min: number, max: number): number;
+    static addSub(a: number, b: number, c: number): number;
+    static mulDiv(a: number, b: number, c: number): number;
+    static addDiv(a: number, b: number, c: number): number;
+    static abs(value: number): number;
+    static max(a: number, b: number): number;
+    static min(a: number, b: number): number;
+    static ifelse(condition: boolean, trueValue: number, falseValue: number): number;
+    static sin(yr: number, ang: number): number;
+    static cos(xr: number, ang: number): number;
+    static tan(xr: number, ang: number): number;
+    static mod(a: number, b: number, c: number): number;
+    static sqrt(value: number): number;
+    static atan2(x: number, y: number): number;
+    static cat2(x: number, y: number, z: number): number;
+    static sat2(x: number, y: number, z: number): number;
+}