@cloud-app-dev/vidc 1.0.50 → 2.0.0-alpha.10

package/es/ScrollList/index.js

@@ -0,0 +1,262 @@
+import "antd/lib/tooltip/style";
+import _Tooltip from "antd/lib/tooltip";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+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; }
+
+import React, { useState, useEffect, useMemo, useRef, useImperativeHandle, forwardRef } from 'react';
+import AutoSizer from 'react-virtualized/dist/es/AutoSizer';
+import InfiniteLoader from 'react-virtualized/dist/es/InfiniteLoader';
+import List from 'react-virtualized/dist/es/List';
+import IconFont from '../IconFont';
+import debounce from 'lodash-es/debounce';
+import cloneDeep from 'lodash-es/cloneDeep';
+import { computedCuurentGrid, arraySliceForX, simpleGrid } from './utils';
+import "./index.css";
+var ScrollList = /*#__PURE__*/forwardRef(function InfiniteScrollLayout(props, ref) {
+  var data = props.data,
+      itemGrid = props.itemGrid,
+      itemHeight = props.itemHeight,
+      threshold = props.threshold,
+      isNoData = props.isNoData,
+      _props$className = props.className,
+      className = _props$className === void 0 ? '' : _props$className,
+      hasLoadPrev = props.hasLoadPrev,
+      loadPrev = props.loadPrev,
+      prethreshold = props.prethreshold,
+      noDataUrl = props.noDataUrl;
+  var infiniteRef = useRef(null);
+  var loadingRef = useRef(false);
+  var scrollRef = useRef(false);
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      showBackTop = _useState2[0],
+      setShowBackUp = _useState2[1];
+
+  var _useState3 = useState(computedCuurentGrid()),
+      _useState4 = _slicedToArray(_useState3, 2),
+      currentGrid = _useState4[0],
+      setContentGrid = _useState4[1];
+
+  var debounced = null;
+  useEffect(function () {
+    var bindResizeEvent = function bindResizeEvent() {
+      setContentGrid(computedCuurentGrid());
+    };
+
+    window.addEventListener('resize', bindResizeEvent, false);
+    return function () {
+      debounced && debounced.cancel();
+      window.removeEventListener('resize', bindResizeEvent, false);
+    }; // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var rowCount = useMemo(function () {
+    return Math.floor(24 / itemGrid[currentGrid]);
+  }, [itemGrid, currentGrid]);
+  var renderData = useMemo(function () {
+    return arraySliceForX(data, rowCount);
+  }, [data, rowCount]);
+
+  function forceUpdateGrid() {
+    infiniteRef.current && infiniteRef.current._registeredChild.forceUpdateGrid();
+  }
+
+  function scrollToPosition() {
+    var _infiniteRef$current$;
+
+    infiniteRef.current && (_infiniteRef$current$ = infiniteRef.current._registeredChild).scrollToPosition.apply(_infiniteRef$current$, arguments);
+  }
+
+  function scrollToRow() {
+    var _infiniteRef$current$2;
+
+    infiniteRef.current && (_infiniteRef$current$2 = infiniteRef.current._registeredChild).scrollToRow.apply(_infiniteRef$current$2, arguments);
+  }
+
+  useImperativeHandle(ref, function () {
+    return {
+      forceUpdateGrid: forceUpdateGrid,
+      scrollToRow: scrollToRow,
+      scrollToPosition: scrollToPosition
+    };
+  });
+
+  var loadMore = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!(props.hasLoadMore && props.loadMore && !loadingRef.current)) {
+                _context.next = 5;
+                break;
+              }
+
+              loadingRef.current = true;
+              _context.next = 4;
+              return props.loadMore();
+
+            case 4:
+              loadingRef.current = false;
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function loadMore() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  function onListScroll(options) {
+    if (hasLoadPrev && !loadingRef.current && loadPrev && options.scrollTop === 0 && scrollRef.current) {
+      loadingRef.current = true;
+      loadPrev().then(function (dataLength) {
+        if (dataLength) {
+          var row = Math.ceil(dataLength / rowCount);
+
+          if (row > 0) {
+            scrollToPosition(row * itemHeight);
+          }
+        }
+
+        loadingRef.current = false;
+      });
+    }
+
+    if (!scrollRef.current && options.scrollTop >= prethreshold) {
+      scrollRef.current = true;
+    }
+
+    debounced && debounced.cancel();
+    debounced = debounce(function () {
+      var flag = options.scrollTop > 200;
+
+      if (showBackTop !== flag) {
+        setShowBackUp(flag);
+      }
+
+      props.onScroll && props.onScroll(options);
+    }, 500);
+    debounced();
+  }
+
+  function rowRender(_ref2) {
+    var key = _ref2.key,
+        index = _ref2.index,
+        style = _ref2.style;
+    var gutter = props.gutter,
+        paddingRow = props.paddingRow,
+        rowClass = props.rowClass,
+        hasLoadMore = props.hasLoadMore,
+        itemClass = props.itemClass;
+    var rowData = renderData[index] || [];
+    var len = rowCount - rowData.length;
+
+    if (rowData.length < rowCount) {
+      for (var i = 0; i < len; i++) {
+        rowData.push(null);
+      }
+    }
+
+    return /*#__PURE__*/React.createElement("div", {
+      key: key,
+      style: _objectSpread(_objectSpread({}, style), {}, {
+        padding: "0 ".concat(paddingRow)
+      }),
+      className: "row-group-part  ".concat(rowClass)
+    }, rowData.map(function (v, i) {
+      return /*#__PURE__*/React.createElement("div", {
+        key: "".concat(key, "-").concat(i),
+        className: "row-item-part ".concat(v === null && hasLoadMore ? 'row-item-placeholder' : '', " ").concat(v !== null ? itemClass : ''),
+        style: {
+          width: "".concat(100 / 24 * itemGrid[currentGrid], "%"),
+          height: itemHeight,
+          marginRight: gutter,
+          paddingBottom: gutter
+        }
+      }, v && props.renderItem(v, i));
+    }));
+  }
+
+  function _isRowLoaded(_ref3) {
+    var index = _ref3.index;
+    return !!renderData[index];
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "lm-c-infinite-scroll-layout ".concat(isNoData ? 'infinite-scroll-empty' : '', " ").concat(className),
+    style: isNoData ? {
+      backgroundImage: "url(".concat(noDataUrl, ")")
+    } : undefined
+  }, /*#__PURE__*/React.createElement(InfiniteLoader, {
+    isRowLoaded: _isRowLoaded,
+    loadMoreRows: loadMore,
+    rowCount: renderData.length + 1,
+    ref: infiniteRef,
+    threshold: threshold
+  }, function (_ref4) {
+    var onRowsRendered = _ref4.onRowsRendered,
+        registerChild = _ref4.registerChild;
+    return /*#__PURE__*/React.createElement(AutoSizer, null, function (_ref5) {
+      var width = _ref5.width,
+          height = _ref5.height;
+      return /*#__PURE__*/React.createElement(List, {
+        width: width,
+        onRowsRendered: onRowsRendered,
+        ref: registerChild,
+        height: height,
+        rowCount: renderData.length,
+        rowHeight: itemHeight,
+        rowRenderer: rowRender,
+        onScroll: onListScroll
+      });
+    });
+  }), props.hasBackTop && showBackTop && /*#__PURE__*/React.createElement(_Tooltip, {
+    title: "\u8FD4\u56DE\u9876\u90E8",
+    placement: "top"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "scoll-back-top",
+    onClick: function onClick() {
+      return scrollToPosition(0);
+    }
+  }, /*#__PURE__*/React.createElement(IconFont, {
+    type: "icon-S_Arrow_MoveUp"
+  }))));
+});
+ScrollList.defaultProps = {
+  itemHeight: 200,
+  gutter: 20,
+  itemGrid: cloneDeep(simpleGrid),
+  hasLoadMore: true,
+  hasLoadPrev: true,
+  threshold: 5,
+  prethreshold: 200,
+  hasBackTop: false,
+  data: []
+};
+export default ScrollList;

package/es/ScrollList/utils.js

@@ -0,0 +1,84 @@
+export function computedCuurentGrid() {
+  var width = document.body.clientWidth;
+
+  if (width >= 1600) {
+    return 'xxl';
+  }
+
+  if (width >= 1200 && width < 1600) {
+    return 'xl';
+  }
+
+  if (width >= 992 && width < 1200) {
+    return 'lg';
+  }
+
+  if (width >= 768 && width < 992) {
+    return 'md';
+  }
+
+  if (width >= 576 && width < 768) {
+    return 'sm';
+  }
+
+  if (width < 576) {
+    return 'xs';
+  }
+} // 切割数组 1维变2维
+
+export function arraySliceForX(arr) {
+  var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+  var newArr = [];
+
+  for (var i = 0, l = arr.length; i < l; i++) {
+    if (newArr.length === 0) {
+      newArr.push([]);
+    }
+
+    if (newArr[newArr.length - 1].length > x - 1) {
+      newArr.push([]);
+    }
+
+    newArr[newArr.length - 1].push(arr[i]);
+  }
+
+  return newArr;
+} // 切割数组 1维变2维，分组聚合展示
+
+export function arraySliceForXG(arr) {
+  var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+  var isGroupTitle = arguments.length > 2 ? arguments[2] : undefined;
+  var newArr = [];
+
+  for (var i = 0, l = arr.length; i < l; i++) {
+    if (newArr.length === 0) {
+      newArr.push([]);
+    }
+
+    if (isGroupTitle(arr[i])) {
+      if (newArr[newArr.length - 1].length === 0) {
+        newArr[newArr.length - 1].push(arr[i]);
+      } else {
+        newArr.push([arr[i]]);
+      }
+
+      newArr.push([]);
+    } else {
+      if (newArr[newArr.length - 1].length > x - 1) {
+        newArr.push([]);
+      }
+
+      newArr[newArr.length - 1].push(arr[i]);
+    }
+  }
+
+  return newArr;
+}
+export var simpleGrid = {
+  xxl: 4,
+  xl: 6,
+  lg: 6,
+  md: 7,
+  sm: 24,
+  xs: 24
+};

package/es/Service/http.d.ts

@@ -0,0 +1,4 @@
+import { RsponseType, XHRResponse } from './interface';
+export declare function $http(options: RsponseType): import("fetch-like-axios").AxiosPromise<any>;
+export declare const $httpMultiPartInstance: import("fetch-like-axios").AxiosInstance;
+export declare const $httpXMLInstance: ({ url, method, data, headers, cancelHttp, isAsync, requestId }: XHRResponse) => Promise<unknown>;

package/es/Service/http.js

@@ -0,0 +1,135 @@
+import { __rest } from "tslib";
+import fetchAxios from 'fetch-like-axios';
+import * as Middleware from './middleware';
+var CancelToken = fetchAxios.CancelToken;
+var config = {
+  baseURL: '/',
+  timeout: 60 * 1000,
+  xhrMode: 'fetch',
+  headers: {
+    Accept: 'application/json; charset=utf-8',
+    'Content-Type': 'application/json; charset=utf-8'
+  }
+};
+var httpInstance = fetchAxios.create(config);
+/**
+ * 请求之前拦截动作
+ */
+
+httpInstance.interceptors.request.use(function (response) {
+  return response;
+}, function (error) {
+  return console.error(error);
+});
+/**
+ * 请求之后拦截动作
+ */
+
+httpInstance.interceptors.response.use(function (response) {
+  if (Middleware.responseMiddleware.length === 0) {
+    return response.data;
+  } else {
+    Middleware.responseMiddleware.forEach(function (fn) {
+      return response = fn(response);
+    });
+    return response;
+  }
+}, function httpUtilErrorRequest(error) {
+  if (Middleware.responseErrorMiddleware.length !== 0) {
+    Middleware.responseErrorMiddleware.forEach(function (fn) {
+      return error = fn(error);
+    });
+    return Promise.reject(error);
+  }
+
+  if (!error.response) {
+    console.error(error);
+    return Promise.reject(error);
+  }
+
+  return Promise.reject(error.response);
+});
+export function $http(options) {
+  var cancel;
+  var cancelToken = new CancelToken(function (c) {
+    cancel = c;
+
+    if (options.cancelHttp) {
+      options.cancelHttp(cancel);
+    }
+  });
+
+  var cancelHttp = options.cancelHttp,
+      newOptions = __rest(options, ["cancelHttp"]);
+
+  return httpInstance(Object.assign(Object.assign({}, newOptions), {
+    cancelToken: cancelToken
+  }));
+}
+export var $httpMultiPartInstance = fetchAxios.create({
+  xhrMode: 'fetch',
+  timeout: 10 * 60 * 1000,
+  headers: {
+    'Content-Type': 'multipart/form-data'
+  }
+});
+$httpMultiPartInstance.interceptors.response.use(function (response) {
+  return response.data;
+}, function (error) {
+  return Promise.reject(error);
+});
+export var $httpXMLInstance = function xhrRequest(_ref) {
+  var url = _ref.url,
+      _ref$method = _ref.method,
+      method = _ref$method === void 0 ? 'GET' : _ref$method,
+      data = _ref.data,
+      headers = _ref.headers,
+      cancelHttp = _ref.cancelHttp,
+      _ref$isAsync = _ref.isAsync,
+      isAsync = _ref$isAsync === void 0 ? false : _ref$isAsync,
+      requestId = _ref.requestId;
+
+  if (!requestId) {
+    console.warn('缺少requestId');
+  }
+
+  return new Promise(function (resolve, reject) {
+    var xhr = new XMLHttpRequest();
+
+    var cancel = function cancel() {
+      return xhr.abort();
+    };
+
+    if (cancelHttp) {
+      cancelHttp(cancel);
+    }
+
+    xhr.open(method, url, !isAsync);
+
+    if (headers) {
+      Object.keys(headers).forEach(function (key) {
+        xhr.setRequestHeader(key, headers[key]);
+      });
+    }
+
+    xhr.onreadystatechange = function () {
+      if (xhr.readyState === 4 && (xhr.status === 200 || xhr.status === 304)) {
+        var _data;
+
+        try {
+          _data = JSON.parse(xhr.response);
+        } catch (e) {
+          _data = xhr.response;
+        }
+
+        resolve(_data);
+      }
+
+      if (xhr.readyState === 4 && !(xhr.status === 200 || xhr.status === 304)) {
+        reject(xhr);
+      }
+    };
+
+    xhr.send(data ? JSON.stringify(data) : null);
+  });
+};

package/es/Service/index.d.ts

@@ -0,0 +1,3 @@
+import { IServiceInterface } from './interface';
+declare let proxy: IServiceInterface;
+export default proxy;

package/es/Service/index.js

@@ -0,0 +1,14 @@
+import { $http, $httpMultiPartInstance, $httpXMLInstance } from './http';
+import { registerResponseMiddleware, registerResponseErrorMiddleware } from './middleware';
+import produce from 'immer';
+import * as logger from './logger';
+var ServiceInterface = {
+  $http: $http,
+  $httpXMLInstance: $httpXMLInstance,
+  $httpMultiPartInstance: $httpMultiPartInstance,
+  registerResponseMiddleware: registerResponseMiddleware,
+  registerResponseErrorMiddleware: registerResponseErrorMiddleware,
+  logger: logger
+};
+var proxy = produce(ServiceInterface, function () {});
+export default proxy;

package/es/Service/interface.d.ts

@@ -0,0 +1,28 @@
+import { AxiosRequestConfig } from 'fetch-like-axios';
+
+export type loggerType = {
+  save(options: { description: string; module: string | number; function: string | number }, token?: string): Promise<any>;
+};
+
+export type RsponseType = AxiosRequestConfig & { requestId?: string; cancelHttp?: (cancel: Function) => void; loggerIndex?: number };
+
+export type XHRResponse = {
+  url: string;
+  method: string;
+  data?: any;
+  headers?: any;
+  cancelHttp?: any;
+  isAsync?: boolean;
+  requestId?: string;
+};
+
+export type MiddleWareType = (config: any) => any;
+
+export type IServiceInterface = {
+  $http(options: RsponseType): Promise<any>;
+  $httpXMLInstance(options: XHRResponse): Promise<any>;
+  $httpMultiPartInstance(options: AxiosRequestConfig): Promise<any>;
+  registerResponseMiddleware(fn: MiddleWareType): void;
+  registerResponseErrorMiddleware(fn: MiddleWareType): void;
+  logger: loggerType;
+};

package/es/Service/logger.d.ts

@@ -0,0 +1,3 @@
+export declare function save(data: {
+    [key: string]: any;
+}, token?: string): import("fetch-like-axios").AxiosPromise<any>;

package/es/Service/logger.js

@@ -0,0 +1,13 @@
+import _cache from "@cloud-app-dev/utils/es/cache";
+import { $http } from './http';
+export function save(data, token) {
+  return $http({
+    method: 'post',
+    url: "/api/log/v1/addLog",
+    data: data,
+    requestId: 'addLog',
+    headers: {
+      Authorization: token || _cache.getCache('token', 'session')
+    }
+  });
+}

package/es/Service/middleware.d.ts

@@ -0,0 +1,5 @@
+import { MiddleWareType } from './interface';
+export declare const responseMiddleware: Array<any>;
+export declare const responseErrorMiddleware: Array<any>;
+export declare function registerResponseMiddleware(fn: MiddleWareType): void;
+export declare function registerResponseErrorMiddleware(fn: MiddleWareType): void;

package/es/Service/middleware.js

@@ -0,0 +1,15 @@
+var _global = window;
+export var responseMiddleware = _global.responseMiddleware || [];
+export var responseErrorMiddleware = _global.responseMiddleware || [];
+export function registerResponseMiddleware(fn) {
+  if (!responseMiddleware.includes(fn)) {
+    responseMiddleware.push(fn);
+    _global.responseMiddleware = responseMiddleware;
+  }
+}
+export function registerResponseErrorMiddleware(fn) {
+  if (!responseErrorMiddleware.includes(fn)) {
+    responseErrorMiddleware.push(fn);
+    _global.responseErrorMiddleware = responseErrorMiddleware;
+  }
+}

package/es/Service/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function formartDesc(desc: string, data: {
+    [key: string]: any;
+}): string;

package/es/Service/utils.js

@@ -0,0 +1,11 @@
+export function formartDesc(desc, data) {
+  try {
+    Object.keys(data).forEach(function (key) {
+      desc = desc.replace("<".concat(key, ">"), data[key]);
+    });
+  } catch (e) {
+    console.warn('日志描述转换异常！', e);
+  }
+
+  return desc;
+}

package/es/TableLayout/index.css

@@ -0,0 +1,4 @@
+.table-layout {
+  padding-top: 20px;
+  height: calc(100% - 32px);
+}

package/es/TableLayout/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import './index.less';
+interface ITableLayoutProps {
+    className?: string;
+    children: React.ReactElement;
+    cutNum?: number;
+    x?: string | number;
+}
+declare function TableLayout({ className, children, cutNum, x }: ITableLayoutProps): JSX.Element;
+export default TableLayout;

package/es/TableLayout/index.js

@@ -0,0 +1,64 @@
+import _resizeObserver from "@cloud-app-dev/utils/es/resizeObserver";
+
+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; }
+
+import React, { useEffect, useRef, useState } from 'react';
+import "./index.css";
+
+function TableLayout(_ref) {
+  var _ref$className = _ref.className,
+      className = _ref$className === void 0 ? '' : _ref$className,
+      children = _ref.children,
+      _ref$cutNum = _ref.cutNum,
+      cutNum = _ref$cutNum === void 0 ? 0 : _ref$cutNum,
+      _ref$x = _ref.x,
+      x = _ref$x === void 0 ? 1200 : _ref$x;
+
+  var _useState = useState(500),
+      _useState2 = _slicedToArray(_useState, 2),
+      height = _useState2[0],
+      setHeight = _useState2[1];
+
+  var domRef = useRef(null);
+  useEffect(function () {
+    var set = function set() {
+      var _a;
+
+      var rect = (_a = domRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+
+      if (rect) {
+        setHeight(rect.height - cutNum);
+      }
+    };
+
+    set();
+    var dom = domRef.current;
+
+    _resizeObserver.createResizeObserver(dom, set);
+
+    return function () {
+      _resizeObserver.unResizeObserver(dom, set);
+    };
+  }, [cutNum]);
+  return /*#__PURE__*/React.createElement("div", {
+    ref: domRef,
+    className: "table-layout ".concat(className)
+  }, /*#__PURE__*/React.cloneElement(children, {
+    scroll: {
+      x: x,
+      y: height
+    }
+  }));
+}
+
+export default TableLayout;