@antsoo-lib/components 0.1.2 → 0.1.4

package/src/form/FormItemInput.tsx

@@ -0,0 +1,114 @@
+import type { HTMLAttributes } from 'vue'
+import { computed, defineComponent } from 'vue'
+
+import classNames from '../_util/classNames'
+import { filterEmpty } from '../_util/props-util'
+import type { CustomSlotsType, VueNode } from '../_util/type'
+import type { ColProps } from '../grid/Col'
+import Col from '../grid/Col'
+import ErrorList from './ErrorList'
+import type { ValidateStatus } from './FormItem'
+import { useInjectForm, useProvideForm, useProvideFormItemPrefix } from './context'
+
+export interface FormItemInputMiscProps {
+  prefixCls: string
+  errors: VueNode[]
+  hasFeedback?: boolean
+  validateStatus?: ValidateStatus
+}
+
+export interface FormItemInputProps {
+  wrapperCol?: ColProps
+  help?: VueNode
+  extra?: VueNode
+  status?: ValidateStatus
+}
+
+const FormItemInput = defineComponent({
+  compatConfig: { MODE: 3 },
+  slots: Object as CustomSlotsType<{
+    help: any
+    errors: any
+    extra: any
+    default: any
+  }>,
+  inheritAttrs: false,
+  props: [
+    'prefixCls',
+    'errors',
+    'hasFeedback',
+    'onDomErrorVisibleChange',
+    'wrapperCol',
+    'help',
+    'extra',
+    'status',
+    'marginBottom',
+    'onErrorVisibleChanged',
+  ],
+  setup(props, { slots }) {
+    const formContext = useInjectForm()
+    const { wrapperCol: contextWrapperCol } = formContext
+
+    // Pass to sub FormItem should not with col info
+    const subFormContext = { ...formContext }
+    delete subFormContext.labelCol
+    delete subFormContext.wrapperCol
+    useProvideForm(subFormContext)
+    useProvideFormItemPrefix({
+      prefixCls: computed(() => props.prefixCls),
+      status: computed(() => props.status),
+    })
+
+    return () => {
+      const {
+        prefixCls,
+        wrapperCol,
+        marginBottom,
+        onErrorVisibleChanged,
+        help = slots.help?.(),
+        errors = filterEmpty(slots.errors?.()),
+        // hasFeedback,
+        // status,
+        extra = slots.extra?.(),
+      } = props
+      const baseClassName = `${prefixCls}-item`
+
+      const mergedWrapperCol: ColProps & HTMLAttributes =
+        wrapperCol || contextWrapperCol?.value || {}
+
+      const className = classNames(`${baseClassName}-control`, mergedWrapperCol.class)
+
+      // Should provides additional icon if `hasFeedback`
+      // const IconNode = status && iconMap[status];
+      return (
+        <Col
+          {...mergedWrapperCol}
+          class={className}
+          v-slots={{
+            default: () => (
+              <>
+                <div class={`${baseClassName}-control-input`}>
+                  <div class={`${baseClassName}-control-input-content`}>{slots.default?.()}</div>
+                </div>
+                {marginBottom !== null || errors.length ? (
+                  <div style={{ display: 'flex', flexWrap: 'nowrap' }}>
+                    <ErrorList
+                      errors={errors}
+                      help={help}
+                      class={`${baseClassName}-explain-connected`}
+                      onErrorVisibleChanged={onErrorVisibleChanged}
+                    />
+                    {!!marginBottom && <div style={{ width: 0, height: `${marginBottom}px` }} />}
+                  </div>
+                ) : null}
+                {extra ? <div class={`${baseClassName}-extra`}>{extra}</div> : null}
+              </>
+            ),
+          }}
+        ></Col>
+      )
+    }
+  },
+})
+
+export default FormItemInput

package/src/form/FormItemLabel.tsx

@@ -0,0 +1,118 @@
+import QuestionCircleOutlined from '@ant-design/icons-vue/QuestionCircleOutlined'
+
+import type { FunctionalComponent, HTMLAttributes } from 'vue'
+
+import classNames from '../_util/classNames'
+import type { VueNode } from '../_util/type'
+import type { ColProps } from '../grid/Col'
+import Col from '../grid/Col'
+import { useLocaleReceiver } from '../locale-provider/LocaleReceiver'
+import defaultLocale from '../locale/en_US'
+import Tooltip from '../tooltip'
+import type { RequiredMark } from './Form'
+import { useInjectForm } from './context'
+import type { FormLabelAlign } from './interface'
+
+export interface FormItemLabelProps {
+  colon?: boolean
+  htmlFor?: string
+  label?: VueNode
+  labelAlign?: FormLabelAlign
+  labelCol?: ColProps & HTMLAttributes
+  requiredMark?: RequiredMark
+  required?: boolean
+  prefixCls: string
+  onClick: Function
+  tooltip: string
+}
+
+const FormItemLabel: FunctionalComponent<FormItemLabelProps> = (props, { slots, emit, attrs }) => {
+  const { prefixCls, htmlFor, labelCol, labelAlign, colon, required, requiredMark } = {
+    ...props,
+    ...attrs,
+  }
+  const [formLocale] = useLocaleReceiver('Form')
+  const label = props.label ?? slots.label?.()
+  if (!label) return null
+  const {
+    vertical,
+    labelAlign: contextLabelAlign,
+    labelCol: contextLabelCol,
+    labelWrap,
+    colon: contextColon,
+  } = useInjectForm()
+  const mergedLabelCol: FormItemLabelProps['labelCol'] = labelCol || contextLabelCol?.value || {}
+
+  const mergedLabelAlign: FormLabelAlign | undefined = labelAlign || contextLabelAlign?.value
+
+  const labelClsBasic = `${prefixCls}-item-label`
+  const labelColClassName = classNames(
+    labelClsBasic,
+    mergedLabelAlign === 'left' && `${labelClsBasic}-left`,
+    mergedLabelCol.class,
+    {
+      [`${labelClsBasic}-wrap`]: !!labelWrap.value,
+    },
+  )
+
+  let labelChildren = label
+  // Keep label is original where there should have no colon
+  const computedColon = colon === true || (contextColon?.value !== false && colon !== false)
+  const haveColon = computedColon && !vertical.value
+  // Remove duplicated user input colon
+  if (haveColon && typeof label === 'string' && (label as string).trim() !== '') {
+    labelChildren = (label as string).replace(/[:|：]\s*$/, '')
+  }
+
+  // Tooltip
+  if (props.tooltip || slots.tooltip) {
+    const tooltipNode = (
+      <span class={`${prefixCls}-item-tooltip`}>
+        <Tooltip title={props.tooltip}>
+          <QuestionCircleOutlined />
+        </Tooltip>
+      </span>
+    )
+
+    labelChildren = (
+      <>
+        {labelChildren}
+        {slots.tooltip ? slots.tooltip?.({ class: `${prefixCls}-item-tooltip` }) : tooltipNode}
+      </>
+    )
+  }
+
+  // Add required mark if optional
+  if (requiredMark === 'optional' && !required) {
+    labelChildren = (
+      <>
+        {labelChildren}
+        <span class={`${prefixCls}-item-optional`}>
+          {formLocale.value?.optional || defaultLocale.Form?.optional}
+        </span>
+      </>
+    )
+  }
+  const labelClassName = classNames({
+    [`${prefixCls}-item-required`]: required,
+    [`${prefixCls}-item-required-mark-optional`]: requiredMark === 'optional',
+    [`${prefixCls}-item-no-colon`]: !computedColon,
+  })
+  return (
+    <Col {...mergedLabelCol} class={labelColClassName}>
+      <label
+        for={htmlFor}
+        class={labelClassName}
+        title={typeof label === 'string' ? label : ''}
+        onClick={(e) => emit('click', e)}
+      >
+        {labelChildren}
+      </label>
+    </Col>
+  )
+}
+
+FormItemLabel.displayName = 'FormItemLabel'
+FormItemLabel.inheritAttrs = false
+
+export default FormItemLabel

package/src/form/context.ts

@@ -0,0 +1,78 @@
+import type { ComputedRef, InjectionKey } from 'vue'
+import { computed, inject, provide } from 'vue'
+
+import type { ColProps } from '../grid'
+import type { RequiredMark } from './Form'
+import type { FieldExpose, ValidateStatus } from './FormItem'
+import type { FormLabelAlign, Rule, ValidateMessages } from './interface'
+import { defaultValidateMessages } from './utils/messages'
+
+export interface FormContextProps {
+  model?: ComputedRef<any>
+  vertical: ComputedRef<boolean>
+  name?: ComputedRef<string>
+  colon?: ComputedRef<boolean>
+  labelAlign?: ComputedRef<FormLabelAlign>
+  labelWrap?: ComputedRef<boolean>
+  labelCol?: ComputedRef<ColProps>
+  wrapperCol?: ComputedRef<ColProps>
+  requiredMark?: ComputedRef<RequiredMark>
+  //itemRef: (name: (string | number)[]) => (node: React.ReactElement) => void;
+  addField: (eventKey: string, field: FieldExpose) => void
+  removeField: (eventKey: string) => void
+  validateTrigger?: ComputedRef<string | string[]>
+  rules?: ComputedRef<{ [k: string]: Rule[] | Rule }>
+  onValidate: (
+    name: string | number | Array<string | number>,
+    status: boolean,
+    errors: string[] | null,
+  ) => void
+  validateMessages: ComputedRef<ValidateMessages>
+}
+
+export const FormContextKey: InjectionKey<FormContextProps> = Symbol('formContextKey')
+
+export const useProvideForm = (state: FormContextProps) => {
+  provide(FormContextKey, state)
+}
+
+export const useInjectForm = () => {
+  return inject(FormContextKey, {
+    name: computed(() => undefined),
+    labelAlign: computed(() => 'right' as FormLabelAlign),
+    vertical: computed(() => false),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    addField: (_eventKey: string, _field: FieldExpose) => {},
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    removeField: (_eventKey: string) => {},
+    model: computed(() => undefined),
+    rules: computed(() => undefined),
+    colon: computed(() => undefined),
+    labelWrap: computed(() => undefined),
+    labelCol: computed(() => undefined),
+    requiredMark: computed(() => false),
+    validateTrigger: computed(() => undefined),
+    onValidate: () => {},
+    validateMessages: computed(() => defaultValidateMessages),
+  } as FormContextProps)
+}
+
+/** Used for ErrorList only */
+export interface FormItemPrefixContextProps {
+  prefixCls: ComputedRef<string>
+  status?: ComputedRef<ValidateStatus>
+}
+
+export const FormItemPrefixContextKey: InjectionKey<FormItemPrefixContextProps> = Symbol(
+  'formItemPrefixContextKey',
+)
+
+export const useProvideFormItemPrefix = (state: FormItemPrefixContextProps) => {
+  provide(FormItemPrefixContextKey, state)
+}
+
+export const useInjectFormItemPrefix = () => {
+  return inject(FormItemPrefixContextKey, {
+    prefixCls: computed(() => ''),
+  })
+}

package/src/form/index.en-US.md

@@ -0,0 +1,255 @@
+---
+category: Components
+type: Data Entry
+cols: 1
+title: Form
+cover: https://mdn.alipayobjects.com/huamei_7uahnr/afts/img/A*-lcdS5Qm1bsAAAAAAAAAAAAADrJ8AQ/original
+coverDark: https://mdn.alipayobjects.com/huamei_7uahnr/afts/img/A*ylFATY6w-ygAAAAAAAAAAAAADrJ8AQ/original
+---
+
+High performance Form component with data scope management. Including data collection, verification, and styles.
+
+## When to use
+
+- When you need to create an instance or collect information.
+- When you need to validate fields in certain rules.
+
+## Form Component
+
+You can align the controls of a `form` using the `layout` prop：
+
+- `horizontal`：to horizontally align the `label`s and controls of the fields. (Default)
+- `vertical`：to vertically align the `label`s and controls of the fields.
+- `inline`：to render form fields in one line.
+
+## Form Item Component
+
+A form consists of one or more form fields whose type includes input, textarea, checkbox, radio, select, tag, and more. A form field is defined using `<a-form-item />`.
+
+## API
+
+### Form
+
+| Property             | Description                                                                                                                                    | Type                                                                                 | Default Value | Version |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------- | ------- |
+| colon                | change default props colon value of Form.Item (only effective when prop layout is horizontal)                                                  | boolean                                                                              | true          |         |
+| disabled             | Set form component disable, only available for antdv components                                                                                | boolean                                                                              | false         | 4.0     |
+| hideRequiredMark     | Hide required mark of all form items                                                                                                           | Boolean                                                                              | false         |         |
+| labelAlign           | text align of label of all items                                                                                                               | 'left' \| 'right'                                                                    | 'right'       |         |
+| labelCol             | The layout of label. You can set `span` `offset` to something like `{span: 3, offset: 12}` or `sm: {span: 3, offset: 12}` same as with `<Col>` | [object](/components/grid/#col)                                                      |               |         |
+| labelWrap            | whether label can be wrap                                                                                                                      | boolean                                                                              | false         | 3.0     |
+| layout               | Define form layout                                                                                                                             | 'horizontal'\|'vertical'\|'inline'                                                   | 'horizontal'  |         |
+| model                | data of form component                                                                                                                         | object                                                                               |               |         |
+| name                 | Form name. Will be the prefix of Field `id`                                                                                                    | string                                                                               | -             | 2.0.0   |
+| noStyle              | No style for `true`, used as a pure field control                                                                                              | boolean                                                                              | false         | 3.0     |
+| rules                | validation rules of form                                                                                                                       | object                                                                               |               |         |
+| scrollToFirstError   | Auto scroll to first failed field when submit                                                                                                  | boolean \| [options](https://github.com/stipsan/scroll-into-view-if-needed/#options) | false         | 2.0.0   |
+| validateOnRuleChange | whether to trigger validation when the `rules` prop is changed                                                                                 | boolean                                                                              | true          |         |
+| validateTrigger      | Config field validate trigger                                                                                                                  | string \| string\[]                                                                  | `change`      | 2.0.0   |
+| wrapperCol           | The layout for input controls, same as `labelCol`                                                                                              | [object](/components/grid/#col)                                                      |               |         |
+
+### Events
+
+| Events Name  | Description                                                              | Arguments                                    | Version |       |
+| ------------ | ------------------------------------------------------------------------ | -------------------------------------------- | ------- | ----- |
+| finish       | Trigger after submitting the form and verifying data successfully        | function(values)                             | -       | 2.0.0 |
+| finishFailed | Trigger after submitting the form and verifying data failed              | function({ values, errorFields, outOfDate }) | -       | 2.0.0 |
+| submit       | Defines a function will be called if form data validation is successful. | Function(e:Event)                            |         |       |
+| validate     | triggers after a form item is validated                                  | Function(name, status, errorMsgs)            |         |       |
+
+### Methods
+
+| Method         | Description                                                                                                                                                                                                        | Parameters                                                                                                                                                                      | Version |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
+| clearValidate  | clear validation message for certain fields. The parameter is name or an array of names of the form items whose validation messages will be removed. When omitted, all fields' validation messages will be cleared | (nameList?: [NamePath](#namepath)\[]) => void                                                                                                                                   |         |
+| resetFields    | reset all the fields and remove validation result                                                                                                                                                                  | (nameList?: [NamePath](#namepath)\[]) => void                                                                                                                                   |         |
+| scrollToField  | Scroll to field position                                                                                                                                                                                           | (name: [NamePath](#namepath), options: \[[ScrollOptions](https://github.com/stipsan/scroll-into-view-if-needed/tree/ece40bd9143f48caf4b99503425ecb16b0ad8249#options)]) => void |         |
+| validate       | Validate fields, it is same as validateFields                                                                                                                                                                      | (nameList?: [NamePath](#namepath)\[]) => Promise                                                                                                                                |         |
+| validateFields | Validate fields                                                                                                                                                                                                    | (nameList?: [NamePath](#namepath)\[]) => Promise                                                                                                                                |         |
+
+#### NamePath
+
+`string | number | (string | number)[]`
+
+### Form.Item
+
+| Property        | Description                                                                                                                                                                                                      | Type                            | Default Value | Version |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------- | ------------- | ------- |
+| autoLink        | Whether to automatically associate form fields. In most cases, you can use automatic association. If the conditions for automatic association are not met, you can manually associate them. See the notes below. | boolean                         | true          |         |
+| colon           | Used with `label`, whether to display `:` after label text.                                                                                                                                                      | boolean                         | true          |         |
+| extra           | The extra prompt message. It is similar to help. Usage example: to display error message and prompt message at the same time.                                                                                    | string\|slot                    |               |         |
+| hasFeedback     | Used with `validateStatus`, this option specifies the validation status icon. Recommended to be used only with `Input`.                                                                                          | boolean                         | false         |         |
+| help            | The prompt message. If not provided, the prompt message will be generated by the validation rule.                                                                                                                | string\|slot                    |               |         |
+| htmlFor         | Set sub label `htmlFor`.                                                                                                                                                                                         | string                          |               |         |
+| label           | Label text                                                                                                                                                                                                       | string\|slot                    |               |         |
+| labelAlign      | text align of label                                                                                                                                                                                              | 'left' \| 'right'               | 'right'       |         |
+| labelCol        | The layout of label. You can set `span` `offset` to something like `{span: 3, offset: 12}` or `sm: {span: 3, offset: 12}` same as with `<Col>`                                                                   | [object](/components/grid/#col) |               |         |
+| name            | a key of `model`. In the use of validate and resetFields method, the attribute is required                                                                                                                       | [NamePath](#namepath)           |               | 2.0.0   |
+| required        | Whether provided or not, it will be generated by the validation rule.                                                                                                                                            | boolean                         | false         |         |
+| rules           | validation rules of form                                                                                                                                                                                         | object \| array                 |               |         |
+| tooltip         | Config tooltip info                                                                                                                                                                                              | string \| slot                  |               | 4.0.4   |
+| validateFirst   | Whether stop validate on first rule of error for this field.                                                                                                                                                     | boolean                         | false         |         |
+| validateStatus  | The validation status. If not provided, it will be generated by validation rule. options: 'success' 'warning' 'error' 'validating'                                                                               | string                          |               |         |
+| validateTrigger | When to validate the value of children node                                                                                                                                                                      | string \| string\[]             | `change`      |         |
+| wrapperCol      | The layout for input controls, same as `labelCol`                                                                                                                                                                | [object](/components/grid/#col) |               |         |
+
+### Note
+
+#### 3.x
+
+Since version 3.0, Form.Item no longer hijacks child elements, but automatically checks through provider/inject dependency injection. This method can improve component performance, and there is no limit to the number of child elements. The same is true for child elements. It can be a high-level component that is further encapsulated.
+
+You can reference [Customized Form Controls](#components-form-demo-customized-form-controls)
+
+But it also has some disadvantages:
+
+1. If the custom component wants Form.Item to be verified and displayed, you need to inject `const {id, onFieldChange, onFieldBlur} = useInjectFormItemContext()` and call the corresponding method.
+
+2. A Form.Item can only collect the data of one form item. If there are multiple form items, it will cause collection confusion, for example,
+
+```html
+<a-form-item>
+  <a-input name="a"></a-input>
+  <a-input name="b"></a-input>
+</a-form-item>
+```
+
+As above Form.Item does not know whether to collect `name="a"` or `name="b"`, you can solve this kind of problem in the following two ways:
+
+The first is to use multiple `a-form-item`:
+
+```html
+<a-form-item>
+  <a-input name="a"></a-input>
+  <a-form-item><a-input name="b"></a-input></a-form-item>
+</a-form-item>
+```
+
+The second way is to wrap it with a custom component and call `useInjectFormItemContext` in the custom component, It is equivalent to merging multiple form items into one.
+
+```html
+<script>
+  // custom component
+  import { Form } from 'ant-design-vue'
+
+  export default {
+    name: 'custom-name',
+    setup() {
+      const formItemContext = Form.useInjectFormItemContext()
+    },
+  }
+</script>
+```
+
+```html
+<a-form-item>
+  <custom-com>
+    <a-input name="a"></a-input>
+    <a-input name="b"></a-input>
+  </custom-com>
+</a-form-item>
+```
+
+Third, the component library provides an `a-form-item-rest` component, which will prevent data collection. You can put form items that do not need to be collected and verified into this component. It is the same as the first This method is very similar, but it does not generate additional dom nodes.
+
+```html
+<a-form-item>
+  <a-input name="a"></a-input>
+  <a-form-item-rest><a-input name="b"></a-input></a-form-item-rest>
+</a-form-item>
+```
+
+#### 2.x
+
+Form.Item hijacks the only child element and listens to the `blur` and `change` events to achieve the purpose of automatic verification, so please make sure that the form field is not wrapped by other elements. If there are multiple child elements, only the change of the first child element will be monitored.
+
+If the form field to be monitored does not meet the conditions of automatic monitoring, you can associate the form field as follows:
+
+```html
+<a-form-item name="form.name" ref="name" :autoLink="false">
+  <a-input v-model:value="other" />
+  <span>hahha</span>
+  <div>
+    <a-input
+      v-model:value="form.name"
+      @blur="() => {$refs.name.onFieldBlur()}"
+      @change="() => {$refs.name.onFieldChange()}"
+    />
+  </div>
+</a-form-item>
+```
+
+### Validation Rules
+
+| Property   | Description                                                                                                      | Type                                       | Default Value |
+| ---------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------ | ------------- |
+| enum       | validate a value from a list of possible values                                                                  | string                                     | -             |
+| len        | validate an exact length of a field                                                                              | number                                     | -             |
+| max        | validate a max length of a field                                                                                 | number                                     | -             |
+| message    | validation error message                                                                                         | string                                     | -             |
+| min        | validate a min length of a field                                                                                 | number                                     | -             |
+| pattern    | validate from a regular expression                                                                               | RegExp                                     | -             |
+| required   | indicates whether field is required                                                                              | boolean                                    | `false`       |
+| transform  | transform a value before validation                                                                              | function(value) => transformedValue:any    | -             |
+| trigger    | When to validate the value of children node.                                                                     | 'blur' \| 'change' \| `['change', 'blur']` | -             |
+| type       | built-in validation type, [available options](https://github.com/yiminghe/async-validator#type)                  | string                                     | 'string'      |
+| validator  | custom validate function (Note: [callback must be called](https://github.com/ant-design/ant-design/issues/5155)) | function(rule, value, callback)            | -             |
+| whitespace | treat required fields that only contain whitespace as errors                                                     | boolean                                    | `false`       |
+
+See more advanced usage at [async-validator](https://github.com/yiminghe/async-validator).
+
+### useForm (v2.2)
+
+`useForm` is a method that can run independently of the Form component. It uses the Vue response mechanism to monitor and verify data, and returns the verification result. You can bind the verification result to any component, `Form. Item` only displays the results.
+
+The following versions need to be provided separately by `@ant-design-vue/use` library, it is not recommended to continue to use, you should upgrade to version 2.2+ as soon as possible
+
+```ts
+import { Form } from 'ant-design-vue'
+
+const useForm = Form.useForm
+
+useForm(modelRef, ruleRef, [options])
+```
+
+Parameter Description:
+
+```ts
+/*
+ `modelRef`, `ruleRef` must be responsive data
+*/
+
+interface Props {
+  [key: string]: any
+}
+function useForm(
+  modelRef: Props | Ref<Props>,
+  rulesRef?: Props | Ref<Props>,
+  options?: {
+    immediate?: boolean
+    deep?: boolean
+    validateOnRuleChange?: boolean
+    debounce?: DebounceSettings
+  },
+): {
+  modelRef: Props | Ref<Props>
+  rulesRef: Props | Ref<Props>
+  initialModel: Props
+  validateInfos: validateInfos
+  resetFields: (newValues?: Props) => void
+  validate: <T = any>(names?: namesType, option?: validateOptions) => Promise<T>
+  validateField: (
+    name?: string,
+    value?: any,
+    rules?: [Record<string, unknown>],
+    option?: validateOptions,
+  ) => Promise<RuleError[]>
+  mergeValidateInfo: (items: ValidateInfo | ValidateInfo[]) => ValidateInfo
+  clearValidate: (names?: namesType) => void
+  onValidate?: (
+    name: string | number | string[] | number[],
+    status: boolean,
+    errorMsgs: string[] | null,
+  ) => void
+}
+```

package/src/form/index.tsx

@@ -0,0 +1,31 @@
+import type { App, Plugin } from 'vue'
+
+import Form, { formProps } from './Form'
+import FormItem, { formItemProps } from './FormItem'
+import FormItemRest, { useInjectFormItemContext } from './FormItemContext'
+import useForm from './useForm'
+
+export type { Rule, RuleObject } from './interface'
+
+export type { FormInstance, FormProps } from './Form'
+export type { FormItemInstance, FormItemProps } from './FormItem'
+
+Form.useInjectFormItemContext = useInjectFormItemContext
+Form.ItemRest = FormItemRest
+/* istanbul ignore next */
+Form.install = function (app: App) {
+  app.component(Form.name, Form)
+  app.component(Form.Item.name, Form.Item)
+  app.component(FormItemRest.name, FormItemRest)
+  return app
+}
+
+export { FormItem, formItemProps, FormItemRest, formProps, useForm, useInjectFormItemContext }
+
+export default Form as typeof Form &
+  Plugin & {
+    readonly Item: typeof Form.Item
+    readonly ItemRest: typeof FormItemRest
+    readonly useForm: typeof useForm
+    readonly useInjectFormItemContext: typeof useInjectFormItemContext
+  }