@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/space/style/compact.d.ts

@@ -0,0 +1,8 @@
+import type { FullToken, GenerateStyle } from '../../theme/internal';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+}
+interface SpaceToken extends FullToken<'Space'> {
+}
+declare const genSpaceCompactStyle: GenerateStyle<SpaceToken>;
+export default genSpaceCompactStyle;

package/dist/locale/antd/space/style/compact.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const genSpaceCompactStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [componentCls]: {
+      display: 'inline-flex',
+      '&-block': {
+        display: 'flex',
+        width: '100%'
+      },
+      '&-vertical': {
+        flexDirection: 'column'
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = genSpaceCompactStyle;
+exports.default = _default;

package/dist/locale/antd/space/style/index.d.ts

@@ -0,0 +1,5 @@
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+}
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;

package/dist/locale/antd/space/style/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _internal = require("../../theme/internal");
+var _compact = _interopRequireDefault(require("./compact"));
+const genSpaceStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [componentCls]: {
+      display: 'inline-flex',
+      '&-rtl': {
+        direction: 'rtl'
+      },
+      '&-vertical': {
+        flexDirection: 'column'
+      },
+      '&-align': {
+        flexDirection: 'column',
+        '&-center': {
+          alignItems: 'center'
+        },
+        '&-start': {
+          alignItems: 'flex-start'
+        },
+        '&-end': {
+          alignItems: 'flex-end'
+        },
+        '&-baseline': {
+          alignItems: 'baseline'
+        }
+      },
+      [`${componentCls}-item:empty`]: {
+        display: 'none'
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Space', token => [genSpaceStyle(token), (0, _compact.default)(token)], () => ({}), {
+  // Space component don't apply extra font style
+  // https://github.com/ant-design/ant-design/issues/40315
+  resetStyle: false
+});
+exports.default = _default;

package/dist/locale/antd/spin/index.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+declare const SpinSizes: readonly ["small", "default", "large"];
+export type SpinSize = typeof SpinSizes[number];
+export type SpinIndicator = React.ReactElement<HTMLElement>;
+export interface SpinProps {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    spinning?: boolean;
+    style?: React.CSSProperties;
+    size?: SpinSize;
+    tip?: React.ReactNode;
+    delay?: number;
+    wrapperClassName?: string;
+    indicator?: SpinIndicator;
+    children?: React.ReactNode;
+}
+export interface SpinClassProps extends SpinProps {
+    hashId: string;
+    spinPrefixCls: string;
+}
+export type SpinFCType = React.FC<SpinProps> & {
+    setDefaultIndicator: (indicator: React.ReactNode) => void;
+};
+declare const SpinFC: SpinFCType;
+export default SpinFC;

package/dist/locale/antd/spin/index.js

@@ -0,0 +1,159 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _omit = _interopRequireDefault(require("rc-util/lib/omit"));
+var React = _interopRequireWildcard(require("react"));
+var _throttleDebounce = require("throttle-debounce");
+var _reactNode = require("../_util/reactNode");
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _index = _interopRequireDefault(require("./style/index"));
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+const SpinSizes = ['small', 'default', 'large'];
+// Render indicator
+let defaultIndicator = null;
+function renderIndicator(prefixCls, props) {
+  const {
+    indicator
+  } = props;
+  const dotClassName = `${prefixCls}-dot`;
+  // should not be render default indicator when indicator value is null
+  if (indicator === null) {
+    return null;
+  }
+  if ((0, _reactNode.isValidElement)(indicator)) {
+    return (0, _reactNode.cloneElement)(indicator, {
+      className: (0, _classnames.default)(indicator.props.className, dotClassName)
+    });
+  }
+  if ((0, _reactNode.isValidElement)(defaultIndicator)) {
+    return (0, _reactNode.cloneElement)(defaultIndicator, {
+      className: (0, _classnames.default)(defaultIndicator.props.className, dotClassName)
+    });
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    className: (0, _classnames.default)(dotClassName, `${prefixCls}-dot-spin`)
+  }, /*#__PURE__*/React.createElement("i", {
+    className: `${prefixCls}-dot-item`,
+    key: 1
+  }), /*#__PURE__*/React.createElement("i", {
+    className: `${prefixCls}-dot-item`,
+    key: 2
+  }), /*#__PURE__*/React.createElement("i", {
+    className: `${prefixCls}-dot-item`,
+    key: 3
+  }), /*#__PURE__*/React.createElement("i", {
+    className: `${prefixCls}-dot-item`,
+    key: 4
+  }));
+}
+function shouldDelay(spinning, delay) {
+  return !!spinning && !!delay && !isNaN(Number(delay));
+}
+const Spin = props => {
+  const {
+      spinPrefixCls: prefixCls,
+      spinning: customSpinning = true,
+      delay = 0,
+      className,
+      rootClassName,
+      size = 'default',
+      tip,
+      wrapperClassName,
+      style,
+      children,
+      hashId
+    } = props,
+    restProps = __rest(props, ["spinPrefixCls", "spinning", "delay", "className", "rootClassName", "size", "tip", "wrapperClassName", "style", "children", "hashId"]);
+  const [spinning, setSpinning] = React.useState(() => customSpinning && !shouldDelay(customSpinning, delay));
+  React.useEffect(() => {
+    if (customSpinning) {
+      const showSpinning = (0, _throttleDebounce.debounce)(delay, () => {
+        setSpinning(true);
+      });
+      showSpinning();
+      return () => {
+        var _a;
+        (_a = showSpinning === null || showSpinning === void 0 ? void 0 : showSpinning.cancel) === null || _a === void 0 ? void 0 : _a.call(showSpinning);
+      };
+    }
+    setSpinning(false);
+  }, [delay, customSpinning]);
+  const isNestedPattern = React.useMemo(() => typeof children !== 'undefined', [children]);
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!tip || isNestedPattern, 'Spin', '`tip` only work in nest pattern.') : void 0;
+  }
+  const {
+    direction,
+    spin
+  } = React.useContext(_configProvider.ConfigContext);
+  const spinClassName = (0, _classnames.default)(prefixCls, spin === null || spin === void 0 ? void 0 : spin.className, {
+    [`${prefixCls}-sm`]: size === 'small',
+    [`${prefixCls}-lg`]: size === 'large',
+    [`${prefixCls}-spinning`]: spinning,
+    [`${prefixCls}-show-text`]: !!tip,
+    [`${prefixCls}-rtl`]: direction === 'rtl'
+  }, className, rootClassName, hashId);
+  const containerClassName = (0, _classnames.default)(`${prefixCls}-container`, {
+    [`${prefixCls}-blur`]: spinning
+  });
+  // fix https://fb.me/react-unknown-prop
+  const divProps = (0, _omit.default)(restProps, ['indicator', 'prefixCls']);
+  const mergedStyle = Object.assign(Object.assign({}, spin === null || spin === void 0 ? void 0 : spin.style), style);
+  const spinElement = /*#__PURE__*/React.createElement("div", Object.assign({}, divProps, {
+    style: mergedStyle,
+    className: spinClassName,
+    "aria-live": "polite",
+    "aria-busy": spinning
+  }), renderIndicator(prefixCls, props), tip && isNestedPattern ? /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-text`
+  }, tip) : null);
+  if (isNestedPattern) {
+    return /*#__PURE__*/React.createElement("div", Object.assign({}, divProps, {
+      className: (0, _classnames.default)(`${prefixCls}-nested-loading`, wrapperClassName, hashId)
+    }), spinning && /*#__PURE__*/React.createElement("div", {
+      key: "loading"
+    }, spinElement), /*#__PURE__*/React.createElement("div", {
+      className: containerClassName,
+      key: "container"
+    }, children));
+  }
+  return spinElement;
+};
+const SpinFC = props => {
+  const {
+    prefixCls: customizePrefixCls
+  } = props;
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const spinPrefixCls = getPrefixCls('spin', customizePrefixCls);
+  const [wrapSSR, hashId] = (0, _index.default)(spinPrefixCls);
+  const spinClassProps = Object.assign(Object.assign({}, props), {
+    spinPrefixCls,
+    hashId
+  });
+  return wrapSSR( /*#__PURE__*/React.createElement(Spin, Object.assign({}, spinClassProps)));
+};
+SpinFC.setDefaultIndicator = indicator => {
+  defaultIndicator = indicator;
+};
+if (process.env.NODE_ENV !== 'production') {
+  SpinFC.displayName = 'Spin';
+}
+var _default = SpinFC;
+exports.default = _default;

package/dist/locale/antd/spin/style/index.d.ts

@@ -0,0 +1,9 @@
+export interface ComponentToken {
+    /**
+     * @desc 内容区域高度
+     * @descEN Height of content area
+     */
+    contentHeight: number;
+}
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;

package/dist/locale/antd/spin/style/index.js

@@ -0,0 +1,207 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+const antSpinMove = new _cssinjs.Keyframes('antSpinMove', {
+  to: {
+    opacity: 1
+  }
+});
+const antRotate = new _cssinjs.Keyframes('antRotate', {
+  to: {
+    transform: 'rotate(405deg)'
+  }
+});
+const genSpinStyle = token => ({
+  [`${token.componentCls}`]: Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+    position: 'absolute',
+    display: 'none',
+    color: token.colorPrimary,
+    fontSize: 0,
+    textAlign: 'center',
+    verticalAlign: 'middle',
+    opacity: 0,
+    transition: `transform ${token.motionDurationSlow} ${token.motionEaseInOutCirc}`,
+    '&-spinning': {
+      position: 'static',
+      display: 'inline-block',
+      opacity: 1
+    },
+    '&-nested-loading': {
+      position: 'relative',
+      [`> div > ${token.componentCls}`]: {
+        position: 'absolute',
+        top: 0,
+        insetInlineStart: 0,
+        zIndex: 4,
+        display: 'block',
+        width: '100%',
+        height: '100%',
+        maxHeight: token.contentHeight,
+        [`${token.componentCls}-dot`]: {
+          position: 'absolute',
+          top: '50%',
+          insetInlineStart: '50%',
+          margin: -token.spinDotSize / 2
+        },
+        [`${token.componentCls}-text`]: {
+          position: 'absolute',
+          top: '50%',
+          width: '100%',
+          paddingTop: (token.spinDotSize - token.fontSize) / 2 + 2,
+          textShadow: `0 1px 2px ${token.colorBgContainer}`,
+          fontSize: token.fontSize
+        },
+        [`&${token.componentCls}-show-text ${token.componentCls}-dot`]: {
+          marginTop: -(token.spinDotSize / 2) - 10
+        },
+        '&-sm': {
+          [`${token.componentCls}-dot`]: {
+            margin: -token.spinDotSizeSM / 2
+          },
+          [`${token.componentCls}-text`]: {
+            paddingTop: (token.spinDotSizeSM - token.fontSize) / 2 + 2
+          },
+          [`&${token.componentCls}-show-text ${token.componentCls}-dot`]: {
+            marginTop: -(token.spinDotSizeSM / 2) - 10
+          }
+        },
+        '&-lg': {
+          [`${token.componentCls}-dot`]: {
+            margin: -(token.spinDotSizeLG / 2)
+          },
+          [`${token.componentCls}-text`]: {
+            paddingTop: (token.spinDotSizeLG - token.fontSize) / 2 + 2
+          },
+          [`&${token.componentCls}-show-text ${token.componentCls}-dot`]: {
+            marginTop: -(token.spinDotSizeLG / 2) - 10
+          }
+        }
+      },
+      [`${token.componentCls}-container`]: {
+        position: 'relative',
+        transition: `opacity ${token.motionDurationSlow}`,
+        '&::after': {
+          position: 'absolute',
+          top: 0,
+          insetInlineEnd: 0,
+          bottom: 0,
+          insetInlineStart: 0,
+          zIndex: 10,
+          width: '100%',
+          height: '100%',
+          background: token.colorBgContainer,
+          opacity: 0,
+          transition: `all ${token.motionDurationSlow}`,
+          content: '""',
+          pointerEvents: 'none'
+        }
+      },
+      [`${token.componentCls}-blur`]: {
+        clear: 'both',
+        opacity: 0.5,
+        userSelect: 'none',
+        pointerEvents: 'none',
+        [`&::after`]: {
+          opacity: 0.4,
+          pointerEvents: 'auto'
+        }
+      }
+    },
+    // tip
+    // ------------------------------
+    [`&-tip`]: {
+      color: token.spinDotDefault
+    },
+    // dots
+    // ------------------------------
+    [`${token.componentCls}-dot`]: {
+      position: 'relative',
+      display: 'inline-block',
+      fontSize: token.spinDotSize,
+      width: '1em',
+      height: '1em',
+      '&-item': {
+        position: 'absolute',
+        display: 'block',
+        width: (token.spinDotSize - token.marginXXS / 2) / 2,
+        height: (token.spinDotSize - token.marginXXS / 2) / 2,
+        backgroundColor: token.colorPrimary,
+        borderRadius: '100%',
+        transform: 'scale(0.75)',
+        transformOrigin: '50% 50%',
+        opacity: 0.3,
+        animationName: antSpinMove,
+        animationDuration: '1s',
+        animationIterationCount: 'infinite',
+        animationTimingFunction: 'linear',
+        animationDirection: 'alternate',
+        '&:nth-child(1)': {
+          top: 0,
+          insetInlineStart: 0
+        },
+        '&:nth-child(2)': {
+          top: 0,
+          insetInlineEnd: 0,
+          animationDelay: '0.4s'
+        },
+        '&:nth-child(3)': {
+          insetInlineEnd: 0,
+          bottom: 0,
+          animationDelay: '0.8s'
+        },
+        '&:nth-child(4)': {
+          bottom: 0,
+          insetInlineStart: 0,
+          animationDelay: '1.2s'
+        }
+      },
+      '&-spin': {
+        transform: 'rotate(45deg)',
+        animationName: antRotate,
+        animationDuration: '1.2s',
+        animationIterationCount: 'infinite',
+        animationTimingFunction: 'linear'
+      }
+    },
+    // Sizes
+    // ------------------------------
+    // small
+    [`&-sm ${token.componentCls}-dot`]: {
+      fontSize: token.spinDotSizeSM,
+      i: {
+        width: (token.spinDotSizeSM - token.marginXXS / 2) / 2,
+        height: (token.spinDotSizeSM - token.marginXXS / 2) / 2
+      }
+    },
+    // large
+    [`&-lg ${token.componentCls}-dot`]: {
+      fontSize: token.spinDotSizeLG,
+      i: {
+        width: (token.spinDotSizeLG - token.marginXXS) / 2,
+        height: (token.spinDotSizeLG - token.marginXXS) / 2
+      }
+    },
+    [`&${token.componentCls}-show-text ${token.componentCls}-text`]: {
+      display: 'block'
+    }
+  })
+});
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Spin', token => {
+  const spinToken = (0, _internal.mergeToken)(token, {
+    spinDotDefault: token.colorTextDescription,
+    spinDotSize: token.controlHeightLG / 2,
+    spinDotSizeSM: token.controlHeightLG * 0.35,
+    spinDotSizeLG: token.controlHeight
+  });
+  return [genSpinStyle(spinToken)];
+}, {
+  contentHeight: 400
+});
+exports.default = _default;

package/dist/locale/antd/statistic/Countdown.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { StatisticProps } from './Statistic';
+import type { valueType } from './utils';
+export interface CountdownProps extends StatisticProps {
+    value?: valueType;
+    format?: string;
+    onFinish?: () => void;
+    onChange?: (value?: valueType) => void;
+}
+declare const _default: React.NamedExoticComponent<CountdownProps>;
+export default _default;

package/dist/locale/antd/statistic/Countdown.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _useForceUpdate = _interopRequireDefault(require("../_util/hooks/useForceUpdate"));
+var _reactNode = require("../_util/reactNode");
+var _Statistic = _interopRequireDefault(require("./Statistic"));
+var _utils = require("./utils");
+const REFRESH_INTERVAL = 1000 / 30;
+function getTime(value) {
+  return new Date(value).getTime();
+}
+const Countdown = props => {
+  const {
+    value,
+    format = 'HH:mm:ss',
+    onChange,
+    onFinish
+  } = props;
+  const forceUpdate = (0, _useForceUpdate.default)();
+  const countdown = React.useRef(null);
+  const stopTimer = () => {
+    onFinish === null || onFinish === void 0 ? void 0 : onFinish();
+    if (countdown.current) {
+      clearInterval(countdown.current);
+      countdown.current = null;
+    }
+  };
+  const syncTimer = () => {
+    const timestamp = getTime(value);
+    if (timestamp >= Date.now()) {
+      countdown.current = setInterval(() => {
+        forceUpdate();
+        onChange === null || onChange === void 0 ? void 0 : onChange(timestamp - Date.now());
+        if (timestamp < Date.now()) {
+          stopTimer();
+        }
+      }, REFRESH_INTERVAL);
+    }
+  };
+  React.useEffect(() => {
+    syncTimer();
+    return () => {
+      if (countdown.current) {
+        clearInterval(countdown.current);
+        countdown.current = null;
+      }
+    };
+  }, [value]);
+  const formatter = (formatValue, config) => (0, _utils.formatCountdown)(formatValue, Object.assign(Object.assign({}, config), {
+    format
+  }));
+  const valueRender = node => (0, _reactNode.cloneElement)(node, {
+    title: undefined
+  });
+  return /*#__PURE__*/React.createElement(_Statistic.default, Object.assign({}, props, {
+    valueRender: valueRender,
+    formatter: formatter
+  }));
+};
+var _default = /*#__PURE__*/React.memo(Countdown);
+exports.default = _default;

package/dist/locale/antd/statistic/Number.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { FormatConfig, valueType } from './utils';
+interface NumberProps extends FormatConfig {
+    value: valueType;
+}
+declare const StatisticNumber: React.FC<NumberProps>;
+export default StatisticNumber;

package/dist/locale/antd/statistic/Number.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+const StatisticNumber = props => {
+  const {
+    value,
+    formatter,
+    precision,
+    decimalSeparator,
+    groupSeparator = '',
+    prefixCls
+  } = props;
+  let valueNode;
+  if (typeof formatter === 'function') {
+    // Customize formatter
+    valueNode = formatter(value);
+  } else {
+    // Internal formatter
+    const val = String(value);
+    const cells = val.match(/^(-?)(\d*)(\.(\d+))?$/);
+    // Process if illegal number
+    if (!cells || val === '-') {
+      valueNode = val;
+    } else {
+      const negative = cells[1];
+      let int = cells[2] || '0';
+      let decimal = cells[4] || '';
+      int = int.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
+      if (typeof precision === 'number') {
+        decimal = decimal.padEnd(precision, '0').slice(0, precision > 0 ? precision : 0);
+      }
+      if (decimal) {
+        decimal = `${decimalSeparator}${decimal}`;
+      }
+      valueNode = [/*#__PURE__*/React.createElement("span", {
+        key: "int",
+        className: `${prefixCls}-content-value-int`
+      }, negative, int), decimal && /*#__PURE__*/React.createElement("span", {
+        key: "decimal",
+        className: `${prefixCls}-content-value-decimal`
+      }, decimal)];
+    }
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    className: `${prefixCls}-content-value`
+  }, valueNode);
+};
+var _default = StatisticNumber;
+exports.default = _default;

package/dist/locale/antd/statistic/Statistic.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import type { FormatConfig, valueType } from './utils';
+export interface StatisticProps extends FormatConfig {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    style?: React.CSSProperties;
+    value?: valueType;
+    valueStyle?: React.CSSProperties;
+    valueRender?: (node: React.ReactNode) => React.ReactNode;
+    title?: React.ReactNode;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    loading?: boolean;
+    onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;
+}
+declare const Statistic: React.FC<StatisticProps>;
+export default Statistic;