@tachybase/components 0.23.8

package/lib/__builtins__/portal.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ReactFC } from '@tachybase/schema';
+export interface IPortalProps {
+    id?: string | symbol;
+}
+export declare const createPortalProvider: (id: string | symbol) => ReactFC<IPortalProps>;
+export declare function createPortalRoot<T extends React.ReactNode>(host: HTMLElement, id: string): {
+    render: (renderer?: () => T) => void;
+    unmount: () => void;
+};

package/lib/__builtins__/portal.js

@@ -0,0 +1,89 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var portal_exports = {};
+__export(portal_exports, {
+  createPortalProvider: () => createPortalProvider,
+  createPortalRoot: () => createPortalRoot
+});
+module.exports = __toCommonJS(portal_exports);
+var import_react = __toESM(require("react"));
+var import_schema = require("@tachybase/schema");
+var import_react_dom = require("react-dom");
+var import_render = require("./render");
+const PortalMap = (0, import_schema.observable)(/* @__PURE__ */ new Map());
+const createPortalProvider = /* @__PURE__ */ __name((id) => {
+  const Portal = /* @__PURE__ */ __name((props) => {
+    if (props.id && !PortalMap.has(props.id)) {
+      PortalMap.set(props.id, null);
+    }
+    return /* @__PURE__ */ import_react.default.createElement(import_react.Fragment, null, props.children, /* @__PURE__ */ import_react.default.createElement(import_schema.Observer, null, () => {
+      if (!props.id) return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null);
+      const portal = PortalMap.get(props.id);
+      if (portal) return (0, import_react_dom.createPortal)(portal, document.body);
+      return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null);
+    }));
+  }, "Portal");
+  Portal.defaultProps = {
+    id
+  };
+  return Portal;
+}, "createPortalProvider");
+function createPortalRoot(host, id) {
+  function render(renderer) {
+    if (PortalMap.has(id)) {
+      PortalMap.set(id, renderer == null ? void 0 : renderer());
+    } else if (host) {
+      (0, import_render.render)(/* @__PURE__ */ import_react.default.createElement(import_react.Fragment, null, renderer == null ? void 0 : renderer()), host);
+    }
+  }
+  __name(render, "render");
+  function unmount() {
+    var _a;
+    if (PortalMap.has(id)) {
+      PortalMap.set(id, null);
+    }
+    if (host) {
+      const unmountResult = (0, import_render.unmount)(host);
+      if (unmountResult && host.parentNode) {
+        (_a = host.parentNode) == null ? void 0 : _a.removeChild(host);
+      }
+    }
+  }
+  __name(unmount, "unmount");
+  return {
+    render,
+    unmount
+  };
+}
+__name(createPortalRoot, "createPortalRoot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPortalProvider,
+  createPortalRoot
+});

package/lib/__builtins__/render.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import type { Root } from 'react-dom/client';
+declare const MARK = "__antd_mobile_root__";
+type ContainerType = (Element | DocumentFragment) & {
+    [MARK]?: Root;
+};
+export declare function render(node: ReactElement, container: ContainerType): void;
+export declare function unmount(container: ContainerType): boolean | Promise<void>;
+export {};

package/lib/__builtins__/render.js

@@ -0,0 +1,99 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var render_exports = {};
+__export(render_exports, {
+  render: () => render,
+  unmount: () => unmount
+});
+module.exports = __toCommonJS(render_exports);
+var ReactDOM = __toESM(require("react-dom"));
+const fullClone = {
+  ...ReactDOM
+};
+const { version, render: reactRender, unmountComponentAtNode } = fullClone;
+let createRoot;
+try {
+  const mainVersion = Number((version || "").split(".")[0]);
+  if (mainVersion >= 18 && fullClone.createRoot) {
+    createRoot = fullClone.createRoot;
+  }
+} catch (e) {
+}
+function toggleWarning(skip) {
+  const { __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } = fullClone;
+  if (__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED && typeof __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED === "object") {
+    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.usingClientEntryPoint = skip;
+  }
+}
+__name(toggleWarning, "toggleWarning");
+const MARK = "__antd_mobile_root__";
+function legacyRender(node, container) {
+  reactRender(node, container);
+}
+__name(legacyRender, "legacyRender");
+function concurrentRender(node, container) {
+  toggleWarning(true);
+  const root = container[MARK] || createRoot(container);
+  toggleWarning(false);
+  root.render(node);
+  container[MARK] = root;
+}
+__name(concurrentRender, "concurrentRender");
+function render(node, container) {
+  if (createRoot) {
+    concurrentRender(node, container);
+    return;
+  }
+  legacyRender(node, container);
+}
+__name(render, "render");
+function legacyUnmount(container) {
+  return unmountComponentAtNode(container);
+}
+__name(legacyUnmount, "legacyUnmount");
+async function concurrentUnmount(container) {
+  return Promise.resolve().then(() => {
+    var _a;
+    (_a = container[MARK]) == null ? void 0 : _a.unmount();
+    delete container[MARK];
+  });
+}
+__name(concurrentUnmount, "concurrentUnmount");
+function unmount(container) {
+  if (createRoot) {
+    return concurrentUnmount(container);
+  }
+  return legacyUnmount(container);
+}
+__name(unmount, "unmount");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render,
+  unmount
+});

package/lib/__builtins__/sort.d.ts

@@ -0,0 +1,73 @@
+import React from 'react';
+import { ReactFC } from '@tachybase/schema';
+import { DragStartEvent } from '@dnd-kit/core';
+export type { Transform } from '@dnd-kit/utilities';
+export interface ISortableContainerProps {
+    list: any[];
+    start?: number;
+    accessibility?: {
+        container?: Element;
+    };
+    onSortStart?: (event: DragStartEvent) => void;
+    onSortEnd?: (event: {
+        oldIndex: number;
+        newIndex: number;
+    }) => void;
+}
+export declare function SortableContainer<T extends React.HTMLAttributes<HTMLElement>>(Component: ReactFC<T>): ReactFC<ISortableContainerProps & T>;
+export declare const useSortableItem: () => Partial<{
+    active: import("@dnd-kit/core").Active | null;
+    activeIndex: number;
+    attributes: import("@dnd-kit/core").DraggableAttributes;
+    data: import("@dnd-kit/sortable").SortableData & {
+        [x: string]: any;
+    };
+    rect: import("react").MutableRefObject<import("@dnd-kit/core").ClientRect | null>;
+    index: number;
+    newIndex: number;
+    items: import("@dnd-kit/core").UniqueIdentifier[];
+    isOver: boolean;
+    isSorting: boolean;
+    isDragging: boolean;
+    listeners: import("@dnd-kit/core/dist/hooks/utilities").SyntheticListenerMap | undefined;
+    node: import("react").MutableRefObject<HTMLElement | null>;
+    overIndex: number;
+    over: import("@dnd-kit/core").Over | null;
+    setNodeRef: (node: HTMLElement | null) => void;
+    setActivatorNodeRef: (element: HTMLElement | null) => void;
+    setDroppableNodeRef: (element: HTMLElement | null) => void;
+    setDraggableNodeRef: (element: HTMLElement | null) => void;
+    transform: import("@dnd-kit/utilities").Transform | null;
+    transition: string | undefined;
+}>;
+export declare const SortableItemContext: React.Context<Partial<{
+    active: import("@dnd-kit/core").Active | null;
+    activeIndex: number;
+    attributes: import("@dnd-kit/core").DraggableAttributes;
+    data: import("@dnd-kit/sortable").SortableData & {
+        [x: string]: any;
+    };
+    rect: import("react").MutableRefObject<import("@dnd-kit/core").ClientRect | null>;
+    index: number;
+    newIndex: number;
+    items: import("@dnd-kit/core").UniqueIdentifier[];
+    isOver: boolean;
+    isSorting: boolean;
+    isDragging: boolean;
+    listeners: import("@dnd-kit/core/dist/hooks/utilities").SyntheticListenerMap | undefined;
+    node: import("react").MutableRefObject<HTMLElement | null>;
+    overIndex: number;
+    over: import("@dnd-kit/core").Over | null;
+    setNodeRef: (node: HTMLElement | null) => void;
+    setActivatorNodeRef: (element: HTMLElement | null) => void;
+    setDroppableNodeRef: (element: HTMLElement | null) => void;
+    setDraggableNodeRef: (element: HTMLElement | null) => void;
+    transform: import("@dnd-kit/utilities").Transform | null;
+    transition: string | undefined;
+}>>;
+export interface ISortableElementProps {
+    index?: number;
+    lockAxis?: 'x' | 'y';
+}
+export declare function SortableElement<T extends React.HTMLAttributes<HTMLElement>>(Component: ReactFC<T>): ReactFC<T & ISortableElementProps>;
+export declare function SortableHandle<T extends React.HTMLAttributes<HTMLElement>>(Component: ReactFC<T>): ReactFC<T>;

package/lib/__builtins__/sort.js

@@ -0,0 +1,126 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var sort_exports = {};
+__export(sort_exports, {
+  SortableContainer: () => SortableContainer,
+  SortableElement: () => SortableElement,
+  SortableHandle: () => SortableHandle,
+  SortableItemContext: () => SortableItemContext,
+  useSortableItem: () => useSortableItem
+});
+module.exports = __toCommonJS(sort_exports);
+var import_react = __toESM(require("react"));
+var import_core = require("@dnd-kit/core");
+var import_sortable = require("@dnd-kit/sortable");
+function SortableContainer(Component) {
+  return ({ list, start = 0, accessibility, onSortStart, onSortEnd, ...props }) => {
+    const _onSortEnd = /* @__PURE__ */ __name((event) => {
+      const { active, over } = event;
+      if (!over) return;
+      const oldIndex = +active.id - 1;
+      const newIndex = +over.id - 1;
+      onSortEnd == null ? void 0 : onSortEnd({
+        oldIndex,
+        newIndex
+      });
+    }, "_onSortEnd");
+    return /* @__PURE__ */ import_react.default.createElement(import_core.DndContext, { accessibility, onDragStart: onSortStart, onDragEnd: _onSortEnd }, /* @__PURE__ */ import_react.default.createElement(import_sortable.SortableContext, { items: list.map((_, index) => index + start + 1), strategy: import_sortable.verticalListSortingStrategy }, /* @__PURE__ */ import_react.default.createElement(Component, { ...props }, props.children)));
+  };
+}
+__name(SortableContainer, "SortableContainer");
+const useSortableItem = /* @__PURE__ */ __name(() => {
+  return (0, import_react.useContext)(SortableItemContext);
+}, "useSortableItem");
+const SortableItemContext = (0, import_react.createContext)({});
+function SortableElement(Component) {
+  return ({ index = 0, lockAxis, ...props }) => {
+    const sortable = (0, import_sortable.useSortable)({
+      id: index + 1
+    });
+    const { setNodeRef, transform, transition, isDragging } = sortable;
+    if (transform) {
+      switch (lockAxis) {
+        case "x":
+          transform.y = 0;
+          break;
+        case "y":
+          transform.x = 0;
+          break;
+        default:
+          break;
+      }
+    }
+    const style = (0, import_react.useMemo)(() => {
+      const zIndex = transform ? 1 : "none";
+      const position = transform ? "relative" : "unset";
+      const itemStyle = {
+        position,
+        touchAction: "none",
+        zIndex,
+        transform: transform ? `translate3d(${transform.x}px, ${transform.y}px, 0)` : "none",
+        transition: `${transform ? "all 200ms ease" : ""}`
+      };
+      const dragStyle = {
+        transition,
+        opacity: "0.8",
+        transform: `translate3d(${(transform == null ? void 0 : transform.x) || 0}px, ${(transform == null ? void 0 : transform.y) || 0}px, 0)`
+      };
+      const computedStyle = isDragging ? {
+        ...itemStyle,
+        ...dragStyle,
+        ...props.style
+      } : {
+        ...itemStyle,
+        ...props.style
+      };
+      return computedStyle;
+    }, [isDragging, transform, transition, props.style]);
+    return /* @__PURE__ */ import_react.default.createElement(SortableItemContext.Provider, { value: sortable }, Component({
+      ...props,
+      style,
+      ref: setNodeRef
+    }));
+  };
+}
+__name(SortableElement, "SortableElement");
+function SortableHandle(Component) {
+  return (props) => {
+    const { attributes, listeners } = useSortableItem();
+    return /* @__PURE__ */ import_react.default.createElement(Component, { ...props, ...attributes, ...listeners });
+  };
+}
+__name(SortableHandle, "SortableHandle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortableContainer,
+  SortableElement,
+  SortableHandle,
+  SortableItemContext,
+  useSortableItem
+});

package/lib/__builtins__/style.d.ts

@@ -0,0 +1,23 @@
+import { type CSSInterpolation, type CSSObject } from '@ant-design/cssinjs';
+import type { ComponentTokenMap, GlobalToken } from 'antd/es/theme/interface';
+export type OverrideComponent = keyof ComponentTokenMap | (string & {});
+export interface StyleInfo {
+    hashId: string;
+    prefixCls: string;
+    rootPrefixCls: string;
+    iconPrefixCls: string;
+}
+export type TokenWithCommonCls<T> = T & {
+    /** Wrap component class with `.` prefix */
+    componentCls: string;
+    /** Origin prefix which do not have `.` prefix */
+    prefixCls: string;
+    /** Wrap icon class with `.` prefix */
+    iconCls: string;
+    /** Wrap ant prefixCls class with `.` prefix */
+    antCls: string;
+};
+export type GenerateStyle<ComponentToken extends object = TokenWithCommonCls<GlobalToken>, ReturnType = CSSInterpolation> = (token: ComponentToken, options?: any) => ReturnType;
+export declare const genCommonStyle: (token: any, componentPrefixCls: string) => CSSObject;
+export type UseComponentStyleResult = [(node: React.ReactNode) => React.ReactElement, string];
+export declare const genStyleHook: <ComponentName extends OverrideComponent>(component: ComponentName, styleFn: (token: TokenWithCommonCls<GlobalToken>, info: StyleInfo) => CSSInterpolation) => (prefixCls: string) => UseComponentStyleResult;

package/lib/__builtins__/style.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var style_exports = {};
+__export(style_exports, {
+  genCommonStyle: () => genCommonStyle,
+  genStyleHook: () => genStyleHook
+});
+module.exports = __toCommonJS(style_exports);
+var import_schema = require("@tachybase/schema");
+var import_cssinjs = require("@ant-design/cssinjs");
+var import_hooks = require("./hooks");
+const genCommonStyle = /* @__PURE__ */ __name((token, componentPrefixCls) => {
+  const { fontFamily, fontSize } = token;
+  const rootPrefixSelector = `[class^="${componentPrefixCls}"], [class*=" ${componentPrefixCls}"]`;
+  return {
+    [rootPrefixSelector]: {
+      fontFamily,
+      fontSize,
+      boxSizing: "border-box",
+      "&::before, &::after": {
+        boxSizing: "border-box"
+      },
+      [rootPrefixSelector]: {
+        boxSizing: "border-box",
+        "&::before, &::after": {
+          boxSizing: "border-box"
+        }
+      }
+    }
+  };
+}, "genCommonStyle");
+const genStyleHook = /* @__PURE__ */ __name((component, styleFn) => {
+  return (prefixCls) => {
+    const { theme, token, hashId } = (0, import_hooks.useToken)();
+    const { getPrefixCls, iconPrefixCls } = (0, import_hooks.useConfig)();
+    const rootPrefixCls = getPrefixCls();
+    return [
+      (0, import_cssinjs.useStyleRegister)(
+        {
+          theme,
+          token,
+          hashId,
+          path: ["formily-antd", component, prefixCls, iconPrefixCls]
+        },
+        () => {
+          const componentCls = `.${prefixCls}`;
+          const mergedToken = (0, import_schema.merge)(token, {
+            ...token["Form"],
+            // Merge the antd form token
+            componentCls,
+            prefixCls,
+            iconCls: `.${iconPrefixCls}`,
+            antCls: `.${rootPrefixCls}`
+          });
+          const styleInterpolation = styleFn(mergedToken, {
+            hashId,
+            prefixCls,
+            rootPrefixCls,
+            iconPrefixCls
+          });
+          return [genCommonStyle(token, prefixCls), styleInterpolation];
+        }
+      ),
+      hashId
+    ];
+  };
+}, "genStyleHook");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genCommonStyle,
+  genStyleHook
+});

package/lib/array-base/index.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { ArrayField, ReactFC, Schema } from '@tachybase/schema';
+import { ButtonProps } from 'antd';
+export interface IArrayBaseAdditionProps extends ButtonProps {
+    title?: string;
+    method?: 'push' | 'unshift';
+    defaultValue?: any;
+}
+export interface IArrayBaseContext {
+    props: IArrayBaseProps;
+    field: ArrayField;
+    schema: Schema;
+}
+export interface IArrayBaseItemProps {
+    index: number;
+    record: ((index: number) => Record<string, any>) | Record<string, any>;
+}
+type CommonProps = ButtonProps & {
+    index?: number;
+};
+export type ArrayBaseMixins = {
+    Addition: ReactFC<IArrayBaseAdditionProps>;
+    Copy: ReactFC<CommonProps>;
+    Remove: ReactFC<CommonProps>;
+    MoveUp: ReactFC<CommonProps>;
+    MoveDown: React.FC<React.PropsWithChildren<CommonProps>>;
+    SortHandle: ReactFC<CommonProps>;
+    Index: React.FC;
+    useArray: () => IArrayBaseContext | null;
+    useIndex: (index?: number) => number;
+    useRecord: (record?: number) => any;
+};
+export interface IArrayBaseProps {
+    disabled?: boolean;
+    onAdd?: (index: number) => void;
+    onCopy?: (index: number) => void;
+    onRemove?: (index: number) => void;
+    onMoveDown?: (index: number) => void;
+    onMoveUp?: (index: number) => void;
+}
+declare function mixin<T extends object = object>(target: T): T & ArrayBaseMixins;
+export declare const ArrayBase: ReactFC<IArrayBaseProps> & {
+    Item: ReactFC<IArrayBaseItemProps>;
+    Index: React.FC<React.HTMLAttributes<HTMLSpanElement>>;
+    SortHandle: ReactFC<CommonProps>;
+    Addition: ReactFC<IArrayBaseAdditionProps>;
+    Copy: React.ForwardRefExoticComponent<ButtonProps & {
+        index?: number;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    Remove: React.ForwardRefExoticComponent<ButtonProps & {
+        index?: number;
+    } & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+    MoveDown: React.ForwardRefExoticComponent<ButtonProps & {
+        index?: number;
+    } & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+    MoveUp: React.ForwardRefExoticComponent<ButtonProps & {
+        index?: number;
+    } & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+    useArray: () => IArrayBaseContext;
+    useIndex: (index?: number) => number;
+    useRecord: (record?: number) => any;
+    mixin: typeof mixin;
+};
+export default ArrayBase;