oolong-engine 0.0.1

package/dist/plugin-pointer/interact/default/stretch/AbsStretchProcessor.d.ts

@@ -0,0 +1,69 @@
+import { StreamProcessor } from "../../basic/StreamProcessor";
+import { InteractiveEvent, IRectNode, Point, Rect } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+import { IPoint } from "../../../../idl";
+import { SingleStretchInfo } from "../../detector/stretch/StretchDetector";
+import { CropProps, GraphicNode, OolongLine, OolongSVGNode } from "../../../../graphics";
+import { AffineMatrix } from "../../../../math";
+import { AlignWorker } from "../../align/AlignWorker";
+import { AlignStretchResultInfo, StretchAlignType } from "../../align/AlignResult";
+import { LayoutWorker } from "../../../../ability/line/LayoutWorker";
+import { RelatedGroupBaseWorker } from "../../../../ability/group/RelatedGroupBaseWorker";
+import { AbsStretchHandler } from "./handler/AbsStretchHandler";
+import { AbsImgNode } from "../../../../graphics/img/AbsImgNode";
+import { StretchCropNodeHandler } from "./handler/StretchCropNodeHandler";
+export interface CropInfo {
+    originCropProps: CropProps;
+    originImgRect: Rect;
+    originTransform: AffineMatrix;
+    globalImgPos: IPoint;
+}
+export interface INodeStretchProp {
+    x: number;
+    y: number;
+    height: number;
+    width: number;
+    points?: IPoint[];
+    crop?: CropInfo;
+}
+export declare abstract class AbsStretchProcessor extends StreamProcessor {
+    minStretchSize: IPoint;
+    originPos: Point;
+    originStretchRect?: Rect;
+    propsMap: Map<GraphicNode, INodeStretchProp>;
+    originTransform: AffineMatrix;
+    viewBounds: IRectNode;
+    target: SingleStretchInfo | null;
+    alignWorker: AlignWorker;
+    alignType: StretchAlignType;
+    originWidthHeightRatio: number;
+    isUniform: boolean;
+    relatedLines: Set<OolongLine>;
+    layoutWorker: LayoutWorker;
+    cropStretchHandler: StretchCropNodeHandler;
+    groupBaseWorker: RelatedGroupBaseWorker;
+    abstract handlers: AbsStretchHandler[];
+    abstract getStretchRect(ctx: AppEventContext): Rect;
+    abstract getMiniSize(ctx: AppEventContext): IPoint;
+    protected abstract recordPropsMap(ctx: AppEventContext): void;
+    protected recordNodePropInfo(node: GraphicNode): INodeStretchProp;
+    computeAnchorPoint(stretchInfo: SingleStretchInfo, rect: Rect): {
+        x: number;
+        y: number;
+    };
+    protected abstract computeOriginTransform(ctx: AppEventContext): void;
+    protected judgeUniform(ctx: AppEventContext): void;
+    computeStretchRect(stretchRect: Rect, delta: IPoint): void;
+    protected computeTarget(event: InteractiveEvent, ctx: AppEventContext): void;
+    onStart(event: InteractiveEvent, ctx: AppEventContext): void;
+    onMove(event: InteractiveEvent, ctx: AppEventContext): void;
+    onUp(event: InteractiveEvent, ctx: AppEventContext): void;
+    protected alignStretchGlobalPoint(event: InteractiveEvent, ctx: AppEventContext): IPoint;
+    protected stretchNode(event: InteractiveEvent, ctx: AppEventContext, streaming: boolean): void;
+    protected afterStretchNode(ctx: AppEventContext, sx: number, sy: number, M: AffineMatrix, streaming: boolean, cropImgNodes: AbsImgNode[], svgNodes: OolongSVGNode[]): void;
+    protected computeScale(stretchRect: Rect): {
+        sx: number;
+        sy: number;
+    };
+    protected abstract drawAlignLine(stretchRect: Rect, alignRes: AlignStretchResultInfo, ctx: AppEventContext): void;
+}

package/dist/plugin-pointer/interact/default/stretch/SingleStretchMode.d.ts

@@ -0,0 +1,7 @@
+import { DownAndMoveStreamMode } from "../../basic/DownAndMoveStreamMode";
+import { InteractiveEvent } from "../../../../common/index";
+import { AppEventContext } from "../../../../app/index";
+export declare class SingleStretchMode extends DownAndMoveStreamMode {
+    constructor();
+    streamEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/default/stretch/SingleStretchProcessorV2.d.ts

@@ -0,0 +1,15 @@
+import { Rect } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+import { AlignStretchResultInfo } from "../../align/AlignResult";
+import { AbsStretchProcessor } from "./AbsStretchProcessor";
+import { IPoint } from "../../../../idl";
+import { SingleStretchNodeHandler } from "./handler/SingleStretchNodeHandler";
+export declare class SingleStretchProcessorV2 extends AbsStretchProcessor {
+    handlers: SingleStretchNodeHandler[];
+    getStretchRect(ctx: AppEventContext): Rect;
+    getMiniSize(ctx: AppEventContext): IPoint;
+    protected recordPropsMap(ctx: AppEventContext): void;
+    protected judgeUniform(ctx: AppEventContext): void;
+    computeOriginTransform(ctx: AppEventContext): void;
+    drawAlignLine(stretchRect: Rect, alignRes: AlignStretchResultInfo, ctx: AppEventContext): void;
+}

package/dist/plugin-pointer/interact/default/stretch/StretchMode.d.ts

@@ -0,0 +1,7 @@
+import { DownAndMoveStreamMode } from "../../basic/DownAndMoveStreamMode";
+import { InteractiveEvent } from "../../../../common/index";
+import { AppEventContext } from "../../../../app/index";
+export declare class StretchMode extends DownAndMoveStreamMode {
+    constructor();
+    streamEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/default/stretch/StretchProcessorV2.d.ts

@@ -0,0 +1,15 @@
+import { AbsStretchProcessor } from "./AbsStretchProcessor";
+import { AppEventContext } from "../../../../app";
+import { Rect } from "../../../../common";
+import { AlignStretchResultInfo } from "../../align/AlignResult";
+import { IPoint } from "../../../../idl";
+import { StretchLineHandler } from "./handler/StretchLineHandler";
+import { StretchNodeHandler } from "./handler/StretchNodeHandler";
+export declare class StretchProcessorV2 extends AbsStretchProcessor {
+    handlers: (StretchLineHandler | StretchNodeHandler)[];
+    protected computeOriginTransform(ctx: AppEventContext): void;
+    protected recordPropsMap(ctx: AppEventContext): void;
+    protected drawAlignLine(stretchRect: Rect, alignRes: AlignStretchResultInfo, ctx: AppEventContext): void;
+    getMiniSize(ctx: AppEventContext): IPoint;
+    getStretchRect(ctx: AppEventContext): Rect;
+}

package/dist/plugin-pointer/interact/default/stretch/handler/AbsStretchHandler.d.ts

@@ -0,0 +1,8 @@
+import { GraphicNode } from "../../../../../graphics";
+import { UpdateNodeInfo } from "../../../../../action";
+import { AffineMatrix } from "../../../../../math";
+import { INodeStretchProp } from "../AbsStretchProcessor";
+export declare abstract class AbsStretchHandler {
+    abstract enable(node: GraphicNode): boolean;
+    abstract handle(node: GraphicNode, info: INodeStretchProp, sx: number, sy: number, M: AffineMatrix): UpdateNodeInfo[];
+}

package/dist/plugin-pointer/interact/default/stretch/handler/SingleStretchNodeHandler.d.ts

@@ -0,0 +1,9 @@
+import { GraphicNode } from "../../../../../graphics";
+import { UpdateNodeInfo } from "../../../../../action";
+import { AffineMatrix } from "../../../../../math";
+import { INodeStretchProp } from "../AbsStretchProcessor";
+import { AbsStretchHandler } from "./AbsStretchHandler";
+export declare class SingleStretchNodeHandler extends AbsStretchHandler {
+    enable(node: GraphicNode): boolean;
+    handle(node: GraphicNode, info: INodeStretchProp, sx: number, sy: number, M: AffineMatrix): UpdateNodeInfo[];
+}

package/dist/plugin-pointer/interact/default/stretch/handler/StretchCropNodeHandler.d.ts

@@ -0,0 +1,10 @@
+import { GraphicNode } from "../../../../../graphics";
+import { UpdateNodeInfo } from "../../../../../action";
+import { AffineMatrix } from "../../../../../math";
+import { INodeStretchProp } from "../AbsStretchProcessor";
+import { AbsStretchHandler } from "./AbsStretchHandler";
+export declare class StretchCropNodeHandler extends AbsStretchHandler {
+    enable(node: GraphicNode): boolean;
+    handle(node: GraphicNode, info: INodeStretchProp, sx: number, sy: number, M: AffineMatrix): UpdateNodeInfo[];
+    private handleCropProp;
+}

package/dist/plugin-pointer/interact/default/stretch/handler/StretchLineHandler.d.ts

@@ -0,0 +1,9 @@
+import { GraphicNode } from "../../../../../graphics";
+import { UpdateNodeInfo } from "../../../../../action";
+import { AffineMatrix } from "../../../../../math";
+import { INodeStretchProp } from "../AbsStretchProcessor";
+import { AbsStretchHandler } from "./AbsStretchHandler";
+export declare class StretchLineHandler extends AbsStretchHandler {
+    enable(node: GraphicNode): boolean;
+    handle(node: GraphicNode, info: INodeStretchProp, sx: number, sy: number, M: AffineMatrix): UpdateNodeInfo[];
+}

package/dist/plugin-pointer/interact/default/stretch/handler/StretchNodeHandler.d.ts

@@ -0,0 +1,9 @@
+import { GraphicNode } from "../../../../../graphics";
+import { UpdateNodeInfo } from "../../../../../action";
+import { AffineMatrix } from "../../../../../math";
+import { INodeStretchProp } from "../AbsStretchProcessor";
+import { AbsStretchHandler } from "./AbsStretchHandler";
+export declare class StretchNodeHandler extends AbsStretchHandler {
+    enable(node: GraphicNode): boolean;
+    handle(node: GraphicNode, info: INodeStretchProp, sx: number, sy: number, M: AffineMatrix): UpdateNodeInfo[];
+}

package/dist/plugin-pointer/interact/detector/CropOriginImgDetector.d.ts

@@ -0,0 +1,8 @@
+import { AbsDetector, InteractiveEvent, StretchType } from "../../../common";
+import { AppEventContext } from "../../../app";
+export interface CropImgDetectInfo {
+    type: StretchType;
+}
+export declare class CropOriginImgDetector extends AbsDetector<CropImgDetectInfo> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/DetectorResult.d.ts

@@ -0,0 +1,34 @@
+import { DetectorEnum } from "../../../common";
+import { NodeDetector } from "./node/NodeDetector";
+import { HoverNodeDetector } from "./hover/HoverNodeDetector";
+import { StretchDetector } from "./stretch/StretchDetector";
+import { ExpandDetector } from "./ExpandDetector";
+import { LineEndPointDetector } from "./LineEndPointDetector";
+import { NodeEdgeDetector } from "./connect/NodeEdgeDetector";
+import { BufferNodeDetector } from "./node/BufferNodeDetector";
+import { BufferHoverNodeDetector } from "./hover/BufferHoverNodeDetector";
+import { HoverNodeAnchorDetector } from "./connect/HoverNodeAnchorDetector";
+import { PolyLineControlPointDetector } from "./PolyLineControlPointDetector";
+import { HoverConnectAnchorDetector } from "./connect/HoverConnectAnchorDetector";
+import { RotateDetector } from "./RotateDetector";
+import { HoverContainerDetector } from "./hover/HoverContainerDetector";
+import { ImgDetector } from "./img/ImgDetector";
+import { CropOriginImgDetector } from "./CropOriginImgDetector";
+export interface DetectorResult {
+    [DetectorEnum.Node]: NodeDetector["result"];
+    [DetectorEnum.HoverNode]: HoverNodeDetector["result"];
+    [DetectorEnum.Stretch]: StretchDetector["result"];
+    [DetectorEnum.ExpandShape]: ExpandDetector["result"];
+    [DetectorEnum.LineEndPoint]: LineEndPointDetector["result"];
+    [DetectorEnum.NodeEdge]: NodeEdgeDetector["result"];
+    [DetectorEnum.BufferNode]: BufferNodeDetector["result"];
+    [DetectorEnum.BufferHoverNode]: BufferHoverNodeDetector["result"];
+    [DetectorEnum.HoverNodeAnchor]: HoverNodeAnchorDetector["result"];
+    [DetectorEnum.PolyControlPoint]: PolyLineControlPointDetector["result"];
+    [DetectorEnum.HoverConnectAnchor]: HoverConnectAnchorDetector["result"];
+    [DetectorEnum.Rotate]: RotateDetector["result"];
+    [DetectorEnum.HoverOnContainer]: HoverContainerDetector["result"];
+    [DetectorEnum.Image]: ImgDetector["result"];
+    [DetectorEnum.ImageOriginBounds]: CropOriginImgDetector["result"];
+    [key: number]: any;
+}

package/dist/plugin-pointer/interact/detector/ExpandDetector.d.ts

@@ -0,0 +1,10 @@
+import { AbsDetector, InteractiveEvent } from "../../../common";
+import { AppEventContext } from "../../../app";
+import { OolongNode } from "../../../graphics";
+export interface ExpandDetectProp {
+    node: OolongNode;
+    realHeight: number;
+}
+export declare class ExpandDetector extends AbsDetector<ExpandDetectProp> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/LineEndPointDetector.d.ts

@@ -0,0 +1,12 @@
+import { AbsDetector, InteractiveEvent } from "../../../common/index";
+import { OolongLine } from "../../../graphics/index";
+import { AppEventContext } from "../../../app/index";
+import { IPoint } from "../../../idl/index";
+export interface LineEndRes {
+    detectPoint: IPoint;
+    isStart: boolean;
+    line: OolongLine;
+}
+export declare class LineEndPointDetector extends AbsDetector<LineEndRes> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/PolyLineControlPointDetector.d.ts

@@ -0,0 +1,14 @@
+import { AbsDetector, InteractiveEvent } from "../../../common/index";
+import { IPoint } from "../../../idl/index";
+import { AppEventContext } from "../../../app/index";
+import { OolongLine } from "../../../graphics/index";
+export interface LineControlRes {
+    line: OolongLine;
+    point: IPoint;
+    isHorizon: boolean;
+    lIndex: number;
+    rIndex: number;
+}
+export declare class PolyLineControlPointDetector extends AbsDetector<LineControlRes> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/RotateDetector.d.ts

@@ -0,0 +1,12 @@
+import { AbsDetector, InteractiveEvent } from "../../../common";
+import { AppEventContext } from "../../../app";
+import { GraphicNode } from "../../../graphics";
+import { IPoint } from "../../../idl";
+export interface RotateInfo {
+    rotateCenter: IPoint;
+    nodes: GraphicNode[];
+}
+export declare class RotateDetector extends AbsDetector<RotateInfo> {
+    static HOT_DISTANCE: number;
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/connect/HoverConnectAnchorDetector.d.ts

@@ -0,0 +1,13 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+import { IPoint } from "../../../../idl";
+import { GraphicNode } from "../../../../graphics";
+export interface HoverConnectAnchorResult {
+    node: GraphicNode;
+    localPoint: IPoint;
+    globalPoint: IPoint;
+    relative: IPoint;
+}
+export declare class HoverConnectAnchorDetector extends AbsDetector<HoverConnectAnchorResult> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/connect/HoverNodeAnchorDetector.d.ts

@@ -0,0 +1,12 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { IPoint } from "../../../../idl";
+import { AppEventContext } from "../../../../app";
+export interface HoverNodeAnchorDetectResult {
+    node: GraphicNode;
+    localPoint: IPoint;
+    ratio: IPoint;
+}
+export declare class HoverNodeAnchorDetector extends AbsDetector<HoverNodeAnchorDetectResult> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/connect/NodeEdgeDetector.d.ts

@@ -0,0 +1,13 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common/index";
+import { GraphicNode } from "../../../../graphics/index";
+import { IPoint } from "../../../../idl/index";
+import { AppEventContext } from "../../../../app/index";
+interface NodeEdgeDetectResult {
+    node: GraphicNode;
+    point: IPoint;
+    relativePos: IPoint;
+}
+export declare class NodeEdgeDetector extends AbsDetector<NodeEdgeDetectResult> {
+    protected onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}
+export {};

package/dist/plugin-pointer/interact/detector/hover/BufferHoverNodeDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common/index";
+import { GraphicNode } from "../../../../graphics/index";
+import { AppEventContext } from "../../../../app/index";
+export declare class BufferHoverNodeDetector extends AbsDetector<GraphicNode> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/hover/HoverContainerDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { AppEventContext } from "../../../../app";
+export declare class HoverContainerDetector extends AbsDetector<GraphicNode> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/hover/HoverNodeDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { AppEventContext } from "../../../../app";
+export declare class HoverNodeDetector extends AbsDetector<GraphicNode> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/img/ImgDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { AppEventContext } from "../../../../app";
+export declare class ImgDetector extends AbsDetector<GraphicNode> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/node/BufferNodeDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common/index";
+import { GraphicNode } from "../../../../graphics/index";
+import { AppEventContext } from "../../../../app/index";
+export declare class BufferNodeDetector extends AbsDetector<GraphicNode[]> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/node/NodeDetector.d.ts

@@ -0,0 +1,6 @@
+import { AbsDetector, InteractiveEvent } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { AppEventContext } from "../../../../app";
+export declare class NodeDetector extends AbsDetector<GraphicNode[]> {
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/detector/stretch/StretchDetector.d.ts

@@ -0,0 +1,16 @@
+import { AbsDetector, InteractiveEvent, Rect, StretchType } from "../../../../common";
+import { GraphicNode } from "../../../../graphics";
+import { AppEventContext } from "../../../../app";
+import { IPoint } from "../../../../idl";
+export interface SingleStretchInfo {
+    nodes: GraphicNode[];
+    type: StretchType;
+}
+export declare class StretchDetector extends AbsDetector<SingleStretchInfo> {
+    static HOT_DISTANCE: number;
+    computeLocalPoint(nodes: GraphicNode[], event: InteractiveEvent, ctx: AppEventContext): {
+        localPoint: IPoint;
+        rect: Rect;
+    };
+    onDetect(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/dragCanvas/DragCanvasCursorProcessor.d.ts

@@ -0,0 +1,7 @@
+import { IProcessor } from "../basic/IProcessor";
+import { InteractiveEvent, InteractiveEventType } from "../../../common";
+import { AppEventContext } from "../../../app";
+export declare class DragCanvasCursorProcessor implements IProcessor {
+    allowEventTypeSet: Set<InteractiveEventType>;
+    process(event: InteractiveEvent, eventCtx: AppEventContext): void;
+}

package/dist/plugin-pointer/interact/dragCanvas/DragCanvasMainMode.d.ts

@@ -0,0 +1,7 @@
+import { AbsMainMode } from "../basic/MainMode";
+import { InteractiveEvent } from "../../../common";
+import { AppEventContext } from "../../../app";
+export declare class DragCanvasMainMode extends AbsMainMode {
+    constructor();
+    canBeEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/dragCanvas/DragCanvasProcessor.d.ts

@@ -0,0 +1,10 @@
+import { StreamProcessor } from "../basic/StreamProcessor";
+import { IPoint } from "../../../idl";
+import { InteractiveEvent } from "../../../common";
+import { AppEventContext } from "../../../app";
+export declare class DragCanvasProcessor extends StreamProcessor {
+    lastPoint: IPoint | null;
+    onStart(event: InteractiveEvent, ctx: AppEventContext): void;
+    onMove(event: InteractiveEvent, ctx: AppEventContext): void;
+    onUp(event: InteractiveEvent, ctx: AppEventContext): void;
+}

package/dist/plugin-pointer/interact/dragCanvas/submode/ContextDragCanvasMode.d.ts

@@ -0,0 +1,7 @@
+import { DownAndMoveStreamMode } from "../../basic/DownAndMoveStreamMode";
+import { InteractiveEvent } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+export declare class ContextDragCanvasMode extends DownAndMoveStreamMode {
+    constructor();
+    streamEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/dragCanvas/submode/DragCanvasMode.d.ts

@@ -0,0 +1,7 @@
+import { InteractiveEvent } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+import { StreamMode } from "../../basic/StreamMode";
+export declare class DragCanvasMode extends StreamMode {
+    constructor();
+    streamEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/dragCanvas/submode/DragCanvasNormalMode.d.ts

@@ -0,0 +1,8 @@
+import { AbsSubMode } from "../../basic/SubMode";
+import { InteractiveEvent } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+export declare class DragCanvasNormalMode extends AbsSubMode {
+    constructor();
+    canBeEnable(_event: InteractiveEvent, _ctx: AppEventContext): boolean;
+    canBeExit(_event: InteractiveEvent, _ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/utils/RectUtils.d.ts

@@ -0,0 +1,7 @@
+import { IPoint } from "../../../idl/index";
+export declare const isContains: (point: IPoint, { x, y, width, height, }: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}) => boolean;

package/dist/plugin-pointer/interact/viewOnly/ViewOnlyMode.d.ts

@@ -0,0 +1,7 @@
+import { AbsMainMode } from "../basic/MainMode";
+import { InteractiveEvent } from "../../../common";
+import { AppEventContext } from "../../../app";
+export declare class ViewOnlyMode extends AbsMainMode {
+    constructor();
+    canBeEnable(event: InteractiveEvent, ctx: AppEventContext): boolean;
+}

package/dist/plugin-pointer/interact/viewOnly/click/ViewOnlyClickMode.d.ts

@@ -0,0 +1,4 @@
+import { ClickMode } from "../../basic/ClickMode";
+export declare class ViewOnlyClickMode extends ClickMode {
+    constructor();
+}

package/dist/plugin-pointer/interact/viewOnly/click/ViewOnlyClickProcessor.d.ts

@@ -0,0 +1,4 @@
+import { ClickProcessor } from "../../basic/ClickProcessor";
+export declare class ViewOnlyClickProcessor extends ClickProcessor {
+    constructor();
+}

package/dist/plugin-pointer/interact/viewOnly/click/ViewOnlyDbClickMode.d.ts

@@ -0,0 +1,4 @@
+import { DbClickMode } from "../../basic/DbClickMode";
+export declare class ViewOnlyDbClickMode extends DbClickMode {
+    constructor();
+}

package/dist/plugin-pointer/interact/viewOnly/click/ViewOnlyDbClickProcessor.d.ts

@@ -0,0 +1,4 @@
+import { ClickProcessor } from "../../basic/ClickProcessor";
+export declare class ViewOnlyDbClickProcessor extends ClickProcessor {
+    constructor();
+}

package/dist/plugin-pointer/interact/viewOnly/normal/ViewOnlyCursorProcessor.d.ts

@@ -0,0 +1,5 @@
+import { AbsCursorProcessor } from "../../basic/cursor/AbsCursorProcessor";
+import { AbsCursorHandler } from "../../basic/cursor/handler/AbsCursorHandler";
+export declare class ViewOnlyCursorProcessor extends AbsCursorProcessor {
+    handlers: AbsCursorHandler[];
+}

package/dist/plugin-pointer/interact/viewOnly/normal/ViewOnlyNormalMode.d.ts

@@ -0,0 +1,8 @@
+import { AbsSubMode } from "../../basic/SubMode";
+import { InteractiveEvent } from "../../../../common";
+import { AppEventContext } from "../../../../app";
+export declare class ViewOnlyNormalMode extends AbsSubMode {
+    constructor();
+    canBeEnable(_event: InteractiveEvent, _ctx: AppEventContext): boolean;
+    canBeExit(_event: InteractiveEvent, _ctx: AppEventContext): boolean;
+}

package/dist/plugin-resize/WindowResizePlugin.d.ts

@@ -0,0 +1,13 @@
+import { IPlugin } from "../app/IPlugin";
+import { GMLRender } from "../application/GMLRender";
+import { AppEventContext } from "../app/index";
+export declare class WindowResizePlugin implements IPlugin {
+    eventCtx: AppEventContext;
+    prevDevicePixelRatio: number;
+    constructor(eventCtx: AppEventContext);
+    start(): void;
+    stop(): void;
+    onResize: () => void;
+    resizeCanvas(gmlRender: GMLRender, devicePixelRatio: number): void;
+    onEnable(event: Event): boolean;
+}

package/dist/plugin-resize/index.d.ts

@@ -0,0 +1 @@
+export * from "./WindowResizePlugin";

package/dist/plugin-wheel/WheelEventPlugin.d.ts

@@ -0,0 +1,11 @@
+import { AppEventContext, IPlugin } from "../app/index";
+export declare class WheelEventPlugin implements IPlugin {
+    eventCtx: AppEventContext;
+    constructor(eventCtx: AppEventContext);
+    start(): void;
+    stop(): void;
+    timer: any;
+    onWheel: (event: WheelEvent) => void;
+    generateImgAndDraw(): void;
+    onEnable(event: Event): boolean;
+}

package/dist/plugin-wheel/WheelUtils.d.ts

@@ -0,0 +1,12 @@
+import { GMLRender } from "../application/GMLRender";
+import { Point } from "../common/Point";
+import { NodeManager } from "../application/nodeManager/NodeManager";
+import { RenderManager } from "../action/render/RenderManager";
+import { ActionManager } from "../action/ActionManager";
+import { AffineMatrix } from "../math/AffineMatrix";
+export declare class WheelUtils {
+    static scroll(deltaX: number, deltaY: number, gmlRender: GMLRender): void;
+    static zoomScale(deltaY: number, gmlRender: GMLRender, globalPoint?: Point): void;
+    static zoomRedraw(gmlRender: GMLRender, nodeManager: NodeManager, renderManager: RenderManager): void;
+    static zoomToFit(gmlRender: GMLRender, nodeManager: NodeManager, actionManager: ActionManager, M: AffineMatrix): void;
+}

package/dist/plugin-wheel/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./WheelEventPlugin";
+export * from "./WheelUtils";

package/dist/preview/PreviewManager.d.ts

@@ -0,0 +1,13 @@
+import { IPoint } from "../idl";
+import { AppEventContext } from "../app";
+import { PreviewQuickCreateManager } from "./PreviewQuickCreateManager";
+import { PreviewCreateManager } from "./previewCreate/PreviewCreateManager";
+import { PreviewResourceManager } from "./PreviewResourceManager";
+export declare class PreviewManager {
+    createManager: PreviewCreateManager;
+    quickCreateManager: PreviewQuickCreateManager;
+    previewResourceManager: PreviewResourceManager;
+    addPreviewNode(ctx: AppEventContext): void;
+    updatePos(pos: IPoint): void;
+    resetPreviewNode(ctx: AppEventContext): void;
+}

package/dist/preview/PreviewQuickCreateManager.d.ts

@@ -0,0 +1,22 @@
+import { AbsProps, GraphicNode } from "../graphics";
+import { AppEventContext } from "../app";
+import { IPoint } from "../idl";
+import { ConnectInfo } from "../graphics/base/NodeConnectEndType";
+import { QuickCreateWorker } from "../ability/quickCreate/QuickCreateWorker";
+import { PolyLineLayoutHandler } from "../ability/line/handler/polyline/PolyLineLayoutHandler";
+export declare class PreviewQuickCreateManager {
+    /**
+     * 创建过程中的预览对象
+     */
+    previewGraphics: GraphicNode[];
+    createWorker: QuickCreateWorker;
+    layoutHandler: PolyLineLayoutHandler;
+    inQuickPreview: boolean;
+    static PREVIEW_ID: string;
+    static PREVIEW_LINE_ID: string;
+    enterQuickPreview(startNode: GraphicNode, relativePos: IPoint, ctx: AppEventContext): void;
+    exitQuickPreview(ctx: AppEventContext): void;
+    protected resetPreviewNode(ctx: AppEventContext): void;
+    protected makeupNodeProps(startNode: GraphicNode, nodePos: IPoint): Partial<AbsProps>[];
+    protected makeupLineProps(start: ConnectInfo, end: ConnectInfo): Partial<AbsProps>[];
+}

package/dist/preview/PreviewResourceManager.d.ts

@@ -0,0 +1,6 @@
+export declare class PreviewResourceManager {
+    previewSvgCode: string;
+    previewSvgResourceUrl: string;
+    setPreviewSvgCode(svgCode: string): void;
+    setPreviewResourceUrl(svgUrl: string): void;
+}

package/dist/preview/previewCreate/PreviewCreateManager.d.ts

@@ -0,0 +1,15 @@
+import { GraphicNode } from "../../graphics";
+import { AppEventContext } from "../../app";
+import { IPoint } from "../../idl";
+import { AbsPreviewHandler } from "./handler/AbsPreviewHandler";
+export declare class PreviewCreateManager {
+    /**
+     * 创建过程中的预览对象
+     */
+    previewGraphics: GraphicNode | null;
+    static PREVIEW_ID: string;
+    handlers: AbsPreviewHandler[];
+    addPreviewNode(ctx: AppEventContext): void;
+    updatePos(pos: IPoint): void;
+    resetPreviewNode(ctx: AppEventContext): void;
+}

package/dist/preview/previewCreate/handler/AbsPreviewHandler.d.ts

@@ -0,0 +1,7 @@
+import { ToolEnum } from "../../../tool";
+import { AppEventContext } from "../../../app";
+import { GraphicNode } from "../../../graphics";
+export declare abstract class AbsPreviewHandler {
+    abstract enable(tool: ToolEnum): boolean;
+    abstract handle(id: string, ctx: AppEventContext): Promise<GraphicNode>;
+}