bee_api 0.0.5

data/vendor/jsoneditor/js/highlighter.js

@@ -0,0 +1,82 @@
+/**
+ * The highlighter can highlight/unhighlight a node, and
+ * animate the visibility of a context menu.
+ * @constructor Highlighter
+ */
+function Highlighter () {
+    this.locked = false;
+}
+
+/**
+ * Hightlight given node and its childs
+ * @param {Node} node
+ */
+Highlighter.prototype.highlight = function (node) {
+    if (this.locked) {
+        return;
+    }
+
+    if (this.node != node) {
+        // unhighlight current node
+        if (this.node) {
+            this.node.setHighlight(false);
+        }
+
+        // highlight new node
+        this.node = node;
+        this.node.setHighlight(true);
+    }
+
+    // cancel any current timeout
+    this._cancelUnhighlight();
+};
+
+/**
+ * Unhighlight currently highlighted node.
+ * Will be done after a delay
+ */
+Highlighter.prototype.unhighlight = function () {
+    if (this.locked) {
+        return;
+    }
+
+    var me = this;
+    if (this.node) {
+        this._cancelUnhighlight();
+
+        // do the unhighlighting after a small delay, to prevent re-highlighting
+        // the same node when moving from the drag-icon to the contextmenu-icon
+        // or vice versa.
+        this.unhighlightTimer = setTimeout(function () {
+            me.node.setHighlight(false);
+            me.node = undefined;
+            me.unhighlightTimer = undefined;
+        }, 0);
+    }
+};
+
+/**
+ * Cancel an unhighlight action (if before the timeout of the unhighlight action)
+ * @private
+ */
+Highlighter.prototype._cancelUnhighlight = function () {
+    if (this.unhighlightTimer) {
+        clearTimeout(this.unhighlightTimer);
+        this.unhighlightTimer = undefined;
+    }
+};
+
+/**
+ * Lock highlighting or unhighlighting nodes.
+ * methods highlight and unhighlight do not work while locked.
+ */
+Highlighter.prototype.lock = function () {
+    this.locked = true;
+};
+
+/**
+ * Unlock highlighting or unhighlighting nodes
+ */
+Highlighter.prototype.unlock = function () {
+    this.locked = false;
+};

data/vendor/jsoneditor/js/history.js

@@ -0,0 +1,218 @@
+/**
+ * @constructor History
+ * Store action history, enables undo and redo
+ * @param {JSONEditor} editor
+ */
+function History (editor) {
+    this.editor = editor;
+    this.clear();
+
+    // map with all supported actions
+    this.actions = {
+        'editField': {
+            'undo': function (params) {
+                params.node.updateField(params.oldValue);
+            },
+            'redo': function (params) {
+                params.node.updateField(params.newValue);
+            }
+        },
+        'editValue': {
+            'undo': function (params) {
+                params.node.updateValue(params.oldValue);
+            },
+            'redo': function (params) {
+                params.node.updateValue(params.newValue);
+            }
+        },
+        'appendNode': {
+            'undo': function (params) {
+                params.parent.removeChild(params.node);
+            },
+            'redo': function (params) {
+                params.parent.appendChild(params.node);
+            }
+        },
+        'insertBeforeNode': {
+            'undo': function (params) {
+                params.parent.removeChild(params.node);
+            },
+            'redo': function (params) {
+                params.parent.insertBefore(params.node, params.beforeNode);
+            }
+        },
+        'insertAfterNode': {
+            'undo': function (params) {
+                params.parent.removeChild(params.node);
+            },
+            'redo': function (params) {
+                params.parent.insertAfter(params.node, params.afterNode);
+            }
+        },
+        'removeNode': {
+            'undo': function (params) {
+                var parent = params.parent;
+                var beforeNode = parent.childs[params.index] || parent.append;
+                parent.insertBefore(params.node, beforeNode);
+            },
+            'redo': function (params) {
+                params.parent.removeChild(params.node);
+            }
+        },
+        'duplicateNode': {
+            'undo': function (params) {
+                params.parent.removeChild(params.clone);
+            },
+            'redo': function (params) {
+                params.parent.insertAfter(params.clone, params.node);
+            }
+        },
+        'changeType': {
+            'undo': function (params) {
+                params.node.changeType(params.oldType);
+            },
+            'redo': function (params) {
+                params.node.changeType(params.newType);
+            }
+        },
+        'moveNode': {
+            'undo': function (params) {
+                params.startParent.moveTo(params.node, params.startIndex);
+            },
+            'redo': function (params) {
+                params.endParent.moveTo(params.node, params.endIndex);
+            }
+        },
+        'sort': {
+            'undo': function (params) {
+                var node = params.node;
+                node.hideChilds();
+                node.sort = params.oldSort;
+                node.childs = params.oldChilds;
+                node.showChilds();
+            },
+            'redo': function (params) {
+                var node = params.node;
+                node.hideChilds();
+                node.sort = params.newSort;
+                node.childs = params.newChilds;
+                node.showChilds();
+            }
+        }
+
+        // TODO: restore the original caret position and selection with each undo
+        // TODO: implement history for actions "expand", "collapse", "scroll", "setDocument"
+    };
+}
+
+/**
+ * The method onChange is executed when the History is changed, and can
+ * be overloaded.
+ */
+History.prototype.onChange = function () {};
+
+/**
+ * Add a new action to the history
+ * @param {String} action  The executed action. Available actions: "editField",
+ *                         "editValue", "changeType", "appendNode",
+ *                         "removeNode", "duplicateNode", "moveNode"
+ * @param {Object} params  Object containing parameters describing the change.
+ *                         The parameters in params depend on the action (for
+ *                         example for "editValue" the Node, old value, and new
+ *                         value are provided). params contains all information
+ *                         needed to undo or redo the action.
+ */
+History.prototype.add = function (action, params) {
+    this.index++;
+    this.history[this.index] = {
+        'action': action,
+        'params': params,
+        'timestamp': new Date()
+    };
+
+    // remove redo actions which are invalid now
+    if (this.index < this.history.length - 1) {
+        this.history.splice(this.index + 1, this.history.length - this.index - 1);
+    }
+
+    // fire onchange event
+    this.onChange();
+};
+
+/**
+ * Clear history
+ */
+History.prototype.clear = function () {
+    this.history = [];
+    this.index = -1;
+
+    // fire onchange event
+    this.onChange();
+};
+
+/**
+ * Check if there is an action available for undo
+ * @return {Boolean} canUndo
+ */
+History.prototype.canUndo = function () {
+    return (this.index >= 0);
+};
+
+/**
+ * Check if there is an action available for redo
+ * @return {Boolean} canRedo
+ */
+History.prototype.canRedo = function () {
+    return (this.index < this.history.length - 1);
+};
+
+/**
+ * Undo the last action
+ */
+History.prototype.undo = function () {
+    if (this.canUndo()) {
+        var obj = this.history[this.index];
+        if (obj) {
+            var action = this.actions[obj.action];
+            if (action && action.undo) {
+                action.undo(obj.params);
+                if (obj.params.oldSelection) {
+                    this.editor.setSelection(obj.params.oldSelection);
+                }
+            }
+            else {
+                util.log('Error: unknown action "' + obj.action + '"');
+            }
+        }
+        this.index--;
+
+        // fire onchange event
+        this.onChange();
+    }
+};
+
+/**
+ * Redo the last action
+ */
+History.prototype.redo = function () {
+    if (this.canRedo()) {
+        this.index++;
+
+        var obj = this.history[this.index];
+        if (obj) {
+            var action = this.actions[obj.action];
+            if (action && action.redo) {
+                action.redo(obj.params);
+                if (obj.params.newSelection) {
+                    this.editor.setSelection(obj.params.newSelection);
+                }
+            }
+            else {
+                util.log('Error: unknown action "' + obj.action + '"');
+            }
+        }
+
+        // fire onchange event
+        this.onChange();
+    }
+};

data/vendor/jsoneditor/js/jsoneditor.js

@@ -0,0 +1,206 @@
+/**
+ * @constructor JSONEditor
+ * @param {Element} container    Container element
+ * @param {Object}  [options]    Object with options. available options:
+ *                               {String} mode      Editor mode. Available values:
+ *                                                  'tree' (default), 'view',
+ *                                                  'form', 'text', and 'code'.
+ *                               {function} change  Callback method, triggered
+ *                                                  on change of contents
+ *                               {Boolean} search   Enable search box.
+ *                                                  True by default
+ *                                                  Only applicable for modes
+ *                                                  'tree', 'view', and 'form'
+ *                               {Boolean} history  Enable history (undo/redo).
+ *                                                  True by default
+ *                                                  Only applicable for modes
+ *                                                  'tree', 'view', and 'form'
+ *                               {String} name      Field name for the root node.
+ *                                                  Only applicable for modes
+ *                                                  'tree', 'view', and 'form'
+ *                               {Number} indentation   Number of indentation
+ *                                                      spaces. 4 by default.
+ *                                                      Only applicable for
+ *                                                      modes 'text' and 'code'
+ * @param {Object | undefined} json JSON object
+ */
+function JSONEditor (container, options, json) {
+    if (!(this instanceof JSONEditor)) {
+        throw new Error('JSONEditor constructor called without "new".');
+    }
+
+    if (arguments.length) {
+        this._create(container, options, json);
+    }
+}
+
+/**
+ * Configuration for all registered modes. Example:
+ * {
+ *     tree: {
+ *         editor: TreeEditor,
+ *         data: 'json'
+ *     },
+ *     text: {
+ *         editor: TextEditor,
+ *         data: 'text'
+ *     }
+ * }
+ *
+ * @type { Object.<String, {editor: Object, data: String} > }
+ */
+JSONEditor.modes = {};
+
+/**
+ * Create the JSONEditor
+ * @param {Element} container    Container element
+ * @param {Object}  [options]    See description in constructor
+ * @param {Object | undefined} json JSON object
+ * @private
+ */
+JSONEditor.prototype._create = function (container, options, json) {
+    this.container = container;
+    this.options = options || {};
+    this.json = json || {};
+
+    var mode = this.options.mode || 'tree';
+    this.setMode(mode);
+};
+
+/**
+ * Detach the editor from the DOM
+ * @private
+ */
+JSONEditor.prototype._delete = function () {};
+
+/**
+ * Set JSON object in editor
+ * @param {Object | undefined} json      JSON data
+ */
+JSONEditor.prototype.set = function (json) {
+    this.json = json;
+};
+
+/**
+ * Get JSON from the editor
+ * @returns {Object} json
+ */
+JSONEditor.prototype.get = function () {
+    return this.json;
+};
+
+/**
+ * Set string containing JSON for the editor
+ * @param {String | undefined} jsonText
+ */
+JSONEditor.prototype.setText = function (jsonText) {
+    this.json = util.parse(jsonText);
+};
+
+/**
+ * Get stringified JSON contents from the editor
+ * @returns {String} jsonText
+ */
+JSONEditor.prototype.getText = function () {
+    return JSON.stringify(this.json);
+};
+
+/**
+ * Set a field name for the root node.
+ * @param {String | undefined} name
+ */
+JSONEditor.prototype.setName = function (name) {
+    if (!this.options) {
+        this.options = {};
+    }
+    this.options.name = name;
+};
+
+/**
+ * Get the field name for the root node.
+ * @return {String | undefined} name
+ */
+JSONEditor.prototype.getName = function () {
+    return this.options && this.options.name;
+};
+
+/**
+ * Change the mode of the editor.
+ * JSONEditor will be extended with all methods needed for the chosen mode.
+ * @param {String} mode     Available modes: 'tree' (default), 'view', 'form',
+ *                          'text', and 'code'.
+ */
+JSONEditor.prototype.setMode = function (mode) {
+    var container = this.container,
+        options = util.extend({}, this.options),
+        data,
+        name;
+
+    options.mode = mode;
+    var config = JSONEditor.modes[mode];
+    if (config) {
+        try {
+            if (config.data == 'text') {
+                // text
+                name = this.getName();
+                data = this.getText();
+
+                this._delete();
+                util.clear(this);
+                util.extend(this, config.editor.prototype);
+                this._create(container, options);
+
+                this.setName(name);
+                this.setText(data);
+            }
+            else {
+                // json
+                name = this.getName();
+                data = this.get();
+
+                this._delete();
+                util.clear(this);
+                util.extend(this, config.editor.prototype);
+                this._create(container, options);
+
+                this.setName(name);
+                this.set(data);
+            }
+
+            if (typeof config.load === 'function') {
+                try {
+                    config.load.call(this);
+                }
+                catch (err) {}
+            }
+        }
+        catch (err) {
+            this._onError(err);
+        }
+    }
+    else {
+        throw new Error('Unknown mode "' + options.mode + '"');
+    }
+};
+
+/**
+ * Throw an error. If an error callback is configured in options.error, this
+ * callback will be invoked. Else, a regular error is thrown.
+ * @param {Error} err
+ * @private
+ */
+JSONEditor.prototype._onError = function(err) {
+    // TODO: onError is deprecated since version 2.2.0. cleanup some day
+    if (typeof this.onError === 'function') {
+        util.log('WARNING: JSONEditor.onError is deprecated. ' +
+            'Use options.error instead.');
+        this.onError(err);
+    }
+
+    if (typeof this.options.error === 'function') {
+        this.options.error(err);
+    }
+    else {
+        throw err;
+    }
+};