@spider-analyzer/timeline 4.0.2 → 5.0.0

package/src/timeline.css

@@ -0,0 +1,139 @@
+/* @spider-analyzer/timeline — default stylesheet.
+ *
+ * Every rule is keyed on a `tl-<slot>` class. Consumers override by
+ * passing `classes={{ <slot>: 'my-class' }}` — the component emits
+ * `tl-<slot> my-class` together, so any CSS in `.my-class` wins via
+ * normal specificity / source order.
+ */
+
+/* Layout */
+.tl-timelineContainer { width: 100%; height: 100%; }
+
+/* Axes / grid */
+.tl-axis { fill: none; stroke: #b4b4b4; stroke-width: 1; }
+.tl-arrow { fill: #b4b4b4; fill-opacity: 1; stroke: #b4b4b4; stroke-width: 1; }
+.tl-now { fill: #545454; stroke: #545454; stroke-width: 1; }
+.tl-grid { stroke: #ececec; stroke-width: 1; }
+.tl-limitMarker { stroke: #b4b4b4; stroke-width: 1; }
+.tl-timeAxisText {
+    font-size: 10px;
+    font-family: Roboto, sans-serif;
+    fill: #b4b4b4;
+    text-align: center;
+    text-anchor: middle;
+    user-select: none;
+}
+.tl-timeAxisDaysText { fill: #545454; }
+.tl-verticalAxisText {
+    font-size: 10px;
+    font-family: Roboto, sans-serif;
+    fill: #b4b4b4;
+    text-align: end;
+    text-anchor: end;
+    user-select: none;
+}
+
+/* Legend */
+.tl-legend {
+    font-size: 12.5px;
+    line-height: 125%;
+    font-family: Roboto, sans-serif;
+    fill-opacity: 1;
+    stroke: none;
+    text-align: end;
+    text-anchor: end;
+    user-select: none;
+}
+
+/* Histogram */
+.tl-histoItem { fill-opacity: 1; stroke-width: 1; }
+.tl-histoHovered { stroke-width: 0; fill: #000000; fill-opacity: 0.3; }
+
+/* Histo tooltip */
+.tl-innerTipMetrics { margin-top: 4px; }
+.tl-innerTipLeft { margin-right: 4px; display: inline-block; }
+.tl-innerTipRight { display: inline-block; float: right; }
+
+/* Quality line */
+.tl-qualityCell { stroke-width: 0; }
+
+/* Buttons */
+.tl-buttonGroup { cursor: pointer; }
+.tl-buttonGroupInactive { cursor: not-allowed; }
+.tl-buttonOverShape { fill: transparent; }
+.tl-buttonIcon {
+    fill: #b4b4b4; fill-opacity: 1;
+    stroke: #b4b4b4; stroke-width: 1; stroke-opacity: 1;
+}
+.tl-buttonIconOver { fill: #ff8080; stroke: #ff8080; }
+
+/* Cursor selection */
+.tl-cursorArea {
+    fill: #00BCD4;
+    fill-opacity: 0.2;
+    stroke: #00BCD4;
+    stroke-width: 1px;
+    stroke-linecap: butt;
+    stroke-linejoin: miter;
+    stroke-opacity: 1;
+    cursor: move;
+    transition: fill 0.5s, stroke 0.5s;
+}
+.tl-cursorArea.tl--maxSize { stroke: #00899f; }
+
+/* Cursor handles */
+.tl-cursorLeftHandle, .tl-cursorRightHandle {
+    fill-opacity: 1;
+    stroke-width: 1px;
+    transition: r 0.5s;
+    r: 4;
+    fill: #ffffff;
+    stroke: #00BCD4;
+    cursor: ew-resize;
+}
+.tl-cursorLeftHandle:hover, .tl-cursorRightHandle:hover { r: 8; }
+.tl-cursorLeftHandle.tl--maxSize { cursor: e-resize; }
+.tl-cursorRightHandle.tl--maxSize { cursor: w-resize; }
+.tl-cursorLeftHandle.tl--outOfView,
+.tl-cursorRightHandle.tl--outOfView {
+    fill: #ececec;
+    stroke: #b4b4b4;
+}
+
+/* Drag overlay */
+.tl-dragOverlay { fill: transparent; fill-opacity: 1; stroke: none; cursor: crosshair; }
+
+/* Cursor icon (offscreen indicator) */
+.tl-cursorIconRect { fill: #00bcd4; fill-opacity: 0.25; stroke: #00bcd4; stroke-width: 0.42; }
+.tl-cursorIconCircle { fill: #ffffff; stroke: #00bcd4; stroke-width: 0.52; }
+.tl-cursorIconRectOver { fill: #ff8080; stroke: #e7594f; }
+.tl-cursorIconCircleOver { stroke: #e7594f; }
+
+/* Zoom buttons */
+.tl-zoomIn { fill: #00BCD4; fill-opacity: 1; stroke: none; }
+.tl-zoomOut { fill: #ff816b; fill-opacity: 1; stroke: none; }
+.tl-zoomArea { fill: transparent; fill-opacity: 1; stroke: none; }
+.tl-zoomInContainer {
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.5s, visibility 0.5s;
+    cursor: pointer;
+}
+.tl-zoomOutContainer { cursor: pointer; }
+
+/* Tooltips (cursor start/stop) */
+.tl-toolTipArea { opacity: 0; visibility: hidden; transition: opacity 0.25s, visibility 0.25s; }
+.tl-toolTip {
+    fill: #1a1a1a;
+    fill-opacity: 0.80;
+    stroke: #ffffff;
+    stroke-opacity: 1;
+    stroke-width: 0.1;
+    stroke-miterlimit: 1.3;
+}
+.tl-toolTipText {
+    font-size: 12.5px;
+    font-family: Roboto, sans-serif;
+    fill: #ffffff;
+}
+.tl-toolTipTextRight { text-align: end; text-anchor: end; }

package/src/utils.ts

@@ -0,0 +1,60 @@
+/**
+ * Tiny local replacements for the lodash-es helpers the library used.
+ * Keeping them in a single file lets us drop lodash-es entirely.
+ */
+
+export const max = (arr: number[] | undefined): number | undefined =>
+    arr && arr.length ? Math.max(...arr) : undefined;
+
+export const sum = (arr: number[] | undefined): number =>
+    arr ? arr.reduce((acc, v) => acc + v, 0) : 0;
+
+export const floor = (n: number, precision = 0): number => {
+    const p = Math.pow(10, precision);
+    return Math.floor(n * p) / p;
+};
+
+export const round = (n: number, precision = 0): number => {
+    const p = Math.pow(10, precision);
+    return Math.round(n * p) / p;
+};
+
+export const clamp = (n: number, lower: number, upper: number): number =>
+    Math.max(lower, Math.min(upper, n));
+
+export const isFunction = (v: unknown): v is (...args: any[]) => any =>
+    typeof v === 'function';
+
+// Deep equality for plain objects, arrays, and primitives — covers the
+// shallow `margin` prop comparison we use.
+export function isEqual(a: any, b: any): boolean {
+    if (a === b) return true;
+    if (a == null || b == null) return false;
+    if (typeof a !== 'object' || typeof b !== 'object') return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) {
+        if (!isEqual(a[k], b[k])) return false;
+    }
+    return true;
+}
+
+// Shallow merge of `...sources` into `target`. Missing keys win from later
+// sources; nested objects get recursively merged too (matching lodash's
+// `merge` for the limited shape we feed it — labels + tools config).
+export function merge<T extends Record<string, any>>(target: T, ...sources: any[]): T {
+    for (const src of sources) {
+        if (!src || typeof src !== 'object') continue;
+        for (const k of Object.keys(src)) {
+            const v = src[k];
+            if (v && typeof v === 'object' && !Array.isArray(v) &&
+                target[k] && typeof target[k] === 'object' && !Array.isArray(target[k])) {
+                (target as any)[k] = merge({ ...target[k] }, v);
+            } else {
+                (target as any)[k] = v;
+            }
+        }
+    }
+    return target;
+}

package/.babelrc

@@ -1,8 +0,0 @@
-{
-  "presets": ["@babel/preset-react", "@babel/env"],
-  "plugins": [
-    "@babel/plugin-transform-react-jsx",
-    "@babel/plugin-proposal-class-properties",
-    "@babel/plugin-proposal-export-default-from"
-  ]
-}

package/.gitlab-ci.yml

@@ -1,27 +0,0 @@
-image: node:16-alpine
-
-stages:
-  - test
-  - deploy
-
-test:
-  stage: test
-  script:
-    - cd test
-    - mkdir -p timeline && cp -rf ../index.js ../package.json ../src timeline
-    - npm install --force
-    - npm run build_gui
-
-pages:
-  stage: deploy
-  script:
-    - cd test
-    - mkdir -p timeline && cp -rf ../index.js ../package.json ../src timeline
-    - npm install --force
-    - npm run build_gui
-    - mv ./bundle ../public
-  artifacts:
-    paths:
-      - public
-  only:
-    - pages

package/Makefile

@@ -1,20 +0,0 @@
-NAME            := timeline
-NPM_REGISTRY    := $(shell npm config get registry)
-NPM             := npm
-
-node_modules: package.json ## install node modules
-	$(NPM) install --quiet --registry=$(NPM_REGISTRY)
-
-clean: node_modules ## remove node_modules directory
-	$(NPM) run clean
-
-build: node_modules ## build dist
-	$(NPM) run build && printf "\nRemember to:\n  - Update \033[36mCHANGELOG.md\033[0m\n  - Increase version: \033[36mnpm version major|minor|patch\033[0m\n"
-
-publish: build ## publish to npm
-	$(NPM) publish --access public && git push origin --tags
-
-help: ## display help
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z._-]+:.*?## / {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
-.DEFAULT_GOAL := help

package/dist/Cursor.js

@@ -1,290 +0,0 @@
-"use strict";
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = Cursor;
-var _react = _interopRequireWildcard(require("react"));
-var _propTypes = _interopRequireDefault(require("prop-types"));
-var _utils = require("./cursorElements/utils");
-var _DragOverlay = _interopRequireDefault(require("./cursorElements/DragOverlay"));
-var _ZoomOut = _interopRequireDefault(require("./cursorElements/ZoomOut"));
-var _CursorIcon = _interopRequireDefault(require("./cursorElements/CursorIcon"));
-var _CursorSelection = _interopRequireDefault(require("./cursorElements/CursorSelection"));
-var _LeftHandle = _interopRequireDefault(require("./cursorElements/LeftHandle"));
-var _RightHandle = _interopRequireDefault(require("./cursorElements/RightHandle"));
-var _ZoomIn = _interopRequireDefault(require("./cursorElements/ZoomIn"));
-var _LeftToolTip = _interopRequireDefault(require("./cursorElements/LeftToolTip"));
-var _RightToolTip = _interopRequireDefault(require("./cursorElements/RightToolTip"));
-var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function Cursor(_ref) {
-  var overlayWidth = _ref.overlayWidth,
-    overlayHeight = _ref.overlayHeight,
-    items = _ref.items,
-    setBarHovered = _ref.setBarHovered,
-    setToolTipVisible = _ref.setToolTipVisible,
-    showHistoToolTip = _ref.showHistoToolTip,
-    tooltipVisible = _ref.tooltipVisible,
-    barHovered = _ref.barHovered,
-    dragging = _ref.dragging,
-    setDragging = _ref.setDragging,
-    origin = _ref.origin,
-    height = _ref.height,
-    startPos = _ref.startPos,
-    endPos = _ref.endPos,
-    canZoom = _ref.canZoom,
-    minZoom = _ref.minZoom,
-    maxZoom = _ref.maxZoom,
-    maxSize = _ref.maxSize,
-    zoomOutLabel = _ref.zoomOutLabel,
-    zoomOut = _ref.zoomOut,
-    cursorIsAfterView = _ref.cursorIsAfterView,
-    cursorIsBeforeView = _ref.cursorIsBeforeView,
-    gotoCursorLabel = _ref.gotoCursorLabel,
-    onGotoCursor = _ref.onGotoCursor,
-    rcToolTipPrefixCls = _ref.rcToolTipPrefixCls,
-    classes = _ref.classes,
-    onStartDrawCursor = _ref.onStartDrawCursor,
-    onDrawCursor = _ref.onDrawCursor,
-    onEndCursor = _ref.onEndCursor,
-    onMoveDomain = _ref.onMoveDomain,
-    onMovedDomain = _ref.onMovedDomain,
-    onDragCursor = _ref.onDragCursor,
-    onEndDragCursor = _ref.onEndDragCursor,
-    startText = _ref.startText,
-    stopText = _ref.stopText,
-    zoomInLabel = _ref.zoomInLabel,
-    zoomIn = _ref.zoomIn,
-    startIsOutOfView = _ref.startIsOutOfView,
-    endIsOutOfView = _ref.endIsOutOfView,
-    tools = _ref.tools,
-    onResizeLeftCursor = _ref.onResizeLeftCursor,
-    onResizeRightCursor = _ref.onResizeRightCursor,
-    onEndResizeCursor = _ref.onEndResizeCursor;
-  var dragOverlay = (0, _react.useRef)();
-  var zoomInButton = (0, _react.useRef)();
-  var cursorSelection = (0, _react.useRef)();
-  var renderIcon = cursorIsAfterView || cursorIsBeforeView;
-  var cursorWidth = endPos - startPos < 1 ? 1 : endPos - startPos;
-  var _useState = (0, _react.useState)(false),
-    _useState2 = _slicedToArray(_useState, 2),
-    isVisibleTTR = _useState2[0],
-    setVisibleTTR = _useState2[1];
-  var _useState3 = (0, _react.useState)(false),
-    _useState4 = _slicedToArray(_useState3, 2),
-    isVisibleTTL = _useState4[0],
-    setVisibleTTL = _useState4[1];
-  var originSelection = {
-    x: startPos,
-    y: 0
-  };
-  return /*#__PURE__*/_react["default"].createElement("g", {
-    transform: "translate(".concat(origin.x, ",").concat(origin.y, ")")
-  }, /*#__PURE__*/_react["default"].createElement(_DragOverlay["default"], {
-    ref: dragOverlay,
-    width: overlayWidth,
-    height: overlayHeight,
-    showToolTipLeft: setVisibleTTL,
-    showToolTipRight: setVisibleTTR,
-    onDrawCursor: onDrawCursor,
-    onEndCursor: onEndCursor,
-    onMovedDomain: onMovedDomain,
-    onMoveDomain: onMoveDomain,
-    onStartDrawCursor: onStartDrawCursor,
-    setToolTipVisible: setToolTipVisible,
-    setBarHovered: setBarHovered,
-    items: items,
-    tooltipVisible: tooltipVisible,
-    barHovered: barHovered,
-    showHistoToolTip: showHistoToolTip,
-    marginBottom: overlayHeight - height - 4,
-    dragging: dragging,
-    setDragging: setDragging,
-    cursorSelection: cursorSelection
-  }), renderIcon && /*#__PURE__*/_react["default"].createElement(_CursorIcon["default"], {
-    classes: classes,
-    rcToolTipPrefixCls: rcToolTipPrefixCls,
-    origin: {
-      x: cursorIsAfterView ? startPos - 17 : startPos - 23,
-      y: height / 2 - 24
-    },
-    position: startPos === 1 ? 'left' : 'right',
-    gotoCursorLabel: gotoCursorLabel,
-    onGotoCursor: onGotoCursor
-  }), /*#__PURE__*/_react["default"].createElement("g", {
-    style: {
-      display: renderIcon ? 'none' : undefined
-    },
-    transform: "translate(".concat(originSelection.x, ",").concat(originSelection.y, ")"),
-    onMouseOver: function onMouseOver() {
-      canZoom && tools.zoomIn !== false && !maxZoom && (0, _utils.show)(zoomInButton.current);
-    },
-    onMouseOut: function onMouseOut() {
-      canZoom && tools.zoomIn !== false && (0, _utils.hide)(zoomInButton.current);
-    }
-  }, /*#__PURE__*/_react["default"].createElement(_CursorSelection["default"], {
-    ref: cursorSelection,
-    classes: classes,
-    dragOverlay: dragOverlay,
-    maxSize: maxSize,
-    canZoom: canZoom,
-    startPos: startPos,
-    endPos: endPos,
-    height: height,
-    showToolTipLeft: setVisibleTTL,
-    showToolTipRight: setVisibleTTR,
-    onDragCursor: onDragCursor,
-    onEndDragCursor: onEndDragCursor,
-    onMovedDomain: onMovedDomain,
-    onMoveDomain: onMoveDomain,
-    zoomIn: zoomIn,
-    width: cursorWidth,
-    setToolTipVisible: setToolTipVisible,
-    setBarHovered: setBarHovered,
-    items: items,
-    tooltipVisible: tooltipVisible,
-    barHovered: barHovered,
-    showHistoToolTip: showHistoToolTip,
-    dragging: dragging,
-    setDragging: setDragging
-  }), /*#__PURE__*/_react["default"].createElement(_LeftHandle["default"], {
-    classes: classes,
-    origin: {
-      x: 0,
-      y: height / 2 + 2
-    },
-    maxSize: maxSize,
-    dragOverlay: dragOverlay,
-    startIsOutOfView: startIsOutOfView,
-    showToolTipLeft: setVisibleTTL,
-    onResizeLeftCursor: onResizeLeftCursor,
-    onEndResizeCursor: onEndResizeCursor,
-    setDragging: setDragging
-  }), /*#__PURE__*/_react["default"].createElement(_RightHandle["default"], {
-    classes: classes,
-    origin: {
-      x: cursorWidth,
-      y: height / 2 + 2
-    },
-    maxSize: maxSize,
-    dragOverlay: dragOverlay,
-    endIsOutOfView: endIsOutOfView,
-    showToolTipRight: setVisibleTTR,
-    onResizeRightCursor: onResizeRightCursor,
-    onEndResizeCursor: onEndResizeCursor,
-    setDragging: setDragging
-  }), canZoom && tools.zoomIn !== false && /*#__PURE__*/_react["default"].createElement(_ZoomIn["default"], {
-    ref: zoomInButton,
-    classes: classes,
-    rcToolTipPrefixCls: rcToolTipPrefixCls,
-    origin: {
-      x: cursorWidth - 25,
-      y: 0
-    },
-    zoomInLabel: zoomInLabel,
-    onZoomIn: zoomIn
-  }), /*#__PURE__*/_react["default"].createElement(_LeftToolTip["default"], {
-    classes: classes,
-    origin: {
-      x: 0,
-      y: height / 2
-    },
-    height: height,
-    startText: startText,
-    isVisibleTooltipLeft: isVisibleTTL
-  }), /*#__PURE__*/_react["default"].createElement(_RightToolTip["default"], {
-    classes: classes,
-    origin: {
-      x: cursorWidth,
-      y: height / 2 + 4
-    },
-    height: height,
-    stopText: stopText,
-    isVisibleTooltipRight: isVisibleTTR
-  })), canZoom && !minZoom && tools.zoomOut !== false && /*#__PURE__*/_react["default"].createElement(_ZoomOut["default"], {
-    classes: classes,
-    rcToolTipPrefixCls: rcToolTipPrefixCls,
-    origin: {
-      x: overlayWidth - 10,
-      y: height - 20
-    },
-    zoomOutLabel: zoomOutLabel,
-    onZoomOut: zoomOut
-  }));
-}
-Cursor.propTypes = {
-  origin: _propTypes["default"].shape({
-    x: _propTypes["default"].number.isRequired,
-    y: _propTypes["default"].number.isRequired
-  }).isRequired,
-  startPos: _propTypes["default"].number.isRequired,
-  startIsOutOfView: _propTypes["default"].bool,
-  endPos: _propTypes["default"].number.isRequired,
-  endIsOutOfView: _propTypes["default"].bool,
-  height: _propTypes["default"].number.isRequired,
-  overlayHeight: _propTypes["default"].number.isRequired,
-  overlayWidth: _propTypes["default"].number.isRequired,
-  items: _propTypes["default"].arrayOf(_propTypes["default"].shape({
-    start: _propTypes["default"].instanceOf(_momentTimezone["default"]).isRequired,
-    end: _propTypes["default"].instanceOf(_momentTimezone["default"]).isRequired,
-    x1: _propTypes["default"].number,
-    x2: _propTypes["default"].number,
-    metrics: _propTypes["default"].arrayOf(_propTypes["default"].number).isRequired,
-    total: _propTypes["default"].number.isRequired
-  })),
-  tooltipVisible: _propTypes["default"].bool,
-  barHovered: _propTypes["default"].number,
-  dragging: _propTypes["default"].bool,
-  setBarHovered: _propTypes["default"].func,
-  setToolTipVisible: _propTypes["default"].func,
-  setDragging: _propTypes["default"].func,
-  cursorIsBeforeView: _propTypes["default"].bool,
-  cursorIsAfterView: _propTypes["default"].bool,
-  maxSize: _propTypes["default"].bool,
-  startText: _propTypes["default"].string.isRequired,
-  stopText: _propTypes["default"].string.isRequired,
-  canZoom: _propTypes["default"].bool.isRequired,
-  maxZoom: _propTypes["default"].bool,
-  minZoom: _propTypes["default"].bool,
-  zoomIn: _propTypes["default"].func,
-  zoomOut: _propTypes["default"].func,
-  onResizeLeftCursor: _propTypes["default"].func.isRequired,
-  onResizeRightCursor: _propTypes["default"].func.isRequired,
-  onEndResizeCursor: _propTypes["default"].func.isRequired,
-  onDragCursor: _propTypes["default"].func.isRequired,
-  onEndDragCursor: _propTypes["default"].func.isRequired,
-  onStartDrawCursor: _propTypes["default"].func.isRequired,
-  onDrawCursor: _propTypes["default"].func.isRequired,
-  onEndCursor: _propTypes["default"].func.isRequired,
-  onMoveDomain: _propTypes["default"].func,
-  onMovedDomain: _propTypes["default"].func,
-  onGotoCursor: _propTypes["default"].func,
-  gotoCursorLabel: _propTypes["default"].string,
-  zoomInLabel: _propTypes["default"].string,
-  zoomOutLabel: _propTypes["default"].string,
-  classes: _propTypes["default"].object,
-  rcToolTipPrefixCls: _propTypes["default"].string.isRequired,
-  tools: _propTypes["default"].shape({
-    zoomIn: _propTypes["default"].bool,
-    zoomOut: _propTypes["default"].bool
-  })
-};
-var identity = function identity() {};
-Cursor.defaultProps = {
-  classes: {},
-  onMoveDomain: identity,
-  onMovedDomain: identity,
-  setBarHovered: identity,
-  setToolTipVisible: identity,
-  setDragging: identity
-};