getFormatterForField

Returns the default formatter for a given [Field](doc:Field).

This can be called directly but is more commonly used via [UiProvider](doc:UiProvider) and [FieldFormatter](doc:FieldFormatter).

Depending on Field, this will return either a Formatter component directly, or [Formatter, props] where props is the default props that would be applied to said formatter.

> **NOTE**
> The formatter components here are loaded using [React.lazy](https://reactjs.org/docs/code-splitting.html). Your build must support
> this otherwise it is recommended to implement your own version (you can copy [this implementation](https://github.com/prestojs/prestojs/blob/master/js-packages/@prestojs/ui/src/getFormatterForField.ts)
> as a starting point).
>
> If you are using [nextjs React.lazy is not supported](https://nextjs.org/docs/advanced-features/dynamic-import) - you can [switch it out for `next/dynamic`](https://github.com/prestojs/prestojs/blob/master/doc-site/getFormatterForField.js).


field

Field

React.ComponentType

string

null

FieldValue

ParsableValueT

SingleValueT

HTMLElement

constructor

new Field

values

__fieldValueType

ValueT

__parsableValueType

_defaultValue

__type

_model

ViewModelConstructor

_name

asyncChoices

AsyncChoicesInterface

Is this field required when saving a record?

blank

boolean

If true an empty string value should be converted to a null value

blankAsNull

choices

Help text that can be displayed with the form widget

helpText

undefined

Label that can be displayed as the form label for a widget

If not specified will be generated from `name`.


label

Indicates this field should only be read, not written. Not enforced but can be used by components to adjust their
output accordingly (eg. exclude it from a form or show it on a form with a read only input)

readOnly

Indicates this field should only be written only and is not intended to be read directly. This is not enforced
but can be used by components to adjust their output accordingly (eg. exclude it from a detail view on a record)

writeOnly

This exists so things like [getWidgetForField](doc:getWidgetForField) can select a widget for
a field without needing to import all fields up front.

For custom fields this isn't required unless your implementation of `getWidgetForField` wants
to do avoid importing the field up front.


fieldClassName

When accessed on a [bound field](doc:viewModelFactory#var-_f) will return the current instance of the ViewModel
the field is bound to.

If called on an unbound field then this will always be undefined and a warning will be raised.


__get

boundRecord

defaultValue

Returns true if field is bound to a ViewModel instance. When a field is bound to a instance
the value for that field is accessible on the 'value' property.

isBound

The [ViewModel](doc:viewModelFactory) class this field is attached to.

This will throw an error if the field is not attached to a model.


model

__set

viewModel

void

name

When `isBound` is true this will return the current value of this field on the bound ViewModel.
Otherwise will always be undefined.

value

clone

Returns a clone of the field that should be functionally equivalent

contributeToClass

Called once after fields are attached to a ViewModel. This occurs the first time `.fields` is
accessed on the ViewModel.

By default this does nothing but can be used by fields to attach extra properties or validate
against the final view model (for example checking that another field does / does not exist).

NOTE: This is called for every distinct ViewModel class; so if class A is extended by class B
then it will be called on both A and B.


format

Format the value for displaying in a form widget. eg. This could convert a `Date` into
a localized date string

isEqual

This is used when determining if two records are equal (see ViewModel.isEqual)


value1

value2

normalize

Normalize a value passed into a ViewModel constructor. This could do things like extract the id of a nested
relation and only store that, eg.

TODO: Do we need to handle things like normalizing to multiple fields? eg. In the example below setting the
id to addressId and relation to address

```js
// This might become
{
    name: 'Sam',
    address: {
        id: 5,
        formatted: '3 Somewhere Road, Some Place',
    },
}
// ...this
{
    name: 'Same',
    address: 5,
}
```


parse

Parse a value received from a form widget `onChange` call. eg. This could convert a localized date string
into a `Date`.

toJS

Convert value to plain JS representation useful for things like passing to a form or posting to
a backend API

toString

RecordBoundField

ListField

BaseRelatedViewModelField

NullableBooleanField

CharField

NumberField

DateField

RangeField

DateTimeField

FileField

TimeField

TestField

Constructors

Properties

Accessors

Methods

__call

FieldProps

number

Promise

ViewModelInterface

Field.__constructor

new RecordBoundField

Field.__fieldValueType

Field.__parsableValueType

ParsableType

Field._defaultValue

Field.asyncChoices

Field.blank

Field.blankAsNull

Field.boundRecord

Field.choices

Field.helpText

Field.isBound

true

Field.label

Field.readOnly

Field.value

Field.writeOnly

Field.fieldClassName

Field.defaultValue

Field.model

Field.name

Field.clone

Field.contributeToClass

Field.format

Field.isEqual

Field.normalize

Field.parse

Field.toJS

Field.toString

new ViewModelFieldPaths

modelClass

flattenedPath

ViewModelFieldPaths

The expanded paths - any nested fields are represented as an array

fieldPaths

FieldPath

The flattened path - any nested fields are joined with '.'

A key representation of this field path that can be used as a cache key

nonRelationFieldNames

Map of relation field name to the paths for that relation

relations

Record

isSubset

Is the specified `paths` a subset of this?

paths

ignoreNested

Stores the field paths for a model in a standardised form for use in caching.

new RecordFieldNameCache

onAnyChange

RecordFieldNameCache

This stores the record instances by the field paths that are used to retrieve them

cache

This stores the current listeners by the field paths

cacheListeners

ChangeListener

Contains all keys in `cache` in descending order of last insert/update

This is used to choose the most recent record when a new record with a subset
of the fields needs to be created. For example if there are 2 existing records
created in this order:

```
{ id: 1, firstName: 'Jon', lastName: 'Doe', email: 'jon@doe.com' }
{ id: 1, firstName: 'John', lastName: 'Doe' }
```

But a record is requested for just 'firstName' we need to create a new record
with just that field. We could create it from either of the existing records
but we want to use the _last_ record inserted - so in this case it would be:

```
{ id: 1, firstName: 'John' }
```


lastUpdatedKeys

ViewModelClassType

recordPk

ExtractPkFieldParseableValueType

relationListenerPaths

When a record has relation fields a listener is added to listen for changes on the related
records. When it receives notifications for those related records it can then in turn notify
the listeners on the original record.

relationListenerUnsubscribe

ChangeListenerUnsubscribe

Add a record to the cache based on the fields that are set on it.

This will also update any cached entries for records that contain only
a subset of the fields set on `record`. Note that this does not update
a superset of fields, ie. updating fields (a,b) won't update a record
that contains (a,b,c)


record

addListener

Add a listener for any changes, additions or deletions for the specified field names

fieldNames

listener

cleanupKey

Remove specified key from cache, cleanup any relation listeners and trigger
listener callbacks if required.

constructWithRelatedRecords

Given a `baseRecord` with no related fields resolved (ie. we just have the id's, not the nested records) construct
a record with all the nested records attached if those records exist in the cache. If any requested record doesn't
exist in the cache then this will return `null`.

baseRecord

delete

Delete a record for the specified field names.

Returns `true` if anything was deleted otherwise `false`


Get a record for the specified key. If the record doesn't yet exist but can be created from
another record in the cache (ie. one with a superset of the fields set) then this will be done
automatically.

setValueForKey

Set a value for the specified `key`, then notify any listeners

`lastUpdatedKeys` is always updated even if the value being set is identical.


setupRelationListeners

When a listener is added to a record for a set of fields we need to also listen
to changes on the caches for any related records. This functions handles setting
up those listeners.