@dfsj/components 3.1.0 → 3.1.2

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

@@ -0,0 +1,68 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { defineComponent, ref, onMounted, nextTick, openBlock, createElementBlock } from 'vue';
+import NodeModel from './NodeModel.js';
+import CanvasNodeRender from './CanvasNodeRender.js';
+import TimerNodePlayer from './TimerNodePlayer.js';
+
+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; }
+var script = defineComponent({
+  __name: 'NodeAxis',
+  props: {
+    config: Object,
+    res: {
+      type: Object
+    }
+  },
+  emits: ['update:frame', 'register'],
+  setup: function setup(__props, _ref) {
+    var __expose = _ref.expose,
+      __emit = _ref.emit;
+    var def = {
+      height: 40,
+      width: "100%",
+      track: {
+        top: "20%"
+      },
+      label: {
+        top: "55%"
+      }
+    };
+    var props = __props;
+    var emits = __emit;
+    var model = new NodeModel(_objectSpread(_objectSpread({}, def), props.config));
+    var renderer = new CanvasNodeRender(model);
+    var player = new TimerNodePlayer(model, renderer);
+    var container = ref();
+    var accept = function accept(index) {
+      return emits("update:frame", index);
+    };
+    onMounted(function () {
+      nextTick(function () {
+        renderer.initialize(container.value, accept);
+        renderer.render();
+        emits('register', {
+          renderer: renderer,
+          player: player
+        });
+      });
+    });
+    function update(provider) {
+      renderer.update(provider);
+      renderer.render();
+    }
+    __expose({
+      renderer: renderer,
+      update: update
+    });
+    return function (_ctx, _cache) {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "container",
+        ref: container,
+        "class": "component node-axis"
+      }, null, 512);
+    };
+  }
+});
+
+export { script as default };

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

@@ -0,0 +1,24 @@
+import Disposable from "../../Visual/src/interface/Disposable";
+import NodeProvider from "./NodeProvider";
+import { NodeAxis } from "./types";
+export default class NodeModel implements Disposable {
+    options: NodeAxis.NodeOptions;
+    nodes: number[];
+    limit: number[];
+    scale: number[];
+    dragging: boolean;
+    pressed: boolean;
+    index: number;
+    range: number[];
+    press: number[];
+    right: boolean;
+    bounds: NodeAxis.Bounds;
+    height: number;
+    width: number;
+    provider: NodeProvider;
+    extent: NodeAxis.Extent;
+    constructor(options: NodeAxis.NodeOptions);
+    update(provider: NodeProvider): void;
+    reset(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,64 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import assign from './utils/assign.js';
+import { render } from './config/node-axis.options.js';
+import NullProvider from './NullProvider.js';
+
+var NodeModel = /*#__PURE__*/function () {
+  function NodeModel(options) {
+    _classCallCheck(this, NodeModel);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "nodes", void 0);
+    _defineProperty(this, "limit", [0.01, 100]);
+    _defineProperty(this, "scale", void 0);
+    _defineProperty(this, "dragging", false);
+    _defineProperty(this, "pressed", false);
+    _defineProperty(this, "index", 0);
+    _defineProperty(this, "range", void 0);
+    _defineProperty(this, "press", [0, 0]);
+    _defineProperty(this, "right", false);
+    _defineProperty(this, "bounds", void 0);
+    _defineProperty(this, "height", 0);
+    _defineProperty(this, "width", 0);
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "extent", void 0);
+    this.options = assign({}, render, options);
+    this.update(NullProvider.SINGLETON);
+  }
+  _createClass(NodeModel, [{
+    key: "update",
+    value: function update(provider) {
+      var _options$node;
+      this.provider = provider;
+      var options = this.options;
+      var count = provider.count;
+      var extent = this.extent = provider.extent;
+      this.scale = count ? [extent[0] / count * 100, extent[1] / count * 100] : [0, 100];
+      if (count > 0 && (_options$node = options.node) !== null && _options$node !== void 0 && _options$node.enabled) {
+        this.nodes = this.provider.extract(extent, options.node.count, this.nodes);
+      }
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      var _options$node2;
+      var provider = this.provider;
+      var options = this.options;
+      this.provider.reset();
+      this.extent = provider.extent;
+      if (provider.count > 0 && (_options$node2 = options.node) !== null && _options$node2 !== void 0 && _options$node2.enabled) {
+        var _options$node3;
+        this.nodes = provider.extract(provider.extent, (_options$node3 = options.node) === null || _options$node3 === void 0 ? void 0 : _options$node3.count, this.nodes);
+      }
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.nodes.length = 0;
+    }
+  }]);
+  return NodeModel;
+}();
+
+export { NodeModel as default };

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

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

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

@@ -0,0 +1,17 @@
+import NodeModel from "./NodeModel";
+import NodeProvider from "./NodeProvider";
+import Disposable from "../../Visual/src/interface/Disposable";
+export default abstract class NodeRender implements Disposable {
+    protected model: NodeModel;
+    protected container: HTMLElement;
+    protected initialized: Boolean;
+    protected accept: Function;
+    constructor(model: NodeModel);
+    initialize(container: HTMLElement, accept: Function): void;
+    update(provider: NodeProvider): void;
+    abstract render(index?: number): void;
+    abstract resize(): void;
+    abstract reset(): void;
+    abstract dataChange(): void;
+    abstract dispose(): void;
+}

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

@@ -0,0 +1,30 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+var NodeRender = /*#__PURE__*/function () {
+  function NodeRender(model) {
+    _classCallCheck(this, NodeRender);
+    _defineProperty(this, "model", void 0);
+    _defineProperty(this, "container", void 0);
+    _defineProperty(this, "initialized", false);
+    _defineProperty(this, "accept", void 0);
+    this.model = model;
+  }
+  _createClass(NodeRender, [{
+    key: "initialize",
+    value: function initialize(container, accept) {
+      this.container = container;
+      this.accept = accept;
+    }
+  }, {
+    key: "update",
+    value: function update(provider) {
+      this.model.update(provider);
+      this.dataChange();
+    }
+  }]);
+  return NodeRender;
+}();
+
+export { NodeRender as default };

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

@@ -0,0 +1,23 @@
+import LayerProvider from "../../Visual/src/interface/LayerProvider";
+import { NodeAxis } from "./types";
+import { Visual, Layer } from "../../Visual/src/types";
+export default class NullLayerProvider implements LayerProvider {
+    static readonly SINGLETON: NullLayerProvider;
+    private constructor();
+    color(index: number): string;
+    get count(): number;
+    dispose(): void;
+    extends(direction: number, minimum?: number): number | Promise<number>;
+    get extensible(): number;
+    get extent(): NodeAxis.Extent;
+    extract(range: number[], count: number, nodes?: number[]): number[];
+    find(query: Visual.Condition): number;
+    format(index: number, type: NodeAxis.Format): string;
+    get(index: number): Layer;
+    getNodeInfo(index: number): Visual.NodeInfo | undefined;
+    reset(): void;
+    scale(offset: number, range: number[], length: number, direction: number): number[];
+    get sections(): NodeAxis.Section[] | null;
+    activate(action: any): void;
+    yield(): void;
+}

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

@@ -0,0 +1,88 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+var _class;
+var NullLayerProvider = /*#__PURE__*/function () {
+  function NullLayerProvider() {
+    _classCallCheck(this, NullLayerProvider);
+  }
+  _createClass(NullLayerProvider, [{
+    key: "color",
+    value: function color(index) {
+      return "";
+    }
+  }, {
+    key: "count",
+    get: function get() {
+      return 0;
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {}
+  }, {
+    key: "extends",
+    value: function _extends(direction, minimum) {
+      return 0;
+    }
+  }, {
+    key: "extensible",
+    get: function get() {
+      return 0;
+    }
+  }, {
+    key: "extent",
+    get: function get() {
+      return [0, 0, 0];
+    }
+  }, {
+    key: "extract",
+    value: function extract(range, count, nodes) {
+      return [];
+    }
+  }, {
+    key: "find",
+    value: function find(query) {
+      return 0;
+    }
+  }, {
+    key: "format",
+    value: function format(index, type) {
+      return "暂无数据";
+    }
+  }, {
+    key: "get",
+    value: function get(index) {
+      return undefined;
+    }
+  }, {
+    key: "getNodeInfo",
+    value: function getNodeInfo(index) {
+      return undefined;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {}
+  }, {
+    key: "scale",
+    value: function scale(offset, range, length, direction) {
+      return [];
+    }
+  }, {
+    key: "sections",
+    get: function get() {
+      return undefined;
+    }
+  }, {
+    key: "activate",
+    value: function activate(action) {}
+  }, {
+    key: "yield",
+    value: function _yield() {}
+  }]);
+  return NullLayerProvider;
+}();
+_class = NullLayerProvider;
+_defineProperty(NullLayerProvider, "SINGLETON", Object.seal(new _class()));
+
+export { NullLayerProvider as default };

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

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

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

@@ -0,0 +1,67 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+var _class;
+var NullProvider = /*#__PURE__*/function () {
+  function NullProvider() {
+    _classCallCheck(this, NullProvider);
+  }
+  _createClass(NullProvider, [{
+    key: "count",
+    get: function get() {
+      return 0;
+    }
+  }, {
+    key: "extensible",
+    get: function get() {
+      return 0;
+    }
+  }, {
+    key: "extent",
+    get: function get() {
+      return [0, 0, 0];
+    }
+  }, {
+    key: "extends",
+    value: function _extends(direction, minimum) {
+      return Promise.resolve(0);
+    }
+  }, {
+    key: "extract",
+    value: function extract(range, count, nodes) {
+      return [];
+    }
+  }, {
+    key: "color",
+    value: function color(index) {
+      return "";
+    }
+  }, {
+    key: "format",
+    value: function format(index, type) {
+      return "暂无数据";
+    }
+  }, {
+    key: "scale",
+    value: function scale(offset, range, length, direction) {
+      return [0, 0];
+    }
+  }, {
+    key: "sections",
+    get: function get() {
+      return null;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {}
+  }, {
+    key: "dispose",
+    value: function dispose() {}
+  }]);
+  return NullProvider;
+}();
+_class = NullProvider;
+_defineProperty(NullProvider, "SINGLETON", Object.freeze(new _class()));
+
+export { NullProvider as default };

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

@@ -0,0 +1,19 @@
+import NodeModel from "./NodeModel";
+import NodeRender from "./NodeRender";
+import { NodeAxis } from "./types";
+import NodePlayer from "./interface/NodePlayer";
+export default class TimerNodePlayer implements NodePlayer {
+    protected renderer: NodeRender;
+    protected model: NodeModel;
+    protected timer: any;
+    protected options: NodeAxis.PlayOptions;
+    constructor(model: NodeModel, renderer: NodeRender, options?: NodeAxis.PlayOptions);
+    get playing(): boolean;
+    play(): void;
+    stop(): void;
+    reset(): void;
+    backward(loop: boolean): void;
+    forward(loop: boolean): void;
+    jump(index: number): void;
+    protected render(index?: number): void;
+}

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

@@ -0,0 +1,150 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import assign from './utils/assign.js';
+import { play } from './config/node-axis.options.js';
+import { Extensible, Direction } from './enum/index.js';
+import NodeMath from '../../Visual/src/utils/NodeMath.js';
+
+var TimerNodePlayer = /*#__PURE__*/function () {
+  function TimerNodePlayer(model, renderer, options) {
+    _classCallCheck(this, TimerNodePlayer);
+    _defineProperty(this, "renderer", void 0);
+    _defineProperty(this, "model", void 0);
+    _defineProperty(this, "timer", void 0);
+    _defineProperty(this, "options", void 0);
+    this.model = model;
+    this.renderer = renderer;
+    this.options = assign({}, play, options);
+  }
+  _createClass(TimerNodePlayer, [{
+    key: "playing",
+    get: function get() {
+      return this.timer != null;
+    }
+  }, {
+    key: "play",
+    value: function play() {
+      var _this = this;
+      if (this.timer == null && this.model.provider.count) {
+        var interval = this.options.interval || 2000;
+        var loop = this.options.loop;
+        this.timer = setInterval(function () {
+          return _this.forward(loop);
+        }, interval);
+      }
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.stop();
+      this.renderer.reset();
+    }
+  }, {
+    key: "backward",
+    value: function backward(loop) {
+      var provider = this.model.provider,
+        count = provider.count;
+      var extent = this.model.extent,
+        index = extent[2];
+      if (count > 0) {
+        if (index <= 0) {
+          if ((provider.extensible & Extensible.HEAD) === Extensible.HEAD) {
+            var amount = provider["extends"](Direction.BACKWARD, extent[1] - extent[0]);
+            if (amount && typeof amount === "number") {
+              NodeMath.translation(this.model.nodes, amount - 1);
+              NodeMath.translation(extent, -1);
+              this.renderer.dataChange();
+              this.render(amount - 1);
+            }
+          } else if (loop) {
+            this.render(count - 1);
+          } else {
+            this.stop();
+          }
+        } else {
+          var center = Math.floor(extent[0] + (extent[1] - extent[0]) / 2);
+          if (index >= 0 && index <= center && extent[0] > 0) {
+            NodeMath.translation(extent, -1, 0, 2);
+            NodeMath.translation(this.model.nodes, -1);
+          }
+          this.render(index - 1);
+        }
+      }
+    }
+  }, {
+    key: "forward",
+    value: function forward(loop) {
+      var provider = this.model.provider;
+      var extent = this.model.extent,
+        count = provider.count,
+        index = extent[2];
+      if (count > 0) {
+        if (index + 1 >= count) {
+          if ((provider.extensible & Extensible.TAIL) === Extensible.TAIL) {
+            var amount = provider["extends"](Direction.FORWARD, extent[1] - extent[0]);
+            if (amount && typeof amount === "number") {
+              this.render(index + 1);
+            }
+          } else if (loop) {
+            this.render(count - 1);
+          } else {
+            this.stop();
+          }
+        } else {
+          var center = Math.floor(extent[0] + (extent[1] - extent[0]) / 2);
+          if (index < count && index >= center && extent[1] < count) {
+            NodeMath.translation(extent, 1, 0, 2);
+            NodeMath.translation(this.model.nodes, 1);
+          }
+          this.render(index + 1);
+        }
+      }
+    }
+  }, {
+    key: "jump",
+    value: function jump(index) {
+      var provider = this.model.provider,
+        extent = this.model.extent,
+        count = provider.count,
+        range = extent[1] - extent[0];
+      if (index < 0) {
+        var totals = range * (Math.floor(-index / range) + 1);
+        var amount = provider["extends"](Direction.BACKWARD, totals);
+        if (amount != null && typeof amount === "number") {
+          index = Math.max(amount - -index, 0);
+          NodeMath.translation(this.model.nodes, amount);
+          this.renderer.dataChange();
+        }
+      } else if (index >= count) {
+        var _totals = range * (Math.floor((index - count) / range) + 1);
+        var _amount = provider["extends"](Direction.FORWARD, _totals);
+        if (_amount != null && typeof _amount === "number") {
+          index = Math.min(index, count + _amount - 1);
+        }
+      }
+      var diff = index - extent[2],
+        dir = diff < 0 ? -1 : diff > 0 ? 1 : 0;
+      var step = diff < 0 ? Math.min(-diff, extent[0]) : Math.min(diff, provider.count - extent[1]);
+      if (step > 0) {
+        NodeMath.translation(extent, step * dir);
+        NodeMath.translation(this.model.nodes, step * dir);
+      }
+      this.render(index);
+    }
+  }, {
+    key: "render",
+    value: function render(index) {
+      this.renderer.render(index);
+    }
+  }]);
+  return TimerNodePlayer;
+}();
+
+export { TimerNodePlayer as default };

package/dist/components/NodeAxis/src/config/node-axis.options.d.ts

@@ -0,0 +1,54 @@
+export declare const render: {
+    background: any;
+    width: number;
+    height: number;
+    jump: boolean;
+    draggable: boolean;
+    translation: boolean;
+    edgeAdjust: string;
+    overlay: {
+        enabled: boolean;
+        empty: string;
+    };
+    track: {
+        left: number;
+        top: string;
+        right: number;
+        height: number;
+        color: string;
+    };
+    node: {
+        enabled: boolean;
+        size: number;
+        count: number;
+        minCount: number;
+        color: string;
+        outlineWidth: number;
+        outlineColor: string;
+        shadow: string;
+    };
+    cursor: {
+        size: number;
+        color: string;
+        outlineWidth: number;
+        outlineColor: string;
+    };
+    scale: {
+        enabled: boolean;
+        limit: number[];
+    };
+    progress: {
+        enabled: boolean;
+        color: string;
+    };
+    label: {
+        enabled: boolean;
+        top: string;
+        font: string;
+        color: string;
+    };
+};
+export declare const play: {
+    interval: number;
+    loop: boolean;
+};