Liking cljdoc? Tell your friends :D

forms.core


constructorcljs

(constructor validator)
(constructor validator data)
(constructor validator data opts)

Form constructor. It accepts the following arguments:

  • validator - returned either by the form.validator/validator or form.validator/comp-validators function
  • data - initial data map
  • opts - map with the form options:
    • :on-commit - function to be called when the form is commited (by calling (commit! form))
    • :auto-validate? - should the form be validated on any data change
Form constructor. It accepts the following arguments:

- `validator` - returned either by the `form.validator/validator` or `form.validator/comp-validators` function
- `data` - initial data map
- `opts` - map with the form options:
    + `:on-commit` - function to be called when the form is commited (by calling `(commit! form)`)
    + `:auto-validate?` - should the form be validated on any data change
raw docstring

errors-keypathscljs

(errors-keypaths data)
(errors-keypaths data path results)

Calculates the error key paths from the error map. It is used to mark all invalid key paths as dirty

Calculates the error key paths from the error map. It is used to mark
all invalid key paths as dirty
raw docstring

Formcljs


IFormcljsprotocol

IForm protocol defines the form behavior

IForm protocol defines the form behavior

clear-cached-dirty-key-paths!cljs

(clear-cached-dirty-key-paths! this)

Clear dirty key paths that are cached after caling the mark-dirty! function

Clear dirty key paths that are cached after caling the `mark-dirty!` function

datacljs

(data this)

Returns the atom that holds the current data map.

Returns the atom that holds the current data map.

errorscljs

(errors this)

Returns the atom that holds the current error map. This map holds all errors, regardless of the key path dirty state.

Returns the atom that holds the current error map. This map holds all
errors, regardless of the key path `dirty` state.

validate!cljs

(validate! this)
(validate! this dirty-only?)

Validates the form.

When called without the second argument - (validate! form) it will validate the whole form and mark all invalid fields as dirty This should happen on submit so you can show all form errors to the user.

When called with true as the second argument - (validate! form true) it wil validate only the fields that are marked as dirty - fields that are not nil and that have a different value than in the :init-data. This can be called on change or blur events.

Validates the form.

When called without the second argument - `(validate! form)` it will validate
the whole form and mark all invalid fields as `dirty` This should happen on
`submit` so you can show all form errors to the user.

When called with `true` as the second argument - `(validate! form true)` it wil
validate only the fields that are marked as dirty - fields that are not `nil` and
that have a different value than in the `:init-data`. This can be called on `change`
or `blur` events.

init!cljs

(init! this)

Initializes the form. If the form constructor was called with the auto-validate? option set to true it will add a watch to the internal state atom and validate the form every time data was changed

Initializes the form. If the form constructor was called with the
`auto-validate?` option set to `true` it will add a watch to the
internal state atom and validate the form every time data was changed

dirty-paths-valid?cljs

(dirty-paths-valid? this)

Are the dirty key paths in the valid state

Are the dirty key paths in the valid state

is-valid-path?cljs

(is-valid-path? this key-path)

Is the key path in the valid state

Is the key path in the valid state

mark-dirty-paths!cljs

(mark-dirty-paths! this)

Creates a diff between the initial data and the current data. Based on that diff it marks the key paths that are dirty.

Creates a diff between the initial data and the current data. Based on that diff
it marks the key paths that are dirty.

commit!cljs

(commit! this)

Commits the form. It will validate the form and mark dirty key paths. After that it will call the :on-commit function that can be used to persist the form.

Commits the form. It will validate the form and mark dirty key paths. After that
it will call the `:on-commit` function that can be used to persist the form.

mark-dirty!cljs

(mark-dirty! this)

Mark all invalid key paths as dirty. It will validate the whole form and cache any key paths that have errors.

Mark all invalid key paths as dirty. It will validate the whole form and
cache any key paths that have errors.

errors-for-pathcljs

(errors-for-path this key-path)

Returns errors for the key path. It is possible that this function will return nil even though the errors exist in the :errors map because this function accounts for the key path dirty state. If the field has errors, but it's not dirty this function will return nil

Returns errors for the key path. It is possible that this function will
return `nil` even though the errors exist in the `:errors` map because
this function accounts for the key path `dirty` state. If the field has
errors, but it's not dirty this function will return `nil`

data-for-pathcljs

(data-for-path this key-path)

Returns data for the key path

Returns data for the key path

statecljs

(state this)

Returns inner state atom. The state map holds the following properties:

  • :errors - map of the current form errors
  • :init-data - initial form data that was passed to the constructor
  • :data - current form data
  • :cached-dirty-key-paths - set of the key paths that were dirty when the whole form was validated
  • :dirty-key-paths - set of the dirty key paths
Returns inner state atom. The state map holds the following properties:

- `:errors` - map of the current form errors
- `:init-data` - initial form data that was passed to the constructor
- `:data` - current form data
- `:cached-dirty-key-paths` - set of the key paths that were dirty when
   the whole form was validated
- `:dirty-key-paths` - set of the dirty key paths

reset-form!cljs

(reset-form! this)
(reset-form! this init-data)

Reset form to the initial state

Reset form to the initial state

is-valid?cljs

(is-valid? this)

Is the form in the valid state

Is the form in the valid state

update!cljs

(update! this data)

Updates the data, marks dirty key paths and validates the form

Updates the data, marks dirty key paths and validates the form
raw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close