bee_api 0.0.5

data/vendor/jsoneditor/js/searchbox.js

@@ -0,0 +1,288 @@
+/**
+ * @constructor SearchBox
+ * Create a search box in given HTML container
+ * @param {JSONEditor} editor    The JSON Editor to attach to
+ * @param {Element} container               HTML container element of where to
+ *                                          create the search box
+ */
+function SearchBox (editor, container) {
+    var searchBox = this;
+
+    this.editor = editor;
+    this.timeout = undefined;
+    this.delay = 200; // ms
+    this.lastText = undefined;
+
+    this.dom = {};
+    this.dom.container = container;
+
+    var table = document.createElement('table');
+    this.dom.table = table;
+    table.className = 'search';
+    container.appendChild(table);
+    var tbody = document.createElement('tbody');
+    this.dom.tbody = tbody;
+    table.appendChild(tbody);
+    var tr = document.createElement('tr');
+    tbody.appendChild(tr);
+
+    var td = document.createElement('td');
+    tr.appendChild(td);
+    var results = document.createElement('div');
+    this.dom.results = results;
+    results.className = 'results';
+    td.appendChild(results);
+
+    td = document.createElement('td');
+    tr.appendChild(td);
+    var divInput = document.createElement('div');
+    this.dom.input = divInput;
+    divInput.className = 'frame';
+    divInput.title = 'Search fields and values';
+    td.appendChild(divInput);
+
+    // table to contain the text input and search button
+    var tableInput = document.createElement('table');
+    divInput.appendChild(tableInput);
+    var tbodySearch = document.createElement('tbody');
+    tableInput.appendChild(tbodySearch);
+    tr = document.createElement('tr');
+    tbodySearch.appendChild(tr);
+
+    var refreshSearch = document.createElement('button');
+    refreshSearch.className = 'refresh';
+    td = document.createElement('td');
+    td.appendChild(refreshSearch);
+    tr.appendChild(td);
+
+    var search = document.createElement('input');
+    this.dom.search = search;
+    search.oninput = function (event) {
+        searchBox._onDelayedSearch(event);
+    };
+    search.onchange = function (event) { // For IE 8
+        searchBox._onSearch(event);
+    };
+    search.onkeydown = function (event) {
+        searchBox._onKeyDown(event);
+    };
+    search.onkeyup = function (event) {
+        searchBox._onKeyUp(event);
+    };
+    refreshSearch.onclick = function (event) {
+        search.select();
+    };
+
+    // TODO: ESC in FF restores the last input, is a FF bug, https://bugzilla.mozilla.org/show_bug.cgi?id=598819
+    td = document.createElement('td');
+    td.appendChild(search);
+    tr.appendChild(td);
+
+    var searchNext = document.createElement('button');
+    searchNext.title = 'Next result (Enter)';
+    searchNext.className = 'next';
+    searchNext.onclick = function () {
+        searchBox.next();
+    };
+    td = document.createElement('td');
+    td.appendChild(searchNext);
+    tr.appendChild(td);
+
+    var searchPrevious = document.createElement('button');
+    searchPrevious.title = 'Previous result (Shift+Enter)';
+    searchPrevious.className = 'previous';
+    searchPrevious.onclick = function () {
+        searchBox.previous();
+    };
+    td = document.createElement('td');
+    td.appendChild(searchPrevious);
+    tr.appendChild(td);
+}
+
+/**
+ * Go to the next search result
+ * @param {boolean} [focus]   If true, focus will be set to the next result
+ *                            focus is false by default.
+ */
+SearchBox.prototype.next = function(focus) {
+    if (this.results != undefined) {
+        var index = (this.resultIndex != undefined) ? this.resultIndex + 1 : 0;
+        if (index > this.results.length - 1) {
+            index = 0;
+        }
+        this._setActiveResult(index, focus);
+    }
+};
+
+/**
+ * Go to the prevous search result
+ * @param {boolean} [focus]   If true, focus will be set to the next result
+ *                            focus is false by default.
+ */
+SearchBox.prototype.previous = function(focus) {
+    if (this.results != undefined) {
+        var max = this.results.length - 1;
+        var index = (this.resultIndex != undefined) ? this.resultIndex - 1 : max;
+        if (index < 0) {
+            index = max;
+        }
+        this._setActiveResult(index, focus);
+    }
+};
+
+/**
+ * Set new value for the current active result
+ * @param {Number} index
+ * @param {boolean} [focus]   If true, focus will be set to the next result.
+ *                            focus is false by default.
+ * @private
+ */
+SearchBox.prototype._setActiveResult = function(index, focus) {
+    // de-activate current active result
+    if (this.activeResult) {
+        var prevNode = this.activeResult.node;
+        var prevElem = this.activeResult.elem;
+        if (prevElem == 'field') {
+            delete prevNode.searchFieldActive;
+        }
+        else {
+            delete prevNode.searchValueActive;
+        }
+        prevNode.updateDom();
+    }
+
+    if (!this.results || !this.results[index]) {
+        // out of range, set to undefined
+        this.resultIndex = undefined;
+        this.activeResult = undefined;
+        return;
+    }
+
+    this.resultIndex = index;
+
+    // set new node active
+    var node = this.results[this.resultIndex].node;
+    var elem = this.results[this.resultIndex].elem;
+    if (elem == 'field') {
+        node.searchFieldActive = true;
+    }
+    else {
+        node.searchValueActive = true;
+    }
+    this.activeResult = this.results[this.resultIndex];
+    node.updateDom();
+
+    // TODO: not so nice that the focus is only set after the animation is finished
+    node.scrollTo(function () {
+        if (focus) {
+            node.focus(elem);
+        }
+    });
+};
+
+/**
+ * Cancel any running onDelayedSearch.
+ * @private
+ */
+SearchBox.prototype._clearDelay = function() {
+    if (this.timeout != undefined) {
+        clearTimeout(this.timeout);
+        delete this.timeout;
+    }
+};
+
+/**
+ * Start a timer to execute a search after a short delay.
+ * Used for reducing the number of searches while typing.
+ * @param {Event} event
+ * @private
+ */
+SearchBox.prototype._onDelayedSearch = function (event) {
+    // execute the search after a short delay (reduces the number of
+    // search actions while typing in the search text box)
+    this._clearDelay();
+    var searchBox = this;
+    this.timeout = setTimeout(function (event) {
+            searchBox._onSearch(event);
+        },
+        this.delay);
+};
+
+/**
+ * Handle onSearch event
+ * @param {Event} event
+ * @param {boolean} [forceSearch]  If true, search will be executed again even
+ *                                 when the search text is not changed.
+ *                                 Default is false.
+ * @private
+ */
+SearchBox.prototype._onSearch = function (event, forceSearch) {
+    this._clearDelay();
+
+    var value = this.dom.search.value;
+    var text = (value.length > 0) ? value : undefined;
+    if (text != this.lastText || forceSearch) {
+        // only search again when changed
+        this.lastText = text;
+        this.results = this.editor.search(text);
+        this._setActiveResult(undefined);
+
+        // display search results
+        if (text != undefined) {
+            var resultCount = this.results.length;
+            switch (resultCount) {
+                case 0: this.dom.results.innerHTML = 'no&nbsp;results'; break;
+                case 1: this.dom.results.innerHTML = '1&nbsp;result'; break;
+                default: this.dom.results.innerHTML = resultCount + '&nbsp;results'; break;
+            }
+        }
+        else {
+            this.dom.results.innerHTML = '';
+        }
+    }
+};
+
+/**
+ * Handle onKeyDown event in the input box
+ * @param {Event} event
+ * @private
+ */
+SearchBox.prototype._onKeyDown = function (event) {
+    event = event || window.event;
+    var keynum = event.which || event.keyCode;
+    if (keynum == 27) { // ESC
+        this.dom.search.value = '';  // clear search
+        this._onSearch(event);
+        util.preventDefault(event);
+        util.stopPropagation(event);
+    }
+    else if (keynum == 13) { // Enter
+        if (event.ctrlKey) {
+            // force to search again
+            this._onSearch(event, true);
+        }
+        else if (event.shiftKey) {
+            // move to the previous search result
+            this.previous();
+        }
+        else {
+            // move to the next search result
+            this.next();
+        }
+        util.preventDefault(event);
+        util.stopPropagation(event);
+    }
+};
+
+/**
+ * Handle onKeyUp event in the input box
+ * @param {Event} event
+ * @private
+ */
+SearchBox.prototype._onKeyUp = function (event) {
+    event = event || window.event;
+    var keynum = event.which || event.keyCode;
+    if (keynum != 27 && keynum != 13) { // !show and !Enter
+        this._onDelayedSearch(event);   // For IE 8
+    }
+};

data/vendor/jsoneditor/js/texteditor.js

@@ -0,0 +1,311 @@
+/**
+ * Create a TextEditor and attach it to given container
+ * @constructor TextEditor
+ * @param {Element} container
+ * @param {Object} [options]         Object with options. available options:
+ *                                   {String} mode         Available values:
+ *                                                         "text" (default)
+ *                                                         or "code".
+ *                                   {Number} indentation  Number of indentation
+ *                                                         spaces. 4 by default.
+ *                                   {function} change     Callback method
+ *                                                         triggered on change
+ * @param {JSON | String} [json]     initial contents of the formatter
+ */
+function TextEditor(container, options, json) {
+    if (!(this instanceof TextEditor)) {
+        throw new Error('TextEditor constructor called without "new".');
+    }
+
+    this._create(container, options, json);
+}
+
+/**
+ * Create a TextEditor and attach it to given container
+ * @constructor TextEditor
+ * @param {Element} container
+ * @param {Object} [options]         See description in constructor
+ * @param {JSON | String} [json]     initial contents of the formatter
+ * @private
+ */
+TextEditor.prototype._create = function (container, options, json) {
+    // check availability of JSON parser (not available in IE7 and older)
+    if (typeof(JSON) == 'undefined') {
+        throw new Error('Your browser does not support JSON. \n\n' +
+            'Please install the newest version of your browser.\n' +
+            '(all modern browsers support JSON).');
+    }
+
+    // read options
+    options = options || {};
+    if (options.indentation) {
+        this.indentation = Number(options.indentation);
+    }
+    this.options = options;
+    this.mode = (options.mode == 'code') ? 'code' : 'text';
+    if (this.mode == 'code') {
+        // verify whether Ace editor is available and supported
+        if (typeof ace === 'undefined') {
+            this.mode = 'text';
+            util.log('WARNING: Cannot load code editor, Ace library not loaded. ' +
+                'Falling back to plain text editor');
+        }
+        if (util.getInternetExplorerVersion() == 8) {
+            this.mode = 'text';
+            util.log('WARNING: Cannot load code editor, Ace is not supported on IE8. ' +
+                'Falling back to plain text editor');
+        }
+    }
+
+    var me = this;
+    this.container = container;
+    this.editor = undefined;    // ace code editor
+    this.textarea = undefined;  // plain text editor (fallback when Ace is not available)
+    this.indentation = 4;       // number of spaces
+
+    this.width = container.clientWidth;
+    this.height = container.clientHeight;
+
+    this.frame = document.createElement('div');
+    this.frame.className = 'jsoneditor';
+    this.frame.onclick = function (event) {
+        // prevent default submit action when TextEditor is located inside a form
+        util.preventDefault(event);
+    };
+
+    // create menu
+    this.menu = document.createElement('div');
+    this.menu.className = 'menu';
+    this.frame.appendChild(this.menu);
+
+    // create format button
+    var buttonFormat = document.createElement('button');
+    //buttonFormat.innerHTML = 'Format';
+    buttonFormat.className = 'format';
+    buttonFormat.title = 'Format JSON data, with proper indentation and line feeds';
+    //buttonFormat.className = 'jsoneditor-button';
+    this.menu.appendChild(buttonFormat);
+    buttonFormat.onclick = function () {
+        try {
+            me.format();
+        }
+        catch (err) {
+            me._onError(err);
+        }
+    };
+
+    // create compact button
+    var buttonCompact = document.createElement('button');
+    //buttonCompact.innerHTML = 'Compact';
+    buttonCompact.className = 'compact';
+    buttonCompact.title = 'Compact JSON data, remove all whitespaces';
+    //buttonCompact.className = 'jsoneditor-button';
+    this.menu.appendChild(buttonCompact);
+    buttonCompact.onclick = function () {
+        try {
+            me.compact();
+        }
+        catch (err) {
+            me._onError(err);
+        }
+
+    };
+
+    this.content = document.createElement('div');
+    this.content.className = 'outer';
+    this.frame.appendChild(this.content);
+
+    this.container.appendChild(this.frame);
+
+    if (this.mode == 'code') {
+        this.editorDom = document.createElement('div');
+        this.editorDom.style.height = '100%'; // TODO: move to css
+        this.editorDom.style.width = '100%'; // TODO: move to css
+        this.content.appendChild(this.editorDom);
+
+        var editor = ace.edit(this.editorDom);
+        editor.setTheme('ace/theme/jsoneditor');
+        editor.setShowPrintMargin(false);
+        editor.setFontSize(13);
+        editor.getSession().setMode('ace/mode/json');
+        editor.getSession().setUseSoftTabs(true);
+        editor.getSession().setUseWrapMode(true);
+        this.editor = editor;
+
+        var poweredBy = document.createElement('a');
+        poweredBy.appendChild(document.createTextNode('powered by ace'));
+        poweredBy.href = 'http://ace.ajax.org';
+        poweredBy.target = '_blank';
+        poweredBy.className = 'poweredBy';
+        poweredBy.onclick = function () {
+            // TODO: this anchor falls below the margin of the content,
+            // therefore the normal a.href does not work. We use a click event
+            // for now, but this should be fixed.
+            window.open(poweredBy.href, poweredBy.target);
+        };
+        this.menu.appendChild(poweredBy);
+
+        if (options.change) {
+            // register onchange event
+            editor.on('change', function () {
+                options.change();
+            });
+        }
+    }
+    else {
+        // load a plain text textarea
+        var textarea = document.createElement('textarea');
+        textarea.className = 'content';
+        textarea.spellcheck = false;
+        this.content.appendChild(textarea);
+        this.textarea = textarea;
+
+        if (options.change) {
+            // register onchange event
+            if (this.textarea.oninput === null) {
+                this.textarea.oninput = function () {
+                    options.change();
+                }
+            }
+            else {
+                // oninput is undefined. For IE8-
+                this.textarea.onchange = function () {
+                    options.change();
+                }
+            }
+        }
+    }
+
+    // load initial json object or string
+    if (typeof(json) == 'string') {
+        this.setText(json);
+    }
+    else {
+        this.set(json);
+    }
+};
+
+/**
+ * Detach the editor from the DOM
+ * @private
+ */
+TextEditor.prototype._delete = function () {
+    if (this.frame && this.container && this.frame.parentNode == this.container) {
+        this.container.removeChild(this.frame);
+    }
+};
+
+/**
+ * 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
+ */
+TextEditor.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;
+    }
+};
+
+/**
+ * Compact the code in the formatter
+ */
+TextEditor.prototype.compact = function () {
+    var json = util.parse(this.getText());
+    this.setText(JSON.stringify(json));
+};
+
+/**
+ * Format the code in the formatter
+ */
+TextEditor.prototype.format = function () {
+    var json = util.parse(this.getText());
+    this.setText(JSON.stringify(json, null, this.indentation));
+};
+
+/**
+ * Set focus to the formatter
+ */
+TextEditor.prototype.focus = function () {
+    if (this.textarea) {
+        this.textarea.focus();
+    }
+    if (this.editor) {
+        this.editor.focus();
+    }
+};
+
+/**
+ * Resize the formatter
+ */
+TextEditor.prototype.resize = function () {
+    if (this.editor) {
+        var force = false;
+        this.editor.resize(force);
+    }
+};
+
+/**
+ * Set json data in the formatter
+ * @param {Object} json
+ */
+TextEditor.prototype.set = function(json) {
+    this.setText(JSON.stringify(json, null, this.indentation));
+};
+
+/**
+ * Get json data from the formatter
+ * @return {Object} json
+ */
+TextEditor.prototype.get = function() {
+    return util.parse(this.getText());
+};
+
+/**
+ * Get the text contents of the TextEditor
+ * @return {String} jsonText
+ */
+TextEditor.prototype.getText = function() {
+    if (this.textarea) {
+        return this.textarea.value;
+    }
+    if (this.editor) {
+        return this.editor.getValue();
+    }
+    return '';
+};
+
+/**
+ * Set the text contents of the TextEditor
+ * @param {String} jsonText
+ */
+TextEditor.prototype.setText = function(jsonText) {
+    if (this.textarea) {
+        this.textarea.value = jsonText;
+    }
+    if (this.editor) {
+        this.editor.setValue(jsonText, -1);
+    }
+};
+
+// register modes at the JSONEditor
+JSONEditor.modes.text = {
+    editor: TextEditor,
+    data: 'text',
+    load: TextEditor.prototype.format
+};
+JSONEditor.modes.code = {
+    editor: TextEditor,
+    data: 'text',
+    load: TextEditor.prototype.format
+};