2021-04-14 00:57:32 +00:00
|
|
|
import Button from 'react-bootstrap/Button'
|
|
|
|
import InputGroup from 'react-bootstrap/InputGroup'
|
|
|
|
import BootstrapForm from 'react-bootstrap/Form'
|
|
|
|
import Alert from 'react-bootstrap/Alert'
|
2022-07-30 13:25:46 +00:00
|
|
|
import { Formik, Form as FormikForm, useFormikContext, useField, FieldArray } from 'formik'
|
2023-06-12 22:39:20 +00:00
|
|
|
import React, { createContext, useContext, useEffect, useRef, useState } from 'react'
|
2021-05-13 13:28:38 +00:00
|
|
|
import copy from 'clipboard-copy'
|
|
|
|
import Thumb from '../svgs/thumb-up-fill.svg'
|
2022-09-18 01:45:21 +00:00
|
|
|
import { Col, Dropdown as BootstrapDropdown, Nav } from 'react-bootstrap'
|
2021-07-01 23:51:58 +00:00
|
|
|
import Markdown from '../svgs/markdown-line.svg'
|
|
|
|
import styles from './form.module.css'
|
|
|
|
import Text from '../components/text'
|
2022-07-30 13:25:46 +00:00
|
|
|
import AddIcon from '../svgs/add-fill.svg'
|
2022-08-10 15:06:31 +00:00
|
|
|
import { mdHas } from '../lib/md'
|
2022-08-25 18:46:07 +00:00
|
|
|
import CloseIcon from '../svgs/close-line.svg'
|
2022-08-26 22:20:09 +00:00
|
|
|
import { useLazyQuery } from '@apollo/client'
|
|
|
|
import { USER_SEARCH } from '../fragments/users'
|
2021-04-14 00:57:32 +00:00
|
|
|
|
2022-02-17 17:23:43 +00:00
|
|
|
export function SubmitButton ({
|
2023-05-18 18:02:19 +00:00
|
|
|
children, variant, value, onClick, disabled, ...props
|
2022-02-17 17:23:43 +00:00
|
|
|
}) {
|
2021-09-10 18:55:36 +00:00
|
|
|
const { isSubmitting, setFieldValue } = useFormikContext()
|
2021-04-14 00:57:32 +00:00
|
|
|
return (
|
|
|
|
<Button
|
|
|
|
variant={variant || 'main'}
|
|
|
|
type='submit'
|
2023-05-18 18:02:19 +00:00
|
|
|
disabled={disabled || isSubmitting}
|
2021-09-10 18:55:36 +00:00
|
|
|
onClick={value
|
|
|
|
? e => {
|
|
|
|
setFieldValue('submit', value)
|
|
|
|
onClick && onClick(e)
|
|
|
|
}
|
|
|
|
: onClick}
|
2021-04-14 00:57:32 +00:00
|
|
|
{...props}
|
|
|
|
>
|
|
|
|
{children}
|
|
|
|
</Button>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-05-13 13:28:38 +00:00
|
|
|
export function CopyInput (props) {
|
|
|
|
const [copied, setCopied] = useState(false)
|
|
|
|
|
|
|
|
const handleClick = () => {
|
|
|
|
copy(props.placeholder)
|
|
|
|
setCopied(true)
|
|
|
|
setTimeout(() => setCopied(false), 1500)
|
|
|
|
}
|
|
|
|
|
|
|
|
return (
|
|
|
|
<Input
|
|
|
|
onClick={handleClick}
|
2021-06-02 23:15:28 +00:00
|
|
|
append={
|
|
|
|
<Button
|
|
|
|
size={props.size}
|
|
|
|
onClick={handleClick}
|
|
|
|
>
|
|
|
|
{copied ? <Thumb width={18} height={18} /> : 'copy'}
|
|
|
|
</Button>
|
|
|
|
}
|
2021-05-13 13:28:38 +00:00
|
|
|
{...props}
|
|
|
|
/>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2022-01-23 17:21:55 +00:00
|
|
|
export function InputSkeleton ({ label, hint }) {
|
2021-05-13 13:28:38 +00:00
|
|
|
return (
|
|
|
|
<BootstrapForm.Group>
|
|
|
|
{label && <BootstrapForm.Label>{label}</BootstrapForm.Label>}
|
2021-11-04 18:22:03 +00:00
|
|
|
<div className='form-control clouds' />
|
2022-01-23 17:21:55 +00:00
|
|
|
{hint &&
|
|
|
|
<BootstrapForm.Text>
|
|
|
|
{hint}
|
|
|
|
</BootstrapForm.Text>}
|
2021-05-13 13:28:38 +00:00
|
|
|
</BootstrapForm.Group>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-06-12 22:39:20 +00:00
|
|
|
export function MarkdownInput ({ label, topLevel, groupClassName, onChange, setHasImgLink, onKeyDown, innerRef, ...props }) {
|
2021-07-01 23:51:58 +00:00
|
|
|
const [tab, setTab] = useState('write')
|
2023-06-12 22:39:20 +00:00
|
|
|
const [, meta, helpers] = useField(props)
|
|
|
|
const [selectionRange, setSelectionRange] = useState({ start: 0, end: 0 })
|
|
|
|
innerRef = innerRef || useRef(null)
|
2021-07-01 23:51:58 +00:00
|
|
|
|
|
|
|
useEffect(() => {
|
|
|
|
!meta.value && setTab('write')
|
|
|
|
}, [meta.value])
|
|
|
|
|
2023-06-12 22:39:20 +00:00
|
|
|
useEffect(() => {
|
|
|
|
if (selectionRange.start <= selectionRange.end && innerRef?.current) {
|
|
|
|
const { start, end } = selectionRange
|
|
|
|
const input = innerRef.current
|
|
|
|
input.setSelectionRange(start, end)
|
|
|
|
}
|
2023-06-13 14:19:50 +00:00
|
|
|
}, [innerRef, selectionRange.start, selectionRange.end])
|
2023-06-12 22:39:20 +00:00
|
|
|
|
2021-07-01 23:51:58 +00:00
|
|
|
return (
|
|
|
|
<FormGroup label={label} className={groupClassName}>
|
|
|
|
<div className={`${styles.markdownInput} ${tab === 'write' ? styles.noTopLeftRadius : ''}`}>
|
|
|
|
<Nav variant='tabs' defaultActiveKey='write' activeKey={tab} onSelect={tab => setTab(tab)}>
|
|
|
|
<Nav.Item>
|
|
|
|
<Nav.Link eventKey='write'>write</Nav.Link>
|
|
|
|
</Nav.Item>
|
|
|
|
<Nav.Item>
|
|
|
|
<Nav.Link eventKey='preview' disabled={!meta.value}>preview</Nav.Link>
|
|
|
|
</Nav.Item>
|
|
|
|
<a
|
|
|
|
className='ml-auto text-muted d-flex align-items-center'
|
|
|
|
href='https://guides.github.com/features/mastering-markdown/' target='_blank' rel='noreferrer'
|
|
|
|
>
|
|
|
|
<Markdown width={18} height={18} />
|
|
|
|
</a>
|
|
|
|
</Nav>
|
|
|
|
<div className={tab !== 'write' ? 'd-none' : ''}>
|
|
|
|
<InputInner
|
2022-08-10 15:06:31 +00:00
|
|
|
{...props} onChange={(formik, e) => {
|
|
|
|
if (onChange) onChange(formik, e)
|
|
|
|
if (setHasImgLink) {
|
|
|
|
setHasImgLink(mdHas(e.target.value, ['link', 'image']))
|
|
|
|
}
|
|
|
|
}}
|
2023-06-12 22:39:20 +00:00
|
|
|
innerRef={innerRef}
|
|
|
|
onKeyDown={(e) => {
|
|
|
|
const metaOrCtrl = e.metaKey || e.ctrlKey
|
|
|
|
if (metaOrCtrl) {
|
|
|
|
if (e.key === 'k') {
|
|
|
|
// some browsers use CTRL+K to focus search bar so we have to prevent that behavior
|
|
|
|
e.preventDefault()
|
|
|
|
insertMarkdownLinkFormatting(innerRef.current, helpers.setValue, setSelectionRange)
|
|
|
|
}
|
|
|
|
if (e.key === 'b') {
|
|
|
|
// some browsers use CTRL+B to open bookmarks so we have to prevent that behavior
|
|
|
|
e.preventDefault()
|
|
|
|
insertMarkdownBoldFormatting(innerRef.current, helpers.setValue, setSelectionRange)
|
|
|
|
}
|
|
|
|
if (e.key === 'i') {
|
|
|
|
// some browsers might use CTRL+I to do something else so prevent that behavior too
|
|
|
|
e.preventDefault()
|
|
|
|
insertMarkdownItalicFormatting(innerRef.current, helpers.setValue, setSelectionRange)
|
|
|
|
}
|
2023-06-19 18:07:06 +00:00
|
|
|
if (e.key === 'Tab' && e.altKey) {
|
|
|
|
e.preventDefault()
|
|
|
|
insertMarkdownTabFormatting(innerRef.current, helpers.setValue, setSelectionRange)
|
|
|
|
}
|
2023-06-12 22:39:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (onKeyDown) onKeyDown(e)
|
|
|
|
}}
|
2021-07-01 23:51:58 +00:00
|
|
|
/>
|
|
|
|
</div>
|
2021-08-10 22:59:06 +00:00
|
|
|
<div className={tab !== 'preview' ? 'd-none' : 'form-group'}>
|
|
|
|
<div className={`${styles.text} form-control`}>
|
2022-07-17 15:33:55 +00:00
|
|
|
{tab === 'preview' && <Text topLevel={topLevel} noFragments>{meta.value}</Text>}
|
2021-07-01 23:51:58 +00:00
|
|
|
</div>
|
|
|
|
</div>
|
|
|
|
</div>
|
|
|
|
</FormGroup>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-06-12 17:29:50 +00:00
|
|
|
function insertMarkdownFormatting (replaceFn, selectFn) {
|
|
|
|
return function (input, setValue, setSelectionRange) {
|
|
|
|
const start = input.selectionStart
|
|
|
|
const end = input.selectionEnd
|
|
|
|
const val = input.value
|
|
|
|
const selectedText = val.substring(start, end)
|
|
|
|
const mdFormatted = replaceFn(selectedText)
|
|
|
|
const newVal = val.substring(0, start) + mdFormatted + val.substring(end)
|
|
|
|
setValue(newVal)
|
|
|
|
// required for undo, see https://stackoverflow.com/a/27028258
|
|
|
|
document.execCommand('insertText', false, mdFormatted)
|
|
|
|
// see https://github.com/facebook/react/issues/6483
|
|
|
|
// for why we don't use `input.setSelectionRange` directly (hint: event order)
|
2023-06-19 18:07:06 +00:00
|
|
|
setSelectionRange(selectFn ? selectFn(start, end, mdFormatted) : { start: start + mdFormatted.length, end: start + mdFormatted.length })
|
2023-06-12 17:29:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-19 18:07:06 +00:00
|
|
|
const insertMarkdownTabFormatting = insertMarkdownFormatting(
|
|
|
|
val => `\t${val}`,
|
|
|
|
(start, end, mdFormatted) => ({ start: start + 1, end: end + 1 }) // move inside tab
|
|
|
|
)
|
2023-06-12 17:29:50 +00:00
|
|
|
const insertMarkdownLinkFormatting = insertMarkdownFormatting(
|
|
|
|
val => `[${val}](url)`,
|
2023-06-19 18:07:06 +00:00
|
|
|
(start, end, mdFormatted) => (
|
|
|
|
start === end
|
|
|
|
? { start: start + 1, end: end + 1 } // move inside brackets
|
|
|
|
: { start: start + mdFormatted.length - 4, end: start + mdFormatted.length - 1 }) // move to select url part
|
|
|
|
)
|
|
|
|
const insertMarkdownBoldFormatting = insertMarkdownFormatting(
|
|
|
|
val => `**${val}**`,
|
|
|
|
(start, end, mdFormatted) => ({ start: start + 2, end: end + 2 }) // move inside bold
|
|
|
|
)
|
|
|
|
const insertMarkdownItalicFormatting = insertMarkdownFormatting(
|
|
|
|
val => `_${val}_`,
|
|
|
|
(start, end, mdFormatted) => ({ start: start + 1, end: end + 1 }) // move inside italic
|
2023-06-12 17:29:50 +00:00
|
|
|
)
|
|
|
|
|
2021-07-01 23:51:58 +00:00
|
|
|
function FormGroup ({ className, label, children }) {
|
2021-04-14 00:57:32 +00:00
|
|
|
return (
|
2021-07-01 23:51:58 +00:00
|
|
|
<BootstrapForm.Group className={className}>
|
2021-04-14 00:57:32 +00:00
|
|
|
{label && <BootstrapForm.Label>{label}</BootstrapForm.Label>}
|
2021-07-01 23:51:58 +00:00
|
|
|
{children}
|
|
|
|
</BootstrapForm.Group>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2022-01-07 18:28:23 +00:00
|
|
|
function InputInner ({
|
|
|
|
prepend, append, hint, showValid, onChange, overrideValue,
|
2023-05-11 19:34:42 +00:00
|
|
|
innerRef, noForm, clear, onKeyDown, ...props
|
2022-01-07 18:28:23 +00:00
|
|
|
}) {
|
2022-08-18 18:15:24 +00:00
|
|
|
const [field, meta, helpers] = noForm ? [{}, {}, {}] : useField(props)
|
|
|
|
const formik = noForm ? null : useFormikContext()
|
2023-05-11 19:34:42 +00:00
|
|
|
const storageKeyPrefix = useContext(StorageKeyPrefixContext)
|
2021-08-22 15:25:17 +00:00
|
|
|
|
2022-01-07 18:28:23 +00:00
|
|
|
const storageKey = storageKeyPrefix ? storageKeyPrefix + '-' + props.name : undefined
|
|
|
|
|
2021-08-22 15:25:17 +00:00
|
|
|
useEffect(() => {
|
|
|
|
if (overrideValue) {
|
|
|
|
helpers.setValue(overrideValue)
|
2022-01-07 18:28:23 +00:00
|
|
|
if (storageKey) {
|
2022-01-08 15:31:37 +00:00
|
|
|
localStorage.setItem(storageKey, overrideValue)
|
2022-01-07 18:28:23 +00:00
|
|
|
}
|
|
|
|
} else if (storageKey) {
|
2022-01-08 15:31:37 +00:00
|
|
|
const draft = localStorage.getItem(storageKey)
|
2022-01-07 18:28:23 +00:00
|
|
|
if (draft) {
|
|
|
|
// for some reason we have to turn off validation to get formik to
|
|
|
|
// not assume this is invalid
|
|
|
|
helpers.setValue(draft, false)
|
|
|
|
}
|
2021-08-22 15:25:17 +00:00
|
|
|
}
|
|
|
|
}, [overrideValue])
|
|
|
|
|
2023-05-11 19:34:42 +00:00
|
|
|
const invalid = (!formik || formik.submitCount > 0) && meta.touched && meta.error
|
2022-08-25 18:46:07 +00:00
|
|
|
|
2021-07-01 23:51:58 +00:00
|
|
|
return (
|
|
|
|
<>
|
2021-04-14 00:57:32 +00:00
|
|
|
<InputGroup hasValidation>
|
|
|
|
{prepend && (
|
|
|
|
<InputGroup.Prepend>
|
2021-05-13 13:28:38 +00:00
|
|
|
{prepend}
|
2021-04-14 00:57:32 +00:00
|
|
|
</InputGroup.Prepend>
|
|
|
|
)}
|
|
|
|
<BootstrapForm.Control
|
2021-08-19 21:13:33 +00:00
|
|
|
onKeyDown={(e) => {
|
2023-06-12 17:29:50 +00:00
|
|
|
const metaOrCtrl = e.metaKey || e.ctrlKey
|
2023-06-12 18:49:58 +00:00
|
|
|
if (metaOrCtrl) {
|
|
|
|
if (e.key === 'Enter') formik?.submitForm()
|
2023-06-12 17:29:50 +00:00
|
|
|
}
|
2023-06-12 18:49:58 +00:00
|
|
|
|
2022-08-26 22:20:09 +00:00
|
|
|
if (onKeyDown) onKeyDown(e)
|
2021-08-19 21:13:33 +00:00
|
|
|
}}
|
2021-09-10 18:55:36 +00:00
|
|
|
ref={innerRef}
|
2021-04-14 00:57:32 +00:00
|
|
|
{...field} {...props}
|
2021-08-22 15:25:17 +00:00
|
|
|
onChange={(e) => {
|
|
|
|
field.onChange(e)
|
2022-01-07 18:28:23 +00:00
|
|
|
|
|
|
|
if (storageKey) {
|
|
|
|
localStorage.setItem(storageKey, e.target.value)
|
|
|
|
}
|
|
|
|
|
2021-08-22 15:25:17 +00:00
|
|
|
if (onChange) {
|
|
|
|
onChange(formik, e)
|
|
|
|
}
|
|
|
|
}}
|
2022-08-25 18:46:07 +00:00
|
|
|
isInvalid={invalid}
|
2022-04-19 18:32:39 +00:00
|
|
|
isValid={showValid && meta.initialValue !== meta.value && meta.touched && !meta.error}
|
2021-04-14 00:57:32 +00:00
|
|
|
/>
|
2022-08-25 18:46:07 +00:00
|
|
|
{(append || (clear && field.value)) && (
|
2021-04-14 00:57:32 +00:00
|
|
|
<InputGroup.Append>
|
2022-08-25 18:46:07 +00:00
|
|
|
{(clear && field.value) &&
|
|
|
|
<Button
|
|
|
|
variant={null}
|
2022-10-20 22:44:44 +00:00
|
|
|
onClick={(e) => {
|
2022-08-25 18:46:07 +00:00
|
|
|
helpers.setValue('')
|
|
|
|
if (storageKey) {
|
|
|
|
localStorage.removeItem(storageKey)
|
|
|
|
}
|
2022-10-20 22:44:44 +00:00
|
|
|
if (onChange) {
|
|
|
|
onChange(formik, { target: { value: '' } })
|
|
|
|
}
|
2022-08-25 18:46:07 +00:00
|
|
|
}}
|
|
|
|
className={`${styles.clearButton} ${invalid ? styles.isInvalid : ''}`}
|
|
|
|
><CloseIcon className='fill-grey' height={20} width={20} />
|
|
|
|
</Button>}
|
2021-05-13 13:28:38 +00:00
|
|
|
{append}
|
2021-04-14 00:57:32 +00:00
|
|
|
</InputGroup.Append>
|
|
|
|
)}
|
|
|
|
<BootstrapForm.Control.Feedback type='invalid'>
|
|
|
|
{meta.touched && meta.error}
|
|
|
|
</BootstrapForm.Control.Feedback>
|
|
|
|
</InputGroup>
|
2021-05-25 00:08:56 +00:00
|
|
|
{hint && (
|
|
|
|
<BootstrapForm.Text>
|
|
|
|
{hint}
|
|
|
|
</BootstrapForm.Text>
|
|
|
|
)}
|
2021-07-01 23:51:58 +00:00
|
|
|
</>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2022-08-26 22:20:09 +00:00
|
|
|
export function InputUserSuggest ({ label, groupClassName, ...props }) {
|
|
|
|
const [getSuggestions] = useLazyQuery(USER_SEARCH, {
|
|
|
|
fetchPolicy: 'network-only',
|
|
|
|
onCompleted: data => {
|
|
|
|
setSuggestions({ array: data.searchUsers, index: 0 })
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
const INITIAL_SUGGESTIONS = { array: [], index: 0 }
|
|
|
|
const [suggestions, setSuggestions] = useState(INITIAL_SUGGESTIONS)
|
|
|
|
const [ovalue, setOValue] = useState()
|
|
|
|
|
|
|
|
return (
|
|
|
|
<FormGroup label={label} className={groupClassName}>
|
|
|
|
<InputInner
|
|
|
|
{...props}
|
|
|
|
autoComplete='off'
|
2022-10-25 17:13:06 +00:00
|
|
|
onChange={(_, e) => getSuggestions({ variables: { q: e.target.value } })}
|
2022-08-26 22:20:09 +00:00
|
|
|
overrideValue={ovalue}
|
|
|
|
onKeyDown={(e) => {
|
|
|
|
switch (e.code) {
|
|
|
|
case 'ArrowUp':
|
|
|
|
e.preventDefault()
|
|
|
|
setSuggestions(
|
|
|
|
{
|
|
|
|
...suggestions,
|
|
|
|
index: Math.max(suggestions.index - 1, 0)
|
|
|
|
})
|
|
|
|
break
|
|
|
|
case 'ArrowDown':
|
|
|
|
e.preventDefault()
|
|
|
|
setSuggestions(
|
|
|
|
{
|
|
|
|
...suggestions,
|
|
|
|
index: Math.min(suggestions.index + 1, suggestions.array.length - 1)
|
|
|
|
})
|
|
|
|
break
|
|
|
|
case 'Enter':
|
|
|
|
e.preventDefault()
|
|
|
|
setOValue(suggestions.array[suggestions.index].name)
|
|
|
|
setSuggestions(INITIAL_SUGGESTIONS)
|
|
|
|
break
|
|
|
|
case 'Escape':
|
|
|
|
e.preventDefault()
|
|
|
|
setSuggestions(INITIAL_SUGGESTIONS)
|
|
|
|
break
|
|
|
|
default:
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
/>
|
2022-09-18 01:45:21 +00:00
|
|
|
<BootstrapDropdown show={suggestions.array.length > 0}>
|
|
|
|
<BootstrapDropdown.Menu className={styles.suggestionsMenu}>
|
2022-08-26 22:20:09 +00:00
|
|
|
{suggestions.array.map((v, i) =>
|
2022-09-18 01:45:21 +00:00
|
|
|
<BootstrapDropdown.Item
|
2022-08-26 22:20:09 +00:00
|
|
|
key={v.name}
|
|
|
|
active={suggestions.index === i}
|
|
|
|
onClick={() => {
|
|
|
|
setOValue(v.name)
|
|
|
|
setSuggestions(INITIAL_SUGGESTIONS)
|
|
|
|
}}
|
|
|
|
>
|
|
|
|
{v.name}
|
2022-09-18 01:45:21 +00:00
|
|
|
</BootstrapDropdown.Item>)}
|
|
|
|
</BootstrapDropdown.Menu>
|
|
|
|
</BootstrapDropdown>
|
2022-08-26 22:20:09 +00:00
|
|
|
</FormGroup>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-07-01 23:51:58 +00:00
|
|
|
export function Input ({ label, groupClassName, ...props }) {
|
|
|
|
return (
|
|
|
|
<FormGroup label={label} className={groupClassName}>
|
|
|
|
<InputInner {...props} />
|
|
|
|
</FormGroup>
|
2021-04-14 00:57:32 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-01-07 00:53:09 +00:00
|
|
|
export function VariableInput ({ label, groupClassName, name, hint, max, min, readOnlyLen, ...props }) {
|
2022-07-30 13:25:46 +00:00
|
|
|
return (
|
|
|
|
<FormGroup label={label} className={groupClassName}>
|
|
|
|
<FieldArray name={name}>
|
|
|
|
{({ form, ...fieldArrayHelpers }) => {
|
2022-08-18 18:15:24 +00:00
|
|
|
const options = form.values[name]
|
2022-07-30 13:25:46 +00:00
|
|
|
return (
|
|
|
|
<>
|
2023-01-07 00:53:09 +00:00
|
|
|
{options?.map((_, i) => (
|
2022-07-30 13:25:46 +00:00
|
|
|
<div key={i}>
|
|
|
|
<BootstrapForm.Row className='mb-2'>
|
|
|
|
<Col>
|
2023-01-07 00:53:09 +00:00
|
|
|
<InputInner name={`${name}[${i}]`} {...props} readOnly={i < readOnlyLen} placeholder={i >= min ? 'optional' : undefined} />
|
2022-07-30 13:25:46 +00:00
|
|
|
</Col>
|
|
|
|
{options.length - 1 === i && options.length !== max
|
|
|
|
? <AddIcon className='fill-grey align-self-center pointer mx-2' onClick={() => fieldArrayHelpers.push('')} />
|
|
|
|
: null}
|
|
|
|
</BootstrapForm.Row>
|
|
|
|
</div>
|
|
|
|
))}
|
|
|
|
</>
|
|
|
|
)
|
|
|
|
}}
|
|
|
|
</FieldArray>
|
|
|
|
{hint && (
|
|
|
|
<BootstrapForm.Text>
|
|
|
|
{hint}
|
|
|
|
</BootstrapForm.Text>
|
|
|
|
)}
|
|
|
|
</FormGroup>
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-06-12 18:03:44 +00:00
|
|
|
export function Checkbox ({ children, label, groupClassName, hiddenLabel, extra, handleChange, inline, disabled, ...props }) {
|
2021-09-12 16:55:38 +00:00
|
|
|
// React treats radios and checkbox inputs differently other input types, select, and textarea.
|
|
|
|
// Formik does this too! When you specify `type` to useField(), it will
|
|
|
|
// return the correct bag of props for you
|
2023-06-12 18:03:44 +00:00
|
|
|
const [field,, helpers] = useField({ ...props, type: 'checkbox' })
|
2021-09-12 16:55:38 +00:00
|
|
|
return (
|
2022-03-07 21:50:13 +00:00
|
|
|
<BootstrapForm.Group className={groupClassName}>
|
|
|
|
{hiddenLabel && <BootstrapForm.Label className='invisible'>{label}</BootstrapForm.Label>}
|
|
|
|
<BootstrapForm.Check
|
|
|
|
custom
|
|
|
|
id={props.id || props.name}
|
|
|
|
inline={inline}
|
|
|
|
>
|
|
|
|
<BootstrapForm.Check.Input
|
2023-06-12 18:03:44 +00:00
|
|
|
{...field} {...props} disabled={disabled} type='checkbox' onChange={(e) => {
|
2022-03-07 21:50:13 +00:00
|
|
|
field.onChange(e)
|
2023-06-12 18:03:44 +00:00
|
|
|
handleChange && handleChange(e.target.checked, helpers.setValue)
|
2022-03-07 21:50:13 +00:00
|
|
|
}}
|
|
|
|
/>
|
2023-06-12 18:03:44 +00:00
|
|
|
<BootstrapForm.Check.Label className={'d-flex' + (disabled ? ' text-muted' : '')}>
|
2022-03-07 21:50:13 +00:00
|
|
|
<div className='flex-grow-1'>{label}</div>
|
|
|
|
{extra &&
|
|
|
|
<div className={styles.checkboxExtra}>
|
|
|
|
{extra}
|
|
|
|
</div>}
|
|
|
|
</BootstrapForm.Check.Label>
|
|
|
|
</BootstrapForm.Check>
|
|
|
|
</BootstrapForm.Group>
|
2021-09-12 16:55:38 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-05-11 19:34:42 +00:00
|
|
|
const StorageKeyPrefixContext = createContext()
|
|
|
|
|
2021-04-14 00:57:32 +00:00
|
|
|
export function Form ({
|
2022-01-07 18:28:23 +00:00
|
|
|
initial, schema, onSubmit, children, initialError, validateImmediately, storageKeyPrefix, ...props
|
2021-04-14 00:57:32 +00:00
|
|
|
}) {
|
2021-05-13 21:19:51 +00:00
|
|
|
const [error, setError] = useState(initialError)
|
2021-04-14 00:57:32 +00:00
|
|
|
|
|
|
|
return (
|
|
|
|
<Formik
|
|
|
|
initialValues={initial}
|
|
|
|
validationSchema={schema}
|
2021-05-25 00:08:56 +00:00
|
|
|
initialTouched={validateImmediately && initial}
|
|
|
|
validateOnBlur={false}
|
2022-07-30 13:25:46 +00:00
|
|
|
onSubmit={async (values, ...args) =>
|
|
|
|
onSubmit && onSubmit(values, ...args).then(() => {
|
2022-01-07 18:28:23 +00:00
|
|
|
if (!storageKeyPrefix) return
|
2022-07-30 13:25:46 +00:00
|
|
|
Object.keys(values).forEach(v => {
|
|
|
|
localStorage.removeItem(storageKeyPrefix + '-' + v)
|
|
|
|
if (Array.isArray(values[v])) {
|
|
|
|
values[v].forEach(
|
|
|
|
(_, i) => localStorage.removeItem(`${storageKeyPrefix}-${v}[${i}]`))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
2022-01-07 18:28:23 +00:00
|
|
|
}).catch(e => setError(e.message || e))}
|
2021-04-14 00:57:32 +00:00
|
|
|
>
|
|
|
|
<FormikForm {...props} noValidate>
|
|
|
|
{error && <Alert variant='danger' onClose={() => setError(undefined)} dismissible>{error}</Alert>}
|
2023-05-11 19:34:42 +00:00
|
|
|
<StorageKeyPrefixContext.Provider value={storageKeyPrefix}>
|
2021-04-24 21:05:07 +00:00
|
|
|
{children}
|
2023-05-11 19:34:42 +00:00
|
|
|
</StorageKeyPrefixContext.Provider>
|
|
|
|
</FormikForm>
|
2021-04-24 21:05:07 +00:00
|
|
|
</Formik>
|
|
|
|
)
|
|
|
|
}
|
2022-09-18 01:45:21 +00:00
|
|
|
|
2022-10-20 22:44:44 +00:00
|
|
|
export function Select ({ label, items, groupClassName, onChange, noForm, ...props }) {
|
2023-05-11 00:26:07 +00:00
|
|
|
const [field, meta] = noForm ? [{}, {}] : useField(props)
|
2022-10-20 22:44:44 +00:00
|
|
|
const formik = noForm ? null : useFormikContext()
|
2023-05-11 00:26:07 +00:00
|
|
|
const invalid = meta.touched && meta.error
|
2022-09-18 01:45:21 +00:00
|
|
|
return (
|
|
|
|
<FormGroup label={label} className={groupClassName}>
|
2022-10-20 22:44:44 +00:00
|
|
|
<BootstrapForm.Control
|
|
|
|
as='select'
|
|
|
|
{...field} {...props}
|
|
|
|
onChange={(e) => {
|
2023-05-11 00:26:07 +00:00
|
|
|
if (field?.onChange) {
|
|
|
|
field.onChange(e)
|
|
|
|
}
|
2022-10-20 22:44:44 +00:00
|
|
|
|
|
|
|
if (onChange) {
|
|
|
|
onChange(formik, e)
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
custom
|
2023-05-11 00:26:07 +00:00
|
|
|
isInvalid={invalid}
|
2022-10-20 22:44:44 +00:00
|
|
|
>
|
2022-10-04 21:21:42 +00:00
|
|
|
{items.map(item => <option key={item}>{item}</option>)}
|
|
|
|
</BootstrapForm.Control>
|
2023-05-11 00:26:07 +00:00
|
|
|
<BootstrapForm.Control.Feedback type='invalid'>
|
|
|
|
{meta.touched && meta.error}
|
|
|
|
</BootstrapForm.Control.Feedback>
|
2022-09-18 01:45:21 +00:00
|
|
|
</FormGroup>
|
|
|
|
)
|
2022-10-04 21:21:42 +00:00
|
|
|
}
|