@cloud-app-dev/vidc 4.0.19 → 4.0.21

package/es/GridList/hook.js

@@ -0,0 +1,270 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useScroll } from 'ahooks';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { getColumnWidth, getElementOffset, getElementSize, getWindowScroll, getWindowSize, isSameElementScroll, isSameElementSize } from "./utils";
+export function useConstRef(value) {
+  var ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+export function useWindowSize() {
+  var _useState = useState(function () {
+      return getWindowSize();
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    windowSize = _useState2[0],
+    setWindowSize = _useState2[1];
+  var windowSizeRef = useConstRef(windowSize);
+  useEffect(function () {
+    function onResize() {
+      var nextWindowSize = getWindowSize();
+      if (!isSameElementSize(windowSizeRef.current, nextWindowSize)) {
+        setWindowSize(nextWindowSize);
+      }
+    }
+    window.addEventListener('resize', onResize);
+    return function () {
+      return window.removeEventListener('resize', onResize);
+    };
+  }, [windowSizeRef]);
+  return windowSize;
+}
+export function useElementSize(ref) {
+  var _useState3 = useState(function () {
+      if (ref.current) {
+        return getElementSize(ref.current);
+      } else {
+        return null;
+      }
+    }),
+    _useState4 = _slicedToArray(_useState3, 2),
+    elementSize = _useState4[0],
+    setElementSize = _useState4[1];
+  var elementSizeRef = useConstRef(elementSize);
+  useEffect(function () {
+    var observer = new ResizeObserver(function (entries) {
+      var nextElementSize = getElementSize(entries[0].target);
+      if (elementSizeRef.current === null || !isSameElementSize(elementSizeRef.current, nextElementSize)) {
+        setElementSize(nextElementSize);
+      }
+    });
+    if (ref.current) observer.observe(ref.current);
+    return function () {
+      return observer.disconnect();
+    };
+  }, [ref]);
+  return elementSize;
+}
+export function useWindowScroll() {
+  var _useState5 = useState(getWindowScroll()),
+    _useState6 = _slicedToArray(_useState5, 2),
+    scrollPosition = _useState6[0],
+    setScrollPosition = _useState6[1];
+  var ref = useConstRef(scrollPosition);
+  useEffect(function () {
+    function update() {
+      var nextScrollPosition = getWindowScroll();
+      if (!isSameElementScroll(ref.current, nextScrollPosition)) {
+        setScrollPosition(nextScrollPosition);
+      }
+    }
+    window.addEventListener('scroll', update);
+    window.addEventListener('resize', update);
+    return function () {
+      window.removeEventListener('scroll', update);
+      window.removeEventListener('resize', update);
+    };
+  }, [ref]);
+  return scrollPosition;
+}
+export function useElementWindowOffset(ref) {
+  var _useState7 = useState(function () {
+      if (ref.current) {
+        return getElementOffset(ref.current);
+      } else {
+        return null;
+      }
+    }),
+    _useState8 = _slicedToArray(_useState7, 2),
+    elementOffset = _useState8[0],
+    setElementOffset = _useState8[1];
+  useEffect(function () {
+    var observer = new ResizeObserver(function (entries) {
+      setElementOffset(getElementOffset(entries[0].target));
+    });
+    if (ref.current) observer.observe(ref.current);
+    return function () {
+      return observer.disconnect();
+    };
+  }, [ref]);
+  return elementOffset;
+}
+export function useIntersecting(ref, rootMargin) {
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    intersecting = _useState10[0],
+    setIntersecting = _useState10[1];
+  useEffect(function () {
+    var observer = new IntersectionObserver(function (entries) {
+      setIntersecting(entries[0].isIntersecting);
+    }, {
+      rootMargin: rootMargin
+    });
+    if (ref.current) observer.observe(ref.current);
+    return function () {
+      return observer.disconnect();
+    };
+  }, [ref, rootMargin]);
+  return intersecting;
+}
+export function useGridListContainerData(ref) {
+  var windowSize = useWindowSize();
+  var windowScroll = useScroll(ref);
+  var elementWindowOffset = useElementWindowOffset(ref);
+  var elementSize = useElementSize(ref);
+  return useMemo(function () {
+    return {
+      windowSize: windowSize,
+      windowScroll: {
+        x: (windowScroll === null || windowScroll === void 0 ? void 0 : windowScroll.left) || 0,
+        y: (windowScroll === null || windowScroll === void 0 ? void 0 : windowScroll.top) || 0
+      },
+      elementWindowOffset: elementWindowOffset,
+      elementSize: elementSize
+    };
+  }, [windowSize, windowScroll, elementWindowOffset, elementSize]);
+}
+export function useGridListConfigData(containerData, props) {
+  var items = props.items,
+    getWindowMargin = props.getWindowMargin,
+    getGridGap = props.getGridGap,
+    getColumnCount = props.getColumnCount,
+    getItemData = props.getItemData;
+  var elementWidth = containerData.elementSize ? containerData.elementSize.width : null;
+  var windowMargin = useMemo(function () {
+    if (getWindowMargin) {
+      return getWindowMargin(containerData.windowSize.height);
+    } else {
+      return containerData.windowSize.height;
+    }
+  }, [containerData.windowSize.height, getWindowMargin]);
+  var gridGap = useMemo(function () {
+    if (elementWidth === null) return null;
+    if (getGridGap) {
+      return getGridGap(elementWidth, containerData.windowSize.height);
+    } else {
+      return 0;
+    }
+  }, [elementWidth, containerData.windowSize.height, getGridGap]);
+  var columnCount = useMemo(function () {
+    if (elementWidth === null) return null;
+    if (gridGap === null) return null;
+    return getColumnCount(elementWidth, gridGap);
+  }, [getColumnCount, elementWidth, gridGap]);
+  var columnWidth = getColumnWidth(columnCount, gridGap, elementWidth);
+  var entries = useMemo(function () {
+    if (columnWidth === null) return null;
+    var safeColumnWidth = columnWidth;
+    return items.map(function (item) {
+      return {
+        data: getItemData(item, safeColumnWidth),
+        item: item
+      };
+    });
+  }, [items, columnWidth, getItemData]);
+  return useMemo(function () {
+    if (windowMargin === null || gridGap === null || columnCount === null || entries === null) {
+      return null;
+    }
+    return {
+      windowMargin: windowMargin,
+      gridGap: gridGap,
+      columnCount: columnCount,
+      entries: entries
+    };
+  }, [windowMargin, gridGap, columnCount, entries]);
+}
+export function useGridListLayoutData(configData) {
+  return useMemo(function () {
+    if (configData === null) return null;
+    var currentRowNumber = 1;
+    var prevRowsTotalHeight = 0;
+    var currentRowMaxHeight = 0;
+    var cells = configData.entries.map(function (entry, index) {
+      var key = entry.data.key;
+      var columnNumber = index % configData.columnCount + 1;
+      var rowNumber = Math.floor(index / configData.columnCount) + 1;
+      if (rowNumber !== currentRowNumber) {
+        currentRowNumber = rowNumber;
+        prevRowsTotalHeight += currentRowMaxHeight + configData.gridGap;
+        currentRowMaxHeight = 0;
+      }
+      var offset = prevRowsTotalHeight;
+      var height = Math.round(entry.data.height);
+      var width = Math.round(entry.data.width);
+      currentRowMaxHeight = Math.max(currentRowMaxHeight, height);
+      return {
+        key: key,
+        columnNumber: columnNumber,
+        rowNumber: rowNumber,
+        offset: offset,
+        height: height,
+        width: width,
+        item: entry.item
+      };
+    });
+    var totalHeight = prevRowsTotalHeight + currentRowMaxHeight;
+    return {
+      totalHeight: totalHeight,
+      cells: cells
+    };
+  }, [configData]);
+}
+export function useGridListRenderData(containerData, configData, layoutData) {
+  return useMemo(function () {
+    if (layoutData === null || configData === null) return null;
+    var cellsToRender = [];
+    var firstRenderedRowNumber = null;
+    var firstRenderedRowOffset = null;
+    if (containerData.elementWindowOffset !== null) {
+      var elementWindowOffset = containerData.elementWindowOffset;
+      var _iterator = _createForOfIteratorHelper(layoutData.cells),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var cell = _step.value;
+          var cellTop = elementWindowOffset + cell.offset;
+          var cellBottom = cellTop + cell.height;
+          var windowTop = containerData.windowScroll.y;
+          var windowBottom = windowTop + containerData.windowSize.height;
+          var renderTop = windowTop - configData.windowMargin;
+          var renderBottom = windowBottom + configData.windowMargin;
+          if (cellTop > renderBottom) continue;
+          if (cellBottom < renderTop) continue;
+          if (firstRenderedRowNumber === null) {
+            firstRenderedRowNumber = cell.rowNumber;
+          }
+          if (cell.rowNumber === firstRenderedRowNumber) {
+            firstRenderedRowOffset = firstRenderedRowOffset ? Math.min(firstRenderedRowOffset, cell.offset) : cell.offset;
+          }
+          cellsToRender.push(cell);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+    return {
+      cellsToRender: cellsToRender,
+      firstRenderedRowNumber: firstRenderedRowNumber,
+      firstRenderedRowOffset: firstRenderedRowOffset
+    };
+  }, [layoutData, configData, containerData.windowScroll.y, containerData.windowSize.height, containerData.elementWindowOffset]);
+}

package/es/GridList/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { GridListCell, GridListItemData } from './interface';
+import './index.less';
+export interface GridListProps<P> {
+    items: P[];
+    getGridGap?: (elementWidth: number, windowHeight: number) => number;
+    getWindowMargin?: (windowHeight: number) => number;
+    getColumnCount: (elementWidth: number, gridGap: number) => number;
+    getItemData: (item: P, columnWidth: number) => GridListItemData;
+    renderItem: (item: P, cell: GridListCell<P>) => React.ReactNode;
+    fixedColumnWidth?: number;
+    className?: string;
+}
+declare const GridList: React.ForwardRefExoticComponent<GridListProps<unknown> & React.RefAttributes<HTMLDivElement>>;
+export default GridList;

package/es/GridList/index.js

@@ -0,0 +1,44 @@
+import React, { useRef } from 'react';
+import { useGridListConfigData, useGridListContainerData, useGridListLayoutData, useGridListRenderData, useIntersecting } from "./hook";
+import { getGridRowStart } from "./utils";
+import "./index.less";
+var GridList = /*#__PURE__*/React.forwardRef(function GridList(props, ref) {
+  var containerRef = useRef(null);
+  var domRef = ref !== null && ref !== void 0 ? ref : containerRef;
+  var containerData = useGridListContainerData(domRef);
+  var configData = useGridListConfigData(containerData, props);
+  var layoutData = useGridListLayoutData(configData);
+  var renderData = useGridListRenderData(containerData, configData, layoutData);
+  var intersecting = useIntersecting(domRef, "".concat(configData !== null ? configData.windowMargin : 0, "px"));
+  var colWidth = props.fixedColumnWidth ? "".concat(props.fixedColumnWidth, "px") : '1fr';
+  return /*#__PURE__*/React.createElement("div", {
+    ref: domRef,
+    className: "cloudapp-grid-list ".concat(props.className || '')
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      boxSizing: 'border-box',
+      height: layoutData !== null ? layoutData.totalHeight : undefined,
+      paddingTop: renderData !== null && renderData.firstRenderedRowOffset !== null ? renderData.firstRenderedRowOffset : 0
+    }
+  }, intersecting && /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'grid',
+      gridTemplateColumns: configData !== null ? "repeat(".concat(configData.columnCount, ", ").concat(colWidth, ")") : undefined,
+      gridGap: configData ? configData.gridGap : undefined,
+      justifyContent: 'center',
+      alignItems: 'center'
+    }
+  }, renderData !== null && renderData.cellsToRender.map(function (cell) {
+    return /*#__PURE__*/React.createElement("div", {
+      key: cell.key,
+      style: {
+        height: cell.height,
+        // maxWidth: cell.width,
+        width: '100%',
+        gridColumnStart: "".concat(cell.columnNumber),
+        gridRowStart: getGridRowStart(cell, renderData)
+      }
+    }, props.renderItem(cell.item, cell));
+  }))));
+});
+export default GridList;

package/es/GridList/index.less

@@ -0,0 +1,8 @@
+.cloudapp-grid-list {
+  width: 100%;
+  height: 100%;
+  padding: 20px;
+  overflow: auto;
+  contain: strict;
+  box-sizing: border-box;
+}

package/es/GridList/interface.d.ts

@@ -0,0 +1,59 @@
+import { MutableRefObject } from 'react';
+
+export type ConstRef<T> = Readonly<MutableRefObject<T>>;
+
+export interface ElementSize {
+  width: number;
+  height: number;
+}
+
+export interface ElementScroll {
+  x: number;
+  y: number;
+}
+
+export interface GridListItemData {
+  key: string;
+  height: number;
+  width: number;
+}
+
+export interface GridListEntry<P> {
+  item: P;
+  data: GridListItemData;
+}
+
+export interface GridListConfigData<P> {
+  windowMargin: number;
+  gridGap: number;
+  columnCount: number;
+  entries: GridListEntry<P>[];
+}
+
+export interface GridListContainerData {
+  windowSize: ElementSize;
+  elementSize: ElementSize | null;
+  windowScroll: ElementScroll;
+  elementWindowOffset: number | null;
+}
+
+export interface GridListCell<P> {
+  key: string;
+  columnNumber: number;
+  rowNumber: number;
+  offset: number;
+  height: number;
+  width: number;
+  item: P;
+}
+
+export interface GridListLayoutData<P> {
+  totalHeight: number;
+  cells: GridListCell<P>[];
+}
+
+export interface GridListRenderData<P> {
+  cellsToRender: GridListCell<P>[];
+  firstRenderedRowNumber: number | null;
+  firstRenderedRowOffset: number | null;
+}

package/es/GridList/utils.d.ts

@@ -0,0 +1,9 @@
+import { ElementScroll, ElementSize, GridListCell, GridListRenderData } from './interface';
+export declare function isSameElementSize(a: ElementSize, b: ElementSize): boolean;
+export declare function getWindowSize(): ElementSize;
+export declare function getElementSize(element: Element): ElementSize;
+export declare function isSameElementScroll(a: ElementScroll, b: ElementScroll): boolean;
+export declare function getWindowScroll(): ElementScroll;
+export declare function getElementOffset(element: Element): number;
+export declare function getColumnWidth(columnCount: number | null, gridGap: number | null, elementWidth: number | null): number;
+export declare function getGridRowStart<P>(cell: GridListCell<P>, renderData: GridListRenderData<P> | null): string;

package/es/GridList/utils.js

@@ -0,0 +1,42 @@
+export function isSameElementSize(a, b) {
+  return a.width === b.width && a.height === b.height;
+}
+export function getWindowSize() {
+  return {
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+}
+export function getElementSize(element) {
+  var rect = element.getBoundingClientRect();
+  return {
+    width: rect.width,
+    height: rect.height
+  };
+}
+export function isSameElementScroll(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+export function getWindowScroll() {
+  return {
+    x: window.scrollX,
+    y: window.scrollY
+  };
+}
+export function getElementOffset(element) {
+  return window.scrollY + element.getBoundingClientRect().top;
+}
+export function getColumnWidth(columnCount, gridGap, elementWidth) {
+  if (columnCount === null || gridGap === null || elementWidth === null) {
+    return null;
+  }
+  var totalGapSpace = (columnCount - 1) * gridGap;
+  var columnWidth = Math.round((elementWidth - totalGapSpace) / columnCount);
+  return columnWidth;
+}
+export function getGridRowStart(cell, renderData) {
+  if (renderData === null) return undefined;
+  var offset = renderData.firstRenderedRowNumber !== null ? renderData.firstRenderedRowNumber - 1 : 0;
+  var gridRowStart = cell.rowNumber - offset;
+  return "".concat(gridRowStart);
+}

package/es/HightLevel/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import './index.less';
+interface HightLevelProps {
+    keyword: string;
+    name: string;
+}
+declare function HighLevel({ keyword, name }: HightLevelProps): React.JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof HighLevel>;
+export default _default;

package/es/HightLevel/index.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { replace, escapeRegExp } from 'lodash-es';
+import "./index.less";
+function HighLevel(_ref) {
+  var keyword = _ref.keyword,
+    name = _ref.name;
+  if (!keyword) {
+    return /*#__PURE__*/React.createElement("span", null, name);
+  }
+  var reg = new RegExp(escapeRegExp(keyword), 'g');
+  var html = replace(name, reg, "<span class=\"high-level\">".concat(keyword, "</span>"));
+  return /*#__PURE__*/React.createElement("span", {
+    dangerouslySetInnerHTML: {
+      __html: html
+    }
+  });
+}
+export default /*#__PURE__*/React.memo(HighLevel);

package/es/HightLevel/index.less

@@ -0,0 +1,3 @@
+.high-level {
+  color: var(--primary-dark);
+}

package/es/IconFont/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface IIconFontProps extends React.HTMLAttributes<HTMLSpanElement> {
+    type?: string;
+    className?: string;
+    title?: string;
+    style?: React.CSSProperties;
+}
+declare function IconFont({ type, className, title, style, ...props }: IIconFontProps): React.JSX.Element;
+declare namespace IconFont {
+    var registerIconFont: (scriptUrl: string) => void;
+}
+export default IconFont;

package/es/IconFont/index.js

@@ -0,0 +1,54 @@
+var _excluded = ["type", "className", "title", "style"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+var global = window;
+if (!global._ICON_SCRIPT_URL) {
+  global._ICON_SCRIPT_URL = {};
+}
+function loadScript(url) {
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement('script');
+    script.src = url;
+    document.body.appendChild(script);
+    script.addEventListener('load', function () {
+      resolve(null);
+    });
+    script.addEventListener('error', function (err) {
+      reject(err);
+    });
+  });
+}
+function registerIconFont(scriptUrl) {
+  if (!global._ICON_SCRIPT_URL[scriptUrl]) {
+    global._ICON_SCRIPT_URL[scriptUrl] = true;
+    loadScript(scriptUrl).catch(function (e) {
+      global._ICON_SCRIPT_URL[scriptUrl] = false;
+      console.error(e);
+    });
+  }
+}
+function IconFont(_ref) {
+  var type = _ref.type,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    title = _ref.title,
+    style = _ref.style,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("i", _extends({
+    className: "anticon ".concat(className),
+    title: title,
+    style: style
+  }, props), /*#__PURE__*/React.createElement("svg", {
+    width: "1em",
+    height: "1em",
+    fill: "currentColor",
+    "aria-hidden": "true",
+    focusable: "false"
+  }, /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#".concat(type)
+  })));
+}
+IconFont.registerIconFont = registerIconFont;
+export default IconFont;

package/es/ImageView/index.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import './index.less';
+interface ImageViewProps {
+    /**
+     * 默认占位图
+     */
+    defaultSrc?: string;
+    /**
+     * 图片真实地址
+     */
+    src?: string;
+    /**
+     * title
+     */
+    alt?: string;
+    onError?: (e: any) => void;
+    className?: string;
+}
+declare function ImageView({ src, defaultSrc, alt, onError, className, ...props }: ImageViewProps): React.JSX.Element;
+export default ImageView;

package/es/ImageView/index.js

@@ -0,0 +1,51 @@
+var _excluded = ["src", "defaultSrc", "alt", "onError", "className"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import "./index.less";
+var defaultUrl = 'data:image/png;base64,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';
+function ImageView(_ref) {
+  var src = _ref.src,
+    _ref$defaultSrc = _ref.defaultSrc,
+    defaultSrc = _ref$defaultSrc === void 0 ? defaultUrl : _ref$defaultSrc,
+    alt = _ref.alt,
+    onError = _ref.onError,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useState = useState(!src),
+    _useState2 = _slicedToArray(_useState, 2),
+    isError = _useState2[0],
+    setErrorStatus = _useState2[1];
+  var imgKey = useRef(Math.random());
+  var isErr = useMemo(function () {
+    return isError || !src;
+  }, [isError, src]);
+  var imgSrc = useMemo(function () {
+    return isErr ? defaultSrc : src;
+  }, [defaultSrc, isErr, src]);
+  useEffect(function () {
+    imgKey.current = Math.random();
+    setErrorStatus(null);
+  }, [src]);
+  function onImageError(e) {
+    setErrorStatus(true);
+    onError === null || onError === void 0 || onError(e);
+  }
+  return /*#__PURE__*/React.createElement("img", _extends({}, props, {
+    className: "lm-t-c-image-card ".concat(isErr ? 'lm-t-c-image-card-placeholder' : '', " ").concat(className),
+    key: imgKey.current,
+    "data-src": src,
+    src: imgSrc,
+    alt: alt,
+    onError: onImageError
+  }));
+}
+export default ImageView;

package/es/ImageView/index.less

@@ -0,0 +1,11 @@
+.lm-t-c-image-card {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+
+  &.lm-t-c-image-card-placeholder {
+    padding: 20%;
+    background-color: var(--gray4);
+    object-fit: contain;
+  }
+}

package/es/InstanceHistory/index.d.ts

@@ -0,0 +1,3 @@
+import { VHistory } from '../useHistory/interface';
+declare const InstanceHistory: VHistory;
+export default InstanceHistory;