heitu 1.0.5 → 1.0.7

package/dist/canvas/core/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const dpr: number;
+export declare const Noop: () => void;

package/dist/canvas/core/constant.js

@@ -0,0 +1,2 @@
+export var dpr = window.devicePixelRatio;
+export var Noop = function Noop() {};

package/dist/canvas/core/shapes/animate.d.ts

@@ -0,0 +1,28 @@
+export type AnimateCartoonConfig = {
+    duration: number;
+    delay?: number;
+    during?: (percent: number, newState: Record<string, string | number>) => void;
+    done?: () => void;
+    aborted?: () => void;
+    scope?: string;
+    force?: boolean;
+    additive?: boolean;
+    setToFinal?: boolean;
+    easing?: any;
+    iterationCount?: number;
+};
+declare class Animate {
+    rafTimer: number | null;
+    startTime: number | null;
+    startProp: Record<string, any>;
+    targetProp: Record<string, any>;
+    cfg: AnimateCartoonConfig;
+    constructor(startProp?: Record<string, any>, targetProp?: Record<string, any>, cfg?: Partial<AnimateCartoonConfig>);
+    forward: boolean;
+    queue: any;
+    start(): void;
+    checkEdge(): void;
+    stop(): void;
+    pushQueue(callback: any): void;
+}
+export default Animate;

package/dist/canvas/core/shapes/animate.js

@@ -0,0 +1,106 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { calcTargetValue, easingFuncs } from "../../utils";
+var defaultCfg = {
+  duration: 1000,
+  easing: 'linear',
+  iterationCount: 1
+};
+var Animate = /*#__PURE__*/function () {
+  function Animate() {
+    var startProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var targetProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var cfg = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, Animate);
+    _defineProperty(this, "rafTimer", null);
+    _defineProperty(this, "startTime", null);
+    _defineProperty(this, "startProp", void 0);
+    _defineProperty(this, "targetProp", void 0);
+    _defineProperty(this, "cfg", void 0);
+    _defineProperty(this, "forward", true);
+    // 正向动画
+    _defineProperty(this, "queue", []);
+    this.startProp = startProp;
+    this.targetProp = targetProp;
+    this.cfg = _objectSpread(_objectSpread({}, defaultCfg), cfg);
+  }
+  _createClass(Animate, [{
+    key: "start",
+    value:
+    // 开始
+    function start() {
+      var _this = this;
+      var _this$cfg = this.cfg,
+        duration = _this$cfg.duration,
+        easing = _this$cfg.easing,
+        during = _this$cfg.during,
+        iterationCount = _this$cfg.iterationCount;
+      var keys = Object.keys(this.targetProp);
+      var rafCb = function rafCb(timestamp) {
+        if (!_this.startTime) {
+          _this.startTime = timestamp;
+        }
+        var elapsedTimeRatio = easingFuncs[easing](Math.min((timestamp - _this.startTime) / duration, 1));
+        if (_this.forward === false) {
+          elapsedTimeRatio = 1 - elapsedTimeRatio;
+        }
+        var currentProp = {};
+        keys.forEach(function (propKey) {
+          var targetValue = calcTargetValue(_this.startProp[propKey], _this.targetProp[propKey], elapsedTimeRatio);
+          currentProp[propKey] = targetValue;
+        });
+        if (during) {
+          during(elapsedTimeRatio, currentProp);
+        }
+        var nextCondition = _this.forward ? elapsedTimeRatio < 1 : 0 < elapsedTimeRatio;
+        if (nextCondition) {
+          _this.rafTimer = requestAnimationFrame(rafCb);
+        } else {
+          _this.queue = [];
+          _this.stop();
+        }
+        if (_this.queue.length > 0) {
+          _this.queue.forEach(function (item) {
+            item(currentProp, elapsedTimeRatio);
+          });
+        }
+        var endCondition = _this.forward ? elapsedTimeRatio === 1 : elapsedTimeRatio === 0;
+        if (endCondition) {
+          if (iterationCount === Infinity) {
+            _this.forward = !_this.forward;
+            _this.startTime = null;
+            _this.start();
+          }
+        }
+      };
+      this.rafTimer = requestAnimationFrame(rafCb);
+    }
+    // 检查边缘
+  }, {
+    key: "checkEdge",
+    value: function checkEdge() {}
+    // 更新
+    // @ts-ignore
+    // onUpdate(currentProp, elapsedTimeRatio: number) {}
+    // 停止
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this.rafTimer) cancelAnimationFrame(this.rafTimer);
+    }
+  }, {
+    key: "pushQueue",
+    value: function pushQueue(callback) {
+      this.queue.push(callback);
+    }
+  }]);
+  return Animate;
+}();
+export default Animate;

package/dist/canvas/core/shapes/circle.d.ts

@@ -0,0 +1,48 @@
+import Node from './node';
+export type ICoord = {
+    x: number;
+    y: number;
+};
+interface ICircle {
+    x?: number;
+    y?: number;
+    radius?: number;
+    lineWidth?: number;
+    fillStyle?: string;
+    strokeStyle?: string;
+    arc?: boolean;
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number;
+    border: 0 | 1 | 2;
+    index: number;
+}
+declare class Circle extends Node {
+    name: string;
+    parent: null;
+    x: number;
+    y: number;
+    radius: number;
+    lineWidth: number;
+    fillStyle: string;
+    strokeStyle: string;
+    arc: boolean;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    index: number;
+    path2D: Path2D | null;
+    border: 0 | 1 | 2;
+    constructor(config: ICircle);
+    deg2rad(deg: number): number;
+    getPointOnArc(x0: number, y0: number, r: number, deg: number): {
+        x: number;
+        y: number;
+    };
+    calcWholeRingD(): string;
+    calcRingSectorD(): string;
+    calcRingD(isWholeArc: boolean): string;
+    draw(ctx: CanvasRenderingContext2D): Path2D;
+    inScope(evt: MouseEvent, ctx: CanvasRenderingContext2D): boolean | undefined;
+}
+export default Circle;

package/dist/canvas/core/shapes/circle.js

@@ -0,0 +1,162 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { isInShape } from "../../utils";
+import { forIn } from 'lodash-es';
+import { dpr } from "../constant";
+import Node from "./node";
+var Circle = /*#__PURE__*/function (_Node) {
+  _inherits(Circle, _Node);
+  var _super = _createSuper(Circle);
+  // 0 填充 1  只有边框  2 边框和填充
+  function Circle(config) {
+    var _this;
+    _classCallCheck(this, Circle);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "name", 'Circle');
+    _defineProperty(_assertThisInitialized(_this), "parent", null);
+    _defineProperty(_assertThisInitialized(_this), "x", void 0);
+    _defineProperty(_assertThisInitialized(_this), "y", void 0);
+    _defineProperty(_assertThisInitialized(_this), "radius", void 0);
+    _defineProperty(_assertThisInitialized(_this), "lineWidth", void 0);
+    _defineProperty(_assertThisInitialized(_this), "fillStyle", void 0);
+    _defineProperty(_assertThisInitialized(_this), "strokeStyle", void 0);
+    _defineProperty(_assertThisInitialized(_this), "arc", void 0);
+    _defineProperty(_assertThisInitialized(_this), "startAngle", void 0);
+    // 圆弧 饼图 角度 60 180 360
+    _defineProperty(_assertThisInitialized(_this), "endAngle", void 0);
+    // 圆弧 饼图
+    _defineProperty(_assertThisInitialized(_this), "innerRadius", void 0);
+    _defineProperty(_assertThisInitialized(_this), "index", void 0);
+    _defineProperty(_assertThisInitialized(_this), "path2D", void 0);
+    _defineProperty(_assertThisInitialized(_this), "border", void 0);
+    _this.x = 10;
+    _this.y = 10;
+    _this.radius = 8;
+    _this.fillStyle = '';
+    _this.strokeStyle = '';
+    _this.lineWidth = 1;
+    _this.startAngle = 0;
+    _this.endAngle = 360;
+    _this.border = 0;
+    _this.innerRadius = 0;
+    _this.arc = false;
+    _this.index = 0;
+    _this.path2D = null;
+    forIn(config, function (value, key) {
+      if (value) _assertThisInitialized(_this)[key] = value;
+    });
+    return _this;
+  }
+  // 角度转弧度
+  _createClass(Circle, [{
+    key: "deg2rad",
+    value: function deg2rad(deg) {
+      return deg * Math.PI / 180;
+    }
+  }, {
+    key: "getPointOnArc",
+    value: function getPointOnArc(x0, y0, r, deg) {
+      var alpha = this.deg2rad(deg);
+      var x = x0 + r * Math.cos(alpha); // Math.cos 传入弧度
+      var y = y0 + r * Math.sin(alpha);
+      return {
+        x: x,
+        y: y
+      };
+    }
+  }, {
+    key: "calcWholeRingD",
+    value: function calcWholeRingD() {
+      var outerM_y = this.y - this.radius;
+      var outerM = "M ".concat(this.x, " ").concat(outerM_y);
+      var outerA = "A ".concat(this.radius, " ").concat(this.radius, " 0 1 1 ").concat(this.x - 0.01, " ").concat(outerM_y);
+      var innerM_y = this.y - this.innerRadius;
+      var innerM = "M ".concat(this.x, " ").concat(innerM_y);
+      var innerA = "A ".concat(this.innerRadius, " ").concat(this.innerRadius, " 0 1 0 ").concat(this.x + 0.01, " ").concat(innerM_y);
+      return "".concat(outerM, " ").concat(outerA, " ").concat(innerM, " ").concat(innerA, " Z");
+    }
+  }, {
+    key: "calcRingSectorD",
+    value: function calcRingSectorD() {
+      var outerStart = this.getPointOnArc(this.x, this.y, this.radius, this.startAngle);
+      var outerEnd = this.getPointOnArc(this.x, this.y, this.radius, this.endAngle);
+      var largeArcFlag = this.endAngle - this.startAngle >= 180 ? 1 : 0;
+      var outerM = "M ".concat(outerStart.x, " ").concat(outerStart.y);
+      var outerA = "A ".concat(this.radius, " ").concat(this.radius, " 0 ").concat(largeArcFlag, " 1 ").concat(outerEnd.x, " ").concat(outerEnd.y);
+      var innerStart = this.getPointOnArc(this.x, this.y, this.innerRadius, this.startAngle);
+      var innerEnd = this.getPointOnArc(this.x, this.y, this.innerRadius, this.endAngle);
+      var moveL = "L".concat(innerEnd.x, " ").concat(innerEnd.y);
+      var innerA = "A ".concat(this.innerRadius, " ").concat(this.innerRadius, " 0 ").concat(largeArcFlag, " 0 ").concat(innerStart.x, " ").concat(innerStart.y);
+      return "".concat(outerM, " ").concat(outerA, " ").concat(moveL, " ").concat(innerA, " Z");
+    }
+  }, {
+    key: "calcRingD",
+    value: function calcRingD(isWholeArc) {
+      return isWholeArc ? this.calcWholeRingD() : this.calcRingSectorD();
+    }
+  }, {
+    key: "draw",
+    value: function draw(ctx) {
+      var isWholeArc = this.startAngle === 0 && this.endAngle === 360; // 是否是整圆
+      var circlePath;
+      switch (this.border) {
+        case 0:
+          circlePath = new Path2D(this.calcRingD(isWholeArc));
+          // 设置绘制样式
+          if (this.fillStyle) ctx.fillStyle = this.fillStyle; // 填充颜色
+          if (this.fillStyle) ctx.strokeStyle = this.fillStyle; // 描边颜色
+          if (this.lineWidth) ctx.lineWidth = this.lineWidth; // 描边宽度
+          ctx.stroke(circlePath);
+          ctx.fill(circlePath);
+          this.path2D = circlePath;
+          return circlePath;
+        case 1:
+          circlePath = new Path2D(this.calcRingD(isWholeArc));
+          ctx.lineWidth = this.lineWidth;
+          if (this.strokeStyle) ctx.strokeStyle = this.strokeStyle; // 描边颜色
+          ctx.stroke(circlePath);
+          this.path2D = circlePath;
+          return circlePath;
+        case 2:
+          circlePath = new Path2D(this.calcRingD(isWholeArc));
+          // 设置绘制样式
+          if (this.fillStyle) ctx.fillStyle = this.fillStyle; // 填充颜色
+          if (this.strokeStyle) ctx.strokeStyle = this.strokeStyle; // 描边颜色
+          if (this.lineWidth) ctx.lineWidth = this.lineWidth; // 描边宽度
+          ctx.stroke(circlePath);
+          ctx.fill(circlePath);
+          this.path2D = circlePath;
+          return circlePath;
+      }
+    }
+  }, {
+    key: "inScope",
+    value: function inScope(evt, ctx) {
+      var mouseX = evt.offsetX * dpr;
+      var mouseY = evt.offsetY * dpr;
+      if (this !== null && this !== void 0 && this.path2D) {
+        return isInShape({
+          mouseX: mouseX,
+          mouseY: mouseY,
+          path2D: this === null || this === void 0 ? void 0 : this.path2D,
+          ctx: ctx || undefined
+        });
+      }
+      return false;
+    }
+  }]);
+  return Circle;
+}(Node);
+export default Circle;

package/dist/canvas/core/shapes/custom.d.ts

@@ -0,0 +1,26 @@
+import Node from './node';
+interface ICustom {
+    x?: number;
+    y?: number;
+    path2D: Path2D | null;
+    fillStyle?: string;
+    strokeStyle?: string;
+    lineWidth?: number;
+}
+declare class Custom extends Node {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fillStyle: string | null;
+    strokeStyle: string | null;
+    lineWidth: number | null;
+    index: number;
+    path2D: Path2D | null;
+    parent: null;
+    constructor(config: ICustom);
+    draw(ctx: CanvasRenderingContext2D): this | undefined;
+    inScope(evt: MouseEvent, ctx: CanvasRenderingContext2D): boolean | undefined;
+}
+export default Custom;

package/dist/canvas/core/shapes/custom.js

@@ -0,0 +1,83 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { isInShape } from "../../utils";
+import { forIn } from 'lodash-es';
+import { dpr } from "../constant";
+import Node from "./node";
+var Custom = /*#__PURE__*/function (_Node) {
+  _inherits(Custom, _Node);
+  var _super = _createSuper(Custom);
+  function Custom(config) {
+    var _this;
+    _classCallCheck(this, Custom);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "name", 'Custom');
+    _defineProperty(_assertThisInitialized(_this), "x", void 0);
+    _defineProperty(_assertThisInitialized(_this), "y", void 0);
+    _defineProperty(_assertThisInitialized(_this), "width", void 0);
+    _defineProperty(_assertThisInitialized(_this), "height", void 0);
+    _defineProperty(_assertThisInitialized(_this), "fillStyle", void 0);
+    _defineProperty(_assertThisInitialized(_this), "strokeStyle", void 0);
+    _defineProperty(_assertThisInitialized(_this), "lineWidth", void 0);
+    _defineProperty(_assertThisInitialized(_this), "index", void 0);
+    _defineProperty(_assertThisInitialized(_this), "path2D", void 0);
+    _defineProperty(_assertThisInitialized(_this), "parent", null);
+    if (!config.path2D) {
+      throw new Error('Mast has key of path2D');
+    }
+    _this.x = 100;
+    _this.y = 100;
+    _this.width = 0;
+    _this.height = 0;
+    _this.fillStyle = null;
+    _this.strokeStyle = null;
+    _this.lineWidth = 1;
+    _this.path2D = null;
+    _this.index = 0;
+    forIn(config, function (value, key) {
+      if (value) _assertThisInitialized(_this)[key] = value;
+    });
+    return _this;
+  }
+  _createClass(Custom, [{
+    key: "draw",
+    value: function draw(ctx) {
+      if (!this.path2D) return;
+      if (this.fillStyle) ctx.fillStyle = this.fillStyle;
+      if (this.strokeStyle) ctx.strokeStyle = this.strokeStyle;
+      if (this.lineWidth) ctx.lineWidth = this.lineWidth;
+      if (this.lineWidth) ctx.stroke(this.path2D);
+      if (this.fillStyle) ctx.fill(this.path2D);
+      return this;
+    }
+  }, {
+    key: "inScope",
+    value: function inScope(evt, ctx) {
+      var mouseX = evt.offsetX * dpr;
+      var mouseY = evt.offsetY * dpr;
+      if (this !== null && this !== void 0 && this.path2D) {
+        return isInShape({
+          mouseX: mouseX,
+          mouseY: mouseY,
+          path2D: this === null || this === void 0 ? void 0 : this.path2D,
+          ctx: ctx || undefined
+        });
+      }
+      return false;
+    }
+  }]);
+  return Custom;
+}(Node);
+export default Custom;

package/dist/canvas/core/shapes/line.d.ts

@@ -0,0 +1,46 @@
+import { Vector2d } from '../type';
+import Node from './node';
+interface ILine {
+    start?: {
+        x: number;
+        y: number;
+    };
+    end?: {
+        x: number;
+        y: number;
+    };
+    points?: number[];
+    smooth?: boolean;
+    strokeStyle: string;
+    lineWidth: number;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'miter' | 'round' | 'miter';
+    index: number;
+}
+declare class Line extends Node {
+    name: string;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    points: number[];
+    smooth: boolean;
+    strokeStyle: string;
+    lineWidth: number;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'miter' | 'round' | 'miter';
+    index: number;
+    path2D: Path2D | null;
+    parent: null;
+    constructor(config: ILine);
+    convertToNormalPoints(points: number[]): Vector2d[];
+    calcSmoothPath2D(): Path2D;
+    calcStraightPath2D(): Path2D;
+    draw(ctx: CanvasRenderingContext2D): this;
+    inScope(evt: MouseEvent, ctx: CanvasRenderingContext2D): boolean | undefined;
+}
+export default Line;