Google Git
Sign in
eclipse / gerrit / titan / titan.Libraries.Web_GUI / 76cfb02808925766efb856ef7de66e5063417ea4 / . / htdocs / Libs / JSONEditor / jsoneditor.custom.js
blob: 19b855218bcef7bbcc14b86cb1383ccc6492ef28 [file] [log] [blame]
/*! JSON Editor v0.7.23 - JSON Schema -> HTML Editor
* By Jeremy Dorn - https://github.com/jdorn/json-editor/
* Released under the MIT license
*
* Date: 2015-09-27
*/
/**
* See README.md for requirements and usage info
*/
(function() {
/*jshint loopfunc: true */
/* Simple JavaScript Inheritance
* By John Resig http://ejohn.org/
* MIT Licensed.
*/
// Inspired by base2 and Prototype
var Class;
(function() {
var initializing = false,
fnTest = /xyz/.test(function() {
window.postMessage("xyz");
}) ? /\b_super\b/ : /.*/;
// The base Class implementation (does nothing)
Class = function() {};
// Create a new Class that inherits from this class
Class.extend = function(prop) {
var _super = this.prototype;
// Instantiate a base class (but only create the instance,
// don't run the init constructor)
initializing = true;
var prototype = new this();
initializing = false;
// Copy the properties over onto the new prototype
for (var name in prop) {
// Check if we're overwriting an existing function
prototype[name] = typeof prop[name] == "function" &&
typeof _super[name] == "function" && fnTest.test(prop[name]) ?
(function(name, fn) {
return function() {
var tmp = this._super;
// Add a new ._super() method that is the same method
// but on the super-class
this._super = _super[name];
// The method only need to be bound temporarily, so we
// remove it when we're done executing
var ret = fn.apply(this, arguments);
this._super = tmp;
return ret;
};
})(name, prop[name]) :
prop[name];
}
// The dummy class constructor
function Class() {
// All construction is actually done in the init method
if (!initializing && this.init)
this.init.apply(this, arguments);
}
// Populate our constructed prototype object
Class.prototype = prototype;
// Enforce the constructor to be what we expect
Class.prototype.constructor = Class;
// And make this class extendable
Class.extend = arguments.callee;
return Class;
};
return Class;
})();
// CustomEvent constructor polyfill
// From MDN
(function() {
function CustomEvent(event, params) {
params = params || {
bubbles: false,
cancelable: false,
detail: undefined
};
var evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
return evt;
}
CustomEvent.prototype = window.Event.prototype;
window.CustomEvent = CustomEvent;
})();
// requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel
// MIT license
(function() {
var lastTime = 0;
var vendors = ['ms', 'moz', 'webkit', 'o'];
for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] ||
window[vendors[x] + 'CancelRequestAnimationFrame'];
}
if (!window.requestAnimationFrame)
window.requestAnimationFrame = function(callback, element) {
var currTime = new Date().getTime();
var timeToCall = Math.max(0, 16 - (currTime - lastTime));
var id = window.setTimeout(function() {
callback(currTime + timeToCall);
},
timeToCall);
lastTime = currTime + timeToCall;
return id;
};
if (!window.cancelAnimationFrame)
window.cancelAnimationFrame = function(id) {
clearTimeout(id);
};
}());
// Array.isArray polyfill
// From MDN
(function() {
if (!Array.isArray) {
Array.isArray = function(arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
}
}());
/**
* Taken from jQuery 2.1.3
*
* @param obj
* @returns {boolean}
*/
var $isplainobject = function(obj) {
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
if (typeof obj !== "object" || obj.nodeType || (obj !== null && obj === obj.window)) {
return false;
}
if (obj.constructor && !Object.prototype.hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")) {
return false;
}
// If the function hasn't returned already, we're confident that
// |obj| is a plain object, created by {} or constructed with new Object
return true;
};
var $extend = function(destination) {
var source, i, property;
for (i = 1; i < arguments.length; i++) {
source = arguments[i];
for (property in source) {
if (!source.hasOwnProperty(property)) continue;
if (source[property] && $isplainobject(source[property])) {
if (!destination.hasOwnProperty(property)) destination[property] = {};
$extend(destination[property], source[property]);
} else {
destination[property] = source[property];
}
}
}
return destination;
};
var $each = function(obj, callback) {
if (!obj || typeof obj !== "object") return;
var i;
if (Array.isArray(obj) || (typeof obj.length === 'number' && obj.length > 0 && (obj.length - 1) in obj)) {
for (i = 0; i < obj.length; i++) {
if (callback(i, obj[i]) === false) return;
}
} else {
if (Object.keys) {
var keys = Object.keys(obj);
for (i = 0; i < keys.length; i++) {
if (callback(keys[i], obj[keys[i]]) === false) return;
}
} else {
for (i in obj) {
if (!obj.hasOwnProperty(i)) continue;
if (callback(i, obj[i]) === false) return;
}
}
}
};
var $trigger = function(el, event) {
var e = document.createEvent('HTMLEvents');
e.initEvent(event, true, true);
el.dispatchEvent(e);
};
var $triggerc = function(el, event) {
var e = new CustomEvent(event, {
bubbles: true,
cancelable: true
});
el.dispatchEvent(e);
};
var JSONEditor = function(element, options) {
if (!(element instanceof Element)) {
throw new Error('element should be an instance of Element');
}
options = $extend({}, JSONEditor.defaults.options, options || {});
this.element = element;
this.options = options;
this.init();
};
JSONEditor.prototype = {
// necessary since we remove the ctor property by doing a literal assignment. Without this
// the $isplainobject function will think that this is a plain object.
constructor: JSONEditor,
init: function() {
var self = this;
this.ready = false;
var theme_class = JSONEditor.defaults.themes[this.options.theme || JSONEditor.defaults.theme];
if (!theme_class) throw "Unknown theme " + (this.options.theme || JSONEditor.defaults.theme);
this.schema = this.options.schema;
this.theme = new theme_class();
this.template = this.options.template;
this.refs = this.options.refs || {};
this.uuid = 0;
this.__data = {};
var icon_class = JSONEditor.defaults.iconlibs[this.options.iconlib || JSONEditor.defaults.iconlib];
if (icon_class) this.iconlib = new icon_class();
this.root_container = this.theme.getContainer();
this.element.appendChild(this.root_container);
this.translate = this.options.translate || JSONEditor.defaults.translate;
// Fetch all external refs via ajax
this._loadExternalRefs(this.schema, function() {
self._getDefinitions(self.schema);
// Validator options
var validator_options = {};
if (self.options.custom_validators) {
validator_options.custom_validators = self.options.custom_validators;
}
self.validator = new JSONEditor.Validator(self, null, validator_options);
// Create the root editor
var editor_class = self.getEditorClass(self.schema);
self.root = self.createEditor(editor_class, {
jsoneditor: self,
schema: self.schema,
required: true,
container: self.root_container
});
self.root.preBuild();
self.root.build();
self.root.postBuild();
// Starting data
if (self.options.startval) self.root.setValue(self.options.startval);
self.validation_results = self.validator.validate(self.root.getValue());
self.root.showValidationErrors(self.validation_results);
self.ready = true;
// Fire ready event asynchronously
window.requestAnimationFrame(function() {
if (!self.ready) return;
self.validation_results = self.validator.validate(self.root.getValue());
self.root.showValidationErrors(self.validation_results);
self.trigger('ready');
self.trigger('change');
});
});
},
getValue: function() {
if (!this.ready) throw "JSON Editor not ready yet. Listen for 'ready' event before getting the value";
return this.root.getValue();
},
setValue: function(value) {
if (!this.ready) throw "JSON Editor not ready yet. Listen for 'ready' event before setting the value";
this.root.setValue(value);
return this;
},
validate: function(value) {
if (!this.ready) throw "JSON Editor not ready yet. Listen for 'ready' event before validating";
// Custom value
if (arguments.length === 1) {
return this.validator.validate(value);
}
// Current value (use cached result)
else {
return this.validation_results;
}
},
destroy: function() {
if (this.destroyed) return;
if (!this.ready) return;
this.schema = null;
this.options = null;
this.root.destroy();
this.root = null;
this.root_container = null;
this.validator = null;
this.validation_results = null;
this.theme = null;
this.iconlib = null;
this.template = null;
this.__data = null;
this.ready = false;
this.element.innerHTML = '';
this.destroyed = true;
},
on: function(event, callback) {
this.callbacks = this.callbacks || {};
this.callbacks[event] = this.callbacks[event] || [];
this.callbacks[event].push(callback);
return this;
},
off: function(event, callback) {
// Specific callback
if (event && callback) {
this.callbacks = this.callbacks || {};
this.callbacks[event] = this.callbacks[event] || [];
var newcallbacks = [];
for (var i = 0; i < this.callbacks[event].length; i++) {
if (this.callbacks[event][i] === callback) continue;
newcallbacks.push(this.callbacks[event][i]);
}
this.callbacks[event] = newcallbacks;
}
// All callbacks for a specific event
else if (event) {
this.callbacks = this.callbacks || {};
this.callbacks[event] = [];
}
// All callbacks for all events
else {
this.callbacks = {};
}
return this;
},
trigger: function(event) {
if (this.callbacks && this.callbacks[event] && this.callbacks[event].length) {
for (var i = 0; i < this.callbacks[event].length; i++) {
this.callbacks[event][i]();
}
}
return this;
},
setOption: function(option, value) {
if (option === "show_errors") {
this.options.show_errors = value;
this.onChange();
}
// Only the `show_errors` option is supported for now
else {
throw "Option " + option + " must be set during instantiation and cannot be changed later";
}
return this;
},
getEditorClass: function(schema) {
var classname;
schema = this.expandSchema(schema);
$each(JSONEditor.defaults.resolvers, function(i, resolver) {
var tmp = resolver(schema);
if (tmp) {
if (JSONEditor.defaults.editors[tmp]) {
classname = tmp;
return false;
}
}
});
if (!classname) throw "Unknown editor for schema " + JSON.stringify(schema);
if (!JSONEditor.defaults.editors[classname]) throw "Unknown editor " + classname;
return JSONEditor.defaults.editors[classname];
},
createEditor: function(editor_class, options) {
options = $extend({}, editor_class.options || {}, options);
return new editor_class(options);
},
onChange: function() {
if (!this.ready) return;
if (this.firing_change) return;
this.firing_change = true;
var self = this;
window.requestAnimationFrame(function() {
self.firing_change = false;
if (!self.ready) return;
// Validate and cache results
self.validation_results = self.validator.validate(self.root.getValue());
if (self.options.show_errors !== "never") {
self.root.showValidationErrors(self.validation_results);
} else {
self.root.showValidationErrors([]);
}
// Fire change event
self.trigger('change');
});
return this;
},
compileTemplate: function(template, name) {
name = name || JSONEditor.defaults.template;
var engine;
// Specifying a preset engine
if (typeof name === 'string') {
if (!JSONEditor.defaults.templates[name]) throw "Unknown template engine " + name;
engine = JSONEditor.defaults.templates[name]();
if (!engine) throw "Template engine " + name + " missing required library.";
}
// Specifying a custom engine
else {
engine = name;
}
if (!engine) throw "No template engine set";
if (!engine.compile) throw "Invalid template engine set";
return engine.compile(template);
},
_data: function(el, key, value) {
// Setting data
if (arguments.length === 3) {
var uuid;
if (el.hasAttribute('data-jsoneditor-' + key)) {
uuid = el.getAttribute('data-jsoneditor-' + key);
} else {
uuid = this.uuid++;
el.setAttribute('data-jsoneditor-' + key, uuid);
}
this.__data[uuid] = value;
}
// Getting data
else {
// No data stored
if (!el.hasAttribute('data-jsoneditor-' + key)) return null;
return this.__data[el.getAttribute('data-jsoneditor-' + key)];
}
},
registerEditor: function(editor) {
this.editors = this.editors || {};
this.editors[editor.path] = editor;
return this;
},
unregisterEditor: function(editor) {
this.editors = this.editors || {};
this.editors[editor.path] = null;
return this;
},
getEditor: function(path) {
if (!this.editors) return;
return this.editors[path];
},
watch: function(path, callback) {
this.watchlist = this.watchlist || {};
this.watchlist[path] = this.watchlist[path] || [];
this.watchlist[path].push(callback);
return this;
},
unwatch: function(path, callback) {
if (!this.watchlist || !this.watchlist[path]) return this;
// If removing all callbacks for a path
if (!callback) {
this.watchlist[path] = null;
return this;
}
var newlist = [];
for (var i = 0; i < this.watchlist[path].length; i++) {
if (this.watchlist[path][i] === callback) continue;
else newlist.push(this.watchlist[path][i]);
}
this.watchlist[path] = newlist.length ? newlist : null;
return this;
},
notifyWatchers: function(path) {
if (!this.watchlist || !this.watchlist[path]) return this;
for (var i = 0; i < this.watchlist[path].length; i++) {
this.watchlist[path][i]();
}
},
isEnabled: function() {
return !this.root || this.root.isEnabled();
},
enable: function() {
this.root.enable();
},
disable: function() {
this.root.disable();
},
_getDefinitions: function(schema, path) {
path = path || '#/definitions/';
if (schema.definitions) {
for (var i in schema.definitions) {
if (!schema.definitions.hasOwnProperty(i)) continue;
this.refs[path + i] = schema.definitions[i];
if (schema.definitions[i].definitions) {
this._getDefinitions(schema.definitions[i], path + i + '/definitions/');
}
}
}
},
_getExternalRefs: function(schema) {
var refs = {};
var merge_refs = function(newrefs) {
for (var i in newrefs) {
if (newrefs.hasOwnProperty(i)) {
refs[i] = true;
}
}
};
if (schema.$ref && typeof schema.$ref !== "object" && schema.$ref.substr(0, 1) !== "#" && !this.refs[schema.$ref]) {
refs[schema.$ref] = true;
}
for (var i in schema) {
if (!schema.hasOwnProperty(i)) continue;
if (schema[i] && typeof schema[i] === "object" && Array.isArray(schema[i])) {
for (var j = 0; j < schema[i].length; j++) {
if (typeof schema[i][j] === "object") {
merge_refs(this._getExternalRefs(schema[i][j]));
}
}
} else if (schema[i] && typeof schema[i] === "object") {
merge_refs(this._getExternalRefs(schema[i]));
}
}
return refs;
},
_loadExternalRefs: function(schema, callback) {
var self = this;
var refs = this._getExternalRefs(schema);
var done = 0,
waiting = 0,
callback_fired = false;
$each(refs, function(url) {
if (self.refs[url]) return;
if (!self.options.ajax) throw "Must set ajax option to true to load external ref " + url;
self.refs[url] = 'loading';
waiting++;
var r = new XMLHttpRequest();
r.open("GET", url, true);
r.onreadystatechange = function() {
if (r.readyState != 4) return;
// Request succeeded
if (r.status === 200) {
var response;
try {
response = JSON.parse(r.responseText);
} catch (e) {
window.console.log(e);
throw "Failed to parse external ref " + url;
}
if (!response || typeof response !== "object") throw "External ref does not contain a valid schema - " + url;
self.refs[url] = response;
self._loadExternalRefs(response, function() {
done++;
if (done >= waiting && !callback_fired) {
callback_fired = true;
callback();
}
});
}
// Request failed
else {
window.console.log(r);
throw "Failed to fetch ref via ajax- " + url;
}
};
r.send();
});
if (!waiting) {
callback();
}
},
expandRefs: function(schema) {
schema = $extend({}, schema);
while (schema.$ref) {
var ref = schema.$ref;
delete schema.$ref;
if (!this.refs[ref]) ref = decodeURIComponent(ref);
schema = this.extendSchemas(schema, this.refs[ref]);
}
return schema;
},
expandSchema: function(schema) {
var self = this;
var extended = $extend({}, schema);
var i;
// Version 3 `type`
if (typeof schema.type === 'object') {
// Array of types
if (Array.isArray(schema.type)) {
$each(schema.type, function(key, value) {
// Schema
if (typeof value === 'object') {
schema.type[key] = self.expandSchema(value);
}
});
}
// Schema
else {
schema.type = self.expandSchema(schema.type);
}
}
// Version 3 `disallow`
if (typeof schema.disallow === 'object') {
// Array of types
if (Array.isArray(schema.disallow)) {
$each(schema.disallow, function(key, value) {
// Schema
if (typeof value === 'object') {
schema.disallow[key] = self.expandSchema(value);
}
});
}
// Schema
else {
schema.disallow = self.expandSchema(schema.disallow);
}
}
// Version 4 `anyOf`
if (schema.anyOf) {
$each(schema.anyOf, function(key, value) {
schema.anyOf[key] = self.expandSchema(value);
});
}
// Version 4 `dependencies` (schema dependencies)
if (schema.dependencies) {
$each(schema.dependencies, function(key, value) {
if (typeof value === "object" && !(Array.isArray(value))) {
schema.dependencies[key] = self.expandSchema(value);
}
});
}
// Version 4 `not`
if (schema.not) {
schema.not = this.expandSchema(schema.not);
}
// allOf schemas should be merged into the parent
if (schema.allOf) {
for (i = 0; i < schema.allOf.length; i++) {
extended = this.extendSchemas(extended, this.expandSchema(schema.allOf[i]));
}
delete extended.allOf;
}
// extends schemas should be merged into parent
if (schema["extends"]) {
// If extends is a schema
if (!(Array.isArray(schema["extends"]))) {
extended = this.extendSchemas(extended, this.expandSchema(schema["extends"]));
}
// If extends is an array of schemas
else {
for (i = 0; i < schema["extends"].length; i++) {
extended = this.extendSchemas(extended, this.expandSchema(schema["extends"][i]));
}
}
delete extended["extends"];
}
// parent should be merged into oneOf schemas
if (schema.oneOf) {
var tmp = $extend({}, extended);
delete tmp.oneOf;
for (i = 0; i < schema.oneOf.length; i++) {
extended.oneOf[i] = this.extendSchemas(this.expandSchema(schema.oneOf[i]), tmp);
}
}
return this.expandRefs(extended);
},
extendSchemas: function(obj1, obj2) {
obj1 = $extend({}, obj1);
obj2 = $extend({}, obj2);
var self = this;
var extended = {};
$each(obj1, function(prop, val) {
// If this key is also defined in obj2, merge them
if (typeof obj2[prop] !== "undefined") {
// Required arrays should be unioned together
if (prop === 'required' && typeof val === "object" && Array.isArray(val)) {
// Union arrays and unique
extended.required = val.concat(obj2[prop]).reduce(function(p, c) {
if (p.indexOf(c) < 0) p.push(c);
return p;
}, []);
}
// Type should be intersected and is either an array or string
else if (prop === 'type' && (typeof val === "string" || Array.isArray(val))) {
// Make sure we're dealing with arrays
if (typeof val === "string") val = [val];
if (typeof obj2.type === "string") obj2.type = [obj2.type];
extended.type = val.filter(function(n) {
return obj2.type.indexOf(n) !== -1;
});
// If there's only 1 type and it's a primitive, use a string instead of array
if (extended.type.length === 1 && typeof extended.type[0] === "string") {
extended.type = extended.type[0];
}
}
// All other arrays should be intersected (enum, etc.)
else if (typeof val === "object" && Array.isArray(val)) {
extended[prop] = val.filter(function(n) {
return obj2[prop].indexOf(n) !== -1;
});
}
// Objects should be recursively merged
else if (typeof val === "object" && val !== null) {
extended[prop] = self.extendSchemas(val, obj2[prop]);
}
// Otherwise, use the first value
else {
extended[prop] = val;
}
}
// Otherwise, just use the one in obj1
else {
extended[prop] = val;
}
});
// Properties in obj2 that aren't in obj1
$each(obj2, function(prop, val) {
if (typeof obj1[prop] === "undefined") {
extended[prop] = val;
}
});
return extended;
}
};
JSONEditor.defaults = {
themes: {},
templates: {},
iconlibs: {},
editors: {},
languages: {},
resolvers: [],
custom_validators: []
};
JSONEditor.Validator = Class.extend({
init: function(jsoneditor, schema, options) {
this.jsoneditor = jsoneditor;
this.schema = schema || this.jsoneditor.schema;
this.options = options || {};
this.translate = this.jsoneditor.translate || JSONEditor.defaults.translate;
},
validate: function(value) {
return this._validateSchema(this.schema, value);
},
_validateSchema: function(schema, value, path) {
var self = this;
var errors = [];
var valid, i, j;
var stringified = JSON.stringify(value);
path = path || 'root';
// Work on a copy of the schema
schema = $extend({}, this.jsoneditor.expandRefs(schema));
/*
* Type Agnostic Validation
*/
// Version 3 `required`
if (schema.required && schema.required === true) {
if (typeof value === "undefined") {
errors.push({
path: path,
property: 'required',
message: this.translate("error_notset")
});
// Can't do any more validation at this point
return errors;
}
}
// Value not defined
else if (typeof value === "undefined") {
// If required_by_default is set, all fields are required
if (this.jsoneditor.options.required_by_default) {
errors.push({
path: path,
property: 'required',
message: this.translate("error_notset")
});
}
// Not required, no further validation needed
else {
return errors;
}
}
// `enum`
if (schema["enum"]) {
valid = false;
for (i = 0; i < schema["enum"].length; i++) {
if (stringified === JSON.stringify(schema["enum"][i])) valid = true;
}
if (!valid) {
errors.push({
path: path,
property: 'enum',
message: this.translate("error_enum")
});
}
}
// `extends` (version 3)
if (schema["extends"]) {
for (i = 0; i < schema["extends"].length; i++) {
errors = errors.concat(this._validateSchema(schema["extends"][i], value, path));
}
}
// `allOf`
if (schema.allOf) {
for (i = 0; i < schema.allOf.length; i++) {
errors = errors.concat(this._validateSchema(schema.allOf[i], value, path));
}
}
// `anyOf`
if (schema.anyOf) {
valid = false;
for (i = 0; i < schema.anyOf.length; i++) {
if (!this._validateSchema(schema.anyOf[i], value, path).length) {
valid = true;
break;
}
}
if (!valid) {
errors.push({
path: path,
property: 'anyOf',
message: this.translate('error_anyOf')
});
}
}
// `oneOf`
if (schema.oneOf) {
valid = 0;
var oneof_errors = [];
for (i = 0; i < schema.oneOf.length; i++) {
// Set the error paths to be path.oneOf[i].rest.of.path
var tmp = this._validateSchema(schema.oneOf[i], value, path);
if (!tmp.length) {
valid++;
}
for (j = 0; j < tmp.length; j++) {
tmp[j].path = path + '.oneOf[' + i + ']' + tmp[j].path.substr(path.length);
}
oneof_errors = oneof_errors.concat(tmp);
}
if (valid !== 1) {
errors.push({
path: path,
property: 'oneOf',
message: this.translate('error_oneOf', [valid])
});
errors = errors.concat(oneof_errors);
}
}
// `not`
if (schema.not) {
if (!this._validateSchema(schema.not, value, path).length) {
errors.push({
path: path,
property: 'not',
message: this.translate('error_not')
});
}
}
// `type` (both Version 3 and Version 4 support)
if (schema.type) {
// Union type
if (Array.isArray(schema.type)) {
valid = false;
for (i = 0; i < schema.type.length; i++) {
if (this._checkType(schema.type[i], value)) {
valid = true;
break;
}
}
if (!valid) {
errors.push({
path: path,
property: 'type',
message: this.translate('error_type_union')
});
}
}
// Simple type
else {
if (!this._checkType(schema.type, value)) {
errors.push({
path: path,
property: 'type',
message: this.translate('error_type', [schema.type])
});
}
}
}
// `disallow` (version 3)
if (schema.disallow) {
// Union type
if (Array.isArray(schema.disallow)) {
valid = true;
for (i = 0; i < schema.disallow.length; i++) {
if (this._checkType(schema.disallow[i], value)) {
valid = false;
break;
}
}
if (!valid) {
errors.push({
path: path,
property: 'disallow',
message: this.translate('error_disallow_union')
});
}
}
// Simple type
else {
if (this._checkType(schema.disallow, value)) {
errors.push({
path: path,
property: 'disallow',
message: this.translate('error_disallow', [schema.disallow])
});
}
}
}
/*
* Type Specific Validation
*/
// Number Specific Validation
if (typeof value === "number") {
// `multipleOf` and `divisibleBy`
if (schema.multipleOf || schema.divisibleBy) {
valid = value / (schema.multipleOf || schema.divisibleBy);
if (valid !== Math.floor(valid)) {
errors.push({
path: path,
property: schema.multipleOf ? 'multipleOf' : 'divisibleBy',
message: this.translate('error_multipleOf', [schema.multipleOf || schema.divisibleBy])
});
}
}
// `maximum`
if (schema.hasOwnProperty('maximum')) {
if (schema.exclusiveMaximum && value >= schema.maximum) {
errors.push({
path: path,
property: 'maximum',
message: this.translate('error_maximum_excl', [schema.maximum])
});
} else if (!schema.exclusiveMaximum && value > schema.maximum) {
errors.push({
path: path,
property: 'maximum',
message: this.translate('error_maximum_incl', [schema.maximum])
});
}
}
// `minimum`
if (schema.hasOwnProperty('minimum')) {
if (schema.exclusiveMinimum && value <= schema.minimum) {
errors.push({
path: path,
property: 'minimum',
message: this.translate('error_minimum_excl', [schema.minimum])
});
} else if (!schema.exclusiveMinimum && value < schema.minimum) {
errors.push({
path: path,
property: 'minimum',
message: this.translate('error_minimum_incl', [schema.minimum])
});
}
}
}
// String specific validation
else if (typeof value === "string") {
// `maxLength`
if (schema.maxLength) {
if ((value + "").length > schema.maxLength) {
errors.push({
path: path,
property: 'maxLength',
message: this.translate('error_maxLength', [schema.maxLength])
});
}
}
// `minLength`
if (schema.minLength) {
if ((value + "").length < schema.minLength) {
errors.push({
path: path,
property: 'minLength',
message: this.translate((schema.minLength === 1 ? 'error_notempty' : 'error_minLength'), [schema.minLength])
});
}
}
// `pattern`
if (schema.pattern) {
if (!(new RegExp(schema.pattern)).test(value)) {
errors.push({
path: path,
property: 'pattern',
message: this.translate('error_pattern')
});
}
}
}
// Array specific validation
else if (typeof value === "object" && value !== null && Array.isArray(value)) {
// `items` and `additionalItems`
if (schema.items) {
// `items` is an array
if (Array.isArray(schema.items)) {
for (i = 0; i < value.length; i++) {
// If this item has a specific schema tied to it
// Validate against it
if (schema.items[i]) {
errors = errors.concat(this._validateSchema(schema.items[i], value[i], path + '.' + i));
}
// If all additional items are allowed
else if (schema.additionalItems === true) {
break;
}
// If additional items is a schema
// TODO: Incompatibility between version 3 and 4 of the spec
else if (schema.additionalItems) {
errors = errors.concat(this._validateSchema(schema.additionalItems, value[i], path + '.' + i));
}
// If no additional items are allowed
else if (schema.additionalItems === false) {
errors.push({
path: path,
property: 'additionalItems',
message: this.translate('error_additionalItems')
});
break;
}
// Default for `additionalItems` is an empty schema
else {
break;
}
}
}
// `items` is a schema
else {
// Each item in the array must validate against the schema
for (i = 0; i < value.length; i++) {
errors = errors.concat(this._validateSchema(schema.items, value[i], path + '.' + i));
}
}
}
// `maxItems`
if (schema.maxItems) {
if (value.length > schema.maxItems) {
errors.push({
path: path,
property: 'maxItems',
message: this.translate('error_maxItems', [schema.maxItems])
});
}
}
// `minItems`
if (schema.minItems) {
if (value.length < schema.minItems) {
errors.push({
path: path,
property: 'minItems',
message: this.translate('error_minItems', [schema.minItems])
});
}
}
// `uniqueItems`
if (schema.uniqueItems) {
var seen = {};
for (i = 0; i < value.length; i++) {
valid = JSON.stringify(value[i]);
if (seen[valid]) {
errors.push({
path: path,
property: 'uniqueItems',
message: this.translate('error_uniqueItems')
});
break;
}
seen[valid] = true;
}
}
}
// Object specific validation
else if (typeof value === "object" && value !== null) {
// `maxProperties`
if (schema.maxProperties) {
valid = 0;
for (i in value) {
if (!value.hasOwnProperty(i)) continue;
valid++;
}
if (valid > schema.maxProperties) {
errors.push({
path: path,
property: 'maxProperties',
message: this.translate('error_maxProperties', [schema.maxProperties])
});
}
}
// `minProperties`
if (schema.minProperties) {
valid = 0;
for (i in value) {
if (!value.hasOwnProperty(i)) continue;
valid++;
}
if (valid < schema.minProperties) {
errors.push({
path: path,
property: 'minProperties',
message: this.translate('error_minProperties', [schema.minProperties])
});
}
}
// Version 4 `required`
if (schema.required && Array.isArray(schema.required)) {
for (i = 0; i < schema.required.length; i++) {
if (typeof value[schema.required[i]] === "undefined") {
errors.push({
path: path,
property: 'required',
message: this.translate('error_required', [schema.required[i]])
});
}
}
}
// `properties`
var validated_properties = {};
if (schema.properties) {
for (i in schema.properties) {
if (!schema.properties.hasOwnProperty(i)) continue;
validated_properties[i] = true;
errors = errors.concat(this._validateSchema(schema.properties[i], value[i], path + '.' + i));
}
}
// `patternProperties`
if (schema.patternProperties) {
for (i in schema.patternProperties) {
if (!schema.patternProperties.hasOwnProperty(i)) continue;
var regex = new RegExp(i);
// Check which properties match
for (j in value) {
if (!value.hasOwnProperty(j)) continue;
if (regex.test(j)) {
validated_properties[j] = true;
errors = errors.concat(this._validateSchema(schema.patternProperties[i], value[j], path + '.' + j));
}
}
}
}
// The no_additional_properties option currently doesn't work with extended schemas that use oneOf or anyOf
if (typeof schema.additionalProperties === "undefined" && this.jsoneditor.options.no_additional_properties && !schema.oneOf && !schema.anyOf) {
schema.additionalProperties = false;
}
// `additionalProperties`
if (typeof schema.additionalProperties !== "undefined") {
for (i in value) {
if (!value.hasOwnProperty(i)) continue;
if (!validated_properties[i]) {
// No extra properties allowed
if (!schema.additionalProperties) {
errors.push({
path: path,
property: 'additionalProperties',
message: this.translate('error_additional_properties', [i])
});
break;
}
// Allowed
else if (schema.additionalProperties === true) {
break;
}
// Must match schema
// TODO: incompatibility between version 3 and 4 of the spec
else {
errors = errors.concat(this._validateSchema(schema.additionalProperties, value[i], path + '.' + i));
}
}
}
}
// `dependencies`
if (schema.dependencies) {
for (i in schema.dependencies) {
if (!schema.dependencies.hasOwnProperty(i)) continue;
// Doesn't need to meet the dependency
if (typeof value[i] === "undefined") continue;
// Property dependency
if (Array.isArray(schema.dependencies[i])) {
for (j = 0; j < schema.dependencies[i].length; j++) {
if (typeof value[schema.dependencies[i][j]] === "undefined") {
errors.push({
path: path,
property: 'dependencies',
message: this.translate('error_dependency', [schema.dependencies[i][j]])
});
}
}
}
// Schema dependency
else {
errors = errors.concat(this._validateSchema(schema.dependencies[i], value, path));
}
}
}
}
// Custom type validation (global)
$each(JSONEditor.defaults.custom_validators, function(i, validator) {
errors = errors.concat(validator.call(self, schema, value, path));
});
// Custom type validation (instance specific)
if (this.options.custom_validators) {
$each(this.options.custom_validators, function(i, validator) {
errors = errors.concat(validator.call(self, schema, value, path));
});
}
return errors;
},
_checkType: function(type, value) {
// Simple types
if (typeof type === "string") {
if (type === "string") return typeof value === "string";
else if (type === "number") return typeof value === "number";
else if (type === "integer") return typeof value === "number" && value === Math.floor(value);
else if (type === "boolean") return typeof value === "boolean";
else if (type === "array") return Array.isArray(value);
else if (type === "object") return value !== null && !(Array.isArray(value)) && typeof value === "object";
else if (type === "null") return value === null;
else return true;
}
// Schema
else {
return !this._validateSchema(type, value).length;
}
}
});
/**
* All editors should extend from this class
*/
JSONEditor.AbstractEditor = Class.extend({
onChildEditorChange: function(editor) {
this.onChange(true);
},
notify: function() {
this.jsoneditor.notifyWatchers(this.path);
},
change: function() {
if (this.parent) this.parent.onChildEditorChange(this);
else this.jsoneditor.onChange();
},
onChange: function(bubble) {
this.notify();
if (this.watch_listener) this.watch_listener();
if (bubble) this.change();
},
register: function() {
this.jsoneditor.registerEditor(this);
this.onChange();
},
unregister: function() {
if (!this.jsoneditor) return;
this.jsoneditor.unregisterEditor(this);
},
getNumColumns: function() {
return 12;
},
init: function(options) {
this.jsoneditor = options.jsoneditor;
this.theme = this.jsoneditor.theme;
this.template_engine = this.jsoneditor.template;
this.iconlib = this.jsoneditor.iconlib;
this.original_schema = options.schema;
this.schema = this.jsoneditor.expandSchema(this.original_schema);
this.options = $extend({}, (this.options || {}), (options.schema.options || {}), options);
if (!options.path && !this.schema.id) this.schema.id = 'root';
this.path = options.path || 'root';
this.formname = options.formname || this.path.replace(/\.([^.]+)/g, '[$1]');
if (this.jsoneditor.options.form_name_root) this.formname = this.formname.replace(/^root\[/, this.jsoneditor.options.form_name_root + '[');
this.key = this.path.split('.').pop();
this.parent = options.parent;
this.link_watchers = [];
if (options.container) this.setContainer(options.container);
},
setContainer: function(container) {
this.container = container;
if (this.schema.id) this.container.setAttribute('data-schemaid', this.schema.id);
if (this.schema.type && typeof this.schema.type === "string") this.container.setAttribute('data-schematype', this.schema.type);
this.container.setAttribute('data-schemapath', this.path);
},
preBuild: function() {
},
build: function() {
},
postBuild: function() {
this.setupWatchListeners();
this.addLinks();
this.setValue(this.getDefault(), true);
this.updateHeaderText();
this.register();
this.onWatchedFieldChange();
},
setupWatchListeners: function() {
var self = this;
// Watched fields
this.watched = {};
if (this.schema.vars) this.schema.watch = this.schema.vars;
this.watched_values = {};
this.watch_listener = function() {
if (self.refreshWatchedFieldValues()) {
self.onWatchedFieldChange();
}
};
this.register();
if (this.schema.hasOwnProperty('watch')) {
var path, path_parts, first, root, adjusted_path;
for (var name in this.schema.watch) {
if (!this.schema.watch.hasOwnProperty(name)) continue;
path = this.schema.watch[name];
if (Array.isArray(path)) {
path_parts = [path[0]].concat(path[1].split('.'));
} else {
path_parts = path.split('.');
if (!self.theme.closest(self.container, '[data-schemaid="' + path_parts[0] + '"]')) path_parts.unshift('#');
}
first = path_parts.shift();
if (first === '#') first = self.jsoneditor.schema.id || 'root';
// Find the root node for this template variable
root = self.theme.closest(self.container, '[data-schemaid="' + first + '"]');
if (!root) throw "Could not find ancestor node with id " + first;
// Keep track of the root node and path for use when rendering the template
adjusted_path = root.getAttribute('data-schemapath') + '.' + path_parts.join('.');
self.jsoneditor.watch(adjusted_path, self.watch_listener);
self.watched[name] = adjusted_path;
}
}
// Dynamic header
if (this.schema.headerTemplate) {
this.header_template = this.jsoneditor.compileTemplate(this.schema.headerTemplate, this.template_engine);
}
},
addLinks: function() {
// Add links
if (!this.no_link_holder) {
this.link_holder = this.theme.getLinksHolder();
this.container.appendChild(this.link_holder);
if (this.schema.links) {
for (var i = 0; i < this.schema.links.length; i++) {
this.addLink(this.getLink(this.schema.links[i]));
}
}
}
},
getButton: function(text, icon, title) {
var btnClass = 'json-editor-btn-' + icon;
if (!this.iconlib) icon = null;
else icon = this.iconlib.getIcon(icon);
if (!icon && title) {
text = title;
title = null;
}
var btn = this.theme.getButton(text, icon, title);
btn.className += ' ' + btnClass + ' ';
return btn;
},
setButtonText: function(button, text, icon, title) {
if (!this.iconlib) icon = null;
else icon = this.iconlib.getIcon(icon);
if (!icon && title) {
text = title;
title = null;
}
return this.theme.setButtonText(button, text, icon, title);
},
addLink: function(link) {
if (this.link_holder) this.link_holder.appendChild(link);
},
getLink: function(data) {
var holder, link;
// Get mime type of the link
var mime = data.mediaType || 'application/javascript';
var type = mime.split('/')[0];
// Template to generate the link href
var href = this.jsoneditor.compileTemplate(data.href, this.template_engine);
// Image links
if (type === 'image') {
holder = this.theme.getBlockLinkHolder();
link = document.createElement('a');
link.setAttribute('target', '_blank');
var image = document.createElement('img');
this.theme.createImageLink(holder, link, image);
// When a watched field changes, update the url
this.link_watchers.push(function(vars) {
var url = href(vars);
link.setAttribute('href', url);
link.setAttribute('title', data.rel || url);
image.setAttribute('src', url);
});
}
// Audio/Video links
else if (['audio', 'video'].indexOf(type) >= 0) {
holder = this.theme.getBlockLinkHolder();
link = this.theme.getBlockLink();
link.setAttribute('target', '_blank');
var media = document.createElement(type);
media.setAttribute('controls', 'controls');
this.theme.createMediaLink(holder, link, media);
// When a watched field changes, update the url
this.link_watchers.push(function(vars) {
var url = href(vars);
link.setAttribute('href', url);
link.textContent = data.rel || url;
media.setAttribute('src', url);
});
}
// Text links
else {
holder = this.theme.getBlockLink();
holder.setAttribute('target', '_blank');
holder.textContent = data.rel;
// When a watched field changes, update the url
this.link_watchers.push(function(vars) {
var url = href(vars);
holder.setAttribute('href', url);
holder.textContent = data.rel || url;
});
}
return holder;
},
refreshWatchedFieldValues: function() {
if (!this.watched_values) return;
var watched = {};
var changed = false;
var self = this;
if (this.watched) {
var val, editor;
for (var name in this.watched) {
if (!this.watched.hasOwnProperty(name)) continue;
editor = self.jsoneditor.getEditor(this.watched[name]);
val = editor ? editor.getValue() : null;
if (self.watched_values[name] !== val) changed = true;
watched[name] = val;
}
}
watched.self = this.getValue();
if (this.watched_values.self !== watched.self) changed = true;
this.watched_values = watched;
return changed;
},
getWatchedFieldValues: function() {
return this.watched_values;
},
updateHeaderText: function() {
if (this.header) {
// If the header has children, only update the text node's value
if (this.header.children.length) {
for (var i = 0; i < this.header.childNodes.length; i++) {
if (this.header.childNodes[i].nodeType === 3) {
this.header.childNodes[i].nodeValue = this.getHeaderText();
break;
}
}
}
// Otherwise, just update the entire node
else {
this.header.textContent = this.getHeaderText();
}
}
},
getHeaderText: function(title_only) {
if (this.header_text) return this.header_text;
else if (title_only) return this.schema.title;
else return this.getTitle();
},
onWatchedFieldChange: function() {
var vars;
if (this.header_template) {
vars = $extend(this.getWatchedFieldValues(), {
key: this.key,
i: this.key,
i0: (this.key * 1),
i1: (this.key * 1 + 1),
title: this.getTitle()
});
var header_text = this.header_template(vars);
if (header_text !== this.header_text) {
this.header_text = header_text;
this.updateHeaderText();
this.notify();
//this.fireChangeHeaderEvent();
}
}
if (this.link_watchers.length) {
vars = this.getWatchedFieldValues();
for (var i = 0; i < this.link_watchers.length; i++) {
this.link_watchers[i](vars);
}
}
},
setValue: function(value) {
this.value = value;
},
getValue: function() {
return this.value;
},
refreshValue: function() {
},
getChildEditors: function() {
return false;
},
destroy: function() {
var self = this;
this.unregister(this);
$each(this.watched, function(name, adjusted_path) {
self.jsoneditor.unwatch(adjusted_path, self.watch_listener);
});
this.watched = null;
this.watched_values = null;
this.watch_listener = null;
this.header_text = null;
this.header_template = null;
this.value = null;
if (this.container && this.container.parentNode) this.container.parentNode.removeChild(this.container);
this.container = null;
this.jsoneditor = null;
this.schema = null;
this.path = null;
this.key = null;
this.parent = null;
},
getDefault: function() {
if (this.schema["default"]) return this.schema["default"];
if (this.schema["enum"]) return this.schema["enum"][0];
var type = this.schema.type || this.schema.oneOf;
if (type && Array.isArray(type)) type = type[0];
if (type && typeof type === "object") type = type.type;
if (type && Array.isArray(type)) type = type[0];
if (typeof type === "string") {
if (type === "number") return 0.0;
if (type === "boolean") return false;
if (type === "integer") return 0;
if (type === "string") return "";
if (type === "object") return {};
if (type === "array") return [];
}
return null;
},
getTitle: function() {
return this.schema.title || this.key;
},
enable: function() {
this.disabled = false;
},
disable: function() {
this.disabled = true;
},
isEnabled: function() {
return !this.disabled;
},
isRequired: function() {
if (typeof this.schema.required === "boolean") return this.schema.required;
else if (this.parent && this.parent.schema && Array.isArray(this.parent.schema.required)) return this.parent.schema.required.indexOf(this.key) > -1;
else if (this.jsoneditor.options.required_by_default) return true;
else return false;
},
getDisplayText: function(arr) {
var disp = [];
var used = {};
// Determine how many times each attribute name is used.
// This helps us pick the most distinct display text for the schemas.
$each(arr, function(i, el) {
if (el.title) {
used[el.title] = used[el.title] || 0;
used[el.title]++;
}
if (el.description) {
used[el.description] = used[el.description] || 0;
used[el.description]++;
}
if (el.format) {
used[el.format] = used[el.format] || 0;
used[el.format]++;
}
if (el.type) {
used[el.type] = used[el.type] || 0;
used[el.type]++;
}
});
// Determine display text for each element of the array
$each(arr, function(i, el) {
var name;
// If it's a simple string
if (typeof el === "string") name = el;
// Object
else if (el.title && used[el.title] <= 1) name = el.title;
else if (el.format && used[el.format] <= 1) name = el.format;
else if (el.type && used[el.type] <= 1) name = el.type;
else if (el.description && used[el.description] <= 1) name = el.descripton;
else if (el.title) name = el.title;
else if (el.format) name = el.format;
else if (el.type) name = el.type;
else if (el.description) name = el.description;
else if (JSON.stringify(el).length < 50) name = JSON.stringify(el);
else name = "type";
disp.push(name);
});
// Replace identical display text with "text 1", "text 2", etc.
var inc = {};
$each(disp, function(i, name) {
inc[name] = inc[name] || 0;
inc[name]++;
if (used[name] > 1) disp[i] = name + " " + inc[name];
});
return disp;
},
getOption: function(key) {
try {
throw "getOption is deprecated";
} catch (e) {
window.console.error(e);
}
return this.options[key];
},
showValidationErrors: function(errors) {
}
});
JSONEditor.defaults.editors["null"] = JSONEditor.AbstractEditor.extend({
getValue: function() {
return null;
},
setValue: function() {
this.onChange();
},
getNumColumns: function() {
return 2;
}
});
JSONEditor.defaults.editors.string = JSONEditor.AbstractEditor.extend({
register: function() {
this._super();
if (!this.input) return;
this.input.setAttribute('name', this.formname);
},
unregister: function() {
this._super();
if (!this.input) return;
this.input.removeAttribute('name');
},
setValue: function(value, initial, from_template) {
var self = this;
if (this.template && !from_template) {
return;
}
if (value === null || typeof value === 'undefined') value = "";
else if (typeof value === "object") value = JSON.stringify(value);
else if (typeof value !== "string") value = "" + value;
if (value === this.serialized) return;
// Sanitize value before setting it
var sanitized = this.sanitize(value);
if (this.input.value === sanitized) {
return;
}
this.input.value = sanitized;
// If using SCEditor, update the WYSIWYG
if (this.sceditor_instance) {
this.sceditor_instance.val(sanitized);
} else if (this.epiceditor) {
this.epiceditor.importFile(null, sanitized);
} else if (this.ace_editor) {
this.ace_editor.setValue(sanitized);
}
var changed = from_template || this.getValue() !== value;
this.refreshValue();
if (initial) this.is_dirty = false;
else if (this.jsoneditor.options.show_errors === "change") this.is_dirty = true;
if (this.adjust_height) this.adjust_height(this.input);
// Bubble this setValue to parents if the value changed
this.onChange(changed);
},
getNumColumns: function() {
var min = Math.ceil(Math.max(this.getTitle().length, this.schema.maxLength || 0, this.schema.minLength || 0) / 5);
var num;
if (this.input_type === 'textarea') num = 6;
else if (['text', 'email'].indexOf(this.input_type) >= 0) num = 4;
else num = 2;
return Math.min(12, Math.max(min, num));
},
build: function() {
var self = this,
i;
if (!this.options.compact) this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
if (this.schema.description) this.description = this.theme.getFormInputDescription(this.schema.description);
this.format = this.schema.format;
if (!this.format && this.schema.media && this.schema.media.type) {
this.format = this.schema.media.type.replace(/(^(application|text)\/(x-)?(script\.)?)|(-source$)/g, '');
}
if (!this.format && this.options.default_format) {
this.format = this.options.default_format;
}
if (this.options.format) {
this.format = this.options.format;
}
// Specific format
if (this.format) {
// Text Area
if (this.format === 'textarea') {
this.input_type = 'textarea';
this.input = this.theme.getTextareaInput();
}
// Range Input
else if (this.format === 'range') {
this.input_type = 'range';
var min = this.schema.minimum || 0;
var max = this.schema.maximum || Math.max(100, min + 1);
var step = 1;
if (this.schema.multipleOf) {
if (min % this.schema.multipleOf) min = Math.ceil(min / this.schema.multipleOf) * this.schema.multipleOf;
if (max % this.schema.multipleOf) max = Math.floor(max / this.schema.multipleOf) * this.schema.multipleOf;
step = this.schema.multipleOf;
}
this.input = this.theme.getRangeInput(min, max, step);
}
// Source Code
else if ([
'actionscript',
'batchfile',
'bbcode',
'c',
'c++',
'cpp',
'coffee',
'csharp',
'css',
'dart',
'django',
'ejs',
'erlang',
'golang',
'handlebars',
'haskell',
'haxe',
'html',
'ini',
'jade',
'java',
'javascript',
'json',
'less',
'lisp',
'lua',
'makefile',
'markdown',
'matlab',
'mysql',
'objectivec',
'pascal',
'perl',
'pgsql',
'php',
'python',
'r',
'ruby',
'sass',
'scala',
'scss',
'smarty',
'sql',
'stylus',
'svg',
'twig',
'vbscript',
'xml',
'yaml'
].indexOf(this.format) >= 0) {
this.input_type = this.format;
this.source_code = true;
this.input = this.theme.getTextareaInput();
}
// HTML5 Input type
else {
this.input_type = this.format;
this.input = this.theme.getFormInputField(this.input_type);
}
}
// Normal text input
else {
this.input_type = 'text';
this.input = this.theme.getFormInputField(this.input_type);
}
// minLength, maxLength, and pattern
if (typeof this.schema.maxLength !== "undefined") this.input.setAttribute('maxlength', this.schema.maxLength);
if (typeof this.schema.pattern !== "undefined") this.input.setAttribute('pattern', this.schema.pattern);
else if (typeof this.schema.minLength !== "undefined") this.input.setAttribute('pattern', '.{' + this.schema.minLength + ',}');
if (this.options.compact) {
this.container.className += ' compact';
} else {
if (this.options.input_width) this.input.style.width = this.options.input_width;
}
if (this.schema.readOnly || this.schema.readonly || this.schema.template) {
this.always_disabled = true;
this.input.disabled = true;
}
this.input
.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
// Don't allow changing if this field is a template
if (self.schema.template) {
this.value = self.value;
return;
}
var val = this.value;
// sanitize value
var sanitized = self.sanitize(val);
if (val !== sanitized) {
this.value = sanitized;
}
self.is_dirty = true;
self.refreshValue();
self.onChange(true);
}, false);
if (this.options.input_height) this.input.style.height = this.options.input_height;
if (this.options.expand_height) {
this.adjust_height = function(el) {
if (!el) return;
var i, ch = el.offsetHeight;
// Input too short
if (el.offsetHeight < el.scrollHeight) {
i = 0;
while (el.offsetHeight < el.scrollHeight + 3) {
if (i > 100) break;
i++;
ch++;
el.style.height = ch + 'px';
}
} else {
i = 0;
while (el.offsetHeight >= el.scrollHeight + 3) {
if (i > 100) break;
i++;
ch--;
el.style.height = ch + 'px';
}
el.style.height = (ch + 1) + 'px';
}
};
this.input.addEventListener('keyup', function(e) {
self.adjust_height(this);
}, false);
this.input.addEventListener('change', function(e) {
self.adjust_height(this);
}, false);
this.adjust_height();
}
if (this.format) this.input.setAttribute('data-schemaformat', this.format);
this.control = this.theme.getFormControl(this.label, this.input, this.description);
this.container.appendChild(this.control);
// Any special formatting that needs to happen after the input is added to the dom
window.requestAnimationFrame(function() {
// Skip in case the input is only a temporary editor,
// otherwise, in the case of an ace_editor creation,
// it will generate an error trying to append it to the missing parentNode
if (self.input.parentNode) self.afterInputReady();
if (self.adjust_height) self.adjust_height(self.input);
});
// Compile and store the template
if (this.schema.template) {
this.template = this.jsoneditor.compileTemplate(this.schema.template, this.template_engine);
this.refreshValue();
} else {
this.refreshValue();
}
},
enable: function() {
if (!this.always_disabled) {
this.input.disabled = false;
// TODO: WYSIWYG and Markdown editors
}
this._super();
},
disable: function() {
this.input.disabled = true;
// TODO: WYSIWYG and Markdown editors
this._super();
},
afterInputReady: function() {
var self = this,
options;
// Code editor
if (this.source_code) {
// WYSIWYG html and bbcode editor
if (this.options.wysiwyg && ['html', 'bbcode'].indexOf(this.input_type) >= 0 &&
window.jQuery && window.jQuery.fn && window.jQuery.fn.sceditor
) {
options = $extend({}, {
plugins: self.input_type === 'html' ? 'xhtml' : 'bbcode',
emoticonsEnabled: false,
width: '100%',
height: 300
}, JSONEditor.plugins.sceditor, self.options.sceditor_options || {});
window.jQuery(self.input).sceditor(options);
self.sceditor_instance = window.jQuery(self.input).sceditor('instance');
self.sceditor_instance.blur(function() {
// Get editor's value
var val = window.jQuery("<div>" + self.sceditor_instance.val() + "</div>");
// Remove sceditor spans/divs
window.jQuery('#sceditor-start-marker,#sceditor-end-marker,.sceditor-nlf', val).remove();
// Set the value and update
self.input.value = val.html();
self.value = self.input.value;
self.is_dirty = true;
self.onChange(true);
});
}
// EpicEditor for markdown (if it's loaded)
else if (this.input_type === 'markdown' && window.EpicEditor) {
this.epiceditor_container = document.createElement('div');
this.input.parentNode.insertBefore(this.epiceditor_container, this.input);
this.input.style.display = 'none';
options = $extend({}, JSONEditor.plugins.epiceditor, {
container: this.epiceditor_container,
clientSideStorage: false
});
this.epiceditor = new window.EpicEditor(options).load();
this.epiceditor.importFile(null, this.getValue());
this.epiceditor.on('update', function() {
var val = self.epiceditor.exportFile();
self.input.value = val;
self.value = val;
self.is_dirty = true;
self.onChange(true);
});
}
// ACE editor for everything else
else if (window.ace) {
var mode = this.input_type;
// aliases for c/cpp
if (mode === 'cpp' || mode === 'c++' || mode === 'c') {
mode = 'c_cpp';
}
this.ace_container = document.createElement('div');
this.ace_container.style.width = '100%';
this.ace_container.style.position = 'relative';
this.ace_container.style.height = '400px';
this.input.parentNode.insertBefore(this.ace_container, this.input);
this.input.style.display = 'none';
this.ace_editor = window.ace.edit(this.ace_container);
this.ace_editor.setValue(this.getValue());
// The theme
if (JSONEditor.plugins.ace.theme) this.ace_editor.setTheme('ace/theme/' + JSONEditor.plugins.ace.theme);
// The mode
mode = window.ace.require("ace/mode/" + mode);
if (mode) this.ace_editor.getSession().setMode(new mode.Mode());
// Listen for changes
this.ace_editor.on('change', function() {
var val = self.ace_editor.getValue();
self.input.value = val;
self.refreshValue();
self.is_dirty = true;
self.onChange(true);
});
}
}
self.theme.afterInputReady(self.input);
},
refreshValue: function() {
this.value = this.input.value;
if (typeof this.value !== "string") this.value = '';
this.serialized = this.value;
},
destroy: function() {
// If using SCEditor, destroy the editor instance
if (this.sceditor_instance) {
this.sceditor_instance.destroy();
} else if (this.epiceditor) {
this.epiceditor.unload();
} else if (this.ace_editor) {
this.ace_editor.destroy();
}
this.template = null;
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
if (this.label && this.label.parentNode) this.label.parentNode.removeChild(this.label);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
this._super();
},
/**
* This is overridden in derivative editors
*/
sanitize: function(value) {
return value;
},
/**
* Re-calculates the value if needed
*/
onWatchedFieldChange: function() {
var self = this,
vars, j;
// If this editor needs to be rendered by a macro template
if (this.template) {
vars = this.getWatchedFieldValues();
this.setValue(this.template(vars), false, true);
}
this._super();
},
showValidationErrors: function(errors) {
var self = this;
if (this.jsoneditor.options.show_errors === "always") {} else if (!this.is_dirty && this.previous_error_setting === this.jsoneditor.options.show_errors) return;
this.previous_error_setting = this.jsoneditor.options.show_errors;
var messages = [];
$each(errors, function(i, error) {
if (error.path === self.path) {
messages.push(error.message);
}
});
if (messages.length) {
this.theme.addInputError(this.input, messages.join('. ') + '.');
} else {
this.theme.removeInputError(this.input);
}
}
});
JSONEditor.defaults.editors.number = JSONEditor.defaults.editors.string.extend({
sanitize: function(value) {
return (value + "").replace(/[^0-9\.\-eE]/g, '');
},
getNumColumns: function() {
return 2;
},
getValue: function() {
return this.value * 1;
}
});
JSONEditor.defaults.editors.integer = JSONEditor.defaults.editors.number.extend({
sanitize: function(value) {
value = value + "";
return value.replace(/[^0-9\-]/g, '');
},
getNumColumns: function() {
return 2;
}
});
JSONEditor.defaults.editors.object = JSONEditor.AbstractEditor.extend({
getDefault: function() {
return $extend({}, this.schema["default"] || {});
},
getChildEditors: function() {
return this.editors;
},
register: function() {
this._super();
if (this.editors) {
for (var i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
this.editors[i].register();
}
}
},
unregister: function() {
this._super();
if (this.editors) {
for (var i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
this.editors[i].unregister();
}
}
},
getNumColumns: function() {
return Math.max(Math.min(12, this.maxwidth), 3);
},
enable: function() {
if (this.editjson_button) this.editjson_button.disabled = false;
if (this.addproperty_button) this.addproperty_button.disabled = false;
this._super();
if (this.editors) {
for (var i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
this.editors[i].enable();
}
}
},
disable: function() {
if (this.editjson_button) this.editjson_button.disabled = true;
if (this.addproperty_button) this.addproperty_button.disabled = true;
this.hideEditJSON();
this._super();
if (this.editors) {
for (var i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
this.editors[i].disable();
}
}
},
layoutEditors: function() {
var self = this,
i, j;
if (!this.row_container) return;
// Sort editors by propertyOrder
this.property_order = Object.keys(this.editors);
this.property_order = this.property_order.sort(function(a, b) {
var ordera = self.editors[a].schema.propertyOrder;
var orderb = self.editors[b].schema.propertyOrder;
if (typeof ordera !== "number") ordera = 1000;
if (typeof orderb !== "number") orderb = 1000;
return ordera - orderb;
});
var container;
if (this.format === 'grid') {
var rows = [];
$each(this.property_order, function(j, key) {
var editor = self.editors[key];
if (editor.property_removed) return;
var found = false;
var width = editor.options.hidden ? 0 : (editor.options.grid_columns || editor.getNumColumns());
var height = editor.options.hidden ? 0 : editor.container.offsetHeight;
// See if the editor will fit in any of the existing rows first
for (var i = 0; i < rows.length; i++) {
// If the editor will fit in the row horizontally
if (rows[i].width + width <= 12) {
// If the editor is close to the other elements in height
// i.e. Don't put a really tall editor in an otherwise short row or vice versa
if (!height || (rows[i].minh * 0.5 < height && rows[i].maxh * 2 > height)) {
found = i;
}
}
}
// If there isn't a spot in any of the existing rows, start a new row
if (found === false) {
rows.push({
width: 0,
minh: 999999,
maxh: 0,
editors: []
});
found = rows.length - 1;
}
rows[found].editors.push({
key: key,
//editor: editor,
width: width,
height: height
});
rows[found].width += width;
rows[found].minh = Math.min(rows[found].minh, height);
rows[found].maxh = Math.max(rows[found].maxh, height);
});
// Make almost full rows width 12
// Do this by increasing all editors' sizes proprotionately
// Any left over space goes to the biggest editor
// Don't touch rows with a width of 6 or less
for (i = 0; i < rows.length; i++) {
if (rows[i].width < 12) {
var biggest = false;
var new_width = 0;
for (j = 0; j < rows[i].editors.length; j++) {
if (biggest === false) biggest = j;
else if (rows[i].editors[j].width > rows[i].editors[biggest].width) biggest = j;
rows[i].editors[j].width *= 12 / rows[i].width;
rows[i].editors[j].width = Math.floor(rows[i].editors[j].width);
new_width += rows[i].editors[j].width;
}
if (new_width < 12) rows[i].editors[biggest].width += 12 - new_width;
rows[i].width = 12;
}
}
// layout hasn't changed
if (this.layout === JSON.stringify(rows)) return false;
this.layout = JSON.stringify(rows);
// Layout the form
container = document.createElement('div');
for (i = 0; i < rows.length; i++) {
var row = this.theme.getGridRow();
container.appendChild(row);
for (j = 0; j < rows[i].editors.length; j++) {
var key = rows[i].editors[j].key;
var editor = this.editors[key];
if (editor.options.hidden) editor.container.style.display = 'none';
else this.theme.setGridColumnSize(editor.container, rows[i].editors[j].width);
row.appendChild(editor.container);
}
}
}
// Normal layout
else {
container = document.createElement('div');
$each(this.property_order, function(i, key) {
var editor = self.editors[key];
if (editor.property_removed) return;
var row = self.theme.getGridRow();
container.appendChild(row);
if (editor.options.hidden) editor.container.style.display = 'none';
else self.theme.setGridColumnSize(editor.container, 12);
row.appendChild(editor.container);
});
}
this.row_container.innerHTML = '';
this.row_container.appendChild(container);
},
getPropertySchema: function(key) {
// Schema declared directly in properties
var schema = this.schema.properties[key] || {};
schema = $extend({}, schema);
var matched = this.schema.properties[key] ? true : false;
// Any matching patternProperties should be merged in
if (this.schema.patternProperties) {
for (var i in this.schema.patternProperties) {
if (!this.schema.patternProperties.hasOwnProperty(i)) continue;
var regex = new RegExp(i);
if (regex.test(key)) {
schema.allOf = schema.allOf || [];
schema.allOf.push(this.schema.patternProperties[i]);
matched = true;
}
}
}
// Hasn't matched other rules, use additionalProperties schema
if (!matched && this.schema.additionalProperties && typeof this.schema.additionalProperties === "object") {
schema = $extend({}, this.schema.additionalProperties);
}
return schema;
},
preBuild: function() {
this._super();
this.editors = {};
this.cached_editors = {};
var self = this;
this.format = this.options.layout || this.options.object_layout || this.schema.format || this.jsoneditor.options.object_layout || 'normal';
this.schema.properties = this.schema.properties || {};
this.minwidth = 0;
this.maxwidth = 0;
// If the object should be rendered as a table row
if (this.options.table_row) {
$each(this.schema.properties, function(key, schema) {
var editor = self.jsoneditor.getEditorClass(schema);
self.editors[key] = self.jsoneditor.createEditor(editor, {
jsoneditor: self.jsoneditor,
schema: schema,
path: self.path + '.' + key,
parent: self,
compact: true,
required: true
});
self.editors[key].preBuild();
var width = self.editors[key].options.hidden ? 0 : (self.editors[key].options.grid_columns || self.editors[key].getNumColumns());
self.minwidth += width;
self.maxwidth += width;
});
this.no_link_holder = true;
}
// If the object should be rendered as a table
else if (this.options.table) {
// TODO: table display format
throw "Not supported yet";
}
// If the object should be rendered as a div
else {
this.defaultProperties = this.schema.defaultProperties || Object.keys(this.schema.properties);
// Increase the grid width to account for padding
self.maxwidth += 1;
$each(this.defaultProperties, function(i, key) {
self.addObjectProperty(key, true);
if (self.editors[key]) {
self.minwidth = Math.max(self.minwidth, (self.editors[key].options.grid_columns || self.editors[key].getNumColumns()));
self.maxwidth += (self.editors[key].options.grid_columns || self.editors[key].getNumColumns());
}
});
}
// Sort editors by propertyOrder
this.property_order = Object.keys(this.editors);
this.property_order = this.property_order.sort(function(a, b) {
var ordera = self.editors[a].schema.propertyOrder;
var orderb = self.editors[b].schema.propertyOrder;
if (typeof ordera !== "number") ordera = 1000;
if (typeof orderb !== "number") orderb = 1000;
return ordera - orderb;
});
},
build: function() {
var self = this;
// If the object should be rendered as a table row
if (this.options.table_row) {
this.editor_holder = this.container;
$each(this.editors, function(key, editor) {
var holder = self.theme.getTableCell();
self.editor_holder.appendChild(holder);
editor.setContainer(holder);
editor.build();
editor.postBuild();
if (self.editors[key].options.hidden) {
holder.style.display = 'none';
}
if (self.editors[key].options.input_width) {
holder.style.width = self.editors[key].options.input_width;
}
});
}
// If the object should be rendered as a table
else if (this.options.table) {
// TODO: table display format
throw "Not supported yet";
}
// If the object should be rendered as a div
else {
this.header = document.createElement('span');
this.header.textContent = this.getTitle();
this.title = this.theme.getHeader(this.header);
this.container.appendChild(this.title);
this.container.style.position = 'relative';
// Edit JSON modal
this.editjson_holder = this.theme.getModal();
this.editjson_textarea = this.theme.getTextareaInput();
this.editjson_textarea.style.height = '170px';
this.editjson_textarea.style.width = '300px';
this.editjson_textarea.style.display = 'block';
this.editjson_save = this.getButton('Save', 'save', 'Save');
this.editjson_save.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.saveJSON();
}, false);
this.editjson_cancel = this.getButton('Cancel', 'cancel', 'Cancel');
this.editjson_cancel.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.hideEditJSON();
}, false);
this.editjson_holder.appendChild(this.editjson_textarea);
this.editjson_holder.appendChild(this.editjson_save);
this.editjson_holder.appendChild(this.editjson_cancel);
// Manage Properties modal
this.addproperty_holder = this.theme.getModal();
this.addproperty_list = document.createElement('div');
this.addproperty_list.style.width = '295px';
this.addproperty_list.style.maxHeight = '160px';
this.addproperty_list.style.padding = '5px 0';
this.addproperty_list.style.overflowY = 'auto';
this.addproperty_list.style.overflowX = 'hidden';
this.addproperty_list.style.paddingLeft = '5px';
this.addproperty_list.setAttribute('class', 'property-selector');
this.addproperty_add = this.getButton('add', 'add', 'add');
this.addproperty_input = this.theme.getFormInputField('text');
this.addproperty_input.setAttribute('placeholder', 'Property name...');
this.addproperty_input.style.width = '220px';
this.addproperty_input.style.marginBottom = '0';
this.addproperty_input.style.display = 'inline-block';
this.addproperty_add.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
if (self.addproperty_input.value) {
if (self.editors[self.addproperty_input.value]) {
window.alert('there is already a property with that name');
return;
}
self.addObjectProperty(self.addproperty_input.value);
if (self.editors[self.addproperty_input.value]) {
self.editors[self.addproperty_input.value].disable();
}
self.onChange(true);
}
}, false);
this.addproperty_holder.appendChild(this.addproperty_list);
this.addproperty_holder.appendChild(this.addproperty_input);
this.addproperty_holder.appendChild(this.addproperty_add);
var spacer = document.createElement('div');
spacer.style.clear = 'both';
this.addproperty_holder.appendChild(spacer);
// Description
if (this.schema.description) {
this.description = this.theme.getDescription(this.schema.description);
this.container.appendChild(this.description);
}
// Validation error placeholder area
this.error_holder = document.createElement('div');
this.container.appendChild(this.error_holder);
// Container for child editor area
this.editor_holder = this.theme.getIndentedPanel();
this.container.appendChild(this.editor_holder);
// Container for rows of child editors
this.row_container = this.theme.getGridContainer();
this.editor_holder.appendChild(this.row_container);
$each(this.editors, function(key, editor) {
var holder = self.theme.getGridColumn();
self.row_container.appendChild(holder);
editor.setContainer(holder);
editor.build();
editor.postBuild();
});
// Control buttons
this.title_controls = this.theme.getHeaderButtonHolder();
this.editjson_controls = this.theme.getHeaderButtonHolder();
this.addproperty_controls = this.theme.getHeaderButtonHolder();
this.title.appendChild(this.title_controls);
this.title.appendChild(this.editjson_controls);
this.title.appendChild(this.addproperty_controls);
// Show/Hide button
this.collapsed = false;
this.toggle_button = this.getButton('', 'collapse', 'Collapse');
this.title_controls.appendChild(this.toggle_button);
this.toggle_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
if (self.collapsed) {
self.editor_holder.style.display = '';
self.collapsed = false;
self.setButtonText(self.toggle_button, '', 'collapse', 'Collapse');
} else {
self.editor_holder.style.display = 'none';
self.collapsed = true;
self.setButtonText(self.toggle_button, '', 'expand', 'Expand');
}
}, false);
// If it should start collapsed
if (this.options.collapsed) {
$trigger(this.toggle_button, 'click');
}
// Collapse button disabled
if (this.schema.options && typeof this.schema.options.disable_collapse !== "undefined") {
if (this.schema.options.disable_collapse) this.toggle_button.style.display = 'none';
} else if (this.jsoneditor.options.disable_collapse) {
this.toggle_button.style.display = 'none';
}
// Edit JSON Button
this.editjson_button = this.getButton('JSON', 'edit', 'Edit JSON');
this.editjson_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.toggleEditJSON();
}, false);
this.editjson_controls.appendChild(this.editjson_button);
this.editjson_controls.appendChild(this.editjson_holder);
// Edit JSON Buttton disabled
if (this.schema.options && typeof this.schema.options.disable_edit_json !== "undefined") {
if (this.schema.options.disable_edit_json) this.editjson_button.style.display = 'none';
} else if (this.jsoneditor.options.disable_edit_json) {
this.editjson_button.style.display = 'none';
}
// Object Properties Button
this.addproperty_button = this.getButton('Properties', 'edit', 'Object Properties');
this.addproperty_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.toggleAddProperty();
}, false);
this.addproperty_controls.appendChild(this.addproperty_button);
this.addproperty_controls.appendChild(this.addproperty_holder);
this.refreshAddProperties();
}
// Fix table cell ordering
if (this.options.table_row) {
this.editor_holder = this.container;
$each(this.property_order, function(i, key) {
self.editor_holder.appendChild(self.editors[key].container);
});
}
// Layout object editors in grid if needed
else {
// Initial layout
this.layoutEditors();
// Do it again now that we know the approximate heights of elements
this.layoutEditors();
}
},
showEditJSON: function() {
if (!this.editjson_holder) return;
this.hideAddProperty();
// Position the form directly beneath the button
// TODO: edge detection
this.editjson_holder.style.left = this.editjson_button.offsetLeft + "px";
this.editjson_holder.style.top = this.editjson_button.offsetTop + this.editjson_button.offsetHeight + "px";
// Start the textarea with the current value
this.editjson_textarea.value = JSON.stringify(this.getValue(), null, 2);
// Disable the rest of the form while editing JSON
this.disable();
this.editjson_holder.style.display = '';
this.editjson_button.disabled = false;
this.editing_json = true;
},
hideEditJSON: function() {
if (!this.editjson_holder) return;
if (!this.editing_json) return;
this.editjson_holder.style.display = 'none';
this.enable();
this.editing_json = false;
},
saveJSON: function() {
if (!this.editjson_holder) return;
try {
var json = JSON.parse(this.editjson_textarea.value);
this.setValue(json);
this.hideEditJSON();
} catch (e) {
window.alert('invalid JSON');
throw e;
}
},
toggleEditJSON: function() {
if (this.editing_json) this.hideEditJSON();
else this.showEditJSON();
},
insertPropertyControlUsingPropertyOrder: function(property, control, container) {
var propertyOrder;
if (this.schema.properties[property])
propertyOrder = this.schema.properties[property].propertyOrder;
if (typeof propertyOrder !== "number") propertyOrder = 1000;
control.propertyOrder = propertyOrder;
for (var i = 0; i < container.childNodes.length; i++) {
var child = container.childNodes[i];
if (control.propertyOrder < child.propertyOrder) {
this.addproperty_list.insertBefore(control, child);
control = null;
break;
}
}
if (control) {
this.addproperty_list.appendChild(control);
}
},
addPropertyCheckbox: function(key) {
var self = this;
var checkbox, label, labelText, control;
checkbox = self.theme.getCheckbox();
checkbox.style.width = 'auto';
if (this.schema.properties[key] && this.schema.properties[key].title)
labelText = this.schema.properties[key].title;
else
labelText = key;
label = self.theme.getCheckboxLabel(labelText);
control = self.theme.getFormControl(label, checkbox);
control.style.paddingBottom = control.style.marginBottom = control.style.paddingTop = control.style.marginTop = 0;
control.style.height = 'auto';
//control.style.overflowY = 'hidden';
this.insertPropertyControlUsingPropertyOrder(key, control, this.addproperty_list);
checkbox.checked = key in this.editors;
checkbox.addEventListener('change', function() {
if (checkbox.checked) {
self.addObjectProperty(key);
} else {
self.removeObjectProperty(key);
}
self.onChange(true);
}, false);
self.addproperty_checkboxes[key] = checkbox;
return checkbox;
},
showAddProperty: function() {
if (!this.addproperty_holder) return;
this.hideEditJSON();
// Position the form directly beneath the button
// TODO: edge detection
this.addproperty_holder.style.left = this.addproperty_button.offsetLeft + "px";
this.addproperty_holder.style.top = this.addproperty_button.offsetTop + this.addproperty_button.offsetHeight + "px";
// Disable the rest of the form while editing JSON
this.disable();
this.adding_property = true;
this.addproperty_button.disabled = false;
this.addproperty_holder.style.display = '';
this.refreshAddProperties();
},
hideAddProperty: function() {
if (!this.addproperty_holder) return;
if (!this.adding_property) return;
this.addproperty_holder.style.display = 'none';
this.enable();
this.adding_property = false;
},
toggleAddProperty: function() {
if (this.adding_property) this.hideAddProperty();
else this.showAddProperty();
},
removeObjectProperty: function(property) {
if (this.editors[property]) {
this.editors[property].unregister();
delete this.editors[property];
this.refreshValue();
this.layoutEditors();
}
},
addObjectProperty: function(name, prebuild_only) {
var self = this;
// Property is already added
if (this.editors[name]) return;
// Property was added before and is cached
if (this.cached_editors[name]) {
this.editors[name] = this.cached_editors[name];
if (prebuild_only) return;
this.editors[name].register();
}
// New property
else {
if (!this.canHaveAdditionalProperties() && (!this.schema.properties || !this.schema.properties[name])) {
return;
}
var schema = self.getPropertySchema(name);
// Add the property
var editor = self.jsoneditor.getEditorClass(schema);
self.editors[name] = self.jsoneditor.createEditor(editor, {
jsoneditor: self.jsoneditor,
schema: schema,
path: self.path + '.' + name,
parent: self
});
self.editors[name].preBuild();
if (!prebuild_only) {
var holder = self.theme.getChildEditorHolder();
self.editor_holder.appendChild(holder);
self.editors[name].setContainer(holder);
self.editors[name].build();
self.editors[name].postBuild();
}
self.cached_editors[name] = self.editors[name];
}
// If we're only prebuilding the editors, don't refresh values
if (!prebuild_only) {
self.refreshValue();
self.layoutEditors();
}
},
onChildEditorChange: function(editor) {
this.refreshValue();
this._super(editor);
},
canHaveAdditionalProperties: function() {
if (typeof this.schema.additionalProperties === "boolean") {
return this.schema.additionalProperties;
}
return !this.jsoneditor.options.no_additional_properties;
},
destroy: function() {
$each(this.cached_editors, function(i, el) {
el.destroy();
});
if (this.editor_holder) this.editor_holder.innerHTML = '';
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.error_holder && this.error_holder.parentNode) this.error_holder.parentNode.removeChild(this.error_holder);
this.editors = null;
this.cached_editors = null;
if (this.editor_holder && this.editor_holder.parentNode) this.editor_holder.parentNode.removeChild(this.editor_holder);
this.editor_holder = null;
this._super();
},
getValue: function() {
var result = this._super();
if (this.jsoneditor.options.remove_empty_properties || this.options.remove_empty_properties) {
for (var i in result) {
if (result.hasOwnProperty(i)) {
if (!result[i]) delete result[i];
}
}
}
return result;
},
refreshValue: function() {
this.value = {};
var self = this;
for (var i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
this.value[i] = this.editors[i].getValue();
}
if (this.adding_property) this.refreshAddProperties();
},
refreshAddProperties: function() {
if (this.options.disable_properties || (this.options.disable_properties !== false && this.jsoneditor.options.disable_properties)) {
this.addproperty_controls.style.display = 'none';
return;
}
var can_add = false,
can_remove = false,
num_props = 0,
i, show_modal = false;
// Get number of editors
for (i in this.editors) {
if (!this.editors.hasOwnProperty(i)) continue;
num_props++;
}
// Determine if we can add back removed properties
can_add = this.canHaveAdditionalProperties() && !(typeof this.schema.maxProperties !== "undefined" && num_props >= this.schema.maxProperties);
if (this.addproperty_checkboxes) {
this.addproperty_list.innerHTML = '';
}
this.addproperty_checkboxes = {};
// Check for which editors can't be removed or added back
for (i in this.cached_editors) {
if (!this.cached_editors.hasOwnProperty(i)) continue;
this.addPropertyCheckbox(i);
if (this.isRequired(this.cached_editors[i]) && i in this.editors) {
this.addproperty_checkboxes[i].disabled = true;
}
if (typeof this.schema.minProperties !== "undefined" && num_props <= this.schema.minProperties) {
this.addproperty_checkboxes[i].disabled = this.addproperty_checkboxes[i].checked;
if (!this.addproperty_checkboxes[i].checked) show_modal = true;
} else if (!(i in this.editors)) {
if (!can_add && !this.schema.properties.hasOwnProperty(i)) {
this.addproperty_checkboxes[i].disabled = true;
} else {
this.addproperty_checkboxes[i].disabled = false;
show_modal = true;
}
} else {
show_modal = true;
can_remove = true;
}
}
if (this.canHaveAdditionalProperties()) {
show_modal = true;
}
// Additional addproperty checkboxes not tied to a current editor
for (i in this.schema.properties) {
if (!this.schema.properties.hasOwnProperty(i)) continue;
if (this.cached_editors[i]) continue;
show_modal = true;
this.addPropertyCheckbox(i);
}
// If no editors can be added or removed, hide the modal button
if (!show_modal) {
this.hideAddProperty();
this.addproperty_controls.style.display = 'none';
}
// If additional properties are disabled
else if (!this.canHaveAdditionalProperties()) {
this.addproperty_add.style.display = 'none';
this.addproperty_input.style.display = 'none';
}
// If no new properties can be added
else if (!can_add) {
this.addproperty_add.disabled = true;
}
// If new properties can be added
else {
this.addproperty_add.disabled = false;
}
},
isRequired: function(editor) {
if (typeof editor.schema.required === "boolean") return editor.schema.required;
else if (Array.isArray(this.schema.required)) return this.schema.required.indexOf(editor.key) > -1;
else if (this.jsoneditor.options.required_by_default) return true;
else return false;
},
setValue: function(value, initial) {
var self = this;
value = value || {};
if (typeof value !== "object" || Array.isArray(value)) value = {};
// First, set the values for all of the defined properties
$each(this.cached_editors, function(i, editor) {
// Value explicitly set
if (typeof value[i] !== "undefined") {
self.addObjectProperty(i);
editor.setValue(value[i], initial);
}
// Otherwise, remove value unless this is the initial set or it's required
else if (!initial && !self.isRequired(editor)) {
self.removeObjectProperty(i);
}
// Otherwise, set the value to the default
else {
editor.setValue(editor.getDefault(), initial);
}
});
$each(value, function(i, val) {
if (!self.cached_editors[i]) {
self.addObjectProperty(i);
if (self.editors[i]) self.editors[i].setValue(val, initial);
}
});
this.refreshValue();
this.layoutEditors();
this.onChange();
},
showValidationErrors: function(errors) {
var self = this;
// Get all the errors that pertain to this editor
var my_errors = [];
var other_errors = [];
$each(errors, function(i, error) {
if (error.path === self.path) {
my_errors.push(error);
} else {
other_errors.push(error);
}
});
// Show errors for this editor
if (this.error_holder) {
if (my_errors.length) {
var message = [];
this.error_holder.innerHTML = '';
this.error_holder.style.display = '';
$each(my_errors, function(i, error) {
self.error_holder.appendChild(self.theme.getErrorMessage(error.message));
});
}
// Hide error area
else {
this.error_holder.style.display = 'none';
}
}
// Show error for the table row if this is inside a table
if (this.options.table_row) {
if (my_errors.length) {
this.theme.addTableRowError(this.container);
} else {
this.theme.removeTableRowError(this.container);
}
}
// Show errors for child editors
$each(this.editors, function(i, editor) {
editor.showValidationErrors(other_errors);
});
}
});
JSONEditor.defaults.editors.array = JSONEditor.AbstractEditor.extend({
getDefault: function() {
return this.schema["default"] || [];
},
register: function() {
this._super();
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].register();
}
}
},
unregister: function() {
this._super();
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].unregister();
}
}
},
getNumColumns: function() {
var info = this.getItemInfo(0);
// Tabs require extra horizontal space
if (this.tabs_holder) {
return Math.max(Math.min(12, info.width + 2), 4);
} else {
return info.width;
}
},
enable: function() {
if (this.add_row_button) this.add_row_button.disabled = false;
if (this.remove_all_rows_button) this.remove_all_rows_button.disabled = false;
if (this.delete_last_row_button) this.delete_last_row_button.disabled = false;
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].enable();
if (this.rows[i].moveup_button) this.rows[i].moveup_button.disabled = false;
if (this.rows[i].movedown_button) this.rows[i].movedown_button.disabled = false;
if (this.rows[i].delete_button) this.rows[i].delete_button.disabled = false;
}
}
this._super();
},
disable: function() {
if (this.add_row_button) this.add_row_button.disabled = true;
if (this.remove_all_rows_button) this.remove_all_rows_button.disabled = true;
if (this.delete_last_row_button) this.delete_last_row_button.disabled = true;
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].disable();
if (this.rows[i].moveup_button) this.rows[i].moveup_button.disabled = true;
if (this.rows[i].movedown_button) this.rows[i].movedown_button.disabled = true;
if (this.rows[i].delete_button) this.rows[i].delete_button.disabled = true;
}
}
this._super();
},
preBuild: function() {
this._super();
this.rows = [];
this.row_cache = [];
this.hide_delete_buttons = this.options.disable_array_delete || this.jsoneditor.options.disable_array_delete;
this.hide_move_buttons = this.options.disable_array_reorder || this.jsoneditor.options.disable_array_reorder;
this.hide_add_button = this.options.disable_array_add || this.jsoneditor.options.disable_array_add;
},
build: function() {
var self = this;
if (!this.options.compact) {
this.header = document.createElement('span');
this.header.textContent = this.getTitle();
this.title = this.theme.getHeader(this.header);
this.container.appendChild(this.title);
this.title_controls = this.theme.getHeaderButtonHolder();
this.title.appendChild(this.title_controls);
if (this.schema.description) {
this.description = this.theme.getDescription(this.schema.description);
this.container.appendChild(this.description);
}
this.error_holder = document.createElement('div');
this.container.appendChild(this.error_holder);
if (this.schema.format === 'tabs') {
this.controls = this.theme.getHeaderButtonHolder();
this.title.appendChild(this.controls);
this.tabs_holder = this.theme.getTabHolder();
this.container.appendChild(this.tabs_holder);
this.row_holder = this.theme.getTabContentHolder(this.tabs_holder);
this.active_tab = null;
} else {
this.panel = this.theme.getIndentedPanel();
this.container.appendChild(this.panel);
this.row_holder = document.createElement('div');
this.panel.appendChild(this.row_holder);
this.controls = this.theme.getButtonHolder();
this.panel.appendChild(this.controls);
}
} else {
this.panel = this.theme.getIndentedPanel();
this.container.appendChild(this.panel);
this.controls = this.theme.getButtonHolder();
this.panel.appendChild(this.controls);
this.row_holder = document.createElement('div');
this.panel.appendChild(this.row_holder);
}
// Add controls
this.addControls();
},
onChildEditorChange: function(editor) {
this.refreshValue();
this.refreshTabs(true);
this._super(editor);
},
getItemTitle: function() {
if (!this.item_title) {
if (this.schema.items && !Array.isArray(this.schema.items)) {
var tmp = this.jsoneditor.expandRefs(this.schema.items);
this.item_title = tmp.title || 'item';
} else {
this.item_title = 'item';
}
}
return this.item_title;
},
getItemSchema: function(i) {
if (Array.isArray(this.schema.items)) {
if (i >= this.schema.items.length) {
if (this.schema.additionalItems === true) {
return {};
} else if (this.schema.additionalItems) {
return $extend({}, this.schema.additionalItems);
}
} else {
return $extend({}, this.schema.items[i]);
}
} else if (this.schema.items) {
return $extend({}, this.schema.items);
} else {
return {};
}
},
getItemInfo: function(i) {
var schema = this.getItemSchema(i);
// Check if it's cached
this.item_info = this.item_info || {};
var stringified = JSON.stringify(schema);
if (typeof this.item_info[stringified] !== "undefined") return this.item_info[stringified];
// Get the schema for this item
schema = this.jsoneditor.expandRefs(schema);
this.item_info[stringified] = {
title: schema.title || "item",
'default': schema["default"],
width: 12,
child_editors: schema.properties || schema.items
};
return this.item_info[stringified];
},
getElementEditor: function(i) {
var item_info = this.getItemInfo(i);
var schema = this.getItemSchema(i);
schema = this.jsoneditor.expandRefs(schema);
schema.title = item_info.title + ' ' + (i + 1);
var editor = this.jsoneditor.getEditorClass(schema);
var holder;
if (this.tabs_holder) {
holder = this.theme.getTabContent();
} else if (item_info.child_editors) {
holder = this.theme.getChildEditorHolder();
} else {
holder = this.theme.getIndentedPanel();
}
this.row_holder.appendChild(holder);
var ret = this.jsoneditor.createEditor(editor, {
jsoneditor: this.jsoneditor,
schema: schema,
container: holder,
path: this.path + '.' + i,
parent: this,
required: true
});
ret.preBuild();
ret.build();
ret.postBuild();
if (!ret.title_controls) {
ret.array_controls = this.theme.getButtonHolder();
holder.appendChild(ret.array_controls);
}
return ret;
},
destroy: function() {
this.empty(true);
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.row_holder && this.row_holder.parentNode) this.row_holder.parentNode.removeChild(this.row_holder);
if (this.controls && this.controls.parentNode) this.controls.parentNode.removeChild(this.controls);
if (this.panel && this.panel.parentNode) this.panel.parentNode.removeChild(this.panel);
this.rows = this.row_cache = this.title = this.description = this.row_holder = this.panel = this.controls = null;
this._super();
},
empty: function(hard) {
if (!this.rows) return;
var self = this;
$each(this.rows, function(i, row) {
if (hard) {
if (row.tab && row.tab.parentNode) row.tab.parentNode.removeChild(row.tab);
self.destroyRow(row, true);
self.row_cache[i] = null;
}
self.rows[i] = null;
});
self.rows = [];
if (hard) self.row_cache = [];
},
destroyRow: function(row, hard) {
var holder = row.container;
if (hard) {
row.destroy();
if (holder.parentNode) holder.parentNode.removeChild(holder);
if (row.tab && row.tab.parentNode) row.tab.parentNode.removeChild(row.tab);
} else {
if (row.tab) row.tab.style.display = 'none';
holder.style.display = 'none';
row.unregister();
}
},
getMax: function() {
if ((Array.isArray(this.schema.items)) && this.schema.additionalItems === false) {
return Math.min(this.schema.items.length, this.schema.maxItems || Infinity);
} else {
return this.schema.maxItems || Infinity;
}
},
refreshTabs: function(refresh_headers) {
var self = this;
$each(this.rows, function(i, row) {
if (!row.tab) return;
if (refresh_headers) {
row.tab_text.textContent = row.getHeaderText();
} else {
if (row.tab === self.active_tab) {
self.theme.markTabActive(row.tab);
row.container.style.display = '';
} else {
self.theme.markTabInactive(row.tab);
row.container.style.display = 'none';
}
}
});
},
setValue: function(value, initial) {
// Update the array's value, adding/removing rows when necessary
value = value || [];
if (!(Array.isArray(value))) value = [value];
var serialized = JSON.stringify(value);
if (serialized === this.serialized) return;
// Make sure value has between minItems and maxItems items in it
if (this.schema.minItems) {
while (value.length < this.schema.minItems) {
value.push(this.getItemInfo(value.length)["default"]);
}
}
if (this.getMax() && value.length > this.getMax()) {
value = value.slice(0, this.getMax());
}
var self = this;
$each(value, function(i, val) {
if (self.rows[i]) {
// TODO: don't set the row's value if it hasn't changed
self.rows[i].setValue(val, initial);
} else if (self.row_cache[i]) {
self.rows[i] = self.row_cache[i];
self.rows[i].setValue(val, initial);
self.rows[i].container.style.display = '';
if (self.rows[i].tab) self.rows[i].tab.style.display = '';
self.rows[i].register();
} else {
self.addRow(val, initial);
}
});
for (var j = value.length; j < self.rows.length; j++) {
self.destroyRow(self.rows[j]);
self.rows[j] = null;
}
self.rows = self.rows.slice(0, value.length);
// Set the active tab
var new_active_tab = null;
$each(self.rows, function(i, row) {
if (row.tab === self.active_tab) {
new_active_tab = row.tab;
return false;
}
});
if (!new_active_tab && self.rows.length) new_active_tab = self.rows[0].tab;
self.active_tab = new_active_tab;
self.refreshValue(initial);
self.refreshTabs(true);
self.refreshTabs();
self.onChange();
// TODO: sortable
},
refreshValue: function(force) {
var self = this;
var oldi = this.value ? this.value.length : 0;
this.value = [];
$each(this.rows, function(i, editor) {
// Get the value for this editor
self.value[i] = editor.getValue();
});
if (oldi !== this.value.length || force) {
// If we currently have minItems items in the array
var minItems = this.schema.minItems && this.schema.minItems >= this.rows.length;
$each(this.rows, function(i, editor) {
// Hide the move down button for the last row
if (editor.movedown_button) {
if (i === self.rows.length - 1) {
editor.movedown_button.style.display = 'none';
} else {
editor.movedown_button.style.display = '';
}
}
// Hide the delete button if we have minItems items
if (editor.delete_button) {
if (minItems) {
editor.delete_button.style.display = 'none';
} else {
editor.delete_button.style.display = '';
}
}
// Get the value for this editor
self.value[i] = editor.getValue();
});
var controls_needed = false;
if (!this.value.length) {
this.delete_last_row_button.style.display = 'none';
this.remove_all_rows_button.style.display = 'none';
} else if (this.value.length === 1) {
this.remove_all_rows_button.style.display = 'none';
// If there are minItems items in the array, hide the delete button beneath the rows
if (minItems || this.hide_delete_buttons) {
this.delete_last_row_button.style.display = 'none';
} else {
this.delete_last_row_button.style.display = '';
controls_needed = true;
}
} else {
// If there are minItems items in the array, hide the delete button beneath the rows
if (minItems || this.hide_delete_buttons) {
this.delete_last_row_button.style.display = 'none';
this.remove_all_rows_button.style.display = 'none';
} else {
this.delete_last_row_button.style.display = '';
this.remove_all_rows_button.style.display = '';
controls_needed = true;
}
}
// If there are maxItems in the array, hide the add button beneath the rows
if ((this.getMax() && this.getMax() <= this.rows.length) || this.hide_add_button) {
this.add_row_button.style.display = 'none';
} else {
this.add_row_button.style.display = '';
controls_needed = true;
}
if (!this.collapsed && controls_needed) {
this.controls.style.display = 'inline-block';
} else {
this.controls.style.display = 'none';
}
}
},
addRow: function(value, initial) {
var self = this;
var i = this.rows.length;
self.rows[i] = this.getElementEditor(i);
self.row_cache[i] = self.rows[i];
if (self.tabs_holder) {
self.rows[i].tab_text = document.createElement('span');
self.rows[i].tab_text.textContent = self.rows[i].getHeaderText();
self.rows[i].tab = self.theme.getTab(self.rows[i].tab_text);
self.rows[i].tab.addEventListener('click', function(e) {
self.active_tab = self.rows[i].tab;
self.refreshTabs();
e.preventDefault();
e.stopPropagation();
}, false);
self.theme.addTab(self.tabs_holder, self.rows[i].tab);
}
var controls_holder = self.rows[i].title_controls || self.rows[i].array_controls;
// Buttons to delete row, move row up, and move row down
if (!self.hide_delete_buttons) {
self.rows[i].delete_button = this.getButton(self.getItemTitle(), 'delete', 'Delete ' + self.getItemTitle());
self.rows[i].delete_button.className += ' delete';
self.rows[i].delete_button.setAttribute('data-i', i);
self.rows[i].delete_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
var value = self.getValue();
var newval = [];
var new_active_tab = null;
$each(value, function(j, row) {
if (j === i) {
// If the one we're deleting is the active tab
if (self.rows[j].tab === self.active_tab) {
// Make the next tab active if there is one
// Note: the next tab is going to be the current tab after deletion
if (self.rows[j + 1]) new_active_tab = self.rows[j].tab;
// Otherwise, make the previous tab active if there is one
else if (j) new_active_tab = self.rows[j - 1].tab;
}
return; // If this is the one we're deleting
}
newval.push(row);
});
self.setValue(newval);
if (new_active_tab) {
self.active_tab = new_active_tab;
self.refreshTabs();
}
self.onChange(true);
}, false);
if (controls_holder) {
controls_holder.appendChild(self.rows[i].delete_button);
}
}
if (i && !self.hide_move_buttons) {
self.rows[i].moveup_button = this.getButton('', 'moveup', 'Move up');
self.rows[i].moveup_button.className += ' moveup';
self.rows[i].moveup_button.setAttribute('data-i', i);
self.rows[i].moveup_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
if (i <= 0) return;
var rows = self.getValue();
var tmp = rows[i - 1];
rows[i - 1] = rows[i];
rows[i] = tmp;
self.setValue(rows);
self.active_tab = self.rows[i - 1].tab;
self.refreshTabs();
self.onChange(true);
}, false);
if (controls_holder) {
controls_holder.appendChild(self.rows[i].moveup_button);
}
}
if (!self.hide_move_buttons) {
self.rows[i].movedown_button = this.getButton('', 'movedown', 'Move down');
self.rows[i].movedown_button.className += ' movedown';
self.rows[i].movedown_button.setAttribute('data-i', i);
self.rows[i].movedown_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
var rows = self.getValue();
if (i >= rows.length - 1) return;
var tmp = rows[i + 1];
rows[i + 1] = rows[i];
rows[i] = tmp;
self.setValue(rows);
self.active_tab = self.rows[i + 1].tab;
self.refreshTabs();
self.onChange(true);
}, false);
if (controls_holder) {
controls_holder.appendChild(self.rows[i].movedown_button);
}
}
if (value) self.rows[i].setValue(value, initial);
self.refreshTabs();
},
addControls: function() {
var self = this;
this.collapsed = false;
this.toggle_button = this.getButton('', 'collapse', 'Collapse');
this.title_controls.appendChild(this.toggle_button);
var row_holder_display = self.row_holder.style.display;
var controls_display = self.controls.style.display;
this.toggle_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
if (self.collapsed) {
self.collapsed = false;
if (self.panel) self.panel.style.display = '';
self.row_holder.style.display = row_holder_display;
if (self.tabs_holder) self.tabs_holder.style.display = '';
self.controls.style.display = controls_display;
self.setButtonText(this, '', 'collapse', 'Collapse');
} else {
self.collapsed = true;
self.row_holder.style.display = 'none';
if (self.tabs_holder) self.tabs_holder.style.display = 'none';
self.controls.style.display = 'none';
if (self.panel) self.panel.style.display = 'none';
self.setButtonText(this, '', 'expand', 'Expand');
}
}, false);
// If it should start collapsed
if (this.options.collapsed) {
$trigger(this.toggle_button, 'click');
}
// Collapse button disabled
if (this.schema.options && typeof this.schema.options.disable_collapse !== "undefined") {
if (this.schema.options.disable_collapse) this.toggle_button.style.display = 'none';
} else if (this.jsoneditor.options.disable_collapse) {
this.toggle_button.style.display = 'none';
}
// Add "new row" and "delete last" buttons below editor
this.add_row_button = this.getButton(this.getItemTitle(), 'add', 'Add ' + this.getItemTitle());
this.add_row_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = self.rows.length;
if (self.row_cache[i]) {
self.rows[i] = self.row_cache[i];
self.rows[i].setValue(self.rows[i].getDefault());
self.rows[i].container.style.display = '';
if (self.rows[i].tab) self.rows[i].tab.style.display = '';
self.rows[i].register();
} else {
self.addRow();
}
self.active_tab = self.rows[i].tab;
self.refreshTabs();
self.refreshValue();
self.onChange(true);
}, false);
self.controls.appendChild(this.add_row_button);
this.delete_last_row_button = this.getButton('Last ' + this.getItemTitle(), 'delete', 'Delete Last ' + this.getItemTitle());
this.delete_last_row_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var rows = self.getValue();
var new_active_tab = null;
if (self.rows.length > 1 && self.rows[self.rows.length - 1].tab === self.active_tab) new_active_tab = self.rows[self.rows.length - 2].tab;
rows.pop();
self.setValue(rows);
if (new_active_tab) {
self.active_tab = new_active_tab;
self.refreshTabs();
}
self.onChange(true);
}, false);
self.controls.appendChild(this.delete_last_row_button);
this.remove_all_rows_button = this.getButton('All', 'delete', 'Delete All');
this.remove_all_rows_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.setValue([]);
self.onChange(true);
}, false);
self.controls.appendChild(this.remove_all_rows_button);
if (self.tabs) {
this.add_row_button.style.width = '100%';
this.add_row_button.style.textAlign = 'left';
this.add_row_button.style.marginBottom = '3px';
this.delete_last_row_button.style.width = '100%';
this.delete_last_row_button.style.textAlign = 'left';
this.delete_last_row_button.style.marginBottom = '3px';
this.remove_all_rows_button.style.width = '100%';
this.remove_all_rows_button.style.textAlign = 'left';
this.remove_all_rows_button.style.marginBottom = '3px';
}
},
showValidationErrors: function(errors) {
var self = this;
// Get all the errors that pertain to this editor
var my_errors = [];
var other_errors = [];
$each(errors, function(i, error) {
if (error.path === self.path) {
my_errors.push(error);
} else {
other_errors.push(error);
}
});
// Show errors for this editor
if (this.error_holder) {
if (my_errors.length) {
var message = [];
this.error_holder.innerHTML = '';
this.error_holder.style.display = '';
$each(my_errors, function(i, error) {
self.error_holder.appendChild(self.theme.getErrorMessage(error.message));
});
}
// Hide error area
else {
this.error_holder.style.display = 'none';
}
}
// Show errors for child editors
$each(this.rows, function(i, row) {
row.showValidationErrors(other_errors);
});
}
});
JSONEditor.defaults.editors.table = JSONEditor.defaults.editors.array.extend({
register: function() {
this._super();
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].register();
}
}
},
unregister: function() {
this._super();
if (this.rows) {
for (var i = 0; i < this.rows.length; i++) {
this.rows[i].unregister();
}
}
},
getNumColumns: function() {
return Math.max(Math.min(12, this.width), 3);
},
preBuild: function() {
var item_schema = this.jsoneditor.expandRefs(this.schema.items || {});
this.item_title = item_schema.title || 'row';
this.item_default = item_schema["default"] || null;
this.item_has_child_editors = item_schema.properties || item_schema.items;
this.width = 12;
this._super();
},
build: function() {
var self = this;
this.table = this.theme.getTable();
this.container.appendChild(this.table);
this.thead = this.theme.getTableHead();
this.table.appendChild(this.thead);
this.header_row = this.theme.getTableRow();
this.thead.appendChild(this.header_row);
this.row_holder = this.theme.getTableBody();
this.table.appendChild(this.row_holder);
// Determine the default value of array element
var tmp = this.getElementEditor(0, true);
this.item_default = tmp.getDefault();
this.width = tmp.getNumColumns() + 2;
if (!this.options.compact) {
this.title = this.theme.getHeader(this.getTitle());
this.container.appendChild(this.title);
this.title_controls = this.theme.getHeaderButtonHolder();
this.title.appendChild(this.title_controls);
if (this.schema.description) {
this.description = this.theme.getDescription(this.schema.description);
this.container.appendChild(this.description);
}
this.panel = this.theme.getIndentedPanel();
this.container.appendChild(this.panel);
this.error_holder = document.createElement('div');
this.panel.appendChild(this.error_holder);
} else {
this.panel = document.createElement('div');
this.container.appendChild(this.panel);
}
this.panel.appendChild(this.table);
this.controls = this.theme.getButtonHolder();
this.panel.appendChild(this.controls);
if (this.item_has_child_editors) {
var ce = tmp.getChildEditors();
var order = tmp.property_order || Object.keys(ce);
for (var i = 0; i < order.length; i++) {
var th = self.theme.getTableHeaderCell(ce[order[i]].getTitle());
if (ce[order[i]].options.hidden) th.style.display = 'none';
self.header_row.appendChild(th);
}
} else {
self.header_row.appendChild(self.theme.getTableHeaderCell(this.item_title));
}
tmp.destroy();
this.row_holder.innerHTML = '';
// Row Controls column
this.controls_header_cell = self.theme.getTableHeaderCell(" ");
self.header_row.appendChild(this.controls_header_cell);
// Add controls
this.addControls();
},
onChildEditorChange: function(editor) {
this.refreshValue();
this._super();
},
getItemDefault: function() {
return $extend({}, {
"default": this.item_default
})["default"];
},
getItemTitle: function() {
return this.item_title;
},
getElementEditor: function(i, ignore) {
var schema_copy = $extend({}, this.schema.items);
var editor = this.jsoneditor.getEditorClass(schema_copy, this.jsoneditor);
var row = this.row_holder.appendChild(this.theme.getTableRow());
var holder = row;
if (!this.item_has_child_editors) {
holder = this.theme.getTableCell();
row.appendChild(holder);
}
var ret = this.jsoneditor.createEditor(editor, {
jsoneditor: this.jsoneditor,
schema: schema_copy,
container: holder,
path: this.path + '.' + i,
parent: this,
compact: true,
table_row: true
});
ret.preBuild();
if (!ignore) {
ret.build();
ret.postBuild();
ret.controls_cell = row.appendChild(this.theme.getTableCell());
ret.row = row;
ret.table_controls = this.theme.getButtonHolder();
ret.controls_cell.appendChild(ret.table_controls);
ret.table_controls.style.margin = 0;
ret.table_controls.style.padding = 0;
}
return ret;
},
destroy: function() {
this.innerHTML = '';
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.row_holder && this.row_holder.parentNode) this.row_holder.parentNode.removeChild(this.row_holder);
if (this.table && this.table.parentNode) this.table.parentNode.removeChild(this.table);
if (this.panel && this.panel.parentNode) this.panel.parentNode.removeChild(this.panel);
this.rows = this.title = this.description = this.row_holder = this.table = this.panel = null;
this._super();
},
setValue: function(value, initial) {
// Update the array's value, adding/removing rows when necessary
value = value || [];
// Make sure value has between minItems and maxItems items in it
if (this.schema.minItems) {
while (value.length < this.schema.minItems) {
value.push(this.getItemDefault());
}
}
if (this.schema.maxItems && value.length > this.schema.maxItems) {
value = value.slice(0, this.schema.maxItems);
}
var serialized = JSON.stringify(value);
if (serialized === this.serialized) return;
var numrows_changed = false;
var self = this;
$each(value, function(i, val) {
if (self.rows[i]) {
// TODO: don't set the row's value if it hasn't changed
self.rows[i].setValue(val);
} else {
self.addRow(val);
numrows_changed = true;
}
});
for (var j = value.length; j < self.rows.length; j++) {
var holder = self.rows[j].container;
if (!self.item_has_child_editors) {
self.rows[j].row.parentNode.removeChild(self.rows[j].row);
}
self.rows[j].destroy();
if (holder.parentNode) holder.parentNode.removeChild(holder);
self.rows[j] = null;
numrows_changed = true;
}
self.rows = self.rows.slice(0, value.length);
self.refreshValue();
if (numrows_changed || initial) self.refreshRowButtons();
self.onChange();
// TODO: sortable
},
refreshRowButtons: function() {
var self = this;
// If we currently have minItems items in the array
var minItems = this.schema.minItems && this.schema.minItems >= this.rows.length;
var need_row_buttons = false;
$each(this.rows, function(i, editor) {
// Hide the move down button for the last row
if (editor.movedown_button) {
if (i === self.rows.length - 1) {
editor.movedown_button.style.display = 'none';
} else {
need_row_buttons = true;
editor.movedown_button.style.display = '';
}
}
// Hide the delete button if we have minItems items
if (editor.delete_button) {
if (minItems) {
editor.delete_button.style.display = 'none';
} else {
need_row_buttons = true;
editor.delete_button.style.display = '';
}
}
if (editor.moveup_button) {
need_row_buttons = true;
}
});
// Show/hide controls column in table
$each(this.rows, function(i, editor) {
if (need_row_buttons) {
editor.controls_cell.style.display = '';
} else {
editor.controls_cell.style.display = 'none';
}
});
if (need_row_buttons) {
this.controls_header_cell.style.display = '';
} else {
this.controls_header_cell.style.display = 'none';
}
var controls_needed = false;
if (!this.value.length) {
this.delete_last_row_button.style.display = 'none';
this.remove_all_rows_button.style.display = 'none';
this.table.style.display = 'none';
} else if (this.value.length === 1 || this.hide_delete_buttons) {
this.table.style.display = '';
this.remove_all_rows_button.style.display = 'none';
// If there are minItems items in the array, hide the delete button beneath the rows
if (minItems || this.hide_delete_buttons) {
this.delete_last_row_button.style.display = 'none';
} else {
this.delete_last_row_button.style.display = '';
controls_needed = true;
}
} else {
this.table.style.display = '';
// If there are minItems items in the array, hide the delete button beneath the rows
if (minItems || this.hide_delete_buttons) {
this.delete_last_row_button.style.display = 'none';
this.remove_all_rows_button.style.display = 'none';
} else {
this.delete_last_row_button.style.display = '';
this.remove_all_rows_button.style.display = '';
controls_needed = true;
}
}
// If there are maxItems in the array, hide the add button beneath the rows
if ((this.schema.maxItems && this.schema.maxItems <= this.rows.length) || this.hide_add_button) {
this.add_row_button.style.display = 'none';
} else {
this.add_row_button.style.display = '';
controls_needed = true;
}
if (!controls_needed) {
this.controls.style.display = 'none';
} else {
this.controls.style.display = '';
}
},
refreshValue: function() {
var self = this;
this.value = [];
$each(this.rows, function(i, editor) {
// Get the value for this editor
self.value[i] = editor.getValue();
});
this.serialized = JSON.stringify(this.value);
},
addRow: function(value) {
var self = this;
var i = this.rows.length;
self.rows[i] = this.getElementEditor(i);
var controls_holder = self.rows[i].table_controls;
// Buttons to delete row, move row up, and move row down
if (!this.hide_delete_buttons) {
self.rows[i].delete_button = this.getButton('', 'delete', 'Delete');
self.rows[i].delete_button.className += ' delete';
self.rows[i].delete_button.setAttribute('data-i', i);
self.rows[i].delete_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
var value = self.getValue();
var newval = [];
$each(value, function(j, row) {
if (j === i) return; // If this is the one we're deleting
newval.push(row);
});
self.setValue(newval);
self.onChange(true);
}, false);
controls_holder.appendChild(self.rows[i].delete_button);
}
if (i && !this.hide_move_buttons) {
self.rows[i].moveup_button = this.getButton('', 'moveup', 'Move up');
self.rows[i].moveup_button.className += ' moveup';
self.rows[i].moveup_button.setAttribute('data-i', i);
self.rows[i].moveup_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
if (i <= 0) return;
var rows = self.getValue();
var tmp = rows[i - 1];
rows[i - 1] = rows[i];
rows[i] = tmp;
self.setValue(rows);
self.onChange(true);
}, false);
controls_holder.appendChild(self.rows[i].moveup_button);
}
if (!this.hide_move_buttons) {
self.rows[i].movedown_button = this.getButton('', 'movedown', 'Move down');
self.rows[i].movedown_button.className += ' movedown';
self.rows[i].movedown_button.setAttribute('data-i', i);
self.rows[i].movedown_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var i = this.getAttribute('data-i') * 1;
var rows = self.getValue();
if (i >= rows.length - 1) return;
var tmp = rows[i + 1];
rows[i + 1] = rows[i];
rows[i] = tmp;
self.setValue(rows);
self.onChange(true);
}, false);
controls_holder.appendChild(self.rows[i].movedown_button);
}
if (value) self.rows[i].setValue(value);
},
addControls: function() {
var self = this;
this.collapsed = false;
this.toggle_button = this.getButton('', 'collapse', 'Collapse');
if (this.title_controls) {
this.title_controls.appendChild(this.toggle_button);
this.toggle_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
if (self.collapsed) {
self.collapsed = false;
self.panel.style.display = '';
self.setButtonText(this, '', 'collapse', 'Collapse');
} else {
self.collapsed = true;
self.panel.style.display = 'none';
self.setButtonText(this, '', 'expand', 'Expand');
}
}, false);
// If it should start collapsed
if (this.options.collapsed) {
$trigger(this.toggle_button, 'click');
}
// Collapse button disabled
if (this.schema.options && typeof this.schema.options.disable_collapse !== "undefined") {
if (this.schema.options.disable_collapse) this.toggle_button.style.display = 'none';
} else if (this.jsoneditor.options.disable_collapse) {
this.toggle_button.style.display = 'none';
}
}
// Add "new row" and "delete last" buttons below editor
this.add_row_button = this.getButton(this.getItemTitle(), 'add', 'Add ' + this.getItemTitle());
this.add_row_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.addRow();
self.refreshValue();
self.refreshRowButtons();
self.onChange(true);
}, false);
self.controls.appendChild(this.add_row_button);
this.delete_last_row_button = this.getButton('Last ' + this.getItemTitle(), 'delete', 'Delete Last ' + this.getItemTitle());
this.delete_last_row_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
var rows = self.getValue();
rows.pop();
self.setValue(rows);
self.onChange(true);
}, false);
self.controls.appendChild(this.delete_last_row_button);
this.remove_all_rows_button = this.getButton('All', 'delete', 'Delete All');
this.remove_all_rows_button.addEventListener('click', function(e) {
e.preventDefault();
e.stopPropagation();
self.setValue([]);
self.onChange(true);
}, false);
self.controls.appendChild(this.remove_all_rows_button);
}
});
// Multiple Editor (for when `type` is an array)
JSONEditor.defaults.editors.multiple = JSONEditor.AbstractEditor.extend({
register: function() {
if (this.editors) {
for (var i = 0; i < this.editors.length; i++) {
if (!this.editors[i]) continue;
this.editors[i].unregister();
}
if (this.editors[this.type]) this.editors[this.type].register();
}
this._super();
},
unregister: function() {
this._super();
if (this.editors) {
for (var i = 0; i < this.editors.length; i++) {
if (!this.editors[i]) continue;
this.editors[i].unregister();
}
}
},
getNumColumns: function() {
if (!this.editors[this.type]) return 4;
return Math.max(this.editors[this.type].getNumColumns(), 4);
},
enable: function() {
if (this.editors) {
for (var i = 0; i < this.editors.length; i++) {
if (!this.editors[i]) continue;
this.editors[i].enable();
}
}
this.switcher.disabled = false;
this._super();
},
disable: function() {
if (this.editors) {
for (var i = 0; i < this.editors.length; i++) {
if (!this.editors[i]) continue;
this.editors[i].disable();
}
}
this.switcher.disabled = true;
this._super();
},
switchEditor: function(i) {
var self = this;
if (!this.editors[i]) {
this.buildChildEditor(i);
}
self.type = i;
self.register();
var current_value = self.getValue();
$each(self.editors, function(type, editor) {
if (!editor) return;
if (self.type === type) {
if (self.keep_values) editor.setValue(current_value, true);
editor.container.style.display = '';
} else editor.container.style.display = 'none';
});
self.refreshValue();
self.refreshHeaderText();
},
buildChildEditor: function(i) {
var self = this;
var type = this.types[i];
var holder = self.theme.getChildEditorHolder();
self.editor_holder.appendChild(holder);
var schema;
if (typeof type === "string") {
schema = $extend({}, self.schema);
schema.type = type;
} else {
schema = $extend({}, self.schema, type);
schema = self.jsoneditor.expandRefs(schema);
// If we need to merge `required` arrays
if (type.required && Array.isArray(type.required) && self.schema.required && Array.isArray(self.schema.required)) {
schema.required = self.schema.required.concat(type.required);
}
}
var editor = self.jsoneditor.getEditorClass(schema);
self.editors[i] = self.jsoneditor.createEditor(editor, {
jsoneditor: self.jsoneditor,
schema: schema,
container: holder,
path: self.path,
parent: self,
required: true
});
self.editors[i].preBuild();
self.editors[i].build();
self.editors[i].postBuild();
if (self.editors[i].header) self.editors[i].header.style.display = 'none';
self.editors[i].option = self.switcher_options[i];
holder.addEventListener('change_header_text', function() {
self.refreshHeaderText();
}, false);
if (i !== self.type) holder.style.display = 'none';
},
preBuild: function() {
var self = this;
this.types = [];
this.type = 0;
this.editors = [];
this.validators = [];
this.keep_values = true;
if (typeof this.jsoneditor.options.keep_oneof_values !== "undefined") this.keep_values = this.jsoneditor.options.keep_oneof_values;
if (typeof this.options.keep_oneof_values !== "undefined") this.keep_values = this.options.keep_oneof_values;
if (this.schema.oneOf) {
this.oneOf = true;
this.types = this.schema.oneOf;
$each(this.types, function(i, oneof) {
//self.types[i] = self.jsoneditor.expandSchema(oneof);
});
delete this.schema.oneOf;
} else {
if (!this.schema.type || this.schema.type === "any") {
this.types = ['string', 'number', 'integer', 'boolean', 'object', 'array', 'null'];
// If any of these primitive types are disallowed
if (this.schema.disallow) {
var disallow = this.schema.disallow;
if (typeof disallow !== 'object' || !(Array.isArray(disallow))) {
disallow = [disallow];
}
var allowed_types = [];
$each(this.types, function(i, type) {
if (disallow.indexOf(type) === -1) allowed_types.push(type);
});
this.types = allowed_types;
}
} else if (Array.isArray(this.schema.type)) {
this.types = this.schema.type;
} else {
this.types = [this.schema.type];
}
delete this.schema.type;
}
this.display_text = this.getDisplayText(this.types);
},
build: function() {
var self = this;
var container = this.container;
this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
this.container.appendChild(this.header);
this.switcher = this.theme.getSwitcher(this.display_text);
container.appendChild(this.switcher);
this.switcher.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
self.switchEditor(self.display_text.indexOf(this.value));
self.onChange(true);
}, false);
this.editor_holder = document.createElement('div');
container.appendChild(this.editor_holder);
var validator_options = {};
if (self.jsoneditor.options.custom_validators) {
validator_options.custom_validators = self.jsoneditor.options.custom_validators;
}
this.switcher_options = this.theme.getSwitcherOptions(this.switcher);
$each(this.types, function(i, type) {
self.editors[i] = false;
var schema;
if (typeof type === "string") {
schema = $extend({}, self.schema);
schema.type = type;
} else {
schema = $extend({}, self.schema, type);
// If we need to merge `required` arrays
if (type.required && Array.isArray(type.required) && self.schema.required && Array.isArray(self.schema.required)) {
schema.required = self.schema.required.concat(type.required);
}
}
self.validators[i] = new JSONEditor.Validator(self.jsoneditor, schema, validator_options);
});
this.switchEditor(0);
},
onChildEditorChange: function(editor) {
if (this.editors[this.type]) {
this.refreshValue();
this.refreshHeaderText();
}
this._super();
},
refreshHeaderText: function() {
var display_text = this.getDisplayText(this.types);
$each(this.switcher_options, function(i, option) {
option.textContent = display_text[i];
});
},
refreshValue: function() {
this.value = this.editors[this.type].getValue();
},
setValue: function(val, initial) {
// Determine type by getting the first one that validates
var self = this;
$each(this.validators, function(i, validator) {
if (!validator.validate(val).length) {
self.type = i;
self.switcher.value = self.display_text[i];
return false;
}
});
this.switchEditor(this.type);
this.editors[this.type].setValue(val, initial);
this.refreshValue();
self.onChange();
},
destroy: function() {
$each(this.editors, function(type, editor) {
if (editor) editor.destroy();
});
if (this.editor_holder && this.editor_holder.parentNode) this.editor_holder.parentNode.removeChild(this.editor_holder);
if (this.switcher && this.switcher.parentNode) this.switcher.parentNode.removeChild(this.switcher);
this._super();
},
showValidationErrors: function(errors) {
var self = this;
// oneOf error paths need to remove the oneOf[i] part before passing to child editors
if (this.oneOf) {
$each(this.editors, function(i, editor) {
if (!editor) return;
var check = self.path + '.oneOf[' + i + ']';
var new_errors = [];
$each(errors, function(j, error) {
if (error.path.substr(0, check.length) === check) {
var new_error = $extend({}, error);
new_error.path = self.path + new_error.path.substr(check.length);
new_errors.push(new_error);
}
});
editor.showValidationErrors(new_errors);
});
} else {
$each(this.editors, function(type, editor) {
if (!editor) return;
editor.showValidationErrors(errors);
});
}
}
});
// Enum Editor (used for objects and arrays with enumerated values)
JSONEditor.defaults.editors["enum"] = JSONEditor.AbstractEditor.extend({
getNumColumns: function() {
return 4;
},
build: function() {
var container = this.container;
this.title = this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
this.container.appendChild(this.title);
this.options.enum_titles = this.options.enum_titles || [];
this["enum"] = this.schema["enum"];
this.selected = 0;
this.select_options = [];
this.html_values = [];
var self = this;
for (var i = 0; i < this["enum"].length; i++) {
this.select_options[i] = this.options.enum_titles[i] || "Value " + (i + 1);
this.html_values[i] = this.getHTML(this["enum"][i]);
}
// Switcher
this.switcher = this.theme.getSwitcher(this.select_options);
this.container.appendChild(this.switcher);
// Display area
this.display_area = this.theme.getIndentedPanel();
this.container.appendChild(this.display_area);
if (this.options.hide_display) this.display_area.style.display = "none";
this.switcher.addEventListener('change', function() {
self.selected = self.select_options.indexOf(this.value);
self.value = self["enum"][self.selected];
self.refreshValue();
self.onChange(true);
}, false);
this.value = this["enum"][0];
this.refreshValue();
if (this["enum"].length === 1) this.switcher.style.display = 'none';
},
refreshValue: function() {
var self = this;
self.selected = -1;
var stringified = JSON.stringify(this.value);
$each(this["enum"], function(i, el) {
if (stringified === JSON.stringify(el)) {
self.selected = i;
return false;
}
});
if (self.selected < 0) {
self.setValue(self["enum"][0]);
return;
}
this.switcher.value = this.select_options[this.selected];
this.display_area.innerHTML = this.html_values[this.selected];
},
enable: function() {
if (!this.always_disabled) this.switcher.disabled = false;
this._super();
},
disable: function() {
this.switcher.disabled = true;
this._super();
},
getHTML: function(el) {
var self = this;
if (el === null) {
return '<em>null</em>';
}
// Array or Object
else if (typeof el === "object") {
// TODO: use theme
var ret = '';
$each(el, function(i, child) {
var html = self.getHTML(child);
// Add the keys to object children
if (!(Array.isArray(el))) {
// TODO: use theme
html = '<div><em>' + i + '</em>: ' + html + '</div>';
}
// TODO: use theme
ret += '<li>' + html + '</li>';
});
if (Array.isArray(el)) ret = '<ol>' + ret + '</ol>';
else ret = "<ul style='margin-top:0;margin-bottom:0;padding-top:0;padding-bottom:0;'>" + ret + '</ul>';
return ret;
}
// Boolean
else if (typeof el === "boolean") {
return el ? 'true' : 'false';
}
// String
else if (typeof el === "string") {
return el.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}
// Number
else {
return el;
}
},
setValue: function(val) {
if (this.value !== val) {
this.value = val;
this.refreshValue();
this.onChange();
}
},
destroy: function() {
if (this.display_area && this.display_area.parentNode) this.display_area.parentNode.removeChild(this.display_area);
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.switcher && this.switcher.parentNode) this.switcher.parentNode.removeChild(this.switcher);
this._super();
}
});
JSONEditor.defaults.editors.select = JSONEditor.AbstractEditor.extend({
setValue: function(value, initial) {
value = this.typecast(value || '');
// Sanitize value before setting it
var sanitized = value;
if (this.enum_values.indexOf(sanitized) < 0) {
sanitized = this.enum_values[0];
}
if (this.value === sanitized) {
return;
}
this.input.value = this.enum_options[this.enum_values.indexOf(sanitized)];
if (this.select2) this.select2.select2('val', this.input.value);
this.value = sanitized;
this.onChange();
},
register: function() {
this._super();
if (!this.input) return;
this.input.setAttribute('name', this.formname);
},
unregister: function() {
this._super();
if (!this.input) return;
this.input.removeAttribute('name');
},
getNumColumns: function() {
if (!this.enum_options) return 3;
var longest_text = this.getTitle().length;
for (var i = 0; i < this.enum_options.length; i++) {
longest_text = Math.max(longest_text, this.enum_options[i].length + 4);
}
return Math.min(12, Math.max(longest_text / 7, 2));
},
typecast: function(value) {
if (this.schema.type === "boolean") {
return !!value;
} else if (this.schema.type === "number") {
return 1 * value;
} else if (this.schema.type === "integer") {
return Math.floor(value * 1);
} else {
return "" + value;
}
},
getValue: function() {
return this.value;
},
preBuild: function() {
var self = this;
this.input_type = 'select';
this.enum_options = [];
this.enum_values = [];
this.enum_display = [];
// Enum options enumerated
if (this.schema["enum"]) {
var display = this.schema.options && this.schema.options.enum_titles || [];
$each(this.schema["enum"], function(i, option) {
self.enum_options[i] = "" + option;
self.enum_display[i] = "" + (display[i] || option);
self.enum_values[i] = self.typecast(option);
});
if (!this.isRequired()) {
self.enum_display.unshift(' ');
self.enum_options.unshift('undefined');
self.enum_values.unshift(undefined);
}
}
// Boolean
else if (this.schema.type === "boolean") {
self.enum_display = this.schema.options && this.schema.options.enum_titles || ['true', 'false'];
self.enum_options = ['1', ''];
self.enum_values = [true, false];
if (!this.isRequired()) {
self.enum_display.unshift(' ');
self.enum_options.unshift('undefined');
self.enum_values.unshift(undefined);
}
}
// Dynamic Enum
else if (this.schema.enumSource) {
this.enumSource = [];
this.enum_display = [];
this.enum_options = [];
this.enum_values = [];
// Shortcut declaration for using a single array
if (!(Array.isArray(this.schema.enumSource))) {
if (this.schema.enumValue) {
this.enumSource = [{
source: this.schema.enumSource,
value: this.schema.enumValue
}];
} else {
this.enumSource = [{
source: this.schema.enumSource
}];
}
} else {
for (i = 0; i < this.schema.enumSource.length; i++) {
// Shorthand for watched variable
if (typeof this.schema.enumSource[i] === "string") {
this.enumSource[i] = {
source: this.schema.enumSource[i]
};
}
// Make a copy of the schema
else if (!(Array.isArray(this.schema.enumSource[i]))) {
this.enumSource[i] = $extend({}, this.schema.enumSource[i]);
} else {
this.enumSource[i] = this.schema.enumSource[i];
}
}
}
// Now, enumSource is an array of sources
// Walk through this array and fix up the values
for (i = 0; i < this.enumSource.length; i++) {
if (this.enumSource[i].value) {
this.enumSource[i].value = this.jsoneditor.compileTemplate(this.enumSource[i].value, this.template_engine);
}
if (this.enumSource[i].title) {
this.enumSource[i].title = this.jsoneditor.compileTemplate(this.enumSource[i].title, this.template_engine);
}
if (this.enumSource[i].filter) {
this.enumSource[i].filter = this.jsoneditor.compileTemplate(this.enumSource[i].filter, this.template_engine);
}
}
}
// Other, not supported
else {
throw "'select' editor requires the enum property to be set.";
}
},
build: function() {
var self = this;
if (!this.options.compact) this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
if (this.schema.description) this.description = this.theme.getFormInputDescription(this.schema.description);
if (this.options.compact) this.container.className += ' compact';
this.input = this.theme.getSelectInput(this.enum_options);
this.theme.setSelectOptions(this.input, this.enum_options, this.enum_display);
if (this.schema.readOnly || this.schema.readonly) {
this.always_disabled = true;
this.input.disabled = true;
}
this.input.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
self.onInputChange();
}, false);
this.control = this.theme.getFormControl(this.label, this.input, this.description);
this.container.appendChild(this.control);
this.value = this.enum_values[0];
},
onInputChange: function() {
var val = this.input.value;
var new_val;
// Invalid option, use first option instead
if (this.enum_options.indexOf(val) === -1) {
new_val = this.enum_values[0];
} else {
new_val = this.enum_values[this.enum_options.indexOf(val)];
}
// If valid hasn't changed
if (new_val === this.value) return;
// Store new value and propogate change event
this.value = new_val;
this.onChange(true);
},
setupSelect2: function() {
// If the Select2 library is loaded use it when we have lots of items
if (window.jQuery && window.jQuery.fn && window.jQuery.fn.select2 && (this.enum_options.length > 2 || (this.enum_options.length && this.enumSource))) {
var options = $extend({}, JSONEditor.plugins.select2);
if (this.schema.options && this.schema.options.select2_options) options = $extend(options, this.schema.options.select2_options);
this.select2 = window.jQuery(this.input).select2(options);
var self = this;
this.select2.on('select2-blur', function() {
self.input.value = self.select2.select2('val');
self.onInputChange();
});
this.select2.on('change', function() {
self.input.value = self.select2.select2('val');
self.onInputChange();
});
} else {
this.select2 = null;
}
},
postBuild: function() {
this._super();
this.theme.afterInputReady(this.input);
this.setupSelect2();
},
onWatchedFieldChange: function() {
var self = this,
vars, j;
// If this editor uses a dynamic select box
if (this.enumSource) {
vars = this.getWatchedFieldValues();
var select_options = [];
var select_titles = [];
for (var i = 0; i < this.enumSource.length; i++) {
// Constant values
if (Array.isArray(this.enumSource[i])) {
select_options = select_options.concat(this.enumSource[i]);
select_titles = select_titles.concat(this.enumSource[i]);
} else {
var items = [];
// Static list of items
if (Array.isArray(this.enumSource[i].source)) {
items = this.enumSource[i].source;
// A watched field
} else {
items = vars[this.enumSource[i].source];
}
if (items) {
// Only use a predefined part of the array
if (this.enumSource[i].slice) {
items = Array.prototype.slice.apply(items, this.enumSource[i].slice);
}
// Filter the items
if (this.enumSource[i].filter) {
var new_items = [];
for (j = 0; j < items.length; j++) {
if (this.enumSource[i].filter({
i: j,
item: items[j],
watched: vars
})) new_items.push(items[j]);
}
items = new_items;
}
var item_titles = [];
var item_values = [];
for (j = 0; j < items.length; j++) {
var item = items[j];
// Rendered value
if (this.enumSource[i].value) {
item_values[j] = this.enumSource[i].value({
i: j,
item: item
});
}
// Use value directly
else {
item_values[j] = items[j];
}
// Rendered title
if (this.enumSource[i].title) {
item_titles[j] = this.enumSource[i].title({
i: j,
item: item
});
}
// Use value as the title also
else {
item_titles[j] = item_values[j];
}
}
// TODO: sort
select_options = select_options.concat(item_values);
select_titles = select_titles.concat(item_titles);
}
}
}
var prev_value = this.value;
this.theme.setSelectOptions(this.input, select_options, select_titles);
this.enum_options = select_options;
this.enum_display = select_titles;
this.enum_values = select_options;
if (this.select2) {
this.select2.select2('destroy');
}
// If the previous value is still in the new select options, stick with it
if (select_options.indexOf(prev_value) !== -1) {
this.input.value = prev_value;
this.value = prev_value;
}
// Otherwise, set the value to the first select option
else {
this.input.value = select_options[0];
this.value = select_options[0] || "";
if (this.parent) this.parent.onChildEditorChange(this);
else this.jsoneditor.onChange();
this.jsoneditor.notifyWatchers(this.path);
}
this.setupSelect2();
}
this._super();
},
enable: function() {
if (!this.always_disabled) {
this.input.disabled = false;
if (this.select2) this.select2.select2("enable", true);
}
this._super();
},
disable: function() {
this.input.disabled = true;
if (this.select2) this.select2.select2("enable", false);
this._super();
},
destroy: function() {
if (this.label && this.label.parentNode) this.label.parentNode.removeChild(this.label);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
if (this.select2) {
this.select2.select2('destroy');
this.select2 = null;
}
this._super();
}
});
JSONEditor.defaults.editors.selectize = JSONEditor.AbstractEditor.extend({
setValue: function(value, initial) {
value = this.typecast(value || '');
// Sanitize value before setting it
var sanitized = value;
if (this.enum_values.indexOf(sanitized) < 0) {
sanitized = this.enum_values[0];
}
if (this.value === sanitized) {
return;
}
this.input.value = this.enum_options[this.enum_values.indexOf(sanitized)];
if (this.selectize) {
this.selectize[0].selectize.addItem(sanitized);
}
this.value = sanitized;
this.onChange();
},
register: function() {
this._super();
if (!this.input) return;
this.input.setAttribute('name', this.formname);
},
unregister: function() {
this._super();
if (!this.input) return;
this.input.removeAttribute('name');
},
getNumColumns: function() {
if (!this.enum_options) return 3;
var longest_text = this.getTitle().length;
for (var i = 0; i < this.enum_options.length; i++) {
longest_text = Math.max(longest_text, this.enum_options[i].length + 4);
}
return Math.min(12, Math.max(longest_text / 7, 2));
},
typecast: function(value) {
if (this.schema.type === "boolean") {
return !!value;
} else if (this.schema.type === "number") {
return 1 * value;
} else if (this.schema.type === "integer") {
return Math.floor(value * 1);
} else {
return "" + value;
}
},
getValue: function() {
return this.value;
},
preBuild: function() {
var self = this;
this.input_type = 'select';
this.enum_options = [];
this.enum_values = [];
this.enum_display = [];
// Enum options enumerated
if (this.schema.enum) {
var display = this.schema.options && this.schema.options.enum_titles || [];
$each(this.schema.enum, function(i, option) {
self.enum_options[i] = "" + option;
self.enum_display[i] = "" + (display[i] || option);
self.enum_values[i] = self.typecast(option);
});
}
// Boolean
else if (this.schema.type === "boolean") {
self.enum_display = this.schema.options && this.schema.options.enum_titles || ['true', 'false'];
self.enum_options = ['1', '0'];
self.enum_values = [true, false];
}
// Dynamic Enum
else if (this.schema.enumSource) {
this.enumSource = [];
this.enum_display = [];
this.enum_options = [];
this.enum_values = [];
// Shortcut declaration for using a single array
if (!(Array.isArray(this.schema.enumSource))) {
if (this.schema.enumValue) {
this.enumSource = [{
source: this.schema.enumSource,
value: this.schema.enumValue
}];
} else {
this.enumSource = [{
source: this.schema.enumSource
}];
}
} else {
for (i = 0; i < this.schema.enumSource.length; i++) {
// Shorthand for watched variable
if (typeof this.schema.enumSource[i] === "string") {
this.enumSource[i] = {
source: this.schema.enumSource[i]
};
}
// Make a copy of the schema
else if (!(Array.isArray(this.schema.enumSource[i]))) {
this.enumSource[i] = $extend({}, this.schema.enumSource[i]);
} else {
this.enumSource[i] = this.schema.enumSource[i];
}
}
}
// Now, enumSource is an array of sources
// Walk through this array and fix up the values
for (i = 0; i < this.enumSource.length; i++) {
if (this.enumSource[i].value) {
this.enumSource[i].value = this.jsoneditor.compileTemplate(this.enumSource[i].value, this.template_engine);
}
if (this.enumSource[i].title) {
this.enumSource[i].title = this.jsoneditor.compileTemplate(this.enumSource[i].title, this.template_engine);
}
if (this.enumSource[i].filter) {
this.enumSource[i].filter = this.jsoneditor.compileTemplate(this.enumSource[i].filter, this.template_engine);
}
}
}
// Other, not supported
else {
throw "'select' editor requires the enum property to be set.";
}
},
build: function() {
var self = this;
if (!this.options.compact) this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
if (this.schema.description) this.description = this.theme.getFormInputDescription(this.schema.description);
if (this.options.compact) this.container.className += ' compact';
this.input = this.theme.getSelectInput(this.enum_options);
this.theme.setSelectOptions(this.input, this.enum_options, this.enum_display);
if (this.schema.readOnly || this.schema.readonly) {
this.always_disabled = true;
this.input.disabled = true;
}
this.input.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
self.onInputChange();
}, false);
this.control = this.theme.getFormControl(this.label, this.input, this.description);
this.container.appendChild(this.control);
this.value = this.enum_values[0];
},
onInputChange: function() {
var val = this.input.value;
var sanitized = val;
if (this.enum_options.indexOf(val) === -1) {
sanitized = this.enum_options[0];
}
this.value = this.enum_values[this.enum_options.indexOf(val)];
this.onChange(true);
},
setupSelectize: function() {
// If the Selectize library is loaded use it when we have lots of items
var self = this;
if (window.jQuery && window.jQuery.fn && window.jQuery.fn.selectize && (this.enum_options.length >= 2 || (this.enum_options.length && this.enumSource))) {
var options = $extend({}, JSONEditor.plugins.selectize);
if (this.schema.options && this.schema.options.selectize_options) options = $extend(options, this.schema.options.selectize_options);
this.selectize = window.jQuery(this.input).selectize($extend(options, {
create: true,
onChange: function() {
self.onInputChange();
}
}));
} else {
this.selectize = null;
}
},
postBuild: function() {
this._super();
this.theme.afterInputReady(this.input);
this.setupSelectize();
},
onWatchedFieldChange: function() {
var self = this,
vars, j;
// If this editor uses a dynamic select box
if (this.enumSource) {
vars = this.getWatchedFieldValues();
var select_options = [];
var select_titles = [];
for (var i = 0; i < this.enumSource.length; i++) {
// Constant values
if (Array.isArray(this.enumSource[i])) {
select_options = select_options.concat(this.enumSource[i]);
select_titles = select_titles.concat(this.enumSource[i]);
}
// A watched field
else if (vars[this.enumSource[i].source]) {
var items = vars[this.enumSource[i].source];
// Only use a predefined part of the array
if (this.enumSource[i].slice) {
items = Array.prototype.slice.apply(items, this.enumSource[i].slice);
}
// Filter the items
if (this.enumSource[i].filter) {
var new_items = [];
for (j = 0; j < items.length; j++) {
if (this.enumSource[i].filter({
i: j,
item: items[j]
})) new_items.push(items[j]);
}
items = new_items;
}
var item_titles = [];
var item_values = [];
for (j = 0; j < items.length; j++) {
var item = items[j];
// Rendered value
if (this.enumSource[i].value) {
item_values[j] = this.enumSource[i].value({
i: j,
item: item
});
}
// Use value directly
else {
item_values[j] = items[j];
}
// Rendered title
if (this.enumSource[i].title) {
item_titles[j] = this.enumSource[i].title({
i: j,
item: item
});
}
// Use value as the title also
else {
item_titles[j] = item_values[j];
}
}
// TODO: sort
select_options = select_options.concat(item_values);
select_titles = select_titles.concat(item_titles);
}
}
var prev_value = this.value;
this.theme.setSelectOptions(this.input, select_options, select_titles);
this.enum_options = select_options;
this.enum_display = select_titles;
this.enum_values = select_options;
// If the previous value is still in the new select options, stick with it
if (select_options.indexOf(prev_value) !== -1) {
this.input.value = prev_value;
this.value = prev_value;
}
// Otherwise, set the value to the first select option
else {
this.input.value = select_options[0];
this.value = select_options[0] || "";
if (this.parent) this.parent.onChildEditorChange(this);
else this.jsoneditor.onChange();
this.jsoneditor.notifyWatchers(this.path);
}
if (this.selectize) {
// Update the Selectize options
this.updateSelectizeOptions(select_options);
} else {
this.setupSelectize();
}
this._super();
}
},
updateSelectizeOptions: function(select_options) {
var selectized = this.selectize[0].selectize,
self = this;
selectized.off();
selectized.clearOptions();
for (var n in select_options) {
selectized.addOption({
value: select_options[n],
text: select_options[n]
});
}
selectized.addItem(this.value);
selectized.on('change', function() {
self.onInputChange();
});
},
enable: function() {
if (!this.always_disabled) {
this.input.disabled = false;
if (this.selectize) {
this.selectize[0].selectize.unlock();
}
}
this._super();
},
disable: function() {
this.input.disabled = true;
if (this.selectize) {
this.selectize[0].selectize.lock();
}
this._super();
},
destroy: function() {
if (this.label && this.label.parentNode) this.label.parentNode.removeChild(this.label);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
if (this.selectize) {
this.selectize[0].selectize.destroy();
this.selectize = null;
}
this._super();
}
});
JSONEditor.defaults.editors.multiselect = JSONEditor.AbstractEditor.extend({
preBuild: function() {
this._super();
this.select_options = {};
this.select_values = {};
var items_schema = this.jsoneditor.expandRefs(this.schema.items || {});
var e = items_schema["enum"] || [];
this.option_keys = [];
for (i = 0; i < e.length; i++) {
// If the sanitized value is different from the enum value, don't include it
if (this.sanitize(e[i]) !== e[i]) continue;
this.option_keys.push(e[i] + "");
this.select_values[e[i] + ""] = e[i];
}
},
build: function() {
var self = this,
i;
if (!this.options.compact) this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
if (this.schema.description) this.description = this.theme.getFormInputDescription(this.schema.description);
if ((!this.schema.format && this.option_keys.length < 8) || this.schema.format === "checkbox") {
this.input_type = 'checkboxes';
this.inputs = {};
this.controls = {};
for (i = 0; i < this.option_keys.length; i++) {
this.inputs[this.option_keys[i]] = this.theme.getCheckbox();
this.select_options[this.option_keys[i]] = this.inputs[this.option_keys[i]];
var label = this.theme.getCheckboxLabel(this.option_keys[i]);
this.controls[this.option_keys[i]] = this.theme.getFormControl(label, this.inputs[this.option_keys[i]]);
}
this.control = this.theme.getMultiCheckboxHolder(this.controls, this.label, this.description);
} else {
this.input_type = 'select';
this.input = this.theme.getSelectInput(this.option_keys);
this.input.multiple = true;
this.input.size = Math.min(10, this.option_keys.length);
for (i = 0; i < this.option_keys.length; i++) {
this.select_options[this.option_keys[i]] = this.input.children[i];
}
if (this.schema.readOnly || this.schema.readonly) {
this.always_disabled = true;
this.input.disabled = true;
}
this.control = this.theme.getFormControl(this.label, this.input, this.description);
}
this.container.appendChild(this.control);
this.control.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
var new_value = [];
for (i = 0; i < self.option_keys.length; i++) {
if (self.select_options[self.option_keys[i]].selected || self.select_options[self.option_keys[i]].checked) new_value.push(self.select_values[self.option_keys[i]]);
}
self.updateValue(new_value);
self.onChange(true);
}, false);
},
setValue: function(value, initial) {
var i;
value = value || [];
if (typeof value !== "object") value = [value];
else if (!(Array.isArray(value))) value = [];
// Make sure we are dealing with an array of strings so we can check for strict equality
for (i = 0; i < value.length; i++) {
if (typeof value[i] !== "string") value[i] += "";
}
// Update selected status of options
for (i in this.select_options) {
if (!this.select_options.hasOwnProperty(i)) continue;
this.select_options[i][this.input_type === "select" ? "selected" : "checked"] = (value.indexOf(i) !== -1);
}
this.updateValue(value);
this.onChange();
},
setupSelect2: function() {
if (window.jQuery && window.jQuery.fn && window.jQuery.fn.select2) {
var options = window.jQuery.extend({}, JSONEditor.plugins.select2);
if (this.schema.options && this.schema.options.select2_options) options = $extend(options, this.schema.options.select2_options);
this.select2 = window.jQuery(this.input).select2(options);
var self = this;
this.select2.on('select2-blur', function() {
var val = self.select2.select2('val');
self.value = val;
self.onChange(true);
});
} else {
this.select2 = null;
}
},
onInputChange: function() {
this.value = this.input.value;
this.onChange(true);
},
postBuild: function() {
this._super();
this.setupSelect2();
},
register: function() {
this._super();
if (!this.input) return;
this.input.setAttribute('name', this.formname);
},
unregister: function() {
this._super();
if (!this.input) return;
this.input.removeAttribute('name');
},
getNumColumns: function() {
var longest_text = this.getTitle().length;
for (var i in this.select_values) {
if (!this.select_values.hasOwnProperty(i)) continue;
longest_text = Math.max(longest_text, (this.select_values[i] + "").length + 4);
}
return Math.min(12, Math.max(longest_text / 7, 2));
},
updateValue: function(value) {
var changed = false;
var new_value = [];
for (var i = 0; i < value.length; i++) {
if (!this.select_options[value[i] + ""]) {
changed = true;
continue;
}
var sanitized = this.sanitize(this.select_values[value[i]]);
new_value.push(sanitized);
if (sanitized !== value[i]) changed = true;
}
this.value = new_value;
if (this.select2) this.select2.select2('val', this.value);
return changed;
},
sanitize: function(value) {
if (this.schema.items.type === "number") {
return 1 * value;
} else if (this.schema.items.type === "integer") {
return Math.floor(value * 1);
} else {
return "" + value;
}
},
enable: function() {
if (!this.always_disabled) {
if (this.input) {
this.input.disabled = false;
} else if (this.inputs) {
for (var i in this.inputs) {
if (!this.inputs.hasOwnProperty(i)) continue;
this.inputs[i].disabled = false;
}
}
if (this.select2) this.select2.select2("enable", true);
}
this._super();
},
disable: function() {
if (this.input) {
this.input.disabled = true;
} else if (this.inputs) {
for (var i in this.inputs) {
if (!this.inputs.hasOwnProperty(i)) continue;
this.inputs[i].disabled = true;
}
}
if (this.select2) this.select2.select2("enable", false);
this._super();
},
destroy: function() {
if (this.select2) {
this.select2.select2('destroy');
this.select2 = null;
}
this._super();
}
});
JSONEditor.defaults.editors.base64 = JSONEditor.AbstractEditor.extend({
getNumColumns: function() {
return 4;
},
build: function() {
var self = this;
this.title = this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
// Input that holds the base64 string
this.input = this.theme.getFormInputField('hidden');
this.container.appendChild(this.input);
// Don't show uploader if this is readonly
if (!this.schema.readOnly && !this.schema.readonly) {
if (!window.FileReader) throw "FileReader required for base64 editor";
// File uploader
this.uploader = this.theme.getFormInputField('file');
this.uploader.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
if (this.files && this.files.length) {
var fr = new FileReader();
fr.onload = function(evt) {
self.value = evt.target.result;
self.refreshPreview();
self.onChange(true);
fr = null;
};
fr.readAsDataURL(this.files[0]);
}
}, false);
}
this.preview = this.theme.getFormInputDescription(this.schema.description);
this.container.appendChild(this.preview);
this.control = this.theme.getFormControl(this.label, this.uploader || this.input, this.preview);
this.container.appendChild(this.control);
},
refreshPreview: function() {
if (this.last_preview === this.value) return;
this.last_preview = this.value;
this.preview.innerHTML = '';
if (!this.value) return;
var mime = this.value.match(/^data:([^;,]+)[;,]/);
if (mime) mime = mime[1];
if (!mime) {
this.preview.innerHTML = '<em>Invalid data URI</em>';
} else {
this.preview.innerHTML = '<strong>Type:</strong> ' + mime + ', <strong>Size:</strong> ' + Math.floor((this.value.length - this.value.split(',')[0].length - 1) / 1.33333) + ' bytes';
if (mime.substr(0, 5) === "image") {
this.preview.innerHTML += '<br>';
var img = document.createElement('img');
img.style.maxWidth = '100%';
img.style.maxHeight = '100px';
img.src = this.value;
this.preview.appendChild(img);
}
}
},
enable: function() {
if (this.uploader) this.uploader.disabled = false;
this._super();
},
disable: function() {
if (this.uploader) this.uploader.disabled = true;
this._super();
},
setValue: function(val) {
if (this.value !== val) {
this.value = val;
this.input.value = this.value;
this.refreshPreview();
this.onChange();
}
},
destroy: function() {
if (this.preview && this.preview.parentNode) this.preview.parentNode.removeChild(this.preview);
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
if (this.uploader && this.uploader.parentNode) this.uploader.parentNode.removeChild(this.uploader);
this._super();
}
});
JSONEditor.defaults.editors.upload = JSONEditor.AbstractEditor.extend({
getNumColumns: function() {
return 4;
},
build: function() {
var self = this;
this.title = this.header = this.label = this.theme.getFormInputLabel(this.getTitle());
// Input that holds the base64 string
this.input = this.theme.getFormInputField('hidden');
this.container.appendChild(this.input);
// Don't show uploader if this is readonly
if (!this.schema.readOnly && !this.schema.readonly) {
if (!this.jsoneditor.options.upload) throw "Upload handler required for upload editor";
// File uploader
this.uploader = this.theme.getFormInputField('file');
this.uploader.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
if (this.files && this.files.length) {
var fr = new FileReader();
fr.onload = function(evt) {
self.preview_value = evt.target.result;
self.refreshPreview();
self.onChange(true);
fr = null;
};
fr.readAsDataURL(this.files[0]);
}
}, false);
}
var description = this.schema.description;
if (!description) description = '';
this.preview = this.theme.getFormInputDescription(description);
this.container.appendChild(this.preview);
this.control = this.theme.getFormControl(this.label, this.uploader || this.input, this.preview);
this.container.appendChild(this.control);
},
refreshPreview: function() {
if (this.last_preview === this.preview_value) return;
this.last_preview = this.preview_value;
this.preview.innerHTML = '';
if (!this.preview_value) return;
var self = this;
var mime = this.preview_value.match(/^data:([^;,]+)[;,]/);
if (mime) mime = mime[1];
if (!mime) mime = 'unknown';
var file = this.uploader.files[0];
this.preview.innerHTML = '<strong>Type:</strong> ' + mime + ', <strong>Size:</strong> ' + file.size + ' bytes';
if (mime.substr(0, 5) === "image") {
this.preview.innerHTML += '<br>';
var img = document.createElement('img');
img.style.maxWidth = '100%';
img.style.maxHeight = '100px';
img.src = this.preview_value;
this.preview.appendChild(img);
}
this.preview.innerHTML += '<br>';
var uploadButton = this.getButton('Upload', 'upload', 'Upload');
this.preview.appendChild(uploadButton);
uploadButton.addEventListener('click', function(event) {
event.preventDefault();
uploadButton.setAttribute("disabled", "disabled");
self.theme.removeInputError(self.uploader);
if (self.theme.getProgressBar) {
self.progressBar = self.theme.getProgressBar();
self.preview.appendChild(self.progressBar);
}
self.jsoneditor.options.upload(self.path, file, {
success: function(url) {
self.setValue(url);
if (self.parent) self.parent.onChildEditorChange(self);
else self.jsoneditor.onChange();
if (self.progressBar) self.preview.removeChild(self.progressBar);
uploadButton.removeAttribute("disabled");
},
failure: function(error) {
self.theme.addInputError(self.uploader, error);
if (self.progressBar) self.preview.removeChild(self.progressBar);
uploadButton.removeAttribute("disabled");
},
updateProgress: function(progress) {
if (self.progressBar) {
if (progress) self.theme.updateProgressBar(self.progressBar, progress);
else self.theme.updateProgressBarUnknown(self.progressBar);
}
}
});
}, false);
},
enable: function() {
if (this.uploader) this.uploader.disabled = false;
this._super();
},
disable: function() {
if (this.uploader) this.uploader.disabled = true;
this._super();
},
setValue: function(val) {
if (this.value !== val) {
this.value = val;
this.input.value = this.value;
this.onChange();
}
},
destroy: function() {
if (this.preview && this.preview.parentNode) this.preview.parentNode.removeChild(this.preview);
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
if (this.uploader && this.uploader.parentNode) this.uploader.parentNode.removeChild(this.uploader);
this._super();
}
});
JSONEditor.defaults.editors.checkbox = JSONEditor.AbstractEditor.extend({
setValue: function(value, initial) {
this.value = !! value;
this.input.checked = this.value;
this.onChange();
},
register: function() {
this._super();
if (!this.input) return;
this.input.setAttribute('name', this.formname);
},
unregister: function() {
this._super();
if (!this.input) return;
this.input.removeAttribute('name');
},
getNumColumns: function() {
return Math.min(12, Math.max(this.getTitle().length / 7, 2));
},
build: function() {
var self = this;
if (!this.options.compact) {
this.label = this.header = this.theme.getCheckboxLabel(this.getTitle());
}
if (this.schema.description) this.description = this.theme.getFormInputDescription(this.schema.description);
if (this.options.compact) this.container.className += ' compact';
this.input = this.theme.getCheckbox();
this.control = this.theme.getFormControl(this.label, this.input, this.description);
if (this.schema.readOnly || this.schema.readonly) {
this.always_disabled = true;
this.input.disabled = true;
}
this.input.addEventListener('change', function(e) {
e.preventDefault();
e.stopPropagation();
self.value = this.checked;
self.onChange(true);
}, false);
this.container.appendChild(this.control);
},
enable: function() {
if (!this.always_disabled) {
this.input.disabled = false;
}
this._super();
},
disable: function() {
this.input.disabled = true;
this._super();
},
destroy: function() {
if (this.label && this.label.parentNode) this.label.parentNode.removeChild(this.label);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
this._super();
}
});
JSONEditor.defaults.editors.arraySelectize = JSONEditor.AbstractEditor.extend({
build: function() {
this.title = this.theme.getFormInputLabel(this.getTitle());
this.title_controls = this.theme.getHeaderButtonHolder();
this.title.appendChild(this.title_controls);
this.error_holder = document.createElement('div');
if (this.schema.description) {
this.description = this.theme.getDescription(this.schema.description);
}
this.input = document.createElement('select');
this.input.setAttribute('multiple', 'multiple');
var group = this.theme.getFormControl(this.title, this.input, this.description);
this.container.appendChild(group);
this.container.appendChild(this.error_holder);
window.jQuery(this.input).selectize({
delimiter: false,
createOnBlur: true,
create: true
});
},
postBuild: function() {
var self = this;
this.input.selectize.on('change', function(event) {
self.refreshValue();
self.onChange(true);
});
},
destroy: function() {
this.empty(true);
if (this.title && this.title.parentNode) this.title.parentNode.removeChild(this.title);
if (this.description && this.description.parentNode) this.description.parentNode.removeChild(this.description);
if (this.input && this.input.parentNode) this.input.parentNode.removeChild(this.input);
this._super();
},
empty: function(hard) {},
setValue: function(value, initial) {
var self = this;
// Update the array's value, adding/removing rows when necessary
value = value || [];
if (!(Array.isArray(value))) value = [value];
this.input.selectize.clearOptions();
this.input.selectize.clear(true);
value.forEach(function(item) {
self.input.selectize.addOption({
text: item,
value: item
});
});
this.input.selectize.setValue(value);
this.refreshValue(initial);
},
refreshValue: function(force) {
this.value = this.input.selectize.getValue();
},
showValidationErrors: function(errors) {
var self = this;
// Get all the errors that pertain to this editor
var my_errors = [];
var other_errors = [];
$each(errors, function(i, error) {
if (error.path === self.path) {
my_errors.push(error);
} else {
other_errors.push(error);
}
});
// Show errors for this editor
if (this.error_holder) {
if (my_errors.length) {
var message = [];
this.error_holder.innerHTML = '';
this.error_holder.style.display = '';
$each(my_errors, function(i, error) {
self.error_holder.appendChild(self.theme.getErrorMessage(error.message));
});
}
// Hide error area
else {
this.error_holder.style.display = 'none';
}
}
}
});
var matchKey = (function() {
var elem = document.documentElement;
if (elem.matches) return 'matches';
else if (elem.webkitMatchesSelector) return 'webkitMatchesSelector';
else if (elem.mozMatchesSelector) return 'mozMatchesSelector';
else if (elem.msMatchesSelector) return 'msMatchesSelector';
else if (elem.oMatchesSelector) return 'oMatchesSelector';
})();
JSONEditor.AbstractTheme = Class.extend({
getContainer: function() {
return document.createElement('div');
},
getFloatRightLinkHolder: function() {
var el = document.createElement('div');
el.setAttribute('style', el.style || {} );
el.style.cssFloat = 'right';
el.style.marginLeft = '10px';
return el;
},
getModal: function() {
var el = document.createElement('div');
el.style.backgroundColor = 'white';
el.style.border = '1px solid black';
el.style.boxShadow = '3px 3px black';
el.style.position = 'absolute';
el.style.zIndex = '10';
el.style.display = 'none';
return el;
},
getGridContainer: function() {
var el = document.createElement('div');
return el;
},
getGridRow: function() {
var el = document.createElement('div');
el.className = 'row';
return el;
},
getGridColumn: function() {
var el = document.createElement('div');
return el;
},
setGridColumnSize: function(el, size) {
},
getLink: function(text) {
var el = document.createElement('a');
el.setAttribute('href', '#');
el.appendChild(document.createTextNode(text));
return el;
},
disableHeader: function(header) {
header.style.color = '#ccc';
},
disableLabel: function(label) {
label.style.color = '#ccc';
},
enableHeader: function(header) {
header.style.color = '';
},
enableLabel: function(label) {
label.style.color = '';
},
getFormInputLabel: function(text) {
var el = document.createElement('label');
el.appendChild(document.createTextNode(text));
return el;
},
getCheckboxLabel: function(text) {
var el = this.getFormInputLabel(text);
el.style.fontWeight = 'normal';
return el;
},
getHeader: function(text) {
var el = document.createElement('h3');
if (typeof text === "string") {
el.textContent = text;
} else {
el.appendChild(text);
}
return el;
},
getCheckbox: function() {
var el = this.getFormInputField('checkbox');
el.style.display = 'inline-block';
el.style.width = 'auto';
return el;
},
getMultiCheckboxHolder: function(controls, label, description) {
var el = document.createElement('div');
if (label) {
label.style.display = 'block';
el.appendChild(label);
}
for (var i in controls) {
if (!controls.hasOwnProperty(i)) continue;
controls[i].style.display = 'inline-block';
controls[i].style.marginRight = '20px';
el.appendChild(controls[i]);
}
if (description) el.appendChild(description);
return el;
},
getSelectInput: function(options) {
var select = document.createElement('select');
if (options) this.setSelectOptions(select, options);
return select;
},
getSwitcher: function(options) {
var switcher = this.getSelectInput(options);
switcher.style.backgroundColor = 'transparent';
switcher.style.display = 'inline-block';
switcher.style.fontStyle = 'italic';
switcher.style.fontWeight = 'normal';
switcher.style.height = 'auto';
switcher.style.marginBottom = 0;
switcher.style.marginLeft = '5px';
switcher.style.padding = '0 0 0 3px';
switcher.style.width = 'auto';
return switcher;
},
getSwitcherOptions: function(switcher) {
return switcher.getElementsByTagName('option');
},
setSwitcherOptions: function(switcher, options, titles) {
this.setSelectOptions(switcher, options, titles);
},
setSelectOptions: function(select, options, titles) {
titles = titles || [];
select.innerHTML = '';
for (var i = 0; i < options.length; i++) {
var option = document.createElement('option');
option.setAttribute('value', options[i]);
option.textContent = titles[i] || options[i];
select.appendChild(option);
}
},
getTextareaInput: function() {
var el = document.createElement('textarea');
el.setAttribute('style', el.style || {} );
el.style.width = '100%';
el.style.height = '300px';
el.style.boxSizing = 'border-box';
return el;
},
getRangeInput: function(min, max, step) {
var el = this.getFormInputField('range');
el.setAttribute('min', min);
el.setAttribute('max', max);
el.setAttribute('step', step);
return el;
},
getFormInputField: function(type) {
var el = document.createElement('input');
el.setAttribute('type', type);
return el;
},
afterInputReady: function(input) {
},
getFormControl: function(label, input, description) {
var el = document.createElement('div');
el.className = 'form-control';
if (label) el.appendChild(label);
if (input.type === 'checkbox') {
label.insertBefore(input, label.firstChild);
} else {
el.appendChild(input);
}
if (description) el.appendChild(description);
return el;
},
getIndentedPanel: function() {
var el = document.createElement('div');
el.setAttribute('style', el.style || {} );
el.style.paddingLeft = '10px';
el.style.marginLeft = '10px';
el.style.borderLeft = '1px solid #ccc';
return el;
},
getChildEditorHolder: function() {
return document.createElement('div');
},
getDescription: function(text) {
var el = document.createElement('p');
el.innerHTML = text;
return el;
},
getCheckboxDescription: function(text) {
return this.getDescription(text);
},
getFormInputDescription: function(text) {
return this.getDescription(text);
},
getHeaderButtonHolder: function() {
return this.getButtonHolder();
},
getButtonHolder: function() {
return document.createElement('div');
},
getButton: function(text, icon, title) {
var el = document.createElement('button');
el.type = 'button';
this.setButtonText(el, text, icon, title);
return el;
},
setButtonText: function(button, text, icon, title) {
button.innerHTML = '';
if (icon) {
button.appendChild(icon);
button.innerHTML += ' ';
}
button.appendChild(document.createTextNode(text));
if (title) button.setAttribute('title', title);
},
getTable: function() {
return document.createElement('table');
},
getTableRow: function() {
return document.createElement('tr');
},
getTableHead: function() {
return document.createElement('thead');
},
getTableBody: function() {
return document.createElement('tbody');
},
getTableHeaderCell: function(text) {
var el = document.createElement('th');
el.textContent = text;
return el;
},
getTableCell: function() {
var el = document.createElement('td');
return el;
},
getErrorMessage: function(text) {
var el = document.createElement('p');
el.setAttribute('style', el.style || {} );
el.style.color = 'red';
el.appendChild(document.createTextNode(text));
return el;
},
addInputError: function(input, text) {},
removeInputError: function(input) {},
addTableRowError: function(row) {},
removeTableRowError: function(row) {},
getTabHolder: function() {
var el = document.createElement('div');
el.innerHTML = "<div style='float: left; width: 130px;' class='tabs'></div><div class='content' style='margin-left: 130px;'></div><div style='clear:both;'></div>";
return el;
},
applyStyles: function(el, styles) {
el.setAttribute('style', el.style || {} );
for (var i in styles) {
if (!styles.hasOwnProperty(i)) continue;
el.style[i] = styles[i];
}
},
closest: function(elem, selector) {
while (elem && elem !== document) {
if (matchKey) {
if (elem[matchKey](selector)) {
return elem;
} else {
elem = elem.parentNode;
}
} else {
return false;
}
}
return false;
},
getTab: function(span) {
var el = document.createElement('div');
el.appendChild(span);
el.setAttribute('style', el.style || {} );
this.applyStyles(el, {
border: '1px solid #ccc',
borderWidth: '1px 0 1px 1px',
textAlign: 'center',
lineHeight: '30px',
borderRadius: '5px',
borderBottomRightRadius: 0,
borderTopRightRadius: 0,
fontWeight: 'bold',
cursor: 'pointer'
});
return el;
},
getTabContentHolder: function(tab_holder) {
return tab_holder.children[1];
},
getTabContent: function() {
return this.getIndentedPanel();
},
markTabActive: function(tab) {
this.applyStyles(tab, {
opacity: 1,
background: 'white'
});
},
markTabInactive: function(tab) {
this.applyStyles(tab, {
opacity: 0.5,
background: ''
});
},
addTab: function(holder, tab) {
holder.children[0].appendChild(tab);
},
getBlockLink: function() {
var link = document.createElement('a');
link.style.display = 'block';
return link;
},
getBlockLinkHolder: function() {
var el = document.createElement('div');
return el;
},
getLinksHolder: function() {
var el = document.createElement('div');
return el;
},
createMediaLink: function(holder, link, media) {
holder.appendChild(link);
media.style.width = '100%';
holder.appendChild(media);
},
createImageLink: function(holder, link, image) {
holder.appendChild(link);
link.appendChild(image);
}
});
JSONEditor.defaults.themes.bootstrap2 = JSONEditor.AbstractTheme.extend({
getRangeInput: function(min, max, step) {
// TODO: use bootstrap slider
return this._super(min, max, step);
},
getGridContainer: function() {
var el = document.createElement('div');
el.className = 'container-fluid';
return el;
},
getGridRow: function() {
var el = document.createElement('div');
el.className = 'row-fluid';
return el;
},
getFormInputLabel: function(text) {
var el = this._super(text);
el.style.display = 'inline-block';
el.style.fontWeight = 'bold';
return el;
},
setGridColumnSize: function(el, size) {
el.className = 'span' + size;
},
getSelectInput: function(options) {
var input = this._super(options);
input.style.width = 'auto';
input.style.maxWidth = '98%';
return input;
},
getFormInputField: function(type) {
var el = this._super(type);
el.style.width = '98%';
return el;
},
afterInputReady: function(input) {
if (input.controlgroup) return;
input.controlgroup = this.closest(input, '.control-group');
input.controls = this.closest(input, '.controls');
if (this.closest(input, '.compact')) {
input.controlgroup.className = input.controlgroup.className.replace(/control-group/g, '').replace(/[ ]{2,}/g, ' ');
input.controls.className = input.controlgroup.className.replace(/controls/g, '').replace(/[ ]{2,}/g, ' ');
input.style.marginBottom = 0;
}
// TODO: use bootstrap slider
},
getIndentedPanel: function() {
var el = document.createElement('div');
el.className = 'well well-small';
el.style.paddingBottom = 0;
return el;
},
getFormInputDescription: function(text) {
var el = document.createElement('p');
el.className = 'help-inline';
el.textContent = text;
return el;
},
getFormControl: function(label, input, description) {
var ret = document.createElement('div');
ret.className = 'control-group';
var controls = document.createElement('div');
controls.className = 'controls';
if (label && input.getAttribute('type') === 'checkbox') {
ret.appendChild(controls);
label.className += ' checkbox';
label.appendChild(input);
controls.appendChild(label);
controls.style.height = '30px';
} else {
if (label) {
label.className += ' control-label';
ret.appendChild(label);
}
controls.appendChild(input);
ret.appendChild(controls);
}
if (description) controls.appendChild(description);
return ret;
},
getHeaderButtonHolder: function() {
var el = this.getButtonHolder();
el.style.marginLeft = '10px';
return el;
},
getButtonHolder: function() {
var el = document.createElement('div');
el.className = 'btn-group';
return el;
},
getButton: function(text, icon, title) {
var el = this._super(text, icon, title);
el.className += ' btn btn-default';
return el;
},
getTable: function() {
var el = document.createElement('table');
el.className = 'table table-bordered';
el.style.width = 'auto';
el.style.maxWidth = 'none';
return el;
},
addInputError: function(input, text) {
if (!input.controlgroup || !input.controls) return;
input.controlgroup.className += ' error';
if (!input.errmsg) {
input.errmsg = document.createElement('p');
input.errmsg.className = 'help-block errormsg';
input.controls.appendChild(input.errmsg);
} else {
input.errmsg.style.display = '';
}
input.errmsg.textContent = text;
},
removeInputError: function(input) {
if (!input.errmsg) return;
input.errmsg.style.display = 'none';
input.controlgroup.className = input.controlgroup.className.replace(/\s?error/g, '');
},
getTabHolder: function() {
var el = document.createElement('div');
el.className = 'tabbable tabs-left';
el.innerHTML = "<ul class='nav nav-tabs span2' style='margin-right: 0;'></ul><div class='tab-content span10' style='overflow:visible;'></div>";
return el;
},
getTab: function(text) {
var el = document.createElement('li');
var a = document.createElement('a');
a.setAttribute('href', '#');
a.appendChild(text);
el.appendChild(a);
return el;
},
getTabContentHolder: function(tab_holder) {
return tab_holder.children[1];
},
getTabContent: function() {
var el = document.createElement('div');
el.className = 'tab-pane active';
return el;
},
markTabActive: function(tab) {
tab.className += ' active';
},
markTabInactive: function(tab) {
tab.className = tab.className.replace(/\s?active/g, '');
},
addTab: function(holder, tab) {
holder.children[0].appendChild(tab);
},
getProgressBar: function() {
var container = document.createElement('div');
container.className = 'progress';
var bar = document.createElement('div');
bar.className = 'bar';
bar.style.width = '0%';
container.appendChild(bar);
return container;
},
updateProgressBar: function(progressBar, progress) {
if (!progressBar) return;
progressBar.firstChild.style.width = progress + "%";
},
updateProgressBarUnknown: function(progressBar) {
if (!progressBar) return;
progressBar.className = 'progress progress-striped active';
progressBar.firstChild.style.width = '100%';
}
});
JSONEditor.defaults.themes.bootstrap3 = JSONEditor.AbstractTheme.extend({
getSelectInput: function(options) {
var el = this._super(options);
el.className += 'form-control';
//el.style.width = 'auto';
return el;
},
setGridColumnSize: function(el, size) {
el.className = 'col-md-' + size;
},
afterInputReady: function(input) {
if (input.controlgroup) return;
input.controlgroup = this.closest(input, '.form-group');
if (this.closest(input, '.compact')) {
input.controlgroup.style.marginBottom = 0;
}
// TODO: use bootstrap slider
},
getTextareaInput: function() {
var el = document.createElement('textarea');
el.className = 'form-control';
return el;
},
getRangeInput: function(min, max, step) {
// TODO: use better slider
return this._super(min, max, step);
},
getFormInputField: function(type) {
var el = this._super(type);
if (type !== 'checkbox') {
el.className += 'form-control';
}
return el;
},
getFormControl: function(label, input, description) {
var group = document.createElement('div');
if (label && input.type === 'checkbox') {
group.className += ' checkbox';
label.appendChild(input);
label.style.fontSize = '14px';
group.style.marginTop = '0';
group.appendChild(label);
input.style.position = 'relative';
input.style.cssFloat = 'left';
} else {
group.className += ' form-group';
if (label) {
label.className += ' control-label';
group.appendChild(label);
}
group.appendChild(input);
}
if (description) group.appendChild(description);
return group;
},
getIndentedPanel: function() {
var el = document.createElement('div');
el.className = 'well well-sm';
el.style.paddingBottom = 0;
return el;
},
getFormInputDescription: function(text) {
var el = document.createElement('p');
el.className = 'help-block';
el.innerHTML = text;
return el;
},
getHeaderButtonHolder: function() {
var el = this.getButtonHolder();
el.style.marginLeft = '10px';
return el;
},
getButtonHolder: function() {
var el = document.createElement('div');
el.className = 'btn-group';
return el;
},
getButton: function(text, icon, title) {
var el = this._super(text, icon, title);
el.className += 'btn btn-default';
return el;
},
getTable: function() {
var el = document.createElement('table');
el.className = 'table table-bordered';
el.style.width = 'auto';
el.style.maxWidth = 'none';
return el;
},
addInputError: function(input, text) {
if (!input.controlgroup) return;
input.controlgroup.className += ' has-error';
if (!input.errmsg) {
input.errmsg = document.createElement('p');
input.errmsg.className = 'help-block errormsg';
input.controlgroup.appendChild(input.errmsg);
} else {
input.errmsg.style.display = '';
}
input.errmsg.textContent = text;
},
removeInputError: function(input) {
if (!input.errmsg) return;
input.errmsg.style.display = 'none';
input.controlgroup.className = input.controlgroup.className.replace(/\s?has-error/g, '');
},
getTabHolder: function() {
var el = document.createElement('div');
el.innerHTML = "<div class='tabs list-group col-md-2'></div><div class='col-md-10'></div>";
el.className = 'rows';
return el;
},
getTab: function(text) {
var el = document.createElement('a');
el.className = 'list-group-item';
el.setAttribute('href', '#');
el.appendChild(text);
return el;
},
markTabActive: function(tab) {
tab.className += ' active';
},
markTabInactive: function(tab) {
tab.className = tab.className.replace(/\s?active/g, '');
},
getProgressBar: function() {
var min = 0,
max = 100,
start = 0;
var container = document.createElement('div');
container.className = 'progress';
var bar = document.createElement('div');
bar.className = 'progress-bar';
bar.setAttribute('role', 'progressbar');
bar.setAttribute('aria-valuenow', start);
bar.setAttribute('aria-valuemin', min);
bar.setAttribute('aria-valuenax', max);
bar.innerHTML = start + "%";
container.appendChild(bar);
return container;
},
updateProgressBar: function(progressBar, progress) {
if (!progressBar) return;
var bar = progressBar.firstChild;
var percentage = progress + "%";
bar.setAttribute('aria-valuenow', progress);
bar.style.width = percentage;
bar.innerHTML = percentage;
},
updateProgressBarUnknown: function(progressBar) {
if (!progressBar) return;
var bar = progressBar.firstChild;
progressBar.className = 'progress progress-striped active';
bar.removeAttribute('aria-valuenow');
bar.style.width = '100%';
bar.innerHTML = '';
}
});
// Base Foundation theme
JSONEditor.defaults.themes.foundation = JSONEditor.AbstractTheme.extend({
getChildEditorHolder: function() {
var el = document.createElement('div');
el.style.marginBottom = '15px';
return el;
},
getSelectInput: function(options) {
var el = this._super(options);
el.style.minWidth = 'none';
el.style.padding = '5px';
el.style.marginTop = '3px';
return el;
},
getSwitcher: function(options) {
var el = this._super(options);
el.style.paddingRight = '8px';
return el;
},
afterInputReady: function(input) {
if (this.closest(input, '.compact')) {
input.style.marginBottom = 0;
}
input.group = this.closest(input, '.form-control');
},
getFormInputLabel: function(text) {
var el = this._super(text);
el.style.display = 'inline-block';
return el;
},
getFormInputField: function(type) {
var el = this._super(type);
el.style.width = '100%';
el.style.marginBottom = type === 'checkbox' ? '0' : '12px';
return el;
},
getFormInputDescription: function(text) {
var el = document.createElement('p');
el.textContent = text;
el.style.marginTop = '-10px';
el.style.fontStyle = 'italic';
return el;
},
getIndentedPanel: function() {
var el = document.createElement('div');
el.className = 'panel';
el.style.paddingBottom = 0;
return el;
},
getHeaderButtonHolder: function() {
var el = this.getButtonHolder();
el.style.display = 'inline-block';
el.style.marginLeft = '10px';
el.style.verticalAlign = 'middle';
return el;
},
getButtonHolder: function() {
var el = document.createElement('div');
el.className = 'button-group';
return el;
},
getButton: function(text, icon, title) {
var el = this._super(text, icon, title);
el.className += ' small button';
return el;
},
addInputError: function(input, text) {
if (!input.group) return;
input.group.className += ' error';
if (!input.errmsg) {
input.insertAdjacentHTML('afterend', '<small class="error"></small>');
input.errmsg = input.parentNode.getElementsByClassName('error')[0];
} else {
input.errmsg.style.display = '';
}
input.errmsg.textContent = text;
},
removeInputError: function(input) {
if (!input.errmsg) return;
input.group.className = input.group.className.replace(/ error/g, '');
input.errmsg.style.display = 'none';
},
getProgressBar: function() {
var progressBar = document.createElement('div');
progressBar.className = 'progress';
var meter = document.createElement('span');
meter.className = 'meter';
meter.style.width = '0%';
progressBar.appendChild(meter);
return progressBar;
},
updateProgressBar: function(progressBar, progress) {
if (!progressBar) return;
progressBar.firstChild.style.width = progress + '%';
},
updateProgressBarUnknown: function(progressBar) {
if (!progressBar) return;
progressBar.firstChild.style.width = '100%';
}
});
// Foundation 3 Specific Theme
JSONEditor.defaults.themes.foundation3 = JSONEditor.defaults.themes.foundation.extend({
getHeaderButtonHolder: function() {
var el = this._super();
el.style.fontSize = '.6em';
return el;
},
getFormInputLabel: function(text) {
var el = this._super(text);
el.style.fontWeight = 'bold';
return el;
},
getTabHolder: function() {
var el = document.createElement('div');
el.className = 'row';
el.innerHTML = "<dl class='tabs vertical two columns'></dl><div class='tabs-content ten columns'></div>";
return el;
},
setGridColumnSize: function(el, size) {
var sizes = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve'];
el.className = 'columns ' + sizes[size];
},
getTab: function(text) {
var el = document.createElement('dd');
var a = document.createElement('a');
a.setAttribute('href', '#');
a.appendChild(text);
el.appendChild(a);
return el;
},
getTabContentHolder: function(tab_holder) {
return tab_holder.children[1];
},
getTabContent: function() {
var el = document.createElement('div');
el.className = 'content active';
el.style.paddingLeft = '5px';
return el;
},
markTabActive: function(tab) {
tab.className += ' active';
},
markTabInactive: function(tab) {
tab.className = tab.className.replace(/\s*active/g, '');
},
addTab: function(holder, tab) {
holder.children[0].appendChild(tab);
}
});
// Foundation 4 Specific Theme
JSONEditor.defaults.themes.foundation4 = JSONEditor.defaults.themes.foundation.extend({
getHeaderButtonHolder: function() {
var el = this._super();
el.style.fontSize = '.6em';
return el;
},
setGridColumnSize: function(el, size) {
el.className = 'columns large-' + size;
},
getFormInputDescription: function(text) {
var el = this._super(text);
el.style.fontSize = '.8rem';
return el;
},
getFormInputLabel: function(text) {
var el = this._super(text);
el.style.fontWeight = 'bold';
return el;
}
});
// Foundation 5 Specific Theme
JSONEditor.defaults.themes.foundation5 = JSONEditor.defaults.themes.foundation.extend({
getFormInputDescription: function(text) {
var el = this._super(text);
el.style.fontSize = '.8rem';
return el;
},
setGridColumnSize: function(el, size) {
el.className = 'columns medium-' + size;
},
getButton: function(text, icon, title) {
var el = this._super(text, icon, title);
el.className = el.className.replace(/\s*small/g, '') + ' tiny';
return el;
},
getTabHolder: function() {
var el = document.createElement('div');
el.innerHTML = "<dl class='tabs vertical'></dl><div class='tabs-content vertical'></div>";
return el;
},
getTab: function(text) {
var el = document.createElement('dd');
var a = document.createElement('a');
a.setAttribute('href', '#');
a.appendChild(text);
el.appendChild(a);
return el;
},
getTabContentHolder: function(tab_holder) {
return tab_holder.children[1];
},
getTabContent: function() {
var el = document.createElement('div');
el.className = 'content active';
el.style.paddingLeft = '5px';
return el;
},
markTabActive: function(tab) {
tab.className += ' active';
},
markTabInactive: function(tab) {
tab.className = tab.className.replace(/\s*active/g, '');
},
addTab: function(holder, tab) {
holder.children[0].appendChild(tab);
}
});
JSONEditor.defaults.themes.html = JSONEditor.AbstractTheme.extend({
getFormInputLabel: function(text) {
var el = this._super(text);
el.style.display = 'block';
el.style.marginBottom = '3px';
el.style.fontWeight = 'bold';
return el;
},
getFormInputDescription: function(text) {
var el = this._super(text);
el.style.fontSize = '.8em';
el.style.margin = 0;
el.style.display = 'inline-block';
el.style.fontStyle = 'italic';
return el;
},
getIndentedPanel: function() {
var el = this._super();
el.style.border = '1px solid #ddd';
el.style.padding = '5px';
el.style.margin = '5px';
el.style.borderRadius = '3px';
return el;
},
getChildEditorHolder: function() {
var el = this._super();
el.style.marginBottom = '8px';
return el;
},
getHeaderButtonHolder: function() {
var el = this.getButtonHolder();
el.style.display = 'inline-block';
el.style.marginLeft = '10px';
el.style.fontSize = '.8em';
el.style.verticalAlign = 'middle';
return el;
},
getTable: function() {
var el = this._super();
el.style.borderBottom = '1px solid #ccc';
el.style.marginBottom = '5px';
return el;
},
addInputError: function(input, text) {
input.style.borderColor = 'red';
if (!input.errmsg) {
var group = this.closest(input, '.form-control');
input.errmsg = document.createElement('div');
input.errmsg.setAttribute('class', 'errmsg');
input.errmsg.style.cssText = input.errmsg.style.cssText || {};
input.errmsg.style.color = 'red';
group.appendChild(input.errmsg);
} else {
input.errmsg.style.display = 'block';
}
input.errmsg.innerHTML = '';
input.errmsg.appendChild(document.createTextNode(text));
},
removeInputError: function(input) {
input.style.borderColor = '';
if (input.errmsg) input.errmsg.style.display = 'none';
},
getProgressBar: function() {
var max = 100,
start = 0;
var progressBar = document.createElement('progress');
progressBar.setAttribute('max', max);
progressBar.setAttribute('value', start);
return progressBar;
},
updateProgressBar: function(progressBar, progress) {
if (!progressBar) return;
progressBar.setAttribute('value', progress);
},
updateProgressBarUnknown: function(progressBar) {
if (!progressBar) return;
progressBar.removeAttribute('value');
}
});
JSONEditor.defaults.themes.jqueryui = JSONEditor.AbstractTheme.extend({
getTable: function() {
var el = this._super();
el.setAttribute('cellpadding', 5);
el.setAttribute('cellspacing', 0);
return el;
},
getTableHeaderCell: function(text) {
var el = this._super(text);
el.className = 'ui-state-active';
el.style.fontWeight = 'bold';
return el;
},
getTableCell: function() {
var el = this._super();
el.className = 'ui-widget-content';
return el;
},
getHeaderButtonHolder: function() {
var el = this.getButtonHolder();
el.style.marginLeft = '10px';
el.style.fontSize = '.6em';
el.style.display = 'inline-block';
return el;
},
getFormInputDescription: function(text) {
var el = this.getDescription(text);
el.style.marginLeft = '10px';
el.style.display = 'inline-block';
return el;
},
getFormControl: function(label, input, description) {
var el = this._super(label, input, description);
if (input.type === 'checkbox') {
el.style.lineHeight = '25px';
el.style.padding = '3px 0';
} else {
el.style.padding = '4px 0 8px 0';
}
return el;
},
getDescription: function(text) {
var el = document.createElement('span');
el.style.fontSize = '.8em';
el.style.fontStyle = 'italic';
el.textContent = text;
return el;
},
getButtonHolder: function() {
var el = document.createElement('div');
el.className = 'ui-buttonset';
el.style.fontSize = '.7em';
return el;
},
getFormInputLabel: function(text) {
var el = document.createElement('label');
el.style.fontWeight = 'bold';
el.style.display = 'block';
el.textContent = text;
return el;
},
getButton: function(text, icon, title) {
var button = document.createElement("button");
button.className = 'ui-button ui-widget ui-state-default ui-corner-all';
// Icon only
if (icon && !text) {
button.className += ' ui-button-icon-only';
icon.className += ' ui-button-icon-primary ui-icon-primary';
button.appendChild(icon);
}
// Icon and Text
else if (icon) {
button.className += ' ui-button-text-icon-primary';
icon.className += ' ui-button-icon-primary ui-icon-primary';
button.appendChild(icon);
}
// Text only
else {
button.className += ' ui-button-text-only';
}
var el = document.createElement('span');
el.className = 'ui-button-text';
el.textContent = text || title || ".";
button.appendChild(el);
button.setAttribute('title', title);
return button;
},
setButtonText: function(button, text, icon, title) {
button.innerHTML = '';
button.className = 'ui-button ui-widget ui-state-default ui-corner-all';
// Icon only
if (icon && !text) {
button.className += ' ui-button-icon-only';
icon.className += ' ui-button-icon-primary ui-icon-primary';
button.appendChild(icon);
}
// Icon and Text
else if (icon) {
button.className += ' ui-button-text-icon-primary';
icon.className += ' ui-button-icon-primary ui-icon-primary';
button.appendChild(icon);
}
// Text only
else {
button.className += ' ui-button-text-only';
}
var el = document.createElement('span');
el.className = 'ui-button-text';
el.textContent = text || title || ".";
button.appendChild(el);
button.setAttribute('title', title);
},
getIndentedPanel: function() {
var el = document.createElement('div');
el.className = 'ui-widget-content ui-corner-all';
el.style.padding = '1em 1.4em';
el.style.marginBottom = '20px';
return el;
},
afterInputReady: function(input) {
if (input.controls) return;
input.controls = this.closest(input, '.form-control');
},
addInputError: function(input, text) {
if (!input.controls) return;
if (!input.errmsg) {
input.errmsg = document.createElement('div');
input.errmsg.className = 'ui-state-error';
input.controls.appendChild(input.errmsg);
} else {
input.errmsg.style.display = '';
}
input.errmsg.textContent = text;
},
removeInputError: function(input) {
if (!input.errmsg) return;
input.errmsg.style.display = 'none';
},
markTabActive: function(tab) {
tab.className = tab.className.replace(/\s*ui-widget-header/g, '') + ' ui-state-active';
},
markTabInactive: function(tab) {
tab.className = tab.className.replace(/\s*ui-state-active/g, '') + ' ui-widget-header';
}
});
JSONEditor.AbstractIconLib = Class.extend({
mapping: {
collapse: '',
expand: '',
"delete": '',
edit: '',
add: '',
cancel: '',
save: '',
moveup: '',
movedown: ''
},
icon_prefix: '',
getIconClass: function(key) {
if (this.mapping[key]) return this.icon_prefix + this.mapping[key];
else return null;
},
getIcon: function(key) {
var iconclass = this.getIconClass(key);
if (!iconclass) return null;
var i = document.createElement('i');
i.className = iconclass;
return i;
}
});
JSONEditor.defaults.iconlibs.bootstrap2 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'chevron-down',
expand: 'chevron-up',
"delete": 'trash',
edit: 'pencil',
add: 'plus',
cancel: 'ban-circle',
save: 'ok',
moveup: 'arrow-up',
movedown: 'arrow-down'
},
icon_prefix: 'icon-'
});
JSONEditor.defaults.iconlibs.bootstrap3 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'chevron-down',
expand: 'chevron-right',
"delete": 'remove',
edit: 'pencil',
add: 'plus',
cancel: 'floppy-remove',
save: 'floppy-saved',
moveup: 'arrow-up',
movedown: 'arrow-down'
},
icon_prefix: 'glyphicon glyphicon-'
});
JSONEditor.defaults.iconlibs.fontawesome3 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'chevron-down',
expand: 'chevron-right',
"delete": 'remove',
edit: 'pencil',
add: 'plus',
cancel: 'ban-circle',
save: 'save',
moveup: 'arrow-up',
movedown: 'arrow-down'
},
icon_prefix: 'icon-'
});
JSONEditor.defaults.iconlibs.fontawesome4 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'caret-square-o-down',
expand: 'caret-square-o-right',
"delete": 'times',
edit: 'pencil',
add: 'plus',
cancel: 'ban',
save: 'save',
moveup: 'arrow-up',
movedown: 'arrow-down'
},
icon_prefix: 'fa fa-'
});
JSONEditor.defaults.iconlibs.foundation2 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'minus',
expand: 'plus',
"delete": 'remove',
edit: 'edit',
add: 'add-doc',
cancel: 'error',
save: 'checkmark',
moveup: 'up-arrow',
movedown: 'down-arrow'
},
icon_prefix: 'foundicon-'
});
JSONEditor.defaults.iconlibs.foundation3 = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'minus',
expand: 'plus',
"delete": 'x',
edit: 'pencil',
add: 'page-add',
cancel: 'x-circle',
save: 'save',
moveup: 'arrow-up',
movedown: 'arrow-down'
},
icon_prefix: 'fi-'
});
JSONEditor.defaults.iconlibs.jqueryui = JSONEditor.AbstractIconLib.extend({
mapping: {
collapse: 'triangle-1-s',
expand: 'triangle-1-e',
"delete": 'trash',
edit: 'pencil',
add: 'plusthick',
cancel: 'closethick',
save: 'disk',
moveup: 'arrowthick-1-n',
movedown: 'arrowthick-1-s'
},
icon_prefix: 'ui-icon ui-icon-'
});
JSONEditor.defaults.templates["default"] = function() {
return {
compile: function(template) {
var matches = template.match(/{{\s*([a-zA-Z0-9\-_ \.]+)\s*}}/g);
var l = matches && matches.length;
// Shortcut if the template contains no variables
if (!l) return function() {
return template;
};
// Pre-compute the search/replace functions
// This drastically speeds up template execution
var replacements = [];
var get_replacement = function(i) {
var p = matches[i].replace(/[{}]+/g, '').trim().split('.');
var n = p.length;
var func;
if (n > 1) {
var cur;
func = function(vars) {
cur = vars;
for (i = 0; i < n; i++) {
cur = cur[p[i]];
if (!cur) break;
}
return cur;
};
} else {
p = p[0];
func = function(vars) {
return vars[p];
};
}
replacements.push({
s: matches[i],
r: func
});
};
for (var i = 0; i < l; i++) {
get_replacement(i);
}
// The compiled function
return function(vars) {
var ret = template + "";
var r;
for (i = 0; i < l; i++) {
r = replacements[i];
ret = ret.replace(r.s, r.r(vars));
}
return ret;
};
}
};
};
JSONEditor.defaults.templates.ejs = function() {
if (!window.EJS) return false;
return {
compile: function(template) {
var compiled = new window.EJS({
text: template
});
return function(context) {
return compiled.render(context);
};
}
};
};
JSONEditor.defaults.templates.handlebars = function() {
return window.Handlebars;
};
JSONEditor.defaults.templates.hogan = function() {
if (!window.Hogan) return false;
return {
compile: function(template) {
var compiled = window.Hogan.compile(template);
return function(context) {
return compiled.render(context);
};
}
};
};
JSONEditor.defaults.templates.markup = function() {
if (!window.Mark || !window.Mark.up) return false;
return {
compile: function(template) {
return function(context) {
return window.Mark.up(template, context);
};
}
};
};
JSONEditor.defaults.templates.mustache = function() {
if (!window.Mustache) return false;
return {
compile: function(template) {
return function(view) {
return window.Mustache.render(template, view);
};
}
};
};
JSONEditor.defaults.templates.swig = function() {
return window.swig;
};
JSONEditor.defaults.templates.underscore = function() {
if (!window._) return false;
return {
compile: function(template) {
return function(context) {
return window._.template(template, context);
};
}
};
};
// Set the default theme
JSONEditor.defaults.theme = 'html';
// Set the default template engine
JSONEditor.defaults.template = 'default';
// Default options when initializing JSON Editor
JSONEditor.defaults.options = {};
// String translate function
JSONEditor.defaults.translate = function(key, variables) {
var lang = JSONEditor.defaults.languages[JSONEditor.defaults.language];
if (!lang) throw "Unknown language " + JSONEditor.defaults.language;
var string = lang[key] || JSONEditor.defaults.languages[JSONEditor.defaults.default_language][key];
if (typeof string === "undefined") throw "Unknown translate string " + key;
if (variables) {
for (var i = 0; i < variables.length; i++) {
string = string.replace(new RegExp('\\{\\{' + i + '}}', 'g'), variables[i]);
}
}
return string;
};
// Translation strings and default languages
JSONEditor.defaults.default_language = 'en';
JSONEditor.defaults.language = JSONEditor.defaults.default_language;
JSONEditor.defaults.languages.en = {
/**
* When a property is not set
*/
error_notset: "Property must be set",
/**
* When a string must not be empty
*/
error_notempty: "Value required",
/**
* When a value is not one of the enumerated values
*/
error_enum: "Value must be one of the enumerated values",
/**
* When a value doesn't validate any schema of a 'anyOf' combination
*/
error_anyOf: "Value must validate against at least one of the provided schemas",
/**
* When a value doesn't validate
* @variables This key takes one variable: The number of schemas the value does not validate
*/
error_oneOf: 'Value must validate against exactly one of the provided schemas. It currently validates against {{0}} of the schemas.',
/**
* When a value does not validate a 'not' schema
*/
error_not: "Value must not validate against the provided schema",
/**
* When a value does not match any of the provided types
*/
error_type_union: "Value must be one of the provided types",
/**
* When a value does not match the given type
* @variables This key takes one variable: The type the value should be of
*/
error_type: "Value must be of type {{0}}",
/**
* When the value validates one of the disallowed types
*/
error_disallow_union: "Value must not be one of the provided disallowed types",
/**
* When the value validates a disallowed type
* @variables This key takes one variable: The type the value should not be of
*/
error_disallow: "Value must not be of type {{0}}",
/**
* When a value is not a multiple of or divisible by a given number
* @variables This key takes one variable: The number mentioned above
*/
error_multipleOf: "Value must be a multiple of {{0}}",
/**
* When a value is greater than it's supposed to be (exclusive)
* @variables This key takes one variable: The maximum
*/
error_maximum_excl: "Value must be less than {{0}}",
/**
* When a value is greater than it's supposed to be (inclusive
* @variables This key takes one variable: The maximum
*/
error_maximum_incl: "Value must be at most {{0}}",
/**
* When a value is lesser than it's supposed to be (exclusive)
* @variables This key takes one variable: The minimum
*/
error_minimum_excl: "Value must be greater than {{0}}",
/**
* When a value is lesser than it's supposed to be (inclusive)
* @variables This key takes one variable: The minimum
*/
error_minimum_incl: "Value must be at least {{0}}",
/**
* When a value have too many characters
* @variables This key takes one variable: The maximum character count
*/
error_maxLength: "Value must be at most {{0}} characters long",
/**
* When a value does not have enough characters
* @variables This key takes one variable: The minimum character count
*/
error_minLength: "Value must be at least {{0}} characters long",
/**
* When a value does not match a given pattern
*/
error_pattern: "Value must match the provided pattern",
/**
* When an array has additional items whereas it is not supposed to
*/
error_additionalItems: "No additional items allowed in this array",
/**
* When there are to many items in an array
* @variables This key takes one variable: The maximum item count
*/
error_maxItems: "Value must have at most {{0}} items",
/**
* When there are not enough items in an array
* @variables This key takes one variable: The minimum item count
*/
error_minItems: "Value must have at least {{0}} items",
/**
* When an array is supposed to have unique items but has duplicates
*/
error_uniqueItems: "Array must have unique items",
/**
* When there are too many properties in an object
* @variables This key takes one variable: The maximum property count
*/
error_maxProperties: "Object must have at most {{0}} properties",
/**
* When there are not enough properties in an object
* @variables This key takes one variable: The minimum property count
*/
error_minProperties: "Object must have at least {{0}} properties",
/**
* When a required property is not defined
* @variables This key takes one variable: The name of the missing property
*/
error_required: "Object is missing the required property '{{0}}'",
/**
* When there is an additional property is set whereas there should be none
* @variables This key takes one variable: The name of the additional property
*/
error_additional_properties: "No additional properties allowed, but property {{0}} is set",
/**
* When a dependency is not resolved
* @variables This key takes one variable: The name of the missing property for the dependency
*/
error_dependency: "Must have property {{0}}"
};
// Miscellaneous Plugin Settings
JSONEditor.plugins = {
ace: {
theme: ''
},
epiceditor: {
},
sceditor: {
},
select2: {
},
selectize: {}
};
// Default per-editor options
for (var i in JSONEditor.defaults.editors) {
if (!JSONEditor.defaults.editors.hasOwnProperty(i)) continue;
JSONEditor.defaults.editors[i].options = JSONEditor.defaults.editors.options || {};
}
// Set the default resolvers
// Use "multiple" as a fall back for everything
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (typeof schema.type !== "string") return "multiple";
});
// If the type is not set but properties are defined, we can infer the type is actually object
JSONEditor.defaults.resolvers.unshift(function(schema) {
// If the schema is a simple type
if (!schema.type && schema.properties) return "object";
});
// If the type is set and it's a basic type, use the primitive editor
JSONEditor.defaults.resolvers.unshift(function(schema) {
// If the schema is a simple type
if (typeof schema.type === "string") return schema.type;
});
// Boolean editors
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (schema.type === 'boolean') {
// If explicitly set to 'checkbox', use that
if (schema.format === "checkbox" || (schema.options && schema.options.checkbox)) {
return "checkbox";
}
// Otherwise, default to select menu
return (JSONEditor.plugins.selectize.enable) ? 'selectize' : 'select';
}
});
// Use the multiple editor for schemas where the `type` is set to "any"
JSONEditor.defaults.resolvers.unshift(function(schema) {
// If the schema can be of any type
if (schema.type === "any") return "multiple";
});
// Editor for base64 encoded files
JSONEditor.defaults.resolvers.unshift(function(schema) {
// If the schema can be of any type
if (schema.type === "string" && schema.media && schema.media.binaryEncoding === "base64") {
return "base64";
}
});
// Editor for uploading files
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (schema.type === "string" && schema.format === "url" && schema.options && schema.options.upload === true) {
if (window.FileReader) return "upload";
}
});
// Use the table editor for arrays with the format set to `table`
JSONEditor.defaults.resolvers.unshift(function(schema) {
// Type `array` with format set to `table`
if (schema.type == "array" && schema.format == "table") {
return "table";
}
});
// Use the `select` editor for dynamic enumSource enums
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (schema.enumSource) return (JSONEditor.plugins.selectize.enable) ? 'selectize' : 'select';
});
// Use the `enum` or `select` editors for schemas with enumerated properties
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (schema["enum"]) {
if (schema.type === "array" || schema.type === "object") {
return "enum";
} else if (schema.type === "number" || schema.type === "integer" || schema.type === "string") {
return (JSONEditor.plugins.selectize.enable) ? 'selectize' : 'select';
}
}
});
// Specialized editors for arrays of strings
JSONEditor.defaults.resolvers.unshift(function(schema) {
if (schema.type === "array" && schema.items && !(Array.isArray(schema.items)) && schema.uniqueItems && ['string', 'number', 'integer'].indexOf(schema.items.type) >= 0) {
// For enumerated strings, number, or integers
if (schema.items.enum) {
return 'multiselect';
}
// For non-enumerated strings (tag editor)
else if (JSONEditor.plugins.selectize.enable && schema.items.type === "string") {
return 'arraySelectize';
}
}
});
// Use the multiple editor for schemas with `oneOf` set
JSONEditor.defaults.resolvers.unshift(function(schema) {
// If this schema uses `oneOf`
if (schema.oneOf) return "multiple";
});
/**
* This is a small wrapper for using JSON Editor like a typical jQuery plugin.
*/
(function() {
if (window.jQuery || window.Zepto) {
var $ = window.jQuery || window.Zepto;
$.jsoneditor = JSONEditor.defaults;
$.fn.jsoneditor = function(options) {
var self = this;
var editor = this.data('jsoneditor');
if (options === 'value') {
if (!editor) throw "Must initialize jsoneditor before getting/setting the value";
// Set value
if (arguments.length > 1) {
editor.setValue(arguments[1]);
}
// Get value
else {
return editor.getValue();
}
} else if (options === 'validate') {
if (!editor) throw "Must initialize jsoneditor before validating";
// Validate a specific value
if (arguments.length > 1) {
return editor.validate(arguments[1]);
}
// Validate current value
else {
return editor.validate();
}
} else if (options === 'destroy') {
if (editor) {
editor.destroy();
this.data('jsoneditor', null);
}
} else {
// Destroy first
if (editor) {
editor.destroy();
}
// Create editor
editor = new JSONEditor(this.get(0), options);
this.data('jsoneditor', editor);
// Setup event listeners
editor.on('change', function() {
self.trigger('change');
});
editor.on('ready', function() {
self.trigger('ready');
});
}
return this;
};
}
})();
window.JSONEditor = JSONEditor;
})();
//# sourceMappingURL=jsoneditor.js.map