@qsxy/element-plus-react 1.0.0-next.1

package/dist/Transfer/search.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transfer/search.tsx
+var search_exports = {};
+__export(search_exports, {
+  default: () => Search
+});
+module.exports = __toCommonJS(search_exports);
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Input = require("../Input/index");
+function Search(props) {
+  const { placeholder = "", value, prefixCls, disabled, onChange, handleClear } = props;
+  const handleChange = (0, import_react.useCallback)(
+    (v, e) => {
+      onChange == null ? void 0 : onChange(e);
+      if (v === "") {
+        handleClear == null ? void 0 : handleClear();
+      }
+    },
+    [handleClear, onChange]
+  );
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_Input.Input,
+    {
+      placeholder,
+      className: prefixCls,
+      value,
+      debounceInput: true,
+      onChange: handleChange,
+      disabled,
+      clearable: true,
+      onClear: handleClear,
+      prefix: /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "search" })
+    }
+  );
+}

package/dist/Transfer/typings/index.d.ts

@@ -0,0 +1,70 @@
+import React from 'react';
+import { BaseProps, NativeProps } from '../../types/common';
+import { PaginationType } from '../interface';
+import { TransferListProps } from './list';
+import { TransferListBodyProps } from './listBody';
+export type TransferDirection = 'left' | 'right';
+export type RenderResult = React.ReactElement | string;
+export interface TransferItem {
+    key?: string | number;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+    [name: string]: any;
+}
+export type KeyWise<T> = T & {
+    key: string;
+};
+export type KeyWiseTransferItem = KeyWise<TransferItem>;
+export type TransferRender<RecordType> = (item: RecordType) => RenderResult;
+export interface ListStyle {
+    direction: TransferDirection;
+}
+export type SelectAllLabel = React.ReactElement<any> | ((info: {
+    selectedCount: number;
+    totalCount: number;
+}) => React.ReactElement<any>);
+export type FieldNames = {
+    key?: string;
+    title?: string;
+    disabled?: string;
+};
+export interface TransferLocale {
+    notFoundContent?: React.ReactElement;
+    searchPlaceholder?: string;
+    itemUnit?: string;
+    itemsUnit?: string;
+    remove?: string;
+    removeAll?: string;
+    removeCurrent?: string;
+}
+export interface TransferProps<RecordType extends TransferItem = TransferItem> extends Omit<BaseProps, 'children'>, NativeProps {
+    disabled?: boolean;
+    data: RecordType[];
+    defaultValue?: (string | number)[];
+    value?: (string | number)[];
+    selectedKeys?: (string | number)[];
+    render?: TransferRender<RecordType>;
+    onChange?: (targetKeys: (string | number)[], direction: TransferDirection, moveKeys: (string | number)[]) => void;
+    onSelectChange?: (sourceSelectedKeys: (string | number)[], targetSelectedKeys: (string | number)[]) => void;
+    listStyle?: ((style: ListStyle) => React.CSSProperties) | React.CSSProperties;
+    operationStyle?: React.CSSProperties;
+    titles?: (React.ReactElement | string)[];
+    operations?: string[];
+    filterable?: boolean;
+    filterMethod?: (inputValue: string, item: RecordType) => boolean;
+    locale?: Partial<TransferLocale>;
+    footer?: (props: TransferListProps<RecordType>, extra: {
+        direction: TransferDirection;
+    }) => React.ReactElement;
+    onSearch?: (direction: TransferDirection, value: string) => void;
+    onScroll?: (direction: TransferDirection, e: any) => void;
+    children?: (props: TransferListBodyProps<RecordType>) => React.ReactElement;
+    showSelectAll?: boolean;
+    selectAllLabels?: SelectAllLabel[];
+    oneWay?: boolean;
+    pagination?: PaginationType;
+    fieldNames?: FieldNames;
+    error?: boolean;
+    warning?: boolean;
+}

package/dist/Transfer/typings/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transfer/typings/index.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Transfer/typings/list.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { BaseProps, NativeProps } from '../../types/common';
+import { PaginationType } from '../interface';
+import { FieldNames, RenderResult, SelectAllLabel, TransferDirection, TransferLocale } from './index';
+import { TransferListBodyProps } from './listBody';
+export interface RenderedItem<RecordType> {
+    renderedText: string;
+    renderedEl: React.ReactElement;
+    item: RecordType;
+}
+export type RenderListFunction<T> = (props: TransferListBodyProps<T>) => React.ReactElement;
+export interface TransferListProps<RecordType> extends TransferLocale, BaseProps, NativeProps {
+    titleText?: string | React.ReactElement;
+    data: RecordType[];
+    filterOption?: (filterText: string, item: RecordType) => boolean;
+    checkedKeys: (string | number)[];
+    handleFilter: (e: any) => void;
+    onItemSelect: (key: string | number, check: boolean) => void;
+    onItemSelectAll: (data: (string | number)[], checkAll: boolean, overWrite?: boolean) => void;
+    onItemRemove?: (keys: (string | number)[]) => void;
+    handleClear: () => void;
+    render?: (item: RecordType) => RenderResult;
+    showSearch?: boolean;
+    searchPlaceholder?: string;
+    itemUnit?: string;
+    itemsUnit?: string;
+    renderList?: RenderListFunction<RecordType>;
+    footer?: (props: TransferListProps<RecordType>, info?: {
+        direction: TransferDirection;
+    }) => React.ReactElement;
+    onScroll: (e: any) => void;
+    disabled?: boolean;
+    direction: TransferDirection;
+    showSelectAll?: boolean;
+    selectAllLabel?: SelectAllLabel;
+    showRemove?: boolean;
+    pagination?: PaginationType;
+    fieldNames: FieldNames;
+}

package/dist/Transfer/typings/list.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transfer/typings/list.ts
+var list_exports = {};
+module.exports = __toCommonJS(list_exports);

package/dist/Transfer/typings/listBody.d.ts

@@ -0,0 +1,17 @@
+import { BaseProps } from '../../types/common';
+import { ElementOf } from '../../types/type';
+import { FieldNames, KeyWiseTransferItem } from './index';
+import { RenderedItem, TransferListProps } from './list';
+export declare const OmitProps: ["handleFilter", "handleClear", "checkedKeys", "instance"];
+export type OmitProp = ElementOf<typeof OmitProps>;
+type PartialTransferListProps<RecordType> = Omit<TransferListProps<RecordType>, OmitProp>;
+export interface ListBodyRef {
+    getItems: RenderedItem<KeyWiseTransferItem>[];
+}
+export interface TransferListBodyProps<RecordType> extends PartialTransferListProps<RecordType>, BaseProps {
+    filteredItems: RecordType[];
+    filteredRenderItems: RenderedItem<RecordType>[];
+    selectedKeys: (string | number)[];
+    fieldNames: FieldNames;
+}
+export {};

package/dist/Transfer/typings/listBody.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transfer/typings/listBody.ts
+var listBody_exports = {};
+__export(listBody_exports, {
+  OmitProps: () => OmitProps
+});
+module.exports = __toCommonJS(listBody_exports);
+var import_type = require("../../types/type");
+var OmitProps = (0, import_type.tuple)("handleFilter", "handleClear", "checkedKeys", "instance");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OmitProps
+});

package/dist/Transition/Transition.d.ts

@@ -0,0 +1,57 @@
+import { Component, RefObject } from 'react';
+import { AnimationEventProps, ComponentChildren } from '../types/common';
+export declare enum STATUS {
+    UNMOUNTED = 0,
+    BEFORE_ENTER = 1,
+    ENTER = 2,
+    AFTER_ENTER = 3,
+    BEFORE_LEAVE = 4,
+    LEAVE = 5,
+    AFTER_LEAVE = 6
+}
+export interface TransitionProps extends AnimationEventProps {
+    animation?: boolean;
+    children?: ComponentChildren;
+    className?: string;
+    name?: string;
+    display?: string;
+    visible?: boolean;
+    unmountOnExit?: boolean;
+    transitionAppear?: boolean;
+    duration?: number;
+    exitedClassName?: string;
+    exitingClassName?: string;
+    enteredClassName?: string;
+    enteringClassName?: string;
+}
+interface TransitionState {
+    status?: number;
+}
+declare class Transition extends Component<TransitionProps, TransitionState> {
+    static displayName: string;
+    static defaultProps: {
+        duration: number;
+    };
+    animationEventListener: any;
+    instanceElement: any;
+    nextCallback: any;
+    needsUpdate: any;
+    childRef: RefObject<any>;
+    constructor(props: TransitionProps);
+    static getDerivedStateFromProps(nextProps: TransitionProps, prevState: TransitionState): {
+        status: STATUS;
+    };
+    getSnapshotBeforeUpdate(): any;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    onTransitionEnd(node: HTMLElement, handler: any): void;
+    setNextCallback(callback: any): any;
+    getChildElement(): any;
+    performEnter(props: TransitionProps): void;
+    performExit(props: TransitionProps): void;
+    cancelNextCallback(): void;
+    safeSetState(nextState: TransitionState, callback: any): void;
+    render(): any;
+}
+export default Transition;

package/dist/Transition/Transition.js

@@ -0,0 +1,266 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Transition/Transition.tsx
+var Transition_exports = {};
+__export(Transition_exports, {
+  STATUS: () => STATUS,
+  default: () => Transition_default
+});
+module.exports = __toCommonJS(Transition_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_getTransitionEnd = __toESM(require("dom-lib/getTransitionEnd"));
+var import_on = __toESM(require("dom-lib/on"));
+var import_isFunction = __toESM(require("lodash/isFunction"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_react = __toESM(require("react"));
+var import_util = require("./util");
+var STATUS = /* @__PURE__ */ ((STATUS2) => {
+  STATUS2[STATUS2["UNMOUNTED"] = 0] = "UNMOUNTED";
+  STATUS2[STATUS2["BEFORE_ENTER"] = 1] = "BEFORE_ENTER";
+  STATUS2[STATUS2["ENTER"] = 2] = "ENTER";
+  STATUS2[STATUS2["AFTER_ENTER"] = 3] = "AFTER_ENTER";
+  STATUS2[STATUS2["BEFORE_LEAVE"] = 4] = "BEFORE_LEAVE";
+  STATUS2[STATUS2["LEAVE"] = 5] = "LEAVE";
+  STATUS2[STATUS2["AFTER_LEAVE"] = 6] = "AFTER_LEAVE";
+  return STATUS2;
+})(STATUS || {});
+var Transition = class extends import_react.Component {
+  constructor(props) {
+    super(props);
+    this.animationEventListener = null;
+    this.instanceElement = null;
+    this.nextCallback = null;
+    this.needsUpdate = null;
+    let initialStatus;
+    if (props.visible) {
+      initialStatus = props.transitionAppear ? 1 /* BEFORE_ENTER */ : 4 /* BEFORE_LEAVE */;
+    } else {
+      initialStatus = props.unmountOnExit ? 0 /* UNMOUNTED */ : 1 /* BEFORE_ENTER */;
+    }
+    this.state = {
+      status: initialStatus
+    };
+    this.nextCallback = null;
+    this.childRef = (0, import_react.createRef)();
+  }
+  static getDerivedStateFromProps(nextProps, prevState) {
+    if (nextProps.visible && nextProps.unmountOnExit) {
+      if (prevState.status === 0 /* UNMOUNTED */) {
+        return { status: 1 /* BEFORE_ENTER */ };
+      }
+    }
+    return null;
+  }
+  getSnapshotBeforeUpdate() {
+    if (!this.props.visible || !this.props.unmountOnExit) {
+      this.needsUpdate = true;
+    }
+    return null;
+  }
+  componentDidMount() {
+    if (this.props.transitionAppear && this.props.visible) {
+      this.performEnter(this.props);
+    }
+  }
+  componentDidUpdate() {
+    const { status } = this.state;
+    const { unmountOnExit } = this.props;
+    if (unmountOnExit && status === 1 /* BEFORE_ENTER */) {
+      if (this.props.visible) {
+        this.performEnter(this.props);
+      } else {
+        if (this.instanceElement) {
+          this.setState({ status: 0 /* UNMOUNTED */ });
+        }
+      }
+      return;
+    }
+    if (this.needsUpdate) {
+      this.needsUpdate = false;
+      if (this.props.visible) {
+        if (status === 5 /* LEAVE */ || status === 1 /* BEFORE_ENTER */) {
+          this.performEnter(this.props);
+        }
+      } else if (status === 2 /* ENTER */ || status === 4 /* BEFORE_LEAVE */) {
+        this.performExit(this.props);
+      }
+    }
+  }
+  componentWillUnmount() {
+    this.cancelNextCallback();
+    this.instanceElement = null;
+  }
+  onTransitionEnd(node, handler) {
+    var _a;
+    this.setNextCallback(handler);
+    (_a = this.animationEventListener) == null ? void 0 : _a.off();
+    if (node) {
+      const { duration, animation } = this.props;
+      this.animationEventListener = (0, import_on.default)(node, animation ? (0, import_util.getAnimationEnd)() : (0, import_getTransitionEnd.default)(), this.nextCallback);
+      if (duration !== null) {
+        setTimeout(this.nextCallback, duration);
+      }
+    } else {
+      setTimeout(this.nextCallback, 0);
+    }
+  }
+  setNextCallback(callback) {
+    let active = true;
+    this.nextCallback = (event) => {
+      if (!active) {
+        return;
+      }
+      if (event) {
+        if (this.instanceElement === event.target) {
+          callback(event);
+          active = false;
+          this.nextCallback = null;
+        }
+        return;
+      }
+      callback(event);
+      active = false;
+      this.nextCallback = null;
+    };
+    this.nextCallback.cancel = () => {
+      active = false;
+    };
+    return this.nextCallback;
+  }
+  getChildElement() {
+    if (this.childRef.current) {
+      return (0, import_util.getDOMNode)(this.childRef.current);
+    }
+    return (0, import_util.getDOMNode)(this);
+  }
+  performEnter(props) {
+    const { beforeEnter, onEnter, afterEnter } = props || this.props;
+    this.cancelNextCallback();
+    const node = this.getChildElement();
+    this.instanceElement = node;
+    beforeEnter == null ? void 0 : beforeEnter(node);
+    this.safeSetState({ status: 2 /* ENTER */ }, () => {
+      onEnter == null ? void 0 : onEnter(node);
+      this.onTransitionEnd(node, () => {
+        this.safeSetState({ status: 4 /* BEFORE_LEAVE */ }, () => {
+          afterEnter == null ? void 0 : afterEnter(node);
+        });
+      });
+    });
+  }
+  performExit(props) {
+    const { beforeLeave, onLeave, afterLeave } = props || this.props;
+    this.cancelNextCallback();
+    const node = this.getChildElement();
+    this.instanceElement = node;
+    beforeLeave == null ? void 0 : beforeLeave(node);
+    this.safeSetState({ status: 5 /* LEAVE */ }, () => {
+      this.onTransitionEnd(node, () => {
+        onLeave == null ? void 0 : onLeave(node);
+        this.safeSetState({ status: 1 /* BEFORE_ENTER */ }, () => {
+          afterLeave == null ? void 0 : afterLeave(node);
+        });
+      });
+    });
+  }
+  cancelNextCallback() {
+    if (this.nextCallback !== null) {
+      this.nextCallback.cancel();
+      this.nextCallback = null;
+    }
+  }
+  safeSetState(nextState, callback) {
+    if (this.instanceElement) {
+      this.setState(nextState, this.setNextCallback(callback));
+    }
+  }
+  render() {
+    const status = this.state.status;
+    if (status === 0 /* UNMOUNTED */) {
+      return null;
+    }
+    const { children, className, name, ...rest } = this.props;
+    const childProps = (0, import_omit.default)(rest, [
+      "animation",
+      "className",
+      "visible",
+      "unmountOnExit",
+      "transitionAppear",
+      "duration",
+      "beforeEnter",
+      "onEnter",
+      "afterEnter",
+      "beforeLeave",
+      "onLeave",
+      "afterLeave"
+    ]);
+    let transitionClassName;
+    if (name) {
+      if (status === 1 /* BEFORE_ENTER */) {
+        transitionClassName = `${name}-leave-to`;
+      } else if (status === 2 /* ENTER */) {
+        transitionClassName = `${name}-enter-from`;
+      } else if (status === 4 /* BEFORE_LEAVE */) {
+        transitionClassName = `${name}-enter-active`;
+      } else if (status === 5 /* LEAVE */) {
+        transitionClassName = `${name}-leave-active`;
+      }
+    }
+    if ((0, import_isFunction.default)(children)) {
+      childProps.className = (0, import_classnames.default)(className, transitionClassName);
+      return children(childProps, this.childRef);
+    }
+    return import_react.Children.toArray(children).map((child) => {
+      var _a, _b;
+      if (typeof child === "string" || typeof child === "number") {
+        child = /* @__PURE__ */ import_react.default.createElement("span", null, child);
+      }
+      return (0, import_react.cloneElement)(child, {
+        ...childProps,
+        // ref: this.childRef,
+        // @ts-ignore
+        className: (0, import_classnames.default)(className, (_a = child.props) == null ? void 0 : _a.className, transitionClassName),
+        style: {
+          // @ts-ignore
+          ...((_b = child.props) == null ? void 0 : _b.style) || {},
+          display: this.state.status > 1 ? this.props.display ?? "block" : "none"
+        }
+      });
+    });
+  }
+};
+Transition.displayName = "Transition";
+Transition.defaultProps = {
+  duration: 100
+};
+var Transition_default = Transition;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STATUS
+});

package/dist/Transition/TransitionGroup.d.ts

@@ -0,0 +1,38 @@
+import React, { Component } from 'react';
+export interface TransitionGroupProps {
+    component: any;
+    children: React.ReactNode;
+    transitionAppear: boolean;
+    enter: boolean;
+    exit: boolean;
+    childFactory: (child: React.ReactNode) => React.ReactNode;
+}
+interface State {
+    children?: React.ReactElement<any>[] | React.ReactElement<any>;
+    contextValue?: {
+        isMounting: boolean;
+    };
+    handleExited?: (child: any, node: any) => void;
+    firstRender?: boolean;
+}
+declare class TransitionGroup extends Component<TransitionGroupProps, State> {
+    mounted: boolean | undefined;
+    static defaultProps: {
+        component: string;
+        childFactory: (child: any) => any;
+    };
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(nextProps: any, { children: prevChildMapping, handleExited, firstRender }: {
+        children: any;
+        handleExited: any;
+        firstRender: any;
+    }): {
+        children: any;
+        firstRender: boolean;
+    };
+    handleExited(child: any, node: any): void;
+    render(): React.JSX.Element;
+}
+export default TransitionGroup;