@dfsj/components 3.1.1 → 3.1.3

package/dist/components/Visual/src/ResolvableLayerProvider.js

@@ -0,0 +1,255 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import clamp from 'lodash-es/clamp';
+import NodeMath from './utils/NodeMath.js';
+import { Extensible } from '../../NodeAxis/src/enum/index.js';
+import AbstractNodeProvider from '../../NodeAxis/src/AbstractNodeProvider.js';
+import mapping from './mapping.js';
+import def from './config/default.provider.js';
+
+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 EMPTY_ARRAY = [];
+var ResolvableLayerProvider = /*#__PURE__*/function (_AbstractNodeProvider) {
+  _inherits(ResolvableLayerProvider, _AbstractNodeProvider);
+  function ResolvableLayerProvider(factory, data, injection, interceptor, config) {
+    var _this;
+    _classCallCheck(this, ResolvableLayerProvider);
+    _this = _callSuper(this, ResolvableLayerProvider);
+    _defineProperty(_assertThisInitialized(_this), "factory", void 0);
+    _defineProperty(_assertThisInitialized(_this), "interceptor", void 0);
+    _defineProperty(_assertThisInitialized(_this), "config", void 0);
+    _defineProperty(_assertThisInitialized(_this), "cache", [-1, null]);
+    _defineProperty(_assertThisInitialized(_this), "total", 0);
+    _defineProperty(_assertThisInitialized(_this), "marks", []);
+    _defineProperty(_assertThisInitialized(_this), "init", void 0);
+    _defineProperty(_assertThisInitialized(_this), "back", void 0);
+    _defineProperty(_assertThisInitialized(_this), "options", null);
+    _defineProperty(_assertThisInitialized(_this), "extended", 0);
+    _defineProperty(_assertThisInitialized(_this), "nodes", []);
+    _this.factory = factory;
+    _this.interceptor = interceptor;
+    _this.config = Object.assign({}, def, config);
+    _this.read(data, injection);
+    return _this;
+  }
+  _createClass(ResolvableLayerProvider, [{
+    key: "read",
+    value: function read(options, injection) {
+      this.options = options;
+      var resolvers = options.nodes.map(function (e) {
+        return new mapping[e.type](e, injection);
+      });
+      var count = resolvers.reduce(function (p, v) {
+        return p + v.count;
+      }, 0);
+      var range = options.range;
+      var index = clamp(options.index, 0, count - 1) || 0;
+      if (range == null) {
+        var nodeCount = options.availableNodeCount || this.config.availableNodeCount;
+        var padding = Array.isArray(nodeCount) ? nodeCount : null;
+        if (padding == null) {
+          var half = Math.floor(nodeCount / 2);
+          padding = [nodeCount % 2 === 0 ? half - 1 : half, half];
+        }
+        if (index - padding[0] < 0) {
+          padding[1] = padding[1] + (padding[0] - index);
+          padding[0] = index;
+        } else if (index + padding[1] >= count) {
+          padding[0] = padding[0] + (index + padding[1] - count) + 1;
+          padding[1] = count - index;
+        }
+        range = [Math.max(0, index - padding[0]), Math.min(count, index + padding[1] + 1)];
+      }
+      var extensible = options.extensible;
+      if (typeof extensible === "string") {
+        this.extended = (extensible.includes("L") ? Extensible.HEAD : 0) | (extensible.includes("R") ? Extensible.TAIL : 0);
+      } else if (typeof extensible === "number") {
+        this.extended = extensible;
+      } else {
+        this.extended = Extensible.NONE;
+      }
+      this.total = count;
+      this.nodes = resolvers;
+      this.init = Object.seal([range[0], range[1], index]);
+      this.back = this.init.slice();
+      this.makeSections();
+    }
+  }, {
+    key: "findNode",
+    value: function findNode(index) {
+      var accept = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.cache;
+      for (var i = 0, start = 0, ii = this.nodes.length; i < ii; i++) {
+        var node = this.nodes[i];
+        if (index >= start && index < start + node.count) {
+          accept[0] = start;
+          accept[1] = node;
+          return accept;
+        }
+        start += node.count;
+      }
+      return EMPTY_ARRAY;
+    }
+  }, {
+    key: "makeSections",
+    value: function makeSections() {
+      this.marks.length = 0;
+      for (var i = 0, start = 0, ii = this.nodes.length; i < ii; i++) {
+        var node = this.nodes[i];
+        start += node.count;
+        if (node.period) {
+          this.marks.push({
+            range: [start - node.count, start],
+            color: this.config.sectionColor[node.period]
+          });
+        }
+      }
+    }
+  }, {
+    key: "get",
+    value: function get(index) {
+      var _this$findNode = this.findNode(index),
+        _this$findNode2 = _slicedToArray(_this$findNode, 2),
+        start = _this$findNode2[0],
+        node = _this$findNode2[1];
+      if (node != null) {
+        var config = node.get(index - start);
+        if (this.interceptor) {
+          config = this.interceptor(config);
+        }
+        return config;
+      }
+      return null;
+    }
+  }, {
+    key: "getNodeInfo",
+    value: function getNodeInfo(index) {
+      var _this$findNode3 = this.findNode(index),
+        _this$findNode4 = _slicedToArray(_this$findNode3, 2),
+        start = _this$findNode4[0],
+        node = _this$findNode4[1];
+      if (node != null) {
+        return node.getNodeInfo(index - start);
+      }
+    }
+  }, {
+    key: "extent",
+    get: function get() {
+      return this.init;
+    }
+  }, {
+    key: "count",
+    get: function get() {
+      return this.total;
+    }
+  }, {
+    key: "sections",
+    get: function get() {
+      return this.marks;
+    }
+  }, {
+    key: "extensible",
+    get: function get() {
+      return this.extended;
+    }
+  }, {
+    key: "color",
+    value: function color(index) {
+      return null;
+    }
+  }, {
+    key: "format",
+    value: function format(index, type) {
+      var _this$findNode5 = this.findNode(index),
+        _this$findNode6 = _slicedToArray(_this$findNode5, 2),
+        start = _this$findNode6[0],
+        node = _this$findNode6[1];
+      if (node != null) {
+        return node.format(index - start, type);
+      }
+    }
+  }, {
+    key: "formatByInject",
+    value: function formatByInject(index, type, finalFormat) {
+      var _this$findNode7 = this.findNode(index),
+        _this$findNode8 = _slicedToArray(_this$findNode7, 2),
+        start = _this$findNode8[0],
+        node = _this$findNode8[1];
+      if (node != null) {
+        return node.formatByInject(index - start, type, finalFormat);
+      }
+    }
+  }, {
+    key: "find",
+    value: function find(query) {
+      var index = null,
+        head = this.nodes[0];
+      if ((index = head.find(query)) != null) {
+        return index;
+      }
+      var size = this.nodes.length;
+      var tail = this.nodes[size - 1];
+      if ((index = tail.find(query)) != null) {
+        return this.total + index;
+      }
+      for (var i = 1, s = head.count, ii = size - 1; i < ii; i++) {
+        var node = this.nodes[i];
+        if ((index = node.find(query)) != null) {
+          if (index > node.count) {
+            break;
+          }
+          return s + index;
+        }
+        s += node.count;
+      }
+      return null;
+    }
+  }, {
+    key: "extends",
+    value: function _extends(direction, minimum) {
+      var oldCount = this.total,
+        extended = 0;
+      var amount = Math.max(minimum, this.extent[1] - this.extent[0]);
+      if (amount !== 0) {
+        var node = this.nodes[direction < 0 ? 0 : this.nodes.length - 1];
+        var side = direction < 0 ? Extensible.HEAD : Extensible.TAIL;
+        var extensible = !!(this.extensible & side) && node.isAutoExtensible;
+        if (extensible) {
+          extended = node["extends"](direction, amount);
+          this.total += Math.abs(extended);
+        }
+      }
+      if (direction < 0 && this.count !== oldCount) {
+        NodeMath.translation(this.init, extended);
+        NodeMath.translation(this.back, extended);
+      }
+      this.makeSections();
+      return extended;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.init = this.back.slice();
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.total = 0;
+      this.nodes = null;
+      this.marks = null;
+      this.cache = null;
+      this.config = null;
+      this.options = null;
+      this.factory = null;
+    }
+  }]);
+  return ResolvableLayerProvider;
+}(AbstractNodeProvider);
+
+export { ResolvableLayerProvider as default };

package/dist/components/Visual/src/config/default.manager.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    buffer: number;
+    transition: number;
+    opacity: number;
+};
+export default _default;

package/dist/components/Visual/src/config/default.manager.js

@@ -0,0 +1,7 @@
+var def = {
+  buffer: 1,
+  transition: 0,
+  opacity: 0.6
+};
+
+export { def as default };

package/dist/components/Visual/src/config/default.provider.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    sectionColor: {
+        history: string;
+        short: string;
+        long: string;
+        tend: string;
+        forecast: string;
+    };
+    statusColor: {
+        ready: any;
+        loading: string;
+        success: string;
+        error: string;
+    };
+    availableNodeCount: number[];
+};
+export default _default;

package/dist/components/Visual/src/config/default.provider.js

@@ -0,0 +1,18 @@
+var def = {
+  sectionColor: {
+    history: "rgba(51,51,51,0.45)",
+    "short": "rgba(51,183,255,0.45)",
+    "long": "rgba(235,255,121,0.45)",
+    tend: "rgba(255,99,13,0.45)",
+    forecast: "rgba(255,99,13,0.45)"
+  },
+  statusColor: {
+    ready: null,
+    loading: "#d076ff",
+    success: "#07ff23",
+    error: "#ff0059"
+  },
+  availableNodeCount: [2, 3]
+};
+
+export { def as default };

package/dist/components/Visual/src/interface/Disposable.d.ts

@@ -0,0 +1,3 @@
+export default interface Disposable {
+    dispose(): void;
+}

package/dist/components/Visual/src/interface/LayerFactory.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "../types";
+import { LayerConfig } from "../types";
+export default interface LayerFactory {
+    create(options: LayerConfig | LayerConfig[]): Promise<Layer | Layer[]>;
+}

package/dist/components/Visual/src/interface/LayerManager.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from "../types";
+export default interface LayerManager {
+    addition(layer: Layer | Layer[]): void;
+    remove(layer: Layer | Layer[]): void;
+    clear(): void;
+    modify(layer: Layer, property: string, value: any): void;
+    query(layer: Layer, property: string): any;
+}

package/dist/components/Visual/src/interface/LayerPlayer.d.ts

@@ -0,0 +1,10 @@
+export default interface LayerPlayer {
+    backward(): any;
+    forward(): any;
+    jump(index: number): any;
+    visible(value: boolean): any;
+    status(index: number): string;
+    update(index: number): void;
+    clear(): any;
+    dispose(): any;
+}

package/dist/components/Visual/src/interface/LayerProvider.d.ts

@@ -0,0 +1,7 @@
+import { Visual } from "../types";
+import NodeProvider from "../../../NodeAxis/src/interface/NodeProvider";
+export default interface LayerProvider extends NodeProvider {
+    get(index: number): Promise<object>;
+    find(query: Visual.Condition): number;
+    getNodeInfo(index: number): Visual.NodeInfo | undefined;
+}

package/dist/components/Visual/src/interface/LayerResolver.d.ts

@@ -0,0 +1,13 @@
+import { NodeAxis } from "../../../NodeAxis/src/types";
+import { LayerConfig, Visual } from "../types";
+export default interface LayerResolver {
+    get count(): number;
+    get period(): string;
+    get isAutoExtensible(): boolean;
+    get(index: number): LayerConfig;
+    getNodeInfo(index: number): Visual.NodeInfo;
+    format(index: number, type: NodeAxis.Format): any;
+    find(query: Visual.Condition): number | null;
+    extends(direction: any, minimum: any): number;
+    dispose(): any;
+}

package/dist/components/Visual/src/mapping.d.ts

@@ -0,0 +1,5 @@
+import IntervalResolver from "./resolvers/IntervalResolver";
+declare const _default: {
+    interval: typeof IntervalResolver;
+};
+export default _default;

package/dist/components/Visual/src/mapping.js

@@ -0,0 +1,7 @@
+import IntervalResolver from './resolvers/IntervalResolver.js';
+
+var mapping = {
+  interval: IntervalResolver
+};
+
+export { mapping as default };

package/dist/components/Visual/src/resolvers/IntervalResolver.d.ts

@@ -0,0 +1,30 @@
+import { DateTime } from "luxon";
+import { NodeAxis } from "../../../NodeAxis/src/types";
+import { LayerConfig } from "../types";
+import LayerResolver from "../interface/LayerResolver";
+import { Visual } from "../types";
+export declare const EMPTY_STRING: string;
+export default class IntervalResolver implements LayerResolver {
+    protected options: any;
+    protected injection: any;
+    protected range: Visual.DateRange;
+    protected step: number;
+    protected unit: Visual.DateUnit;
+    protected transform: Visual.Transform[];
+    protected layer: any;
+    protected total: number;
+    constructor(options: Visual.Node, injection: any);
+    get count(): number;
+    get period(): string;
+    get isAutoExtensible(): boolean;
+    get(index: number): LayerConfig;
+    getNodeInfo(index: number): Visual.NodeInfo;
+    format(index: number, type: NodeAxis.Format): string;
+    formatByInject(index: number, type: NodeAxis.Format, finalFormat: string): string;
+    find(query: Visual.Condition): number | null;
+    extends(direction: number, minimum: number): number;
+    dispose(): void;
+    protected getQuery(index: number): any;
+    protected getNodeInfoByTime(time: DateTime): Visual.NodeInfo;
+    protected getTime(index: number): DateTime;
+}

package/dist/components/Visual/src/resolvers/IntervalResolver.js

@@ -0,0 +1,170 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { DateTime } from 'luxon';
+import { toFormat, getFormatDate, getCount } from './tools.resolver.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 EMPTY_STRING = Object.freeze("");
+var IntervalResolver = /*#__PURE__*/function () {
+  function IntervalResolver(options, injection) {
+    _classCallCheck(this, IntervalResolver);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "injection", void 0);
+    _defineProperty(this, "range", void 0);
+    _defineProperty(this, "step", void 0);
+    _defineProperty(this, "unit", void 0);
+    _defineProperty(this, "transform", void 0);
+    _defineProperty(this, "layer", void 0);
+    _defineProperty(this, "total", void 0);
+    this.options = options;
+    this.injection = injection;
+    this.transform = options.transform;
+    this.step = options.interval;
+    this.unit = options.symbol;
+    this.layer = options.layer;
+    this.range = options.range.map(function (e) {
+      return DateTime.fromSQL(e);
+    });
+    this.total = getCount(this.range, this.unit, this.step);
+  }
+  _createClass(IntervalResolver, [{
+    key: "count",
+    get: function get() {
+      return this.total;
+    }
+  }, {
+    key: "period",
+    get: function get() {
+      return this.options.period;
+    }
+  }, {
+    key: "isAutoExtensible",
+    get: function get() {
+      return true;
+    }
+  }, {
+    key: "get",
+    value: function get(index) {
+      var name = this.format(index, "short");
+      var custom = this.getQuery(index);
+      var injection = this.injection;
+      if (this.layer.type === "group") {
+        return {
+          injection: injection,
+          type: "group",
+          opacity: this.layer.opacity,
+          layers: this.layer.layers.map(function (layer) {
+            return Object.assign({
+              name: name
+            }, layer, {
+              custom: custom
+            });
+          })
+        };
+      }
+      return Object.assign({
+        name: name,
+        injection: injection
+      }, this.layer, {
+        custom: custom
+      });
+    }
+  }, {
+    key: "getNodeInfo",
+    value: function getNodeInfo(index) {
+      return Object.assign(this.getNodeInfoByTime(this.getTime(index)), {
+        extend: this.options.extend,
+        fields: this.getQuery(index),
+        layer: this.options.layer
+      });
+    }
+  }, {
+    key: "format",
+    value: function format(index, type) {
+      var pattern = this.options.format[type];
+      if (pattern != null) {
+        return toFormat(pattern, this.getNodeInfo(index));
+      }
+      return EMPTY_STRING;
+    }
+  }, {
+    key: "formatByInject",
+    value: function formatByInject(index, type, finalFormat) {
+      var pattern = this.options.format[type];
+      if (pattern != null) {
+        return getFormatDate(pattern, this.getNodeInfo(index), finalFormat);
+      }
+      return EMPTY_STRING;
+    }
+  }, {
+    key: "find",
+    value: function find(query) {
+      if (query.time != null) {
+        var target = DateTime.fromSQL(query.time),
+          begin = this.range[0];
+        if (this.unit === "xun") {
+          return Math.round(target.diff(begin, "month").months * 3);
+        }
+        return Math.round(target.diff(begin, this.unit).get(this.unit) / this.step);
+      }
+      return null;
+    }
+  }, {
+    key: "extends",
+    value: function _extends(direction, minimum) {
+      var side = direction < 0 ? 0 : 1,
+        unit = this.unit,
+        step = this.step,
+        time = this.range[side];
+      this.range[side] = time.plus(_defineProperty({}, unit, minimum * direction * step));
+      this.total += minimum;
+      return minimum;
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.options = null;
+      this.transform = null;
+      this.injection = null;
+    }
+  }, {
+    key: "getQuery",
+    value: function getQuery(index) {
+      var _this = this;
+      var time = this.getTime(index);
+      var now = DateTime.fromMillis(Date.now());
+      return this.transform.reduce(function (model, item) {
+        var clone = time,
+          offset = item.offset;
+        if (clone.hasSame(now, "day") && clone.hour < item.split) offset = 0;
+        if (offset) clone = clone.plus({
+          "millisecond": offset
+        });
+        model[item.field] = toFormat(item.pattern, _this.getNodeInfoByTime(clone));
+        return model;
+      }, {});
+    }
+  }, {
+    key: "getNodeInfoByTime",
+    value: function getNodeInfoByTime(time) {
+      return _objectSpread({
+        time: time,
+        unit: this.unit,
+        step: this.step
+      }, this.injection);
+    }
+  }, {
+    key: "getTime",
+    value: function getTime(index) {
+      if (index === 0) {
+        return this.range[0];
+      }
+      return this.range[0].plus(_defineProperty({}, this.unit, index * this.step));
+    }
+  }]);
+  return IntervalResolver;
+}();
+
+export { EMPTY_STRING, IntervalResolver as default };

package/dist/components/Visual/src/resolvers/tools.resolver.d.ts

@@ -0,0 +1,4 @@
+import { Visual } from "../types";
+export declare function getCount(range: Visual.DateRange, symbol: Visual.DateUnit, interval: number): number;
+export declare function toFormat(pattern: string, nodeInfo: Visual.NodeInfo): string;
+export declare function getFormatDate(pattern: string, nodeInfo: Visual.NodeInfo, resolveFormat?: string): any;