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

package/build.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+const fs = require('fs/promises');
+const path = require('path');
+const existsSync = require('fs').existsSync;
+
+const client = require.resolve('@nocobase/client');
+const antd = require.resolve('antd');
+
+exports.run = async (log) => {
+  const localeDir = path.resolve(__dirname, './dist/locale');
+  if (existsSync(localeDir)) {
+    await fs.rmdir(localeDir, { force: true, recursive: true });
+  }
+
+  log('coping client locale');
+  await fs.cp(path.resolve(path.dirname(client), 'locale'), localeDir, {
+    recursive: true,
+    force: true,
+  });
+
+  log('coping antd locale');
+  await fs.cp(path.resolve(path.dirname(antd)), path.resolve(localeDir, 'antd'), {
+    recursive: true,
+    force: true,
+  });
+};

package/client.d.ts

@@ -1,3 +1,2 @@
-export * from './src/client';
-export { default } from './src/client';
-
+export * from './dist/client';
+export { default } from './dist/client';

package/client.js

@@ -1 +1 @@
-module.exports = require('./lib/client/index.js');
+module.exports = require('./dist/client/index.js');

package/dist/client/index.js

@@ -0,0 +1,11 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@nocobase/client")) : typeof define === "function" && define.amd ? define(["exports", "@nocobase/client"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@nocobase/plugin-client"] = {}, global["@nocobase/client"]));
+})(this, function(exports2, client) {
+  "use strict";
+  class ClientPlugin extends client.Plugin {
+    async load() {
+    }
+  }
+  exports2.default = ClientPlugin;
+  Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+});

package/{lib/server → dist}/index.d.ts

@@ -1 +1,2 @@
+export * from './server';
 export { default } from './server';

package/dist/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('./server');
+
+
+
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () { return server__namespace.default; }
+});
+Object.keys(server).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return server[k]; }
+  });
+});

package/dist/locale/antd/_util/ActionButton.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { ButtonProps, LegacyButtonType } from '../button/button';
+export interface ActionButtonProps {
+    type?: LegacyButtonType;
+    actionFn?: (...args: any[]) => any | PromiseLike<any>;
+    close?: Function;
+    autoFocus?: boolean;
+    prefixCls: string;
+    buttonProps?: ButtonProps;
+    emitEvent?: boolean;
+    quitOnNullishReturnValue?: boolean;
+    children?: React.ReactNode;
+}
+declare const ActionButton: React.FC<ActionButtonProps>;
+export default ActionButton;

package/dist/locale/antd/_util/ActionButton.js

@@ -0,0 +1,103 @@
+"use strict";
+
+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 _useState = _interopRequireDefault(require("rc-util/lib/hooks/useState"));
+var React = _interopRequireWildcard(require("react"));
+var _button = _interopRequireDefault(require("../button"));
+var _button2 = require("../button/button");
+function isThenable(thing) {
+  return !!(thing && thing.then);
+}
+const ActionButton = props => {
+  const {
+    type,
+    children,
+    prefixCls,
+    buttonProps,
+    close,
+    autoFocus,
+    emitEvent,
+    quitOnNullishReturnValue,
+    actionFn
+  } = props;
+  const clickedRef = React.useRef(false);
+  const buttonRef = React.useRef(null);
+  const [loading, setLoading] = (0, _useState.default)(false);
+  const onInternalClose = function () {
+    close === null || close === void 0 ? void 0 : close.apply(void 0, arguments);
+  };
+  React.useEffect(() => {
+    let timeoutId = null;
+    if (autoFocus) {
+      timeoutId = setTimeout(() => {
+        var _a;
+        (_a = buttonRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+      });
+    }
+    return () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, []);
+  const handlePromiseOnOk = returnValueOfOnOk => {
+    if (!isThenable(returnValueOfOnOk)) {
+      return;
+    }
+    setLoading(true);
+    returnValueOfOnOk.then(function () {
+      setLoading(false, true);
+      onInternalClose.apply(void 0, arguments);
+      clickedRef.current = false;
+    }, e => {
+      // See: https://github.com/ant-design/ant-design/issues/6183
+      setLoading(false, true);
+      clickedRef.current = false;
+      return Promise.reject(e);
+    });
+  };
+  const onClick = e => {
+    if (clickedRef.current) {
+      return;
+    }
+    clickedRef.current = true;
+    if (!actionFn) {
+      onInternalClose();
+      return;
+    }
+    let returnValueOfOnOk;
+    if (emitEvent) {
+      returnValueOfOnOk = actionFn(e);
+      if (quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
+        clickedRef.current = false;
+        onInternalClose(e);
+        return;
+      }
+    } else if (actionFn.length) {
+      returnValueOfOnOk = actionFn(close);
+      // https://github.com/ant-design/ant-design/issues/23358
+      clickedRef.current = false;
+    } else {
+      returnValueOfOnOk = actionFn();
+      if (!returnValueOfOnOk) {
+        onInternalClose();
+        return;
+      }
+    }
+    handlePromiseOnOk(returnValueOfOnOk);
+  };
+  return /*#__PURE__*/React.createElement(_button.default, Object.assign({}, (0, _button2.convertLegacyProps)(type), {
+    onClick: onClick,
+    loading: loading,
+    prefixCls: prefixCls
+  }, buttonProps, {
+    ref: buttonRef
+  }), children);
+};
+var _default = ActionButton;
+exports.default = _default;

package/dist/locale/antd/_util/PurePanel.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface BaseProps {
+    prefixCls?: string;
+    style?: React.CSSProperties;
+}
+export default function genPurePanel<ComponentProps extends BaseProps>(Component: any, defaultPrefixCls?: string, getDropdownCls?: null | ((prefixCls: string) => string), postProps?: (props: ComponentProps) => ComponentProps): any;

package/dist/locale/antd/_util/PurePanel.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = genPurePanel;
+var _useMergedState = _interopRequireDefault(require("rc-util/lib/hooks/useMergedState"));
+var React = _interopRequireWildcard(require("react"));
+var _configProvider = _interopRequireWildcard(require("../config-provider"));
+/* istanbul ignore next */
+function genPurePanel(Component, defaultPrefixCls, getDropdownCls, postProps) {
+  return function PurePanel(props) {
+    const {
+      prefixCls: customizePrefixCls,
+      style
+    } = props;
+    const holderRef = React.useRef(null);
+    const [popupHeight, setPopupHeight] = React.useState(0);
+    const [popupWidth, setPopupWidth] = React.useState(0);
+    const [open, setOpen] = (0, _useMergedState.default)(false, {
+      value: props.open
+    });
+    const {
+      getPrefixCls
+    } = React.useContext(_configProvider.ConfigContext);
+    const prefixCls = getPrefixCls(defaultPrefixCls || 'select', customizePrefixCls);
+    React.useEffect(() => {
+      // We do not care about ssr
+      setOpen(true);
+      if (typeof ResizeObserver !== 'undefined') {
+        const resizeObserver = new ResizeObserver(entries => {
+          const element = entries[0].target;
+          setPopupHeight(element.offsetHeight + 8);
+          setPopupWidth(element.offsetWidth);
+        });
+        const interval = setInterval(() => {
+          var _a;
+          const dropdownCls = getDropdownCls ? `.${getDropdownCls(prefixCls)}` : `.${prefixCls}-dropdown`;
+          const popup = (_a = holderRef.current) === null || _a === void 0 ? void 0 : _a.querySelector(dropdownCls);
+          if (popup) {
+            clearInterval(interval);
+            resizeObserver.observe(popup);
+          }
+        }, 10);
+        return () => {
+          clearInterval(interval);
+          resizeObserver.disconnect();
+        };
+      }
+    }, []);
+    let mergedProps = Object.assign(Object.assign({}, props), {
+      style: Object.assign(Object.assign({}, style), {
+        margin: 0
+      }),
+      open,
+      visible: open,
+      getPopupContainer: () => holderRef.current
+    });
+    if (postProps) {
+      mergedProps = postProps(mergedProps);
+    }
+    return /*#__PURE__*/React.createElement(_configProvider.default, {
+      theme: {
+        token: {
+          motion: false
+        }
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      ref: holderRef,
+      style: {
+        paddingBottom: popupHeight,
+        position: 'relative',
+        minWidth: popupWidth
+      }
+    }, /*#__PURE__*/React.createElement(Component, Object.assign({}, mergedProps))));
+  };
+}

package/dist/locale/antd/_util/capitalize.d.ts

@@ -0,0 +1 @@
+export default function capitalize<T extends string>(str: T): Capitalize<T>;

package/dist/locale/antd/_util/capitalize.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = capitalize;
+function capitalize(str) {
+  if (typeof str !== 'string') {
+    return str;
+  }
+  const ret = str.charAt(0).toUpperCase() + str.slice(1);
+  return ret;
+}

package/dist/locale/antd/_util/colors.d.ts

@@ -0,0 +1,13 @@
+import type { PresetColorKey } from '../theme/interface';
+type InverseColor = `${PresetColorKey}-inverse`;
+export declare const PresetStatusColorTypes: readonly ["success", "processing", "error", "default", "warning"];
+export type PresetColorType = PresetColorKey | InverseColor;
+export type PresetStatusColorType = typeof PresetStatusColorTypes[number];
+/**
+ * determine if the color keyword belongs to the `Ant Design` {@link PresetColors}.
+ * @param color color to be judged
+ * @param includeInverse whether to include reversed colors
+ */
+export declare function isPresetColor(color?: any, includeInverse?: boolean): boolean;
+export declare function isPresetStatusColor(color?: any): color is PresetStatusColorType;
+export {};

package/dist/locale/antd/_util/colors.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetStatusColorTypes = void 0;
+exports.isPresetColor = isPresetColor;
+exports.isPresetStatusColor = isPresetStatusColor;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _interface = require("../theme/interface");
+const inverseColors = _interface.PresetColors.map(color => `${color}-inverse`);
+const PresetStatusColorTypes = ['success', 'processing', 'error', 'default', 'warning'];
+/**
+ * determine if the color keyword belongs to the `Ant Design` {@link PresetColors}.
+ * @param color color to be judged
+ * @param includeInverse whether to include reversed colors
+ */
+exports.PresetStatusColorTypes = PresetStatusColorTypes;
+function isPresetColor(color) {
+  let includeInverse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (includeInverse) {
+    return [].concat((0, _toConsumableArray2.default)(inverseColors), (0, _toConsumableArray2.default)(_interface.PresetColors)).includes(color);
+  }
+  return _interface.PresetColors.includes(color);
+}
+function isPresetStatusColor(color) {
+  return PresetStatusColorTypes.includes(color);
+}

package/dist/locale/antd/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/dist/locale/antd/_util/easings.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.easeInOutCubic = easeInOutCubic;
+// eslint-disable-next-line import/prefer-default-export
+function easeInOutCubic(t, b, c, d) {
+  const cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  // eslint-disable-next-line no-return-assign
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}

package/dist/locale/antd/_util/extendsObject.d.ts

@@ -0,0 +1,3 @@
+type RecordType = Record<string, any>;
+declare function extendsObject<T extends RecordType>(...list: T[]): RecordType;
+export default extendsObject;

package/dist/locale/antd/_util/extendsObject.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function extendsObject() {
+  const result = Object.assign({}, arguments.length <= 0 ? undefined : arguments[0]);
+  for (let i = 1; i < arguments.length; i++) {
+    const obj = i < 0 || arguments.length <= i ? undefined : arguments[i];
+    if (obj) {
+      Object.keys(obj).forEach(key => {
+        const val = obj[key];
+        if (val !== undefined) {
+          result[key] = val;
+        }
+      });
+    }
+  }
+  return result;
+}
+var _default = extendsObject;
+exports.default = _default;

package/dist/locale/antd/_util/getRenderPropValue.d.ts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+export type RenderFunction = () => React.ReactNode;
+export declare const getRenderPropValue: (propValue?: React.ReactNode | RenderFunction) => React.ReactNode;

package/dist/locale/antd/_util/getRenderPropValue.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRenderPropValue = void 0;
+const getRenderPropValue = propValue => {
+  if (!propValue) {
+    return null;
+  }
+  if (typeof propValue === 'function') {
+    return propValue();
+  }
+  return propValue;
+};
+exports.getRenderPropValue = getRenderPropValue;

package/dist/locale/antd/_util/getScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function isWindow(obj: any): obj is Window;
+export default function getScroll(target: HTMLElement | Window | Document | null, top: boolean): number;

package/dist/locale/antd/_util/getScroll.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getScroll;
+exports.isWindow = isWindow;
+function isWindow(obj) {
+  return obj !== null && obj !== undefined && obj === obj.window;
+}
+function getScroll(target, top) {
+  var _a, _b;
+  if (typeof window === 'undefined') {
+    return 0;
+  }
+  const method = top ? 'scrollTop' : 'scrollLeft';
+  let result = 0;
+  if (isWindow(target)) {
+    result = target[top ? 'pageYOffset' : 'pageXOffset'];
+  } else if (target instanceof Document) {
+    result = target.documentElement[method];
+  } else if (target instanceof HTMLElement) {
+    result = target[method];
+  } else if (target) {
+    // According to the type inference, the `target` is `never` type.
+    // Since we configured the loose mode type checking, and supports mocking the target with such shape below::
+    //    `{ documentElement: { scrollLeft: 200, scrollTop: 400 } }`,
+    //    the program may falls into this branch.
+    // Check the corresponding tests for details. Don't sure what is the real scenario this happens.
+    result = target[method];
+  }
+  if (target && !isWindow(target) && typeof result !== 'number') {
+    result = (_b = ((_a = target.ownerDocument) !== null && _a !== void 0 ? _a : target).documentElement) === null || _b === void 0 ? void 0 : _b[method];
+  }
+  return result;
+}

package/dist/locale/antd/_util/hooks/useClosable.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+export type UseClosableParams = {
+    closable?: boolean;
+    closeIcon?: boolean | ReactNode;
+    defaultClosable?: boolean;
+    defaultCloseIcon?: ReactNode;
+    customCloseIconRender?: (closeIcon: ReactNode) => ReactNode;
+};
+export default function useClosable(closable?: boolean, closeIcon?: boolean | ReactNode, customCloseIconRender?: (closeIcon: ReactNode) => ReactNode, defaultCloseIcon?: ReactNode, defaultClosable?: boolean): [closable: boolean, closeIcon: React.ReactNode | null];

package/dist/locale/antd/_util/hooks/useClosable.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useClosable;
+var _icons = require("@ant-design/icons");
+var _react = _interopRequireDefault(require("react"));
+function useInnerClosable(closable, closeIcon, defaultClosable) {
+  if (typeof closable === 'boolean') {
+    return closable;
+  }
+  if (closeIcon === undefined) {
+    return !!defaultClosable;
+  }
+  return closeIcon !== false && closeIcon !== null;
+}
+function useClosable(closable, closeIcon, customCloseIconRender) {
+  let defaultCloseIcon = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : /*#__PURE__*/_react.default.createElement(_icons.CloseOutlined, null);
+  let defaultClosable = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  const mergedClosable = useInnerClosable(closable, closeIcon, defaultClosable);
+  if (!mergedClosable) {
+    return [false, null];
+  }
+  const mergedCloseIcon = typeof closeIcon === 'boolean' || closeIcon === undefined || closeIcon === null ? defaultCloseIcon : closeIcon;
+  return [true, customCloseIconRender ? customCloseIconRender(mergedCloseIcon) : mergedCloseIcon];
+}

package/dist/locale/antd/_util/hooks/useFlexGapSupport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/dist/locale/antd/_util/hooks/useFlexGapSupport.js

@@ -0,0 +1,17 @@
+"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"));
+var _styleChecker = require("../styleChecker");
+var _default = () => {
+  const [flexible, setFlexible] = React.useState(false);
+  React.useEffect(() => {
+    setFlexible((0, _styleChecker.detectFlexGapSupported)());
+  }, []);
+  return flexible;
+};
+exports.default = _default;

package/dist/locale/antd/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useForceUpdate(): React.DispatchWithoutAction;

package/dist/locale/antd/_util/hooks/useForceUpdate.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useForceUpdate;
+var React = _interopRequireWildcard(require("react"));
+function useForceUpdate() {
+  const [, forceUpdate] = React.useReducer(x => x + 1, 0);
+  return forceUpdate;
+}

package/dist/locale/antd/_util/hooks/usePatchElement.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export default function usePatchElement(): [
+    React.ReactElement[],
+    (element: React.ReactElement) => Function
+];

package/dist/locale/antd/_util/hooks/usePatchElement.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = usePatchElement;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var React = _interopRequireWildcard(require("react"));
+function usePatchElement() {
+  const [elements, setElements] = React.useState([]);
+  const patchElement = React.useCallback(element => {
+    // append a new element to elements (and create a new ref)
+    setElements(originElements => [].concat((0, _toConsumableArray2.default)(originElements), [element]));
+    // return a function that removes the new element out of elements (and create a new ref)
+    // it works a little like useEffect
+    return () => {
+      setElements(originElements => originElements.filter(ele => ele !== element));
+    };
+  }, []);
+  return [elements, patchElement];
+}

package/dist/locale/antd/_util/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export default function useSyncState<T>(initialValue: T): UseSyncStateProps<T>;
+export {};

package/dist/locale/antd/_util/hooks/useSyncState.js

@@ -0,0 +1,19 @@
+"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 = useSyncState;
+var React = _interopRequireWildcard(require("react"));
+var _useForceUpdate = _interopRequireDefault(require("./useForceUpdate"));
+function useSyncState(initialValue) {
+  const ref = React.useRef(initialValue);
+  const forceUpdate = (0, _useForceUpdate.default)();
+  return [() => ref.current, newValue => {
+    ref.current = newValue;
+    // re-render
+    forceUpdate();
+  }];
+}

package/dist/locale/antd/_util/isNumeric.d.ts

@@ -0,0 +1,2 @@
+declare const isNumeric: (value: any) => boolean;
+export default isNumeric;

package/dist/locale/antd/_util/isNumeric.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const isNumeric = value => !isNaN(parseFloat(value)) && isFinite(value);
+var _default = isNumeric;
+exports.default = _default;

package/dist/locale/antd/_util/motion.d.ts

@@ -0,0 +1,8 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const initCollapseMotion: (rootCls?: string) => CSSMotionProps;
+declare const SelectPlacements: readonly ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = typeof SelectPlacements[number];
+declare const getTransitionDirection: (placement?: SelectCommonPlacement) => "slide-down" | "slide-up";
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionName, getTransitionDirection };
+export default initCollapseMotion;