🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →
Sign In

form-schema-kit

Package Overview
Dependencies
Maintainers
1
Versions
9
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

form-schema-kit - npm Package Compare versions

Comparing version
1.0.0
 to
1.0.1
+10
src/defaults/field-mask-tokens.js
'use strict'
module.exports = function () {
return {
9: { pattern: /[0-9]/ },
0: { pattern: /[*0-9]/ },
a: { pattern: /[A-Za-z]/ },
'*': { pattern: /[A-Za-z0-9]/ }
}
}
+13
src/defaults/field-types.js
'use strict'
module.exports = function () {
return {
custom: 'Custom',
hidden: 'Hidden',
text: 'Text',
textarea: 'Textarea',
checkbox: 'Checkbox',
radio: 'Radio',
select: 'Select'
}
}
+9
src/defaults/index.js
'use strict'
var fieldTypes = require('./field-types')
var fieldMaskTokens = require('./field-mask-tokens')
module.exports = function (o) {
o.fieldtypes = fieldTypes()
o.fieldMaskTokens = fieldMaskTokens()
return o
}
+16
src/field/get-dynamic-type.js
'use strict'
var fieldIsDisappear = require('./is-disappear')
module.exports = function (field) { // careful with as_is
var fieldtypes = this.fieldtypes
if (field.appear === 'label') {
return fieldtypes.custom
}
var appear_as_value = field.depend_visible === 'single' || field.appear === 'single'
// todo: readme field.appear, field.depend_visible (deprecate)
if (fieldIsDisappear.call(this, field) && (appear_as_value || !field.appear)) {
return appear_as_value ? fieldtypes.custom : fieldtypes.hidden
}
}
+6
src/field/get-options.js
'use strict'
var fieldIsDepended = require('./is-depended')
module.exports = function (field) {
return fieldIsDepended.call(this, field) ? field.options_depended || [] : field.options
}
+5
src/field/get-primary.js
'use strict'
module.exports = function (field) {
return field && field.depends_on && this.fields[field.depends_on]
}
+71
src/field/get-value-default.js
'use strict'
var sanitizeFieldValue = require('./sanitize-value')
var fieldIsDepended = require('./is-depended')
var fieldGetOptions = require('./get-options')
var isArray = require('wsk-utils/var/is/object/array')
var each = require('wsk-utils/var/object/each')
module.exports = function (field) {
var output
if (!(field.preselect && fieldIsDepended.call(this, field))) {
output = sanitizeFieldValue(field.stored_values)
} else {
output = []
}
if (field.preselect) {
var options = fieldGetOptions.call(this, field)
if (isArray(options) && options.length > 0) {
var single_value = field.field_type !== this.fieldtypes.checkbox
options = options.slice(0)
var mode = field.preselect.toString().split(':')
var preselect_mode = mode.shift()
var preselect_value = mode.join(':')
switch (preselect_mode) {
case 'all':
each(options, function (i, option) {
output.push(option.id)
})
break
case 'first':
output.push(options.shift().id)
break
case 'last':
output.push(options.pop().id)
break
case 'eq':
each(preselect_value.split(','), function (i, pos) {
if (!isNaN(pos)) {
var _option = options.slice(~~pos).shift()
if (_option) {
output.push(_option.id)
}
}
})
break
// TODO: manual
case 'value':
case 'label':
case 'id':
if (preselect_value || (field.preselect_pattern && field.preselect_pattern instanceof RegExp)) {
each(options, function (i, option) {
if (preselect_value ? preselect_value === option[preselect_mode] : field.preselect_pattern.test(option[preselect_mode])) {
output.push(option.id)
if (single_value) {
return false
}
}
})
}
break
}
if (single_value && output.length) {
output = [output.shift()]
}
}
}
return output
}
+40
src/field/get-value.js
'use strict'
var each = require('wsk-utils/var/object/each')
var isObject = require('wsk-utils/var/is/object')
module.exports = function (field, mode) {
var output = []
var fieldtypes = this.fieldtypes
var rootDependencyState = this.dependency_state
switch (mode || '') {
case 'label':
case 'id':
case 'fields':
break
default:
mode = 'value'
}
each(rootDependencyState[field.name], function (i, v) {
switch (field.field_type) {
case fieldtypes.select:
case fieldtypes.checkbox:
case fieldtypes.radio:
output.push(v[mode])
break
default:
if (mode !== 'label' && mode !== 'fields') {
mode = 'value'
}
if (isObject(v)) {
output.push(v[mode])
} else {
output.push(v)
}
}
})
return output
}
+15
src/field/index.js
'use strict'
var each = require('wsk-utils/var/object/each')
var initializeFieldValue = require('./initialize-value')
var fieldUpdate = require('./update')
var initializeField = function (fieldName, field, _this) {
initializeFieldValue.call(_this, field)
field.update = function (values) {
return fieldUpdate.call(_this, field, values)
}
}
module.exports = function () {
each(this.fields, initializeField, this)
}
+40
src/field/initialize-value.js
'use strict'
var fieldUpdateDepended = require('./update-depended')
var fieldGetDefaultValues = require('./get-value-default')
var fieldGetPrimary = require('./get-primary')
var fieldGetValue = require('./get-value')
var fieldUpdateHelper = require('./update-helper')
var fieldInitializeValues = function (field, initial) {
if (initial !== false) {
initial = initial || {}
}
if (initial) {
if (initial[field.name]) {
return false
}
initial[field.name] = true
}
var primary = fieldGetPrimary.call(this, field)
if (primary) {
if (initial) {
fieldInitializeValues.call(this, primary, initial)
}
// generating values for text fields and depended_options for others
fieldUpdateDepended.call(this, field)
} else {
fieldUpdateHelper.call(this, field, fieldGetDefaultValues.call(this, field))
}
if (fieldGetValue.call(this, field, 'id')[0]) {
if (field.predefined == null) {
field.predefined = true
}
} else {
field.predefined = false
}
}
module.exports = fieldInitializeValues
+6
src/field/is-depended.js
'use strict'
var fieldGetPrimary = require('./get-primary')
module.exports = function (field) {
return !!fieldGetPrimary.call(this, field)
}
+28
src/field/is-disappear.js
'use strict'
var fieldGetOptions = require('./get-options')
var fieldIsDepended = require('./is-depended')
module.exports = function (field) {
var options
var fieldtypes = this.fieldtypes
switch (field.field_type) {
case fieldtypes.select:
case fieldtypes.checkbox:
case fieldtypes.radio:
options = fieldGetOptions.call(this, field)
if (!(options && options.length) || (fieldtypes.checkbox !== field.field_type && options && options.length === 1)) {
return true
}
break
case fieldtypes.text:
case fieldtypes.textarea:
if (fieldIsDepended.call(this, field)) {
options = fieldGetOptions.call(this, field)
if (!(options && options.length)) {
return true
}
}
break
}
return false
}
+24
src/field/is-required.js
'use strict'
var fieldGetOptions = require('./get-options')
module.exports = function (field) {
var fieldtypes = this.fieldtypes
var required = !!field.required
if (required) {
switch (field.field_type) {
case fieldtypes.select:
case fieldtypes.checkbox:
case fieldtypes.radio:
var options = fieldGetOptions.call(this, field)
if (!(options && options.length > 0)) {
return false
}
break
case fieldtypes.hidden:
return false
}
}
return required
}
+8
src/field/sanitize-value.js
'use strict'
var isString = require('wsk-utils/var/is/string')
var isNumber = require('wsk-utils/var/is/number')
var isArray = require('wsk-utils/var/is/object/array')
module.exports = function (value) {
return isArray(value) ? value.slice(0) : isString(value) && value ? [value] : isNumber(value) && isFinite(value) ? [value.toString()] : []
} 
+93
src/field/set-value.js
'use strict'
var sanitizeFieldValue = require('./sanitize-value')
var fieldGetOptions = require('./get-options')
var fieldIsDepended = require('./is-depended')
var each = require('wsk-utils/var/object/each')
var isObject = require('wsk-utils/var/is/object')
var trim = require('wsk-utils/var/string/trim')
module.exports = function (field, value, as_is) { // careful with as_is
var fieldtypes = this.fieldtypes
var rootValues = this.values
var rootDependencyState = this.dependency_state
rootValues[field.name] = []
rootDependencyState[field.name] = []
var values = sanitizeFieldValue(value)
if (as_is || field.field_type === fieldtypes.custom) {
rootValues[field.name] = values
rootDependencyState[field.name] = values
return
}
var options = fieldGetOptions.call(this, field)
var is_hidden = false
// noinspection FallThroughInSwitchStatementJS
switch (field.field_type) {
case fieldtypes.hidden:
is_hidden = true
// depended hidden field could have multiple values
if (fieldIsDepended.call(this, field) || (options && options.length)) {
each(values, function (i, val) {
each(options, function (j, opt) {
// eslint-disable-next-line eqeqeq
if ((isObject(opt) ? opt.value : opt) == val) { // jshint ignore:line
rootValues[field.name].push((isObject(opt) ? opt.id : opt))
rootDependencyState[field.name].push(opt)
return false
}
})
})
break
} // jshint ignore:line
// eslint-disable-next-line
case fieldtypes.text:
case fieldtypes.textarea:
var val = sanitizeFieldValue(values[0]) + ''
if (!is_hidden) {
val = trim(val)
}
if (val) {
rootValues[field.name].push(val)
rootDependencyState[field.name].push(val)
}
break
// pay attention: for this field types fieldValueSet should receive options id, not actual values.
case fieldtypes.select:
case fieldtypes.checkbox:
case fieldtypes.radio:
if (options && options.length) {
var founded = false
each(values, function (i, value) {
founded = false
each(options, function (j, option) {
// eslint-disable-next-line eqeqeq
if (value == option.id) { // jshint ignore:line
founded = j
return false // break;
}
})
if (founded !== false) {
rootValues[field.name].push(options[founded].id)
rootDependencyState[field.name].push(options[founded])
// store only one value for Select and Radio
if (field.field_type !== fieldtypes.checkbox) {
return false // break;
}
}
})
// if value still not set for single-option Select and Radio, set it.
if (field.field_type !== fieldtypes.checkbox && founded === false && options.length === 1 && options[0]) {
if (field.appear !== 'always') {
rootValues[field.name][0] = options[0].id
rootDependencyState[field.name].push(options[0])
}
}
}
break
}
}
+103
src/field/update-depended.js
'use strict'
var fieldUpdateHelper = require('./update-helper')
var fieldGetDefaultValue = require('./get-value-default')
var fieldIsDepended = require('./is-depended')
var each = require('wsk-utils/var/object/each')
var isString = require('wsk-utils/var/is/string')
var isArray = require('wsk-utils/var/is/object/array')
var _get_option_by_case_insensitive_key = function (o, k) {
var _k
for (_k in o) {
if (Object.prototype.hasOwnProperty.call(o, _k)) {
if (_k.toLowerCase() === k.toLowerCase()) {
return o[_k]
}
}
}
}
var _cb_each_rootDependencyState_options_sub = function (i, o, id) {
var check_value = isString(o) ? o : (o && o.id)
if (check_value === id) {
return false // break;
}
}
var _cb_each_rootDependencyState_options = function (i, _o, field) {
// add option into existing options if not present yet
var check_value = isString(_o) ? _o : (_o && _o.id)
if (check_value && each(field._opts, _cb_each_rootDependencyState_options_sub, check_value) !== false) {
field._opts.push(_o)
}
}
var _cb_each_rootDependencyState = function (i, value, field) {
var _options
if (field.children) {
if (field.live && typeof value === 'string') {
_options = _get_option_by_case_insensitive_key(field.children, value)
} else {
_options = field.children[value && value.id || value]
}
}
if (isArray(field._opts)) { // field has a multiple values (Checkbox)
each(_options, _cb_each_rootDependencyState_options, field)
} else {
if (_options) {
if (isString(_options)) {
field._opts = [_options]
} else if (isArray(_options)) {
field._opts = _options.slice(0)
}
}
}
}
// init depended fields (reset/set values and options_depended)
module.exports = function (field) {
var fieldtypes = this.fieldtypes
var rootDependencyState = this.dependency_state
if (!fieldIsDepended.call(this, field)) {
return false
}
if (!rootDependencyState[field.depends_on] || !rootDependencyState[field.depends_on].length) {
_cb_each_rootDependencyState(0, '', field)
} else {
each(rootDependencyState[field.depends_on], _cb_each_rootDependencyState, field)
}
var options = field.options_depended = field._opts
delete field._opts
// don't we want to use instance.values here? No, we don't.
// we will try to set depended field DEFAULT value from real stored_values.
var value; var defaultValue = fieldGetDefaultValue.call(this, field)
if (options) {
switch (field.field_type) {
case fieldtypes.hidden:
case fieldtypes.text:
case fieldtypes.textarea:
value = []
each(options, function (i, opt) {
if (isString(opt)) {
value.push(opt)
} else {
// in case opt is {id: null, label: null, value: null}, task#61231: visibility dependency for text fields
if (opt.id === null) {
value = value.concat(defaultValue)
} else {
value.push(opt.value)
}
}
})
break
}
}
fieldUpdateHelper.call(this, field, value || defaultValue)
}
+17
src/field/update-helper.js
'use strict'
var fieldSetValue = require('./set-value')
var fieldValidate = require('./validate')
var fieldGetOptions = require('./get-options')
var fieldDynamicType = require('./get-dynamic-type')
module.exports = function (field, values, as_is) {
fieldSetValue.call(this, field, values, as_is)
var options = fieldGetOptions.call(this, field)
if (options) {
field.$options = options
}
field.$type = (fieldDynamicType.call(this, field) || ((field.field_type === this.fieldtypes.text) && field.data_type || field.field_type)).toLowerCase()
fieldValidate.call(this, field)
}
+20
src/field/update.js
'use strict'
var fieldUpdateHelper = require('./update-helper')
var fieldUpdateDepended = require('./update-depended')
var each = require('wsk-utils/var/object/each')
var fieldUpdateAllDepended = function (field) {
var _this = this
each(_this.dependency[field.name], function (i, field) {
var field_depended = _this.fields[field]
if (field_depended) {
fieldUpdateDepended.call(_this, field_depended)
fieldUpdateAllDepended.call(_this, field_depended)
}
})
}
module.exports = function (field, values) {
fieldUpdateHelper.call(this, field, values)
fieldUpdateAllDepended.call(this, field)
}
+39
src/field/validate.js
'use strict'
var fieldGetValues = require('./get-value')
var fieldValidator = require('./validator')
var isBoolean = require('wsk-utils/var/is/boolean')
var isUndefined = require('wsk-utils/var/is/undefined')
var isString = require('wsk-utils/var/is/string')
module.exports = function (field, validator) {
var values
if (isUndefined(validator)) {
values = fieldGetValues.call(this, field)
validator = fieldValidator.call(this, field, values, fieldGetValues.call(this, field, 'label'))
} else {
validator = {
validated: isBoolean(validator) ? validator !== false : false,
validation_error: isString(validator) ? validator : '',
validation_type: 'manual'
}
}
if (!validator.validated) {
field.$error = validator.validation_error || field.validation_message || 'Field validation error.'
field.$validationType = validator.validation_type || 'general'
field.$valid = false
} else {
if (isBoolean(field.$valid)) {
field.$valid_once = true
}
if (values && values.length) {
field.$valid_once = true
} else {
field.$valid_once = null
}
field.$error = ''
field.$validationType = ''
field.$valid = true
}
return validator.validated
}
+157
src/field/validator.js
'use strict'
var fieldIsDisappear = require('./is-disappear')
var fieldIsRequired = require('./is-required')
var each = require('wsk-utils/var/object/each')
var isFunction = require('wsk-utils/var/is/function')
var isBoolean = require('wsk-utils/var/is/boolean')
var isUndefined = require('wsk-utils/var/is/undefined')
var isString = require('wsk-utils/var/is/string')
var isArray = require('wsk-utils/var/is/object/array')
var _prepareRegexp = function (pattern) {
if (isString(pattern)) {
// don't forget to sanitize backslashes (\\) in string pattern
try {
// eslint-disable-next-line no-new-func
pattern = (new Function('return ' + pattern))() // jshint ignore:line
} catch (e) {}
}
if (pattern instanceof RegExp) {
return pattern
}
}
var _formFieldSubValidator = function (rules, value, valueLabel) {
var _this = this
var out
each(rules, function (i, p) {
if (p.fields) {
each(p.fields, function (field_name, patterns) {
patterns = isArray(patterns) ? patterns : [patterns]
each(patterns, function (i, p2) {
var pattern = _prepareRegexp(p2.pattern || p2)
if (pattern) {
if (p2.pattern) {
p2.pattern = pattern
} else {
patterns[i] = pattern
}
p2.$live = true
each(p.mode === 'label' ? valueLabel : value, function (j, v) {
out = out || {}
out[field_name] = out[field_name] || []
if (p.pattern.test(v)) {
out[field_name].push(p2)
}
})
}
})
})
}
})
each(out, function (field_name, _rules) {
var fld = _this.fields[field_name]
if (fld) {
fld.validation = fld.validation || []
fld.validation = fld.validation.filter(function (rule) {
return !rule.$live
}).concat(_rules)
formFieldValidator.call(_this, fld, true)
}
})
}
var formFieldValidator = function (field, value, valueLabel) {
var fieldtypes = this.fieldtypes
var validated = true
var validation_error = ''
var validation_type = ''
var skip = false
var val = ''
if (fieldIsDisappear.call(this, field)) {
skip = true
}
if (!skip && isFunction(field.validation)) {
var result = field.validation.call(this, field, value)
if (result && !isUndefined(result.validated)) {
validated = !!result.validated
validation_error = result.message
skip = true
} else {
validated = result !== false
// skip next validations only if true or false returned.
// otherwise, will operates like default
skip = isBoolean(result)
}
}
// validate if field value is not empty
if (!skip && fieldIsRequired.call(this, field)) {
if (!(value && value.length !== 0)) {
validated = false
validation_error = field.validation_message || 'Field is required.'
validation_type = 'required'
skip = true
}
}
if (!skip && field.minlength) {
val = (value && value[0] && value[0].length || 0)
if (val < field.minlength) {
validated = false
validation_error = field.validation_message || '' + (field.minlength - val) + ' characters remain to reach a minimum length.'
validation_type = 'minlength'
skip = true
}
}
if (field.field_type !== fieldtypes.hidden && field.validation) {
var patterns = isString(field.validation) || field.validation instanceof RegExp || field.validation.pattern ? [field.validation] : field.validation.length ? field.validation : []
each(patterns, function (i, p) {
var pattern = _prepareRegexp(p.pattern || p)
if (pattern) {
if (p.pattern) {
p.pattern = pattern
} else {
patterns[i] = pattern
}
}
})
_formFieldSubValidator.call(this, patterns, value, valueLabel)
if (!skip) {
each(patterns, function (i, p) {
var pattern = _prepareRegexp(p.pattern || p)
if (pattern && !p.fields) {
each(value, function (j, v) {
validated = pattern.test(v)
validation_error = p.message
if (!validated) {
if (p.type) {
validation_type = p.type
}
return false // break;
}
})
}
if (!validated) {
return false // break;
}
})
}
}
return { validated: validated, validation_error: validation_error, validation_type: validation_type }
}
module.exports = formFieldValidator
+38
src/form/get-data.js
'use strict'
var each = require('wsk-utils/var/object/each')
var formTraverse = require('./traverse')
var fieldGetValue = require('../field/get-value')
var arrayParser = function (_i, value, name, out) {
out.push({ name: name, value: value })
}
var objectParser = function (_i, value, name, out) {
out[name] = out[name] || []
out[name].push(value)
}
var stringParser = function (_i, value, name, out) {
out.push(encodeURIComponent(name) + '=' + encodeURIComponent(value))
}
module.exports = function (type, page_id, mode) {
var _this = this
var out, parser
if (type === Object) {
parser = objectParser
out = {}
} else if (type === String) {
parser = stringParser
out = []
} else {
parser = arrayParser
out = []
}
formTraverse.call(this, function (i, field) {
if (!field.local) {
var values = fieldGetValue.call(_this, field, mode)
each(values, parser, field.name, out)
}
}, page_id == null ? -Infinity : -page_id)
return type === String ? out.join('&') : out
}
+47
src/form/traverse.js
'use strict'
var each = require('wsk-utils/var/object/each')
var isNumber = require('wsk-utils/var/is/number')
var isArray = require('wsk-utils/var/is/object/array')
var _fieldsTraverseInPage = function (i, page, cb, data, withSkipped) {
if (withSkipped !== false || !page.$skipped) {
each(page.fields, cb, data)
if (isArray(page.sub)) {
each(page.sub, _fieldsTraverseInPage, cb, data, withSkipped)
}
}
}
var _fieldsTraverseNotSkipped = function (i, page, cb, data) {
if (page.$skipped !== true) {
_fieldsTraverseInPage(i, page, cb, data, false)
}
}
module.exports = function (cb, page_id, data) {
var with_skipped = true
if (page_id === -Infinity || page_id === Infinity || page_id == null) {
with_skipped = page_id >= 0
page_id = null
} else if (isNumber(page_id)) {
if (1 / page_id < 0) {
with_skipped = false
page_id = Math.abs(page_id)
}
page_id = ~~page_id
}
if (page_id !== null) {
if (this.pages[page_id]) {
if (with_skipped) {
_fieldsTraverseInPage(page_id, this.pages[page_id], cb, data)
} else {
_fieldsTraverseNotSkipped(page_id, this.pages[page_id], cb, data)
}
}
} else if (with_skipped) {
each(this.fields, cb, data)
} else {
each(this.pages, _fieldsTraverseNotSkipped, cb, data)
}
}
+15
src/form/validate.js
'use strict'
var formTraverse = require('./traverse')
module.exports = function (page_id) {
var invalid_fields_count = 0
formTraverse.call(this, function (i, field) {
if (!field.$valid) {
field.$valid_once = true
invalid_fields_count += 1
}
}, page_id == null ? -Infinity : -page_id)
return invalid_fields_count === 0
}
+15
src/initialize/field/base.js
'use strict'
var extend = require('wsk-utils/var/object/extend')
module.exports = function (question, rootFields, fields_object, fieldTypes) {
var field_name = question.name
var fieldDef = fields_object[field_name]
var field = rootFields[field_name] = question
// allow override field_type for any except hidden
var field_type = field.field_type !== fieldTypes.hidden && fieldDef && fieldDef.field_type ? fieldDef.field_type : field.field_type
if (fieldDef && !fieldDef.create) {
extend(field, fieldDef, { name: field_name, field_type: field_type })
}
}
+11
src/initialize/field/create.js
'use strict'
var extend = require('wsk-utils/var/object/extend')
module.exports = function (field, field_name, rootFields, $instance) {
if (!rootFields[field_name] && field.create && field.field_type) {
if (!(field.create.call && !field.create.call($instance))) {
rootFields[field_name] = extend({}, field, { name: field_name })
delete rootFields[field_name].create
}
}
} 
+55
src/initialize/field/depend-combine.js
'use strict'
var each = require('wsk-utils/var/object/each')
var formFieldProcess = require('./process')
module.exports = function (field, rootFields, rootPages, fieldTypes) {
// combine depended fields if needed (field.depend_combine: true)
if (field.depends_on && field.children) {
var field_primary = rootFields[field.depends_on]
var field_secondary = field
if (!field_primary || !field_secondary) {
return // continue;
}
if (!field_primary.depend_combine || !field_primary.options || !field_primary.options.length) {
return // continue;
}
var field_fake = {
label: field_secondary.label,
name: field_primary.name + '2' + field_secondary.name,
field_type: fieldTypes.select,
placeholder: field_secondary.placeholder,
required: field_primary.required || field_secondary.required,
local: true,
options: []
}
var children1 = {}
var children2 = {}
var pv = field_primary.stored_values && field_primary.stored_values.toString()
var sv = field_secondary.stored_values && field_secondary.stored_values.toString()
each(field_primary.options, function (a, value_main) {
field_fake.options.push({ label: value_main.label })
each(field_secondary.children[value_main.id], function (b, value_children) {
var id = value_main.id + ':' + value_children.id
if (pv && sv && value_main.id === pv && value_children.id === sv) {
field_fake.stored_values = [id]
}
field_fake.options.push({ label: value_children.label, value: id, id: id })
children1[id] = [
{ label: value_main.label, value: value_main.value, id: value_main.id }
]
children2[id] = [
{ label: value_children.label, value: value_children.value, id: value_children.id }
]
})
})
formFieldProcess('replace', rootFields, rootPages, { name: field_primary.name, label: field_primary.label, field_type: fieldTypes.hidden, depends_on: field_fake.name, children: children1 })
formFieldProcess('replace', rootFields, rootPages, { name: field_secondary.name, label: field_secondary.label, field_type: fieldTypes.hidden, depends_on: field_fake.name, children: children2 })
formFieldProcess('add', rootFields, rootPages, field_fake, field_primary.name)
}
}
+27
src/initialize/field/dependency.js
'use strict'
var formFieldProcess = require('./process')
module.exports = function (field, rootFields, rootPages, rootDependency) {
var field_name = field.name
var depends_on = field.depends_on
if (depends_on) {
// depends_on cannot point to itself and depends_on should point to existing field
if (depends_on !== field_name && rootFields[depends_on]) {
if (!rootDependency[depends_on]) {
rootDependency[depends_on] = []
}
rootDependency[depends_on].push(field_name)
} else {
// depends_on field is absent - try to make simple field with all possible values
if (field.children && field.children.all) {
field.options = field.children.all
field.children = undefined
field.depends_on = undefined
} else {
formFieldProcess('delete', rootFields, rootPages, field)
}
}
}
}
+49
src/initialize/field/final.js
'use strict'
var isString = require('wsk-utils/var/is/string')
var random = require('wsk-utils/var/string/random')
var FIELD_TCPA = 'leadid_tcpa_disclosure'
var FIELD_SELECT_PLACEHOLDER = '-please select-'
var FILED_TEXT_MAXLENGTH = 255
module.exports = function (field, fieldTypes, formCampaignForTcpa) {
if (field.name === FIELD_TCPA) {
field.id = field.name
if (formCampaignForTcpa) {
field.id += '_' + formCampaignForTcpa
}
field.id += '_' + random()
} else {
field.id = 'fsk_' + random()
}
// set default placeholder for select fields
if (field.field_type === fieldTypes.select && !isString(field.placeholder)) {
field.placeholder = FIELD_SELECT_PLACEHOLDER
}
if (field.maxlength) {
field.maxlength = ~~field.maxlength
}
if (field.minlength) {
field.minlength = ~~field.minlength
}
if (field.field_type === fieldTypes.text && !field.maxlength) {
field.maxlength = FILED_TEXT_MAXLENGTH
}
if (field.field_type === fieldTypes.checkbox) {
// single checkbox
if (!field.depends_on && (!field.options || !field.options.length)) {
field.options = [
{ label: field.label, value: '1', id: '1' }
]
field.label = ''
}
if (field.controls === false) {
field.preselect = 'all'
}
}
}
+15
src/initialize/field/live.js
'use strict'
module.exports = function (field, fields_live_update, fieldTypes, $instance) {
if (field.field_type === fieldTypes.text || field.field_type === fieldTypes.textarea) {
// jshint eqnull:true
if (fields_live_update && field.live_update == null) {
field.live_update = fields_live_update
}
} else if ('live_update' in field) {
delete field.live_update
}
if (field.live_update) {
$instance.$live_update = true
}
} 
+32
src/initialize/field/multiply.js
'use strict'
var extend = require('wsk-utils/var/object/extend')
module.exports = function (field, rootFields, fields_object) {
var field_name
var newField
var multiply_suffix
var j = 0
for (; j < field.multiply || 0; j += 1) {
multiply_suffix = '{' + j + '}' + '[' + j + ']'
field_name = field.name + multiply_suffix
newField = extend({}, field, {
required: j ? false : field.required,
stored_values: j ? null : field.stored_values
}, fields_object[field_name], {
name: field_name,
$orig: field.name,
$index: j,
multiply: field.multiply
})
delete newField.x
if ((rootFields[field.depends_on] || {}).multiply) {
newField.depends_on += multiply_suffix
}
rootFields[field_name] = newField
if (!j) {
rootFields[field.name].x = true
}
}
} 
+53
src/initialize/field/process.js
'use strict'
var isString = require('wsk-utils/var/is/string')
var isObject = require('wsk-utils/var/is/object')
var isArray = require('wsk-utils/var/is/object/array')
var each = require('wsk-utils/var/object/each')
module.exports = function (act, rootFields, rootPages, field, add_before_name) {
var field_name = act === 'delete' && isString(field) ? field : isObject(field) ? field.name : null
if (!field_name || !act || (act === 'add' ? rootFields[field_name] : !rootFields[field_name])) {
return
}
var name_to_process = field_name
if (act === 'add') {
if (add_before_name) {
name_to_process = add_before_name
} else { // add to top of first page
each(rootPages[0].fields, function (i, field) {
name_to_process = field.name
return false // break;
})
}
}
if (name_to_process) {
var _processPageFields = function (j, page_field, page) {
if (page_field.name === name_to_process) {
if (act === 'delete') {
delete rootFields[field_name]
page.fields.splice(j, 1)
} else {
rootFields[field_name] = field
page.fields.splice(j, act === 'add' ? 0 : 1, rootFields[field_name])
}
return false // break;
}
}
var _processPage = function (i, page) {
var done = each(page.fields, _processPageFields, page) === false
if (!done && isArray(page.sub)) {
done = each(page.sub, _processPage) === false
}
if (done) {
return false // break;
}
}
each(rootPages, _processPage)
}
} 
+90
src/initialize/field/value-default.js
'use strict'
var each = require('wsk-utils/var/object/each')
var isUndefined = require('wsk-utils/var/is/undefined')
var isObject = require('wsk-utils/var/is/object')
var isArray = require('wsk-utils/var/is/object/array')
var fieldValueSanitize = require('../../field/sanitize-value')
var findFieldOptionId = function (options, user_value, is_children) {
var founded
if (user_value && options) {
user_value = user_value.toLowerCase()
if (is_children) {
each(options, function (i, option) {
founded = findFieldOptionId(option, user_value)
if (founded) {
return false // break;
}
})
} else {
each(options, function (i, option) {
if (option.id.toLowerCase() === user_value || option.label.toLowerCase() === user_value) {
founded = options[i].id
return false // break;
}
})
}
}
// noinspection JSUnusedAssignment
return founded
}
module.exports = function (field, fieldTypes, $instance) {
var fields_values = $instance._fields_values
var fields_values_override = $instance._fields_values_override
var fields_values_user = $instance._fields_values_user
var fields_preselect_user = $instance._fields_preselect_user
// field.stored_values will be replaced by values settings, if it was DEFINED
// so, null, '', [] and so on will replace existing stored_values
var stored_values = fields_values[field.name]
var user_values = fields_values_user && (fields_values_user[field.name] || (field.$orig && fields_values_user[field.$orig])) || undefined
var user_preselects = fields_preselect_user && (fields_preselect_user[field.name] || (field.$orig && fields_preselect_user[field.$orig])) || undefined
if (field.multiply) {
user_values = fields_values_user && fields_values_user[field.$orig]
user_preselects = fields_preselect_user && fields_preselect_user[field.$orig]
}
if (isArray(user_values)) {
user_values = user_values[field.$index || 0]
}
if (isArray(user_preselects)) {
user_preselects = user_preselects[field.$index || 0]
}
if (field && !isUndefined(stored_values)) {
field.stored_values = isObject(stored_values) ? stored_values : [stored_values]
}
if (fields_values_user && !isUndefined(user_values)) {
// user values will override stored_values
if (
// if instance is top form (default functionality)
!$instance.parent ||
fields_values_override ||
// or if instance is child form and this field doesn't contain any stored_values (added functionality for task#16247)
!fieldValueSanitize(field.stored_values).shift()
) {
if (field.field_type === fieldTypes.select || field.field_type === fieldTypes.checkbox || field.field_type === fieldTypes.radio) {
field.stored_values = findFieldOptionId(field.children || field.options, user_values, field.depends_on)
} else {
field.stored_values = user_values
}
field.predefined = 'user'
}
} else if (field.stored_values && field.field_type === fieldTypes.select && field.stored_values.length > 1) {
field.predefined = false
}
if (user_preselects && !isUndefined(user_preselects)) {
if (
!$instance.parent ||
fields_values_override ||
!field.preselect
) {
if (field.field_type === fieldTypes.select || field.field_type === fieldTypes.checkbox || field.field_type === fieldTypes.radio) {
field.preselect = user_preselects
field.predefined = 'user'
}
}
}
}
+111
src/initialize/index.js
'use strict'
var noop = require('wsk-utils/var/noop')
var each = require('wsk-utils/var/object/each')
var extend = require('wsk-utils/var/object/extend')
var isArray = require('wsk-utils/var/is/object/array')
var isFunction = require('wsk-utils/var/is/function')
var isUndefined = require('wsk-utils/var/is/undefined')
var initFieldValueDefault = require('./field/value-default')
var initFieldBase = require('./field/base')
var initFieldCreate = require('./field/create')
var initFieldMultiply = require('./field/multiply')
var initFieldLive = require('./field/live')
var initFieldDependCombine = require('./field/depend-combine')
var initFieldDependency = require('./field/dependency')
var initFieldFinal = require('./field/final')
var pagesInit = require('./pages')
// initialize fields and pages
var _getArray = function (o, prop) {
return o && o[prop] && o[prop].length && o[prop].slice ? o[prop].slice(0) : false // slice - to avoid modifying raw fields
}
module.exports = function ($instance, formRaw, rootFields, rootPages, rootDependency, fieldTypes) {
fieldTypes = fieldTypes || $instance.fieldtypes
var call = $instance.call || noop
var setting = call('settings.get') || noop
var settingSetDefault = call('settings.setDefault')
var questions = isArray(formRaw) ? formRaw.slice() : (_getArray(formRaw.form, 'questions') || [])
if (!questions.length) {
if (!setting('allow_empty')) {
return
}
questions = [{ name: 'fsk%allowed%empty', field_type: fieldTypes.hidden, local: true }]
}
var fieldsSettings = setting('fields') || {}
// apply fields_hotfix for fields if present
var fieldsHotfix = setting('fields_hotfix')
if (!isUndefined(fieldsHotfix) && isFunction(fieldsHotfix.apply)) {
fieldsHotfix.apply(questions)
}
// base init fields
each(questions, function (i, question) {
initFieldBase(question, rootFields, fieldsSettings, fieldTypes)
})
var zipSettings
each(rootFields, function (i, field) {
initFieldMultiply(field, rootFields, fieldsSettings)
// only one zip instance per form
if (!zipSettings) {
zipSettings = fieldsSettings[field.name] && fieldsSettings[field.name].zip
if (!zipSettings && zipSettings !== false) {
zipSettings = rootFields[field.name].zip
}
if (zipSettings) {
settingSetDefault('zip', extend({ zip: field.name }, zipSettings))
}
}
})
each(rootFields, function (i, field) {
if (field.x) {
delete rootFields[field.name]
}
})
$instance._fields_values = setting('values') || {}
$instance._fields_values_override = setting('values_override') // TODO: manual
$instance._fields_values_user = setting('values_user') || null
$instance._fields_preselect_user = setting('preselect') || null // TODO: manual
// if we have user values (from url) and this instance is child form
if (($instance._fields_values_user || $instance._fields_preselect_user) && $instance.parent && !$instance._fields_values_override) {
// then we want to set user values for result-forms only if parent results instance is top and it's not followed by session (called with new clean public key)
if ($instance.parent.parent || $instance.parent.session.followed) {
$instance._fields_values_user = null
$instance._fields_preselect_user = null
}
}
each(rootFields, function (i, field) {
initFieldValueDefault(field, fieldTypes, $instance)
})
// create fields from fieldsSettings with create: true property
each(fieldsSettings, function (field_name, field) {
initFieldCreate(field, field_name, rootFields, $instance)
})
var fields_live_update = setting('fields_live_update') // TODO: manual
each(rootFields, function (i, field) {
initFieldLive(field, fields_live_update, fieldTypes, $instance)
})
pagesInit(setting('pages') || _getArray(formRaw, 'pages') || _getArray(formRaw.form, 'pages'), rootFields, rootPages, setting('pages_auto_generate'), setting('pages_auto_generate_label'), setting('pages_auto_generate_position'))
each(rootFields, function (i, field) {
initFieldDependCombine(field, rootFields, rootPages, fieldTypes)
})
each(rootFields, function (i, field) {
initFieldDependency(field, rootFields, rootPages, rootDependency)
})
each(rootFields, function (i, field) {
initFieldFinal(field, fieldTypes, formRaw.campaign)
})
}
+108
src/initialize/pages.js
'use strict'
var isString = require('wsk-utils/var/is/string')
var isObject = require('wsk-utils/var/is/object')
var isArray = require('wsk-utils/var/is/object/array')
var each = require('wsk-utils/var/object/each')
var extend = require('wsk-utils/var/object/extend')
var random = require('wsk-utils/var/string/random')
module.exports = function (pages_array, rootFields, rootPages, pages_auto_generate, pages_auto_generate_label, pages_auto_generate_position) {
// base init pages
var fields_temp = extend({}, rootFields)
// pages_auto_generate, pages_auto_generate_label and pages_auto_generate_position is deprecated
var auto_page_enabled = pages_auto_generate !== false
var auto_page_settings = { label: pages_auto_generate_label || '', classname: 'auto' }
var auto_page_position = pages_auto_generate_position === 'first' ? 0 : -1
var pagesInit = function (pages_array, auto_page) {
var pages = []
var _pagesExecuteBy = function (i, by, field) {
if (isString(by)) {
if (by.charAt(0) === '!') {
by = by.slice(1)
return !(field[by] === false)
} else {
var index = by.indexOf('=')
if (index > 0) {
return !(by.slice(index + 1) === field[by.slice(0, index)])
}
}
if (by in field) {
return !(field[by] === true)
}
}
}
var _pagesArrayProcess = function (i, page, pages, parentPages) {
var pageFields = page.fields
var pageFilter = page.filter
var pageFieldBy = page.by || undefined // todo: manual
if (pageFieldBy) {
pageFieldBy = isArray(pageFieldBy) ? pageFieldBy : [pageFieldBy]
}
if (!isObject(pageFields) && !pageFieldBy) {
if (pageFields === 'auto') {
extend(auto_page_settings, page)
if (parentPages) {
auto_page_position = parentPages.concat(pages.length)
} else {
auto_page_position = pages.length
}
} else {
auto_page_enabled = pageFields !== 'auto-skip'
}
return // continue;
}
var fields_in_page = []
each(pageFieldBy ? fields_temp : pageFields, function (j, _field) {
var field_name = isString(_field) ? _field : _field.name
var field = fields_temp[field_name]
if (field) {
if (pageFieldBy && (each(pageFieldBy, _pagesExecuteBy, field) !== false)) {
return // continue;
}
if ((auto_page && !auto_page_enabled) || (pageFilter && isString(pageFilter) && !rootFields[field_name][pageFilter])) {
delete rootFields[field_name]
} else {
fields_in_page.push(rootFields[field_name])
if (page.repeatable) {
delete rootFields[field_name]
}
}
delete fields_temp[field_name]
}
})
if (isArray(page.sub)) {
each(page.sub, _pagesArrayProcess, (page.sub = []), parentPages ? parentPages.concat(pages.length) : [pages.length])
}
if (fields_in_page.length) {
pages.push(extend({}, page, { hash: random(), fields: page.repeatable ? [] : fields_in_page, _fieldsOrig: !page.repeatable ? null : fields_in_page }))
}
}
each(pages_array, _pagesArrayProcess, pages)
if (!auto_page) {
auto_page_settings.fields = fields_temp
var p = pagesInit([auto_page_settings], true).pop(); var pagesStore = pages
if (p) {
if (isArray(auto_page_position)) {
while (auto_page_position.length > 1) {
pagesStore = pages[auto_page_position.shift()]
pagesStore = pagesStore && pagesStore.sub
}
}
if (pagesStore) {
pagesStore.splice(auto_page_position < 0 ? pages.length : auto_page_position, 0, p)
}
}
}
return pages
}
var pages = pagesInit(pages_array || [])
rootPages.push.apply(rootPages, pages)
}
+5
-5
index.js
'use strict'
var defaults = require('./defaults')
var initialize = require('./initialize')
var initializeFields = require('./field')
var defaults = require('./src/defaults')
var initialize = require('./src/initialize')
var initializeFields = require('./src/field')
var formValidate = require('./form/validate')
var formData = require('./form/get-data')
var formValidate = require('./src/form/validate')
var formData = require('./src/form/get-data')

@@ -9,0 +9,0 @@ function Fsk (fields) {

+4
-2
package.json
{
"name": "form-schema-kit",
"version": "1.0.0",
"version": "1.0.1",
"description": "Simple JSON form schema for generating live fields with validations, dependencies, pages.",
"main": "index.js",
"files": [],
"files": [
"src"
],
"scripts": {},

@@ -8,0 +10,0 @@ "repository": {