@dfsj/components 3.1.1 → 3.1.2

package/dist/components/Modal/src/hooks/useModalDrag.js

@@ -3,7 +3,6 @@ import { useTimeoutFn } from './useTimeout.js';
 import { clamp } from '../utils/index.js';
 
 function useModalDragMove(context) {
-  console.log('拖拽..............................................................');
   var moving = ref(false);
   var locator = reactive({
     top: null,
@@ -48,7 +47,6 @@ function useModalDragMove(context) {
             var ex = context.props.extent;
             var dx = event.x - sign.x;
             var dy = event.y - sign.y;
-            console.log('that.refs', that.refs, that);
             var br = that.refs.body.getBoundingClientRect();
             var el = ex.left != null ? ex.left : -Number.MAX_VALUE;
             var et = ex.top != null ? ex.top : -Number.MAX_VALUE;
@@ -62,6 +60,8 @@ function useModalDragMove(context) {
             locator.left = sign.l + Δx;
             locator.top = sign.t + Δy;
           }
+          locator.right = "unset !important";
+          locator.bottom = "unset !important";
           that.emit('update:offset', locator);
         }
       };
@@ -76,14 +76,9 @@ function useModalDragMove(context) {
     var _dragWrap$getAttribut;
     var proxy = that.proxy;
     var dragWrap = proxy.$el;
-    console.log('dragWrap', dragWrap);
     if (!dragWrap) return;
     var display = getStyle(dragWrap, 'display');
     var draggable = (_dragWrap$getAttribut = dragWrap.getAttribute('data-drag')) !== null && _dragWrap$getAttribut !== void 0 ? _dragWrap$getAttribut : true;
-    console.log({
-      display: display,
-      draggable: draggable
-    });
     if (display !== 'none') {
       if (draggable === null || unref(context.destroyOnClose)) {
         drag(dragWrap);

package/dist/components/Modal/src/props.d.ts

@@ -4,7 +4,20 @@ export declare const baseProps: {
         type: NumberConstructor;
         default: () => number;
     };
-    sizes: ArrayConstructor;
+    sizes: {
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+        from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+        from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+        of<T_4>(...items: T_4[]): T_4[];
+        readonly [Symbol.species]: ArrayConstructor;
+    };
     offset: ObjectConstructor;
     overflow: StringConstructor;
     maximum: BooleanConstructor;
@@ -33,6 +46,10 @@ export declare const headerProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    background: {
+        type: StringConstructor;
+        default: string;
+    };
     maximizer: {
         type: BooleanConstructor;
         default: boolean;

package/dist/components/Modal/src/props.js

@@ -41,6 +41,10 @@ var headerProps = {
     type: Boolean,
     "default": true
   },
+  background: {
+    type: String,
+    "default": 'linear-gradient(90deg,#125580 9%,#36b77c 51%,#125580 92%)'
+  },
   maximizer: {
     type: Boolean,
     "default": true

package/dist/components/Modal/src/utils/index.js

@@ -15,8 +15,8 @@ function doLocator(offset, sizes, locator, offsetable, sizeable) {
   });
   var top = offsetable && ensure(locator.top != null ? locator.top : offset && offset.top);
   var lft = offsetable && ensure(locator.left != null ? locator.left : offset && offset.left);
-  var rgt = offsetable && ensure(offset && offset.right);
-  var bom = offsetable && ensure(offset && offset.bottom);
+  var rgt = offsetable && ensure(locator.right || offset && offset.right);
+  var bom = offsetable && ensure(locator.bottom || offset && offset.bottom);
   var wid = siz && siz[0];
   var hei = siz && siz[1];
   var transformX, transformY, transform;

package/dist/components/NodeAxis/index.d.ts

@@ -0,0 +1,6 @@
+import AbstractNodeProvider from "./src/AbstractNodeProvider";
+import CanvasNodeRender from "./src/CanvasNodeRender";
+import NodeAxis from "./src/NodeAxis.vue";
+import NullLayerProvider from "./src/NullLayerProvider";
+import { Extensible, TimeModes, Direction } from "./src/enum";
+export { CanvasNodeRender, AbstractNodeProvider, NodeAxis, NullLayerProvider, Extensible, TimeModes, Direction };

package/dist/components/NodeAxis/src/AbstractNodeProvider.d.ts

@@ -0,0 +1,15 @@
+import NodeProvider from "./NodeProvider";
+import { NodeAxis } from "./types";
+export default abstract class AbstractNodeProvider implements NodeProvider {
+    extract(range: number[], count: number, nodes?: number[]): number[];
+    scale(offset: number, range: number[], length: number, direction: number): number[];
+    abstract get count(): number;
+    abstract color(index: number): string;
+    abstract extends(direction: number, minimum?: number): Promise<number> | number;
+    abstract get extensible(): number;
+    abstract get extent(): NodeAxis.Extent;
+    abstract format(index: number, type: NodeAxis.Format): string;
+    abstract get sections(): NodeAxis.Section[] | null;
+    abstract reset(): any;
+    abstract dispose(): void;
+}

package/dist/components/NodeAxis/src/AbstractNodeProvider.js

@@ -0,0 +1,23 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import NodeMath from '../../Visual/src/utils/NodeMath.js';
+
+var AbstractNodeProvider = /*#__PURE__*/function () {
+  function AbstractNodeProvider() {
+    _classCallCheck(this, AbstractNodeProvider);
+  }
+  _createClass(AbstractNodeProvider, [{
+    key: "extract",
+    value: function extract(range, count, nodes) {
+      return NodeMath.extract(range, count, nodes);
+    }
+  }, {
+    key: "scale",
+    value: function scale(offset, range, length, direction) {
+      return NodeMath.scale(offset, range, length, direction);
+    }
+  }]);
+  return AbstractNodeProvider;
+}();
+
+export { AbstractNodeProvider as default };

package/dist/components/NodeAxis/src/BCanvasNodeRender.d.ts

@@ -0,0 +1,19 @@
+import NodeRender from "./NodeRender";
+export default class BCanvasNodeRender extends NodeRender {
+    protected canvas: HTMLCanvasElement;
+    protected context: CanvasRenderingContext2D;
+    protected overlay: HTMLElement;
+    protected cache: any;
+    protected onMouseWheel(event: WheelEvent): void;
+    protected onMouseMove(event: MouseEvent): void;
+    protected onMouseLeave(event: any): void;
+    protected onMouseDown(event: any): void;
+    protected onMouseUp(event: any): void;
+    protected showOverlay(index: number): any;
+    initialize(container: HTMLElement, accept: Function): void;
+    resize(): void;
+    reset(): void;
+    dataChange(): void;
+    dispose(): void;
+    render(index?: number): void;
+}

package/dist/components/NodeAxis/src/CanvasNodeRender.d.ts

@@ -0,0 +1,28 @@
+import NodeRender from "./NodeRender";
+export default class CanvasNodeRender extends NodeRender {
+    protected canvas: HTMLCanvasElement;
+    protected context: CanvasRenderingContext2D;
+    protected overlay: HTMLElement;
+    protected cache: any;
+    protected zrender: any;
+    protected onMouseMove(event: any): void;
+    protected onMouseLeave(event: any): void;
+    protected onMouseDown(event: any): void;
+    protected showOverlay(index: number): any;
+    getBoundingClientRect(): {
+        length: number;
+        width: number;
+        height: number;
+        label: number;
+        left: number;
+        right: number;
+        top: number;
+        bound: DOMRect;
+    };
+    initialize(container: HTMLElement, accept: Function): void;
+    resize(): void;
+    reset(): void;
+    dataChange(): void;
+    dispose(): void;
+    render(index?: number): void;
+}

package/dist/components/NodeAxis/src/CanvasNodeRender.js

@@ -0,0 +1,400 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
+import _get from '@babel/runtime/helpers/get';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import NodeMath from '../../Visual/src/utils/NodeMath.js';
+import NodeRender from './NodeRender.js';
+import * as zrender from 'zrender/dist/zrender';
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var CanvasNodeRender = /*#__PURE__*/function (_NodeRender) {
+  _inherits(CanvasNodeRender, _NodeRender);
+  function CanvasNodeRender() {
+    var _this;
+    _classCallCheck(this, CanvasNodeRender);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, CanvasNodeRender, [].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "canvas", void 0);
+    _defineProperty(_assertThisInitialized(_this), "context", void 0);
+    _defineProperty(_assertThisInitialized(_this), "overlay", void 0);
+    _defineProperty(_assertThisInitialized(_this), "cache", {});
+    _defineProperty(_assertThisInitialized(_this), "zrender", void 0);
+    return _this;
+  }
+  _createClass(CanvasNodeRender, [{
+    key: "onMouseMove",
+    value: function onMouseMove(event) {
+      var _event$event, _event$event2;
+      event === null || event === void 0 || (_event$event = event.event) === null || _event$event === void 0 || _event$event.preventDefault();
+      event === null || event === void 0 || (_event$event2 = event.event) === null || _event$event2 === void 0 || _event$event2.stopImmediatePropagation();
+      var provider = this.model.provider;
+      var bounds = this.model.bounds;
+      var extent = this.model.extent;
+      var offset = event.offsetX - bounds.left;
+      var number = NodeMath.index(offset, extent, bounds.length);
+      var index = NodeMath.clamp(number, extent[0], extent[1] - 1);
+      var model = this.model,
+        o = model.options;
+      if (o.overlay.enabled) {
+        this.overlay.hidden = false;
+        var rect = this.overlay.getBoundingClientRect();
+        var left = event.offsetX + 10;
+        if (event.offsetX + rect.width > this.container.offsetWidth) {
+          left -= rect.width + 5;
+        }
+        var top = event.offsetY + 15;
+        if (event.y + rect.height > window.innerHeight) {
+          top -= rect.height + 5;
+        }
+        this.overlay.style.transform = "translate3d(".concat(left, "px, ").concat(top, "px, 0px)");
+        var cursor = model.dragging ? extent[2] : model.pressed ? model.index : index;
+        if (model.pressed === false) {
+          var ss = model.options.cursor.size / 2;
+          var x1 = NodeMath.offset(extent[2], extent, bounds.length) + bounds.left;
+          var y1 = bounds.top;
+          var x2 = event.offsetX,
+            y2 = event.offsetY;
+          var radius = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
+          if (radius <= ss) cursor = extent[2];
+        }
+        this.showOverlay(cursor);
+      }
+      if (model.dragging && model.pressed) {
+        if (index !== extent[2]) {
+          this.render(index);
+        }
+      } else if (model.pressed && model.right && o.translation) {
+        var move = index - model.index,
+          count = provider.count;
+        if (move < 0 && extent[1] < count) {
+          NodeMath.translation(extent, +1, 0, 2);
+          NodeMath.translation(model.nodes, +1);
+        } else if (move > 0 && extent[0] > 0) {
+          NodeMath.translation(extent, -1, 0, 2);
+          NodeMath.translation(model.nodes, -1);
+        }
+        this.render();
+      }
+    }
+  }, {
+    key: "onMouseLeave",
+    value: function onMouseLeave(event) {
+      var _event$event3, _event$event4;
+      event === null || event === void 0 || (_event$event3 = event.event) === null || _event$event3 === void 0 || _event$event3.preventDefault();
+      event === null || event === void 0 || (_event$event4 = event.event) === null || _event$event4 === void 0 || _event$event4.stopImmediatePropagation();
+      this.overlay.style.opacity = String(0);
+      this.model.dragging = false;
+      this.model.pressed = false;
+      this.model.right = false;
+    }
+  }, {
+    key: "onMouseDown",
+    value: function onMouseDown(event) {
+      var provider = this.model.provider;
+      var b = this.model.bounds,
+        x = event.offsetX,
+        y = event.offsetY,
+        e = this.model.extent,
+        o = this.model.options;
+      if (o.draggable && provider.count) {
+        var ss = this.model.options.cursor.size / 2;
+        var x1 = NodeMath.offset(e[2], this.model.range, b.length) + b.left;
+        var y1 = b.top;
+        var radius = Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
+        this.model.dragging = radius <= ss;
+      }
+      this.model.pressed = true;
+      this.model.press[0] = x;
+      this.model.press[1] = y;
+      this.model.right = event.button === 2;
+      this.model.index = NodeMath.index(x - b.left, e, b.length);
+      this.render(NodeMath.clamp(this.model.index, e[0], e[1] - 1));
+    }
+  }, {
+    key: "showOverlay",
+    value: function showOverlay(index) {
+      var _this$model$options$o, _this$model$options$o2;
+      this.overlay.style.opacity = String(1);
+      var provider = this.model.provider;
+      if (provider.count) {
+        var value = this.cache[index];
+        if (value == null) {
+          value = this.cache[index] = provider.format(index, "long");
+        }
+        console.log('value', value);
+        return this.overlay.innerText = value;
+      }
+      console.log('this.model.options.overlay?.empty ', (_this$model$options$o = this.model.options.overlay) === null || _this$model$options$o === void 0 ? void 0 : _this$model$options$o.empty);
+      this.overlay.innerHTML = ((_this$model$options$o2 = this.model.options.overlay) === null || _this$model$options$o2 === void 0 ? void 0 : _this$model$options$o2.empty) || "Node is unavailable!";
+    }
+  }, {
+    key: "getBoundingClientRect",
+    value: function getBoundingClientRect() {
+      var _this$model$options$l;
+      var options = this.model.options;
+      var bound = this.container.getBoundingClientRect();
+      var width = NodeMath.valueBy(options.width || bound.width, this.container.offsetWidth || window.innerWidth),
+        height = NodeMath.valueBy(options.height || bound.height, this.container.offsetHeight || window.innerHeight),
+        left = NodeMath.valueBy(options.track.left, width),
+        top = NodeMath.valueBy(options.track.top, height),
+        right = NodeMath.valueBy(options.track.right, width),
+        label = NodeMath.valueBy((_this$model$options$l = this.model.options.label) === null || _this$model$options$l === void 0 ? void 0 : _this$model$options$l.top, height);
+      if (left == null) {
+        left = Math.max(options.cursor.size, options.node.size || 0) / 2;
+      }
+      if (top == null) {
+        var _options$label;
+        top = height / ((_options$label = options.label) !== null && _options$label !== void 0 && _options$label.enabled ? 3 : 2);
+      }
+      if (right == null) {
+        right = left;
+      }
+      if (label == null) {
+        var _options$node;
+        label = Math.max(options.cursor.size, (_options$node = options.node) === null || _options$node === void 0 ? void 0 : _options$node.size, options.track.height) / 2 + 10;
+      }
+      var length = width - (left + right);
+      return {
+        length: length,
+        width: width,
+        height: height,
+        label: label,
+        left: left,
+        right: right,
+        top: top,
+        bound: bound
+      };
+    }
+  }, {
+    key: "initialize",
+    value: function initialize(container, accept) {
+      if (this.initialized === false) {
+        _get(_getPrototypeOf(CanvasNodeRender.prototype), "initialize", this).call(this, container, accept);
+        var _this$getBoundingClie = this.getBoundingClientRect(),
+          width = _this$getBoundingClie.width,
+          height = _this$getBoundingClie.height;
+        var sizes = this.getBoundingClientRect();
+        console.log('计算得到的尺寸', sizes);
+        this.zrender = zrender.init(this.container, {
+          renderer: 'canvas',
+          devicePixelRatio: 2,
+          width: width,
+          height: height,
+          pointerSize: 50
+        });
+        this.overlay = document.createElement("div");
+        this.overlay.className = "node-axis--overlay";
+        container.appendChild(this.overlay);
+        this.resize();
+        this.initialized = true;
+      }
+    }
+  }, {
+    key: "resize",
+    value: function resize() {
+      var _this$getBoundingClie2 = this.getBoundingClientRect(),
+        width = _this$getBoundingClie2.width,
+        height = _this$getBoundingClie2.height,
+        right = _this$getBoundingClie2.right,
+        left = _this$getBoundingClie2.left,
+        top = _this$getBoundingClie2.top,
+        label = _this$getBoundingClie2.label,
+        length = _this$getBoundingClie2.length;
+      this.model.width = width;
+      this.model.height = height;
+      this.model.bounds = {
+        left: left,
+        top: top,
+        right: right,
+        length: length,
+        label: label
+      };
+      this.zrender && this.zrender.resize({
+        width: width,
+        height: height
+      });
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.model.reset();
+      this.render();
+    }
+  }, {
+    key: "dataChange",
+    value: function dataChange() {
+      var _this2 = this;
+      Object.keys(this.cache).forEach(function (key) {
+        return delete _this2.cache[key];
+      });
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      var _this$zrender, _this$container, _this$container$remov;
+      this.dataChange();
+      (_this$zrender = this.zrender) === null || _this$zrender === void 0 || _this$zrender.dispose();
+      this.zrender = null;
+      (_this$container = this.container) === null || _this$container === void 0 || (_this$container$remov = _this$container.remove) === null || _this$container$remov === void 0 || _this$container$remov.call(_this$container);
+    }
+  }, {
+    key: "render",
+    value: function render(index) {
+      var _this$zrender2,
+        _this$zrender3,
+        _this$zrender3$add,
+        _this3 = this;
+      var provider = this.model.provider,
+        range = this.model.extent;
+        this.context;
+        var b = this.model.bounds,
+        o = this.model.options,
+        h = o.track.height,
+        c = (provider === null || provider === void 0 ? void 0 : provider.count) || 0,
+        d = range[1] - range[0];
+      if (index == null) index = range[2];
+      var indexColor = provider.color(index);
+      this.model.range = NodeMath.clampArray(range, [0, c]);
+      if (this.zrender) (_this$zrender2 = this.zrender) === null || _this$zrender2 === void 0 || _this$zrender2.clear();
+      var lineTrack = new zrender.Polyline({
+        shape: {
+          points: [[b === null || b === void 0 ? void 0 : b.left, b === null || b === void 0 ? void 0 : b.top], [(b === null || b === void 0 ? void 0 : b.left) + (b === null || b === void 0 ? void 0 : b.length), b === null || b === void 0 ? void 0 : b.top]]
+        },
+        style: {
+          stroke: o.track.color,
+          lineWidth: h
+        }
+      });
+      this.zrender && ((_this$zrender3 = this.zrender) === null || _this$zrender3 === void 0 || (_this$zrender3$add = _this$zrender3.add) === null || _this$zrender3$add === void 0 ? void 0 : _this$zrender3$add.call(_this$zrender3, lineTrack));
+      var sections = provider.sections;
+      if (sections && sections.length) {
+        sections.forEach(function (section) {
+          if (NodeMath.inRange(range, section.range)) {
+            var _this3$zrender;
+            var x1 = NodeMath.clamp(NodeMath.offset(section.range[0] - 1, range, b.length), 0, b.length);
+            var x2 = NodeMath.clamp(NodeMath.offset(section.range[1] - 1, range, b.length), 0, b.length);
+            var lineSections = new zrender.Polyline({
+              shape: {
+                points: [[b.left + x1, b.top], [b.left + x2, b.top]]
+              },
+              style: {
+                stroke: section.color,
+                lineWidth: h
+              },
+              cursor: 'default'
+            });
+            (_this3$zrender = _this3.zrender) === null || _this3$zrender === void 0 || _this3$zrender.add(lineSections);
+          }
+        });
+      }
+      if (c && d > 1 && o.progress && o.progress.enabled) {
+        var _this$zrender4;
+        var x = NodeMath.clamp(NodeMath.offset(index, range, b.length), 0, b.length);
+        var lineProgress = new zrender.Polyline({
+          shape: {
+            points: [[b === null || b === void 0 ? void 0 : b.left, b === null || b === void 0 ? void 0 : b.top], [(b === null || b === void 0 ? void 0 : b.left) + x, b === null || b === void 0 ? void 0 : b.top]]
+          },
+          style: {
+            stroke: o.progress.color,
+            lineWidth: h
+          },
+          cursor: 'default'
+        });
+        (_this$zrender4 = this.zrender) === null || _this$zrender4 === void 0 || _this$zrender4.add(lineProgress);
+      }
+      if (this.model.nodes) {
+        var labeled = o.label && o.label.enabled;
+        this.model.nodes.forEach(function (e, i) {
+          var _this3$zrender2;
+          var x = b.left + NodeMath.offset(e, range, b.length);
+          var circle = new zrender.Circle({
+            shape: {
+              cx: x,
+              cy: b === null || b === void 0 ? void 0 : b.top,
+              r: o.node.size / 2
+            },
+            style: {
+              fill: '#fff',
+              stroke: o.node.outlineColor,
+              lineWidth: o.node.outlineWidth
+            }
+          });
+          (_this3$zrender2 = _this3.zrender) === null || _this3$zrender2 === void 0 || _this3$zrender2.add(circle);
+          circle.onmouseover = function (ev) {
+            _this3.onMouseMove(ev);
+          };
+          circle.onmouseout = function (ev) {
+            _this3.onMouseLeave(ev);
+          };
+          circle.onclick = function (ev) {
+            console.log('onclick', ev);
+            _this3.onMouseDown(ev);
+          };
+          circle.oncontextmenu = function (ev) {
+            console.log('oncontextmenu', ev);
+            ev === null || ev === void 0 || ev.event.preventDefault();
+            ev === null || ev === void 0 || ev.event.stopImmediatePropagation();
+          };
+          if (labeled) {
+            var _this3$zrender3;
+            var t1 = new zrender.Text({
+              style: {
+                text: provider.format(e, 'short'),
+                align: i === 0 && d > 1 ? 'left' : e === range[1] - 1 && d > 1 ? 'right' : 'center',
+                textVerticalAlign: 'middle',
+                fontFamily: 'Lato',
+                fontWeight: 'bolder',
+                textFill: '#0ff',
+                blend: 'lighten'
+              },
+              position: [x, b.label]
+            });
+            (_this3$zrender3 = _this3.zrender) === null || _this3$zrender3 === void 0 || _this3$zrender3.add(t1);
+          }
+        });
+      }
+      if (c && range[0] <= index && index < range[1]) {
+        var _this$zrender5;
+        var _x = b.left + NodeMath.offset(index, range, b.length);
+        var circle = new zrender.Circle({
+          shape: {
+            cx: _x,
+            cy: b.top,
+            r: o.cursor.size / 2
+          },
+          style: {
+            fill: indexColor || o.cursor.color,
+            stroke: o.cursor.outlineColor,
+            lineWidth: o.cursor.outlineWidth
+          }
+        });
+        circle.onmouseover = function (ev) {
+          _this3.onMouseMove(ev);
+        };
+        circle.onmouseout = function (ev) {
+          _this3.onMouseLeave(ev);
+        };
+        circle.onclick = function (ev) {
+          _this3.onMouseDown(ev);
+        };
+        circle.oncontextmenu = function (ev) {
+          ev === null || ev === void 0 || ev.event.preventDefault();
+          ev === null || ev === void 0 || ev.event.stopImmediatePropagation();
+        };
+        (_this$zrender5 = this.zrender) === null || _this$zrender5 === void 0 || _this$zrender5.add(circle);
+      }
+      this.model.extent[2] = index;
+      this.accept.call(this, index);
+    }
+  }]);
+  return CanvasNodeRender;
+}(NodeRender);
+
+export { CanvasNodeRender as default };

package/dist/components/NodeAxis/src/NodeAxis.d.ts

@@ -0,0 +1,12 @@
+import { PropType } from "vue";
+import NodeRender from "./NodeRender";
+declare const _default: import("vue").DefineComponent<{
+    render: PropType<NodeRender>;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:frame"[], "update:frame", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    render: PropType<NodeRender>;
+}>> & {
+    "onUpdate:frame"?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;

package/dist/components/NodeAxis/src/NodeAxis.vue.d.ts

@@ -0,0 +1,17 @@
+declare const _default: import("vue").DefineComponent<{
+    config: ObjectConstructor;
+    res: {
+        type: ObjectConstructor;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:frame" | "register")[], "update:frame" | "register", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: ObjectConstructor;
+    res: {
+        type: ObjectConstructor;
+    };
+}>> & {
+    "onUpdate:frame"?: (...args: any[]) => any;
+    onRegister?: (...args: any[]) => any;
+}, {}, {}>;
+export default _default;

package/dist/components/NodeAxis/src/NodeAxis.vue.js

@@ -0,0 +1,5 @@
+import script from './NodeAxis.vue2.js';
+
+script.__file = "src/components/NodeAxis/src/NodeAxis.vue";
+
+export { script as default };