@retikz/core 0.0.1-rc.0

package/dist/es/elements/Text.d.ts

@@ -0,0 +1,19 @@
+import { FC, PropsWithChildren, Ref, SVGProps } from 'react';
+import { FontProps } from '../types/svg/font';
+type TextVerticalAlign = 'top' | 'center' | 'bottom';
+export type DominantBaseline = 'auto' | 'text-bottom' | 'alphabetic' | 'ideographic' | 'middle' | 'central' | 'mathematical' | 'hanging' | 'text-top';
+export type TextProps = {
+    x?: SVGProps<SVGTextElement>['x'];
+    y?: SVGProps<SVGTextElement>['y'];
+    align?: 'start' | 'middle' | 'end' | 'inherit';
+    verticalAlign?: TextVerticalAlign | DominantBaseline;
+    fontSize?: SVGProps<SVGTextElement>['fontSize'];
+    fill?: SVGProps<SVGTextElement>['fill'];
+    ref?: Ref<SVGTextElement>;
+} & FontProps & SVGProps<SVGTextElement>;
+/**
+ * 文本节点
+ * @tikz node
+ */
+declare const Text: FC<PropsWithChildren<TextProps>>;
+export default Text;

package/dist/es/elements/Text.js

@@ -0,0 +1,35 @@
+import { j as jsxRuntimeExports } from "../_virtual/jsx-runtime.js";
+import { useMemo } from "react";
+import { textWrapParse } from "../utils/string.js";
+const Text = (props) => {
+  const { children, ref, align, verticalAlign, fontSize, fill, ...otherProps } = props;
+  const dominantBaseline = useMemo(() => {
+    switch (verticalAlign) {
+      case "top":
+        return "text-top";
+      case "bottom":
+        return "text-bottom";
+      case "center":
+        return "central";
+      default:
+        return verticalAlign;
+    }
+  }, [verticalAlign]);
+  const textProps = {
+    textAnchor: align || "middle",
+    dominantBaseline: dominantBaseline || "central",
+    fontSize: fontSize || "1em",
+    fill: fill || "currentColor",
+    ...otherProps
+  };
+  const parseChildren = (children2) => {
+    if (typeof children2 === "string") {
+      return textWrapParse(children2).map((child, index) => /* @__PURE__ */ jsxRuntimeExports.jsx("tspan", { children: child }, index));
+    }
+    return children2;
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("text", { ref, ...textProps, children: parseChildren(children) });
+};
+export {
+  Text as default
+};

package/dist/es/hooks/context/useCalculate.d.ts

@@ -0,0 +1,7 @@
+export type CalculateProps = {
+    precision: number | false;
+};
+export declare const CalculateContext: import('react').Context<CalculateProps>;
+declare const useCalculate: () => CalculateProps;
+export declare const useCalculateValue: (value: number, deep?: boolean) => number;
+export default useCalculate;

package/dist/es/hooks/context/useCalculate.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+const CalculateContext = createContext({ precision: 2 });
+const useCalculate = () => {
+  return useContext(CalculateContext);
+};
+export {
+  CalculateContext,
+  useCalculate as default
+};

package/dist/es/hooks/context/useNodes.d.ts

@@ -0,0 +1,9 @@
+import { default as NodeModel, NodeConfig, StateListener } from '../../model/component/node';
+export declare const NodesContext: import('react').Context<Map<string, NodeModel>>;
+declare const useNodes: () => {
+    subscribeModel: (name: string, listener: StateListener) => false | (() => boolean);
+    getModel: (name: string) => NodeModel | undefined;
+    updateModel: (name: string, config: NodeConfig, init?: boolean) => void;
+    deleteModel: (name: string) => void;
+};
+export default useNodes;

package/dist/es/hooks/context/useNodes.js

@@ -0,0 +1,33 @@
+import { createContext, useContext } from "react";
+import NodeModel from "../../model/component/node.js";
+const NodesContext = createContext(/* @__PURE__ */ new Map());
+const useNodes = () => {
+  const nodes = useContext(NodesContext);
+  return {
+    subscribeModel: (name, listener) => {
+      const model = nodes.get(name);
+      if (!model) return false;
+      return model.subscribe(listener);
+    },
+    getModel: (name) => nodes.get(name),
+    updateModel: (name, config, init = true) => {
+      const model = nodes.get(name);
+      if (model) {
+        model.update(config, init);
+      } else {
+        nodes.set(name, new NodeModel(config, init));
+      }
+    },
+    deleteModel: (name) => {
+      const model = nodes.get(name);
+      if (!model) return;
+      model.dispose();
+      model.notify();
+      nodes.delete(name);
+    }
+  };
+};
+export {
+  NodesContext,
+  useNodes as default
+};

package/dist/es/hooks/context/usePath.d.ts

@@ -0,0 +1,13 @@
+import { default as PathModel, StateListener } from '../../model/component/path';
+import { Position } from '../../types/coordinate/descartes';
+export declare const PathContext: import('react').Context<PathModel | null>;
+declare const usePath: () => {
+    model: PathModel;
+    subscribeModel: (listener: StateListener) => (() => boolean) | undefined;
+    updateModel: (config: {
+        ways?: Array<Position[]>;
+        lineWidth?: number;
+        init?: boolean;
+    }) => void;
+};
+export default usePath;

package/dist/es/hooks/context/usePath.js

@@ -0,0 +1,20 @@
+import { createContext, useContext } from "react";
+const PathContext = createContext(null);
+const usePath = () => {
+  const pathModel = useContext(PathContext);
+  if (!pathModel) throw new Error("usePath must be used within a PathProvider");
+  return {
+    model: pathModel,
+    subscribeModel: (listener) => {
+      if (!pathModel) return;
+      return pathModel.subscribe(listener);
+    },
+    updateModel: (config) => {
+      pathModel == null ? void 0 : pathModel.update(config);
+    }
+  };
+};
+export {
+  PathContext,
+  usePath as default
+};

package/dist/es/hooks/context/useScope.d.ts

@@ -0,0 +1,11 @@
+import { DrawProps } from '../../components/draw/Draw';
+import { NodeProps } from '../../components/node';
+import { Position } from '../../types/coordinate/descartes';
+export type ScopeProps = {
+    offset?: Position;
+    node?: Omit<NodeProps, 'name' | 'ref' | 'position' | 'offset'>;
+    draw?: Omit<DrawProps, 'ref' | 'way' | 'offset'>;
+};
+export declare const ScopeContext: import('react').Context<ScopeProps>;
+declare const useScope: () => ScopeProps;
+export default useScope;

package/dist/es/hooks/context/useScope.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from "react";
+const ScopeContext = createContext({});
+const useScope = () => useContext(ScopeContext);
+export {
+  ScopeContext,
+  useScope as default
+};

package/dist/es/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+declare const useForceUpdate: () => import('react').ActionDispatch<[]>;
+export default useForceUpdate;

package/dist/es/hooks/useForceUpdate.js

@@ -0,0 +1,8 @@
+import { useReducer } from "react";
+const useForceUpdate = () => {
+  const [_, forceUpdate] = useReducer(() => ({}), {});
+  return forceUpdate;
+};
+export {
+  useForceUpdate as default
+};

package/dist/es/index.d.ts

@@ -0,0 +1,10 @@
+export { default as Draw } from './components/draw/Draw';
+export type { DrawProps } from './components/draw/Draw';
+export { default as Node } from './components/node';
+export type { NodeProps } from './components/node';
+export { default as PathNode } from './components/pathNode';
+export type { PathNodeProps } from './components/pathNode';
+export { default as Scope } from './components/Scope';
+export type { ScopeProps } from './components/Scope';
+export { default as TikZ } from './components/TikZ';
+export type { TikZProps } from './components/TikZ';

package/dist/es/index.js

@@ -0,0 +1,12 @@
+import { default as default2 } from "./components/draw/Draw.js";
+import { default as default3 } from "./components/node/Node.js";
+import { default as default4 } from "./components/pathNode/PathNode.js";
+import { default as default5 } from "./components/Scope.js";
+import { default as default6 } from "./components/TikZ.js";
+export {
+  default2 as Draw,
+  default3 as Node,
+  default4 as PathNode,
+  default5 as Scope,
+  default6 as TikZ
+};

package/dist/es/model/component/node.d.ts

@@ -0,0 +1,45 @@
+import { Direction } from '../../types/coordinate';
+import { Position } from '../../types/coordinate/descartes';
+import { DirectionDistance } from '../../types/distance';
+import { Area, Size } from '../../types/shape';
+import { RectMidPoint, RectThirdPoint, RectVertexPoint } from '../../types/shape/rect';
+export type StateListener = (state?: NodeModel, prevState?: NodeModel) => void;
+export type NodeConfig = {
+    /** 内容中心位置 */
+    position: Position;
+    /** 内容（文本）尺寸 */
+    contentSize: Size;
+    /** 内边框距离 */
+    innerSep: DirectionDistance;
+    /** 外边框距离 */
+    outerSep: DirectionDistance;
+};
+export type NodeAttribute = keyof NodeConfig;
+export default class NodeModel {
+    type: string[];
+    /** 是否初始化节点数据, 很多节点在 layout 阶段才能初始化全部数据 */
+    init: boolean;
+    /** 节点是否已经被销毁，如果已近销毁，其他地方应该删除对节点对象的引用 */
+    disposed: boolean;
+    center: Position;
+    size: Size;
+    innerSep: DirectionDistance;
+    outerSep: DirectionDistance;
+    listeners: Set<StateListener>;
+    constructor(config: NodeConfig, init?: boolean);
+    update(config: Partial<NodeConfig>, init?: boolean): void;
+    notify(preSelf?: NodeModel): void;
+    subscribe(listener: StateListener): () => boolean;
+    dispose(): void;
+    /** 获取某个点相对于节点外边界的区域 */
+    getPointArea(point: Position): Area;
+    /** 获取外边界特殊点（中点，顶点，三等分点） */
+    getOuterPoint(point: RectVertexPoint | RectMidPoint | RectThirdPoint): Position | undefined;
+    /** 获取外部点与 node 中心连线与外边缘的交点 */
+    getCrossPoint(point: Position): Position;
+    /** 获取到边界的距离 */
+    getOuterDistance(direction: Direction): number;
+    /** 判断某个变量是否为初始化完成的节点 */
+    static isInitializedNode: (node: unknown) => boolean;
+    static isNode: (node: unknown) => boolean;
+}

package/dist/es/model/component/node.js

@@ -0,0 +1,164 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { Area } from "../../types/shape/index.js";
+import { RectThirdPoint, RectMidPoint, RectVertexPoint } from "../../types/shape/rect.js";
+import { isSameArray, isSameObj } from "../../utils/compare.js";
+import { between } from "../../utils/math.js";
+import Line from "../equation/line.js";
+const _NodeModel = class _NodeModel {
+  constructor(config, init = true) {
+    __publicField(this, "type", ["node"]);
+    /** 是否初始化节点数据, 很多节点在 layout 阶段才能初始化全部数据 */
+    __publicField(this, "init", false);
+    /** 节点是否已经被销毁，如果已近销毁，其他地方应该删除对节点对象的引用 */
+    __publicField(this, "disposed", false);
+    __publicField(this, "center", [0, 0]);
+    __publicField(this, "size", [0, 0]);
+    __publicField(this, "innerSep", { left: 0, right: 0, top: 0, bottom: 0 });
+    __publicField(this, "outerSep", { left: 0, right: 0, top: 0, bottom: 0 });
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    this.update(config, init);
+  }
+  update(config, init = true) {
+    const preSelf = { ...this };
+    const { position, contentSize, innerSep, outerSep } = config;
+    let needUpdate = false;
+    if (!this.init && init) {
+      this.init = init;
+      needUpdate = true;
+    }
+    if (position && !isSameArray(position, this.center)) {
+      this.center = position;
+      needUpdate = true;
+    }
+    if (contentSize && !isSameArray(contentSize, this.size)) {
+      this.size = contentSize;
+      needUpdate = true;
+    }
+    if (innerSep && !isSameObj(innerSep, this.innerSep)) {
+      this.innerSep = innerSep;
+      needUpdate = true;
+    }
+    if (outerSep && !isSameObj(outerSep, this.outerSep)) {
+      this.outerSep = outerSep;
+      needUpdate = true;
+    }
+    if (this.init && needUpdate) {
+      this.notify(preSelf);
+    }
+  }
+  notify(preSelf) {
+    this.listeners.forEach((listener) => listener({ ...this }, preSelf));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  dispose() {
+    this.listeners.clear();
+    this.disposed = true;
+    this.notify(this);
+  }
+  /** 获取某个点相对于节点外边界的区域 */
+  getPointArea(point) {
+    const [pX, pY] = point;
+    const [x, y] = this.center;
+    const edgeX = [x - this.getOuterDistance("left"), x + this.getOuterDistance("right")];
+    const edgeY = [y - this.getOuterDistance("top"), y + this.getOuterDistance("bottom")];
+    if (between(pX, edgeX) && between(pY, edgeY)) return Area.INSIDE;
+    if (between(pX, edgeX, true) && between(pY, edgeY, true)) return Area.EDGE;
+    return Area.OUTSIDE;
+  }
+  /** 获取外边界特殊点（中点，顶点，三等分点） */
+  getOuterPoint(point) {
+    if (!this.init) return void 0;
+    const [x, y] = this.center;
+    const [width, height] = this.size;
+    const { left: innerLeft, right: innerRight, top: innerTop, bottom: innerBottom } = this.innerSep;
+    const { left: outerLeft, right: outerRight, top: outerTop, bottom: outerBottom } = this.outerSep;
+    switch (point) {
+      case RectVertexPoint.TL:
+        return [x - width / 2 - innerLeft - outerLeft, y - height / 2 - innerTop - outerTop];
+      case RectVertexPoint.TR:
+        return [x + width / 2 + innerRight + outerRight, y - height / 2 - innerTop - outerTop];
+      case RectVertexPoint.BL:
+        return [x - width / 2 - innerLeft - outerLeft, y + height / 2 + innerBottom + outerBottom];
+      case RectVertexPoint.BR:
+        return [x + width / 2 + innerRight + outerRight, y + height / 2 + innerBottom + outerBottom];
+      case RectMidPoint.T:
+        return [x, y - height / 2 - innerTop - outerTop];
+      case RectMidPoint.B:
+        return [x, y + height / 2 + innerBottom + outerBottom];
+      case RectMidPoint.L:
+        return [x - width / 2 - innerLeft - outerLeft, y];
+      case RectMidPoint.R:
+        return [x + width / 2 + innerRight + outerRight, y];
+      case RectThirdPoint.TL:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case RectThirdPoint.TR:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case RectThirdPoint.BL:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case RectThirdPoint.BR:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case RectThirdPoint.LT:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case RectThirdPoint.LB:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case RectThirdPoint.RT:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case RectThirdPoint.RB:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+    }
+  }
+  /** 获取外部点与 node 中心连线与外边缘的交点 */
+  getCrossPoint(point) {
+    if (!this.init) return this.center;
+    const pointArea = this.getPointArea(point);
+    if (pointArea === Area.EDGE) return point;
+    const line = Line.fromPoints(point, this.center);
+    const PointTL = this.getOuterPoint(RectVertexPoint.TL);
+    const PointTR = this.getOuterPoint(RectVertexPoint.TR);
+    const topCrossPoint = line.getIntersection(Line.fromPoints(PointTL, PointTR));
+    if (topCrossPoint && point[1] < this.center[1] && between(topCrossPoint[0], [PointTL[0], PointTR[0]], true)) {
+      return topCrossPoint;
+    }
+    const PointBL = this.getOuterPoint(RectVertexPoint.BL);
+    const PointBR = this.getOuterPoint(RectVertexPoint.BR);
+    const belowCrossPoint = line.getIntersection(Line.fromPoints(PointBL, PointBR));
+    if (belowCrossPoint && point[1] > this.center[1] && between(belowCrossPoint[0], [PointBL[0], PointBR[0]], true))
+      return belowCrossPoint;
+    const leftCrossPoint = line.getIntersection(Line.fromPoints(PointTL, PointBL));
+    if (leftCrossPoint && point[0] < this.center[0] && between(leftCrossPoint[1], [PointTL[1], PointBL[1]], true))
+      return leftCrossPoint;
+    const rightCrossPoint = line.getIntersection(Line.fromPoints(PointTR, PointBR));
+    return rightCrossPoint;
+  }
+  /** 获取到边界的距离 */
+  getOuterDistance(direction) {
+    switch (direction) {
+      case "top":
+        return this.size[1] / 2 + this.innerSep.top + this.outerSep.top;
+      case "bottom":
+        return this.size[1] / 2 + this.innerSep.bottom + this.outerSep.bottom;
+      case "left":
+        return this.size[0] / 2 + this.innerSep.left + this.outerSep.left;
+      case "right":
+        return this.size[0] / 2 + this.innerSep.right + this.outerSep.right;
+    }
+  }
+};
+/** 判断某个变量是否为初始化完成的节点 */
+__publicField(_NodeModel, "isInitializedNode", (node) => {
+  return _NodeModel.isNode(node) && node.init;
+});
+__publicField(_NodeModel, "isNode", (node) => {
+  if (typeof node !== "object" || node === null) return false;
+  if (!("type" in node) || !Array.isArray(node.type)) return false;
+  return node.type.includes("node");
+});
+let NodeModel = _NodeModel;
+export {
+  NodeModel as default
+};

package/dist/es/model/component/path.d.ts

@@ -0,0 +1,19 @@
+import { Position } from '../../types/coordinate/descartes';
+export type StateListener = (state?: PathModel, prevState?: PathModel) => void;
+export default class PathModel {
+    type: string[];
+    init: boolean;
+    disposed: boolean;
+    ways: Array<Position[]>;
+    lineWidth: number;
+    listeners: Set<StateListener>;
+    constructor(ways: Array<Position[]>, lineWidth: number, init?: boolean);
+    update(config: {
+        ways?: Array<Position[]>;
+        lineWidth?: number;
+        init?: boolean;
+    }): void;
+    notify(preSelf?: PathModel): void;
+    subscribe(listener: StateListener): () => boolean;
+    dispose(): void;
+}

package/dist/es/model/component/path.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PathModel {
+  constructor(ways, lineWidth, init = true) {
+    __publicField(this, "type", ["path"]);
+    __publicField(this, "init", false);
+    __publicField(this, "disposed", false);
+    __publicField(this, "ways", []);
+    __publicField(this, "lineWidth", 1);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    this.update({ ways, lineWidth, init });
+  }
+  update(config) {
+    const { ways, lineWidth, init } = config;
+    const preSelf = { ...this };
+    let needUpdate = false;
+    if (!this.init && init) {
+      this.init = init;
+      needUpdate = true;
+    }
+    if (ways && ways !== this.ways) {
+      this.ways = ways;
+      needUpdate = true;
+    }
+    if (lineWidth && lineWidth !== this.lineWidth) {
+      this.lineWidth = lineWidth;
+      needUpdate = true;
+    }
+    if (this.init && needUpdate) this.notify(preSelf);
+  }
+  notify(preSelf) {
+    this.listeners.forEach((listener) => listener({ ...this }, preSelf));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  dispose() {
+    this.listeners.clear();
+    this.disposed = true;
+    this.notify(this);
+  }
+}
+export {
+  PathModel as default
+};

package/dist/es/model/equation/line.d.ts

@@ -0,0 +1,21 @@
+import { Position } from '../../types/coordinate/descartes';
+export default class Line {
+    private a;
+    private b;
+    private c;
+    constructor(a: number, b: number, c: number);
+    getY(x: number): number | undefined;
+    getX(y: number): number | undefined;
+    /** 判断点是否在线上 */
+    isPointOn(point: Position, epsilon?: number): boolean;
+    /** 两点获取直线方程 */
+    static fromPoints: (point1: Position, point2: Position) => Line;
+    /** 获取两点的夹角(弧度制) */
+    static getDegree: (point1: Position, point2: Position) => number;
+    /** 根据百分比获取点位置 */
+    static getPositionByPercent: (startPoint: Position, endPoint: Position, percent: number) => Position;
+    /** 获取两条直线交点 */
+    getIntersection(line: Line, epsilon?: number): Position | undefined;
+    /** 点到直线距离 */
+    getPointDistance(point: Position): number;
+}

package/dist/es/model/equation/line.js

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const _Line = class _Line {
+  constructor(a, b, c) {
+    // 一般式系数 Ax + By + C = 0，A >= 0
+    __publicField(this, "a", 0);
+    __publicField(this, "b", 0);
+    __publicField(this, "c", 0);
+    if (a === 0 && b === 0) {
+      return;
+    }
+    this.a = a;
+    this.b = b;
+    this.c = c;
+  }
+  getY(x) {
+    if (this.b === 0) return;
+    return -(this.a * x + this.c) / this.b;
+  }
+  getX(y) {
+    if (this.a === 0) return;
+    return -(this.b * y + this.c) / this.a;
+  }
+  /** 判断点是否在线上 */
+  isPointOn(point, epsilon = 1e-9) {
+    const value = this.a * point[0] + this.b * point[1] + this.c;
+    return Math.abs(value) <= epsilon;
+  }
+  /** 获取两条直线交点 */
+  getIntersection(line, epsilon = 1e-9) {
+    const A1 = this.a;
+    const B1 = this.b;
+    const C1 = this.c;
+    const A2 = line.a;
+    const B2 = line.b;
+    const C2 = line.c;
+    const D = A1 * B2 - A2 * B1;
+    if (Math.abs(D) <= epsilon) return;
+    const x = (C2 * B1 - C1 * B2) / D;
+    const y = (A2 * C1 - A1 * C2) / D;
+    return [x, y];
+  }
+  /** 点到直线距离 */
+  getPointDistance(point) {
+    return Math.abs(this.a * point[0] + this.b * point[1] + this.c) / Math.sqrt(this.a * this.a + this.b * this.b);
+  }
+};
+/** 两点获取直线方程 */
+__publicField(_Line, "fromPoints", (point1, point2) => {
+  const [x1, y1] = point1;
+  const [x2, y2] = point2;
+  const A = y2 - y1;
+  const B = x1 - x2;
+  const C = x2 * y1 - x1 * y2;
+  return new _Line(A, B, C);
+});
+/** 获取两点的夹角(弧度制) */
+__publicField(_Line, "getDegree", (point1, point2) => {
+  const [x1, y1] = point1;
+  const [x2, y2] = point2;
+  return Math.atan2(y2 - y1, x2 - x1);
+});
+/** 根据百分比获取点位置 */
+__publicField(_Line, "getPositionByPercent", (startPoint, endPoint, percent) => {
+  const [x1, y1] = startPoint;
+  const [x2, y2] = endPoint;
+  const dirX = x2 - x1;
+  const dirY = y2 - y1;
+  return [x1 + dirX * percent, y1 + dirY * percent];
+});
+let Line = _Line;
+export {
+  Line as default
+};

package/dist/es/model/geometry/point/DescartesPoint.d.ts

@@ -0,0 +1,21 @@
+import { PointPosition } from '../../../types/coordinate';
+import { DescartesPosition, Position } from '../../../types/coordinate/descartes';
+import { PolarPosition } from '../../../types/coordinate/polar';
+import { default as PolarPoint } from './PolarPoint';
+/** 笛卡尔坐标点 */
+export default class DescartesPoint {
+    readonly position: Position;
+    constructor(point: Position | DescartesPosition);
+    /** 获取极坐标 */
+    getPolarPosition(): PolarPosition;
+    /** 获取极点 */
+    getPolarPoint(): PolarPoint;
+    /** 将笛卡尔坐标点转换为极坐标点 */
+    static convertPolarToDescartesPosition: (position: Position) => PolarPosition;
+    /** 对象形式转换为数组形式 */
+    static covertToPosition: (position: DescartesPosition) => number[];
+    /** 将坐标格式转换为笛卡尔坐标数组形式 */
+    static formatPosition: (point: PointPosition) => Position;
+    /** 多个点相加 */
+    static plus: (...positions: Array<PointPosition>) => Position;
+}

package/dist/es/model/geometry/point/DescartesPoint.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import PolarPoint from "./PolarPoint.js";
+const _DescartesPoint = class _DescartesPoint {
+  constructor(point) {
+    __publicField(this, "position");
+    this.position = Array.isArray(point) ? [...point] : [point.x, point.y];
+  }
+  /** 获取极坐标 */
+  getPolarPosition() {
+    return _DescartesPoint.convertPolarToDescartesPosition(this.position);
+  }
+  /** 获取极点 */
+  getPolarPoint() {
+    return new PolarPoint(this.getPolarPosition());
+  }
+};
+/** 将笛卡尔坐标点转换为极坐标点 */
+__publicField(_DescartesPoint, "convertPolarToDescartesPosition", (position) => {
+  const [x, y] = position;
+  return { radius: Math.sqrt(x * x + y * y), angle: Math.atan2(y, x) };
+});
+/** 对象形式转换为数组形式 */
+__publicField(_DescartesPoint, "covertToPosition", (position) => {
+  return [position.x, position.y];
+});
+/** 将坐标格式转换为笛卡尔坐标数组形式 */
+__publicField(_DescartesPoint, "formatPosition", (point) => {
+  if (Array.isArray(point)) return point;
+  if (point.hasOwnProperty("x") && point.hasOwnProperty("y")) {
+    const p = point;
+    return [p.x, p.y];
+  }
+  return PolarPoint.convertPolarToDescartesPosition(point);
+});
+/** 多个点相加 */
+__publicField(_DescartesPoint, "plus", (...positions) => {
+  return positions.reduce(
+    (acc, cur) => {
+      const formatCur = _DescartesPoint.formatPosition(cur);
+      return [acc[0] + formatCur[0], acc[1] + formatCur[1]];
+    },
+    [0, 0]
+  );
+});
+let DescartesPoint = _DescartesPoint;
+export {
+  DescartesPoint as default
+};