reformation.core — edu.byu.odh/reformation 24

atom? clj/s

(atom? a)

A CLJC implementation of atom?

base-text-on-change clj/s

(base-text-on-change {:keys [UPDATE valpath event]})

Basic text on-change event handler. :UPDATE update function passed on, changing elements at :valpath according to the value got from synthetic event event

check-form-validation clj/s

(check-form-validation)

checkbox clj/s

(checkbox {:keys [_READ UPDATE valpath] :as fn-map}
          {:keys [validation-function disabled style-classes default-value]
           :as _input-map})

Create a checkbox

checkset clj/s

(checkset {:keys [READ UPDATE valpath default-value]})

If a checkbox value is nil, set it; otherwise, return it.

div clj/s

(div {:keys [READ valpath] :as _fn-map-with-path}
     &
     [{:keys [style-classes] :as _opt-map}])

produce a div, usually for review-versions from a textarea

fm-map-atom clj/s

This atom is set when render-application is called

from-dictionary clj/s

(from-dictionary dictionary k)

Return valid entries k from dictionary, or error meaningfully

get-given-value clj/s

(get-given-value {:keys [value default-value]})

Get the given value, given a warning if :value is being mis-used

hidden-input clj/s

(hidden-input input-map)

Generate a hidden input

invalid-feedback-el clj/s

(invalid-feedback-el invalid-feedback)

keywordize-form clj/s

(keywordize-form fm dictionary)

Transform all keyword values in the form fm into their dictionary lookups

map-structure clj/s

(map-structure v)

Produce a map with the same key-structure from the vector

radio clj/s

(radio {:keys [options on-change]})

render-application clj/s

(render-application fm fn-map-or-atom & [pathv])

Render the editable application.

fm is the schema of the application, a vector laying out the fields and their attributes. fn-map is either an Atom to hold the information a user inputs, or a map that must with:

:READ a function that takes args with the same signature as get-in :UPDATE a function that takes args with the same signature as update-in :DICTIONARY(optional) a map of keyword to reformation-compatible structures

render-label clj/s

(render-label {:keys [for-id label-text]})

Create a label to go into a .row

render-review clj/s

(render-review schema application)

Parse the application map and render the review based on the ordered schema of the application, with values in application expected to be as given by render-application, as an atom or not. Resulting form will be read-only with no changes possible.

report-form-validation clj/s

(report-form-validation)

Creates a popup informing the user which 'required' fields are filled in improperly, doesn't work unless render-application has been called first.

reset-default clj/s

(reset-default default-schema-vec)

(reset-default A default-schema-vec)

Reset the given atom to a default state based on a default map, where it will possess each of the (possibly nested) structural elements of the given default, but values only according to an internal :default

sanitize-dom-args clj/s

(sanitize-dom-args opt-map)

Remove args that the react doesn't like from the opt-map, to be used right before a dom element is specified

select-box clj/s

(select-box m)

substructure? clj/s

Determine whether an item is a valid substructure for a form

text-area clj/s

(text-area {:keys [READ _UPDATE _DICTIONARY valpath] :as _fn-map-with-path}
           opt-map)

Renders :type :textarea elements. In addition to the usual opts includes optional :rows and cols for the html "rows=" and "cols=" attributes.

text-input clj/s

(text-input {:keys [READ valpath] :as _fn-map-with-path} opt-map)

Generate a regular text input, sanitizing the args

tinput clj/s

(tinput {:keys [READ UPDATE _DICTIONARY] :as fn-map} valpath & [opt-map])

Produce data-bound inputs for a given map, using :READ and :UPDATE for values and changes. opt-map specifies options including display variables.

to-validation clj/s

(to-validation f & [error-message])

Given a predicate, wrap it properly to be a validation function for tinput. Validation function runs on the input at earlier-given :timing (default every change), altering the validity of the element as prescribed. It waits for .checkValidity on the input to explain the error

togglebox clj/s

(togglebox {:keys [_label content valpath _READ _UPDATE _default-value
                   override-inline? open-height disabled _style-classes]
            :or {open-height "5em"}
            :as opt-map})

Builds a group which, when toggled, displays its :content

validation-function? clj/s

(validation-function? f)