@retikz/core 0.0.1-rc.0

package/dist/lib/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Draw = require("./components/draw/Draw.cjs");
+const Node = require("./components/node/Node.cjs");
+const PathNode = require("./components/pathNode/PathNode.cjs");
+const Scope = require("./components/Scope.cjs");
+const TikZ = require("./components/TikZ.cjs");
+exports.Draw = Draw.default;
+exports.Node = Node.default;
+exports.PathNode = PathNode.default;
+exports.Scope = Scope.default;
+exports.TikZ = TikZ.default;

package/dist/lib/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/lib/model/component/node.cjs

@@ -0,0 +1,164 @@
+"use strict";
+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);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../../types/shape/index.cjs");
+const rect = require("../../types/shape/rect.cjs");
+const compare = require("../../utils/compare.cjs");
+const math = require("../../utils/math.cjs");
+const line = require("../equation/line.cjs");
+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 && !compare.isSameArray(position, this.center)) {
+      this.center = position;
+      needUpdate = true;
+    }
+    if (contentSize && !compare.isSameArray(contentSize, this.size)) {
+      this.size = contentSize;
+      needUpdate = true;
+    }
+    if (innerSep && !compare.isSameObj(innerSep, this.innerSep)) {
+      this.innerSep = innerSep;
+      needUpdate = true;
+    }
+    if (outerSep && !compare.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 (math.between(pX, edgeX) && math.between(pY, edgeY)) return index.Area.INSIDE;
+    if (math.between(pX, edgeX, true) && math.between(pY, edgeY, true)) return index.Area.EDGE;
+    return index.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 rect.RectVertexPoint.TL:
+        return [x - width / 2 - innerLeft - outerLeft, y - height / 2 - innerTop - outerTop];
+      case rect.RectVertexPoint.TR:
+        return [x + width / 2 + innerRight + outerRight, y - height / 2 - innerTop - outerTop];
+      case rect.RectVertexPoint.BL:
+        return [x - width / 2 - innerLeft - outerLeft, y + height / 2 + innerBottom + outerBottom];
+      case rect.RectVertexPoint.BR:
+        return [x + width / 2 + innerRight + outerRight, y + height / 2 + innerBottom + outerBottom];
+      case rect.RectMidPoint.T:
+        return [x, y - height / 2 - innerTop - outerTop];
+      case rect.RectMidPoint.B:
+        return [x, y + height / 2 + innerBottom + outerBottom];
+      case rect.RectMidPoint.L:
+        return [x - width / 2 - innerLeft - outerLeft, y];
+      case rect.RectMidPoint.R:
+        return [x + width / 2 + innerRight + outerRight, y];
+      case rect.RectThirdPoint.TL:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case rect.RectThirdPoint.TR:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case rect.RectThirdPoint.BL:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case rect.RectThirdPoint.BR:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case rect.RectThirdPoint.LT:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case rect.RectThirdPoint.LB:
+        return [x - (width / 2 + innerLeft + outerLeft) / 3, y + (height / 2 + innerBottom + outerBottom) / 3];
+      case rect.RectThirdPoint.RT:
+        return [x + (width / 2 + innerRight + outerRight) / 3, y - (height / 2 + innerTop + outerTop) / 3];
+      case rect.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 === index.Area.EDGE) return point;
+    const line$1 = line.default.fromPoints(point, this.center);
+    const PointTL = this.getOuterPoint(rect.RectVertexPoint.TL);
+    const PointTR = this.getOuterPoint(rect.RectVertexPoint.TR);
+    const topCrossPoint = line$1.getIntersection(line.default.fromPoints(PointTL, PointTR));
+    if (topCrossPoint && point[1] < this.center[1] && math.between(topCrossPoint[0], [PointTL[0], PointTR[0]], true)) {
+      return topCrossPoint;
+    }
+    const PointBL = this.getOuterPoint(rect.RectVertexPoint.BL);
+    const PointBR = this.getOuterPoint(rect.RectVertexPoint.BR);
+    const belowCrossPoint = line$1.getIntersection(line.default.fromPoints(PointBL, PointBR));
+    if (belowCrossPoint && point[1] > this.center[1] && math.between(belowCrossPoint[0], [PointBL[0], PointBR[0]], true))
+      return belowCrossPoint;
+    const leftCrossPoint = line$1.getIntersection(line.default.fromPoints(PointTL, PointBL));
+    if (leftCrossPoint && point[0] < this.center[0] && math.between(leftCrossPoint[1], [PointTL[1], PointBL[1]], true))
+      return leftCrossPoint;
+    const rightCrossPoint = line$1.getIntersection(line.default.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;
+exports.default = NodeModel;

package/dist/lib/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/lib/model/component/path.cjs

@@ -0,0 +1,47 @@
+"use strict";
+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);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+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);
+  }
+}
+exports.default = PathModel;

package/dist/lib/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/lib/model/equation/line.cjs

@@ -0,0 +1,75 @@
+"use strict";
+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);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+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;
+exports.default = Line;

package/dist/lib/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/lib/model/geometry/point/DescartesPoint.cjs

@@ -0,0 +1,50 @@
+"use strict";
+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);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const PolarPoint = require("./PolarPoint.cjs");
+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.default(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.default.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;
+exports.default = DescartesPoint;

package/dist/lib/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/lib/model/geometry/point/PolarPoint.cjs

@@ -0,0 +1,27 @@
+"use strict";
+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);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const DescartesPoint = require("./DescartesPoint.cjs");
+const _PolarPoint = class _PolarPoint {
+  constructor(point) {
+    __publicField(this, "position");
+    this.position = { radius: point.radius, angle: point.angle };
+  }
+  /** 获取笛卡尔坐标 */
+  getDescartesPosition() {
+    return _PolarPoint.convertPolarToDescartesPosition(this.position);
+  }
+  /** 获取笛卡尔点 */
+  getDescartesPoint() {
+    return new DescartesPoint.default(this.getDescartesPosition());
+  }
+};
+/** 将极坐标点转换为笛卡尔坐标点 */
+__publicField(_PolarPoint, "convertPolarToDescartesPosition", (position) => {
+  const { radius, angle } = position;
+  return [radius * Math.cos(angle), radius * Math.sin(angle)];
+});
+let PolarPoint = _PolarPoint;
+exports.default = PolarPoint;

package/dist/lib/model/geometry/point/PolarPoint.d.ts

@@ -0,0 +1,14 @@
+import { Position } from '../../../types/coordinate/descartes';
+import { PolarPosition } from '../../../types/coordinate/polar';
+import { default as DescartesPoint } from './DescartesPoint';
+/** 笛卡尔坐标点 */
+export default class PolarPoint {
+    readonly position: PolarPosition;
+    constructor(point: PolarPosition);
+    /** 获取笛卡尔坐标 */
+    getDescartesPosition(): Position;
+    /** 获取笛卡尔点 */
+    getDescartesPoint(): DescartesPoint;
+    /** 将极坐标点转换为笛卡尔坐标点 */
+    static convertPolarToDescartesPosition: (position: PolarPosition) => Position;
+}