/*
   * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from {@link #getTargetFromEvent} for this node)
   * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
   * @param {Event} e The event
   * @param {Object} data An object containing arbitrary data supplied by the drag source
   * @return {String} status The CSS class that communicates the drop status back to the source so that the underlying {@link Ext.dd.StatusProxy} can be updated
   */

/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Ching En Cheng <c.cheng@metaways.de>
 * @copyright   Copyright (c) 2021 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2017 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2017-2019 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2020 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Michael Spahn <m.spahn@metaways.de>
 * @copyright   Copyright (c) 2017 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @package     Filemanager
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Ching En Cheng <c.cheng@metaways.de>
 * @copyright   Copyright (c) 2021 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @package     Tinebase
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2010-2012 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 *
 * @package     Tinebase
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2010-2015 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @copyright   Copyright (c) 2007-2014 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @copyright   Copyright (c) 2012-2017 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2007-2014 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2010-2012 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Martin Jatho <m.jatho@metaways.de>
 * @copyright   Copyright (c) 2007-2012 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Martin Jatho <m.jatho@metaways.de>
 * @copyright   Copyright (c) 2007-2020 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Michael Spahn <m.spahn@metaways.de>
 * @copyright   Copyright (c) 2017 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2010-2012 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2011-2015 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2014 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 * TODO         maybe we don't need this
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2014 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/*
 * Tine 2.0
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2018 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/*
 * Tine 2.0
 * Filemanager combo box and store
 * 
 * @package     Filemanager
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @author      Michael Spahn <m.spahn@metaways.de>
 * @copyright   Copyright (c) 2012-2017 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/*
 * register additional action for genericpickergridpanel
 */

/*
export const apply = Ext.apply;
export const applyIf = Ext.applyIf;
export const id = Ext.id;
export const extend = Ext.extend;
export const override = Ext.override;
export const namespace = Ext.namespace;
export const urlEncode = Ext.urlEncode;
export const urlDecode = Ext.urlDecode;
export const urlAppend = Ext.urlAppend;
export const toArray = Ext.toArray;
export const isIterable = Ext.isIterable;
export const each = Ext.each;
export const iterate = Ext.iterate;
// export const getDom = Ext.getDom;
// export const getBody = Ext.getBody;
// export const removeNode = Ext.removeNode;
export const isEmpty = Ext.isEmpty;
export const isArray = Ext.isArray;
export const isDate = Ext.isDate;
export const isObject = Ext.isObject;
export const isPrimitive = Ext.isPrimitive;
export const isFunction = Ext.isFunction;
export const isNumber = Ext.isNumber;
export const isString = Ext.isString;
export const isBoolean = Ext.isBoolean;
export const isElement = Ext.isElement;
export const isDefined = Ext.isDefined;
export const escapeRe = Ext.escapeRe;
export const ns = Ext.ns;
*/

/* .EffectScope */

/* .PersonaContainer */

/* .Personas.WARNING */

/* .ReactiveEffect */

/* .computed */

/* .getCurrentScope */

/* .isProxy */

/* .isReactive */

/* .isRef */

/* .isShallow */

/* .markRaw */

/* .pauseTracking */

/* .proxyRefs */

/* .reactive */

/* .ref */

/* .resetTracking */

/* .shallowReactive */

/* .toRaw */

/* .track */

/* .trigger */

/* @__PURE__ */

/* APP_INIT */

/* APP_UNMOUNT */

/* COLLECTION */

/* COMMENT */

/* COMMON */

/* COMPONENT_ADDED */

/* COMPONENT_EMIT */

/* COMPONENT_REMOVED */

/* COMPONENT_UPDATED */

/* CONTEXT */

/* DATA */

/* ELEMENT */

/* INVALID */

/* OTHER */

/* PROPS */

/* SETUP */

/* STYLE, PROPS */

/* TEXT */

/* ["default"] */

/* ["default"].locals */

/* asset import */

/* binding */

/* cancelled */

/* createElementBlock */

/* default */

/* default.locals */

/* detached */

/* do not include inferred name to avoid breaking existing code */

/* do not throw in dev if user provided error component */

/* harmony default export */

/* harmony export */

/* harmony import */

/* hydrating */

/* iPadOS pre v13 */

/* import() | Filemanager/js/FilemanagerFileLocationPlugin */

/* import() | Tinebase/js/ace */

/* isAbsent */

/* isBlock */

/* isBlock: prevent a block from tracking itself */

/* istanbul ignore if  */

/* istanbul ignore next  */

/* mergeRef: true */

/* onBeforeMount */

/* openBlock */

/* prepend */

/* reexport safe */

/* ref */

/* shallow */

/* shouldCast */

/* shouldCastTrue */

/* treat default function as factory */

/* unused harmony exports ITERATE_KEY, deferredComputed, enableTracking */

/* we know it doesn't need it */

/*!
 * Ext JS Library 3.1.1
 * Copyright(c) 2006-2010 Ext JS, LLC
 * licensing@extjs.com
 * http://www.extjs.com/license
 */

/*#__PURE__*/

/**
     * <p>Extends one class to create a subclass and optionally overrides members with the passed literal. This method
     * also adds the function "override()" to the subclass that can be used to override members of the class.</p>
     * For example, to create a subclass of Ext GridPanel:
     * <pre><code>
    MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
    constructor: function(config) {
    //      Create configuration for this Grid.
    var store = new Ext.data.Store({...});
    var colModel = new Ext.grid.ColumnModel({...});
    //      Create a new config object containing our computed properties
    //      *plus* whatever was in the config parameter.
    config = Ext.apply({
        store: store,
        colModel: colModel
    }, config);
     MyGridPanel.superclass.constructor.call(this, config);
    //      Your postprocessing here
    },
    yourMethod: function() {
    // etc.
    }
    });
    </code></pre>
     *
     * <p>This function also supports a 3-argument call in which the subclass's constructor is
     * passed as an argument. In this form, the parameters are as follows:</p>
     * <div class="mdetail-params"><ul>
     * <li><code>subclass</code> : Function <div class="sub-desc">The subclass constructor.</div></li>
     * <li><code>superclass</code> : Function <div class="sub-desc">The constructor of class being extended</div></li>
     * <li><code>overrides</code> : Object <div class="sub-desc">A literal with members which are copied into the subclass's
     * prototype, and are therefore shared among all instances of the new class.</div></li>
     * </ul></div>
     *
     * @param {Function} superclass The constructor of class being extended.
     * @param {Object} overrides <p>A literal with members which are copied into the subclass's
     * prototype, and are therefore shared between all instances of the new class.</p>
     * <p>This may contain a special member named <tt><b>constructor</b></tt>. This is used
     * to define the constructor of the new class, and is returned. If this property is
     * <i>not</i> specified, a constructor is generated and returned which just calls the
     * superclass's constructor passing on its parameters.</p>
     * <p><b>It is essential that you call the superclass constructor in any provided constructor. See example code.</b></p>
     * @return {Function} The subclass constructor from the <code>overrides</code> parameter, or a generated one if not provided.
     */

/**
     * <p>Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
     * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
     * <code>true</code>, then DOM event listeners are also removed from all child nodes. The body node
     * will be ignored if passed in.</p>
     * @param {HTMLElement} node The node to remove
     */

/**
     * <p>Returns true if the passed value is empty.</p>
     * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>
     * <li>null</li>
     * <li>undefined</li>
     * <li>an empty array</li>
     * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>
     * </ul></div>
     * @param {Mixed} value The value to test
     * @param {Boolean} allowBlank (optional) true to allow empty strings (defaults to false)
     * @return {Boolean}
     */

/**
     * <p>Utility method for returning a default value if the passed value is empty.</p>
     * <p>The value is deemed to be empty if it is<div class="mdetail-params"><ul>
     * <li>null</li>
     * <li>undefined</li>
     * <li>an empty array</li>
     * <li>a zero length string (Unless the <tt>allowBlank</tt> parameter is <tt>true</tt>)</li>
     * </ul></div>
     * @param {Mixed} value The value to test
     * @param {Mixed} defaultValue The value to return if the original value is empty
     * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
     * @return {Mixed} value, if non-empty, else defaultValue
     */

/**
     * <p>Zips N sets together.</p>
     * <pre><code>
    // Example 1:
    Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
    // Example 2:
    Ext.zip(
    [ "+", "-", "+"],
    [  12,  10,  22],
    [  43,  15,  96],
    function(a, b, c){
    return "$" + a + "" + b + "." + c
    }
    ); // ["$+12.43", "$-10.15", "$+22.96"]
     * </code></pre>
     * @param {Arrays|NodeLists} arr This argument may be repeated. Array(s) to contribute values.
     * @param {Function} zipper (optional) The last item in the argument list. This will drive how the items are zipped together.
     * @return {Array} The zipped set.
     */

/**
     * @event forceNodeSelected
     * Fires when node was force selected (e.g. by dbl click)
     * @param nodeData selected node data
     */

/**
     * @event invalidNodeSelected
     * Fires if a node is selected which does not fulfill the provided constraints
     */

/**
     * @event nodeSelected
     * Fires when a file was selected which fulfills all constraints
     * @param nodeData selected node data
     */

/**
     * @internal
     */

/**
     * @param selected node
     */

/**
     * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
     * Usage:<pre><code>
    Ext.override(MyClass, {
    newMethod1: function(){
    // etc.
    },
    newMethod2: function(foo){
    // etc.
    }
    });
    </code></pre>
     * @param {Object} origclass The class to override
     * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal
     * containing one or more methods.
     * @method override
     */

/**
     * Appends content to the query string of a URL, handling logic for whether to place
     * a question mark or ampersand.
     * @param {String} url The URL to append to.
     * @param {String} s The content to append to the URL.
     * @return (String) The resulting URL
     */

/**
     * Applies event listeners to elements by selectors when the document is ready.
     * The event name is specified with an <tt>&#64;</tt> suffix.
     * <pre><code>
    Ext.addBehaviors({
    // add a listener for click on all anchors in element with id foo
    '#foo a&#64;click' : function(e, t){
    // do something
    },
     // add the same listener to multiple selectors (separated by comma BEFORE the &#64;)
    '#foo a, #bar span.some-class&#64;mouseover' : function(){
    // do something
    }
    });
     * </code></pre> 
     * @param {Object} obj The list of behaviors to apply
     */

/**
     * Attempts to destroy and then remove a set of named properties of the passed object.
     * @param {Object} o The object (most likely a Component) who's properties you wish to destroy.
     * @param {Mixed} arg1 The name of the property to destroy and remove from the object.
     * @param {Mixed} etc... More property names to destroy and remove.
     */

/**
     * Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
     * DOM (if applicable) and calling their destroy functions (if available).  This method is primarily
     * intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of
     * {@link Ext.util.Observable} can be passed in.  Any number of elements and/or components can be
     * passed into this function in a single call as separate arguments.
     * @param {Mixed} arg1 An {@link Ext.Element}, {@link Ext.Component}, or an Array of either of these to destroy
     * @param {Mixed} arg2 (optional)
     * @param {Mixed} etc... (optional)
     */

/**
     * By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
     * you may want to set this to true.
     * @type Boolean
     */

/**
     * Calculates the mean of the Array
     * @param {Array} arr The Array to calculate the mean value of.
     * @return {Number} The mean.
     */

/**
     * Calculates the sum of the Array
     * @param {Array} arr The Array to calculate the sum value of.
     * @return {Number} The sum.
     */

/**
     * Converts any iterable (numeric indices and a length property) into a true array
     * Don't use this on strings. IE doesn't support "abc"[0] which this implementation depends on.
     * For strings, use this instead: "abc".match(/./g) => [a,b,c];
     * @param {Iterable} the iterable object to be turned into a true Array.
     * @return (Array) array
     */

/**
     * Copies a set of named properties fom the source object to the destination object.
     * <p>example:<pre><code>
    ImageComponent = Ext.extend(Ext.BoxComponent, {
    initComponent: function() {
    this.autoEl = { tag: 'img' };
    MyComponent.superclass.initComponent.apply(this, arguments);
    this.initialBox = Ext.copyTo({}, this.initialConfig, 'x,y,width,height');
    }
    });
     * </code></pre> 
     * @param {Object} The destination object.
     * @param {Object} The source object.
     * @param {Array/String} Either an Array of property names, or a comma-delimited list
     * of property names to copy.
     * @return {Object} The modified object.
    */

/**
     * Copies all the properties of config to obj if they don't already exist.
     * @param {Object} obj The receiver of the properties
     * @param {Object} config The source of the properties
     * @return {Object} returns obj
     */

/**
     * Creates a copy of the passed Array with falsy values removed.
     * @param {Array/NodeList} arr The Array from which to remove falsy values.
     * @return {Array} The new, compressed Array.
     */

/**
     * Creates a copy of the passed Array, filtered to contain only unique values.
     * @param {Array} arr The Array to filter
     * @return {Array} The new Array containing unique values.
     */

/**
     * Creates namespaces to be used for scoping variables and classes so that they are not global.
     * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
     * <pre><code>
    Ext.namespace('Company', 'Company.data');
    Ext.namespace('Company.data'); // equivalent and preferable to above syntax
    Company.Widget = function() { ... }
    Company.data.CustomStore = function(config) { ... }
    </code></pre>
     * @param {String} namespace1
     * @param {String} namespace2
     * @param {String} etc
     * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
     * @method namespace
     */

/**
     * EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
     * Currently not optimized for performance.
     * @type Boolean
     */

/**
     * Escapes the passed string for use in a regular expression
     * @param {String} str
     * @return {String}
     */

/**
     * Fires if no preview is available. Later it should be used to be fired if the browser is not able to load images.
     */

/**
     * Generates unique ids. If the element already has an id, it is unchanged
     * @param {Mixed} el (optional) The element to generate an id for
     * @param {String} prefix (optional) Id prefix (defaults "ext-gen")
     * @return {String} The generated Id.
     */

/**
     * If the dialog will close and an valid node was selected
     * @param node
     */

/**
     * Indicates whether to use native browser parsing for JSON methods.
     * This option is ignored if the browser does not support native JSON methods.
     * <b>Note: Native JSON methods will not work with objects that have functions.
     * Also, property names must be quoted, otherwise the data will not parse.</b> (Defaults to false)
     * @type Boolean
     */

/**
     * Invokes a method on each item in an Array.
     * <pre><code>
    // Example:
    Ext.invoke(Ext.query("p"), "getAttribute", "id");
    // [el1.getAttribute("id"), el2.getAttribute("id"), ..., elN.getAttribute("id")]
     * </code></pre>
     * @param {Array|NodeList} arr The Array of items to invoke the method on.
     * @param {String} methodName The method name to invoke.
     * @param {Anything} ... Arguments to send into the method invocation.
     * @return {Array} The results of invoking the method on each item in the array.
     */

/**
     * Iterates an array calling the supplied function.
     * @param {Array/NodeList/Mixed} array The array to be iterated. If this
     * argument is not really an array, the supplied function is called once.
     * @param {Function} fn The function to be called with each item. If the
     * supplied function returns false, iteration stops and this method returns
     * the current <code>index</code>. This function is called with
     * the following arguments:
     * <div class="mdetail-params"><ul>
     * <li><code>item</code> : <i>Mixed</i>
     * <div class="sub-desc">The item at the current <code>index</code>
     * in the passed <code>array</code></div></li>
     * <li><code>index</code> : <i>Number</i>
     * <div class="sub-desc">The current index within the array</div></li>
     * <li><code>allItems</code> : <i>Array</i>
     * <div class="sub-desc">The <code>array</code> passed as the first
     * argument to <code>Ext.each</code>.</div></li>
     * </ul></div>
     * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed.
     * Defaults to the <code>item</code> at the current <code>index</code>
     * within the passed <code>array</code>.
     * @return See description for the fn parameter.
     */

/**
     * Iterates either the elements in an array, or each of the properties in an object.
     * <b>Note</b>: If you are only iterating arrays, it is better to call {@link #each}.
     * @param {Object/Array} object The object or array to be iterated
     * @param {Function} fn The function to be called for each iteration.
     * The iteration will stop if the supplied function returns false, or
     * all array elements / object properties have been covered. The signature
     * varies depending on the type of object being interated:
     * <div class="mdetail-params"><ul>
     * <li>Arrays : <tt>(Object item, Number index, Array allItems)</tt>
     * <div class="sub-desc">
     * When iterating an array, the supplied function is called with each item.</div></li>
     * <li>Objects : <tt>(String key, Object value, Object)</tt>
     * <div class="sub-desc">
     * When iterating an object, the supplied function is called with each key-value pair in
     * the object, and the iterated object</div></li>
     * </ul></div>
     * @param {Object} scope The scope (<code>this</code> reference) in which the specified function is executed. Defaults to
     * the <code>object</code> being iterated.
     */

/**
     * Partitions the set into two sets: a true set and a false set.
     * Example: 
     * Example2: 
     * <pre><code>
    // Example 1:
    Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
    // Example 2:
    Ext.partition(
    Ext.query("p"),
    function(val){
    return val.className == "class1"
    }
    );
    // true are those paragraph elements with a className of "class1",
    // false set are those that do not have that className.
     * </code></pre>
     * @param {Array|NodeList} arr The array to partition
     * @param {Function} truth (optional) a function to determine truth.  If this is omitted the element
     *                   itself must be able to be evaluated for its truthfulness.
     * @return {Array} [true<Array>,false<Array>]
     */

/**
     * Plucks the value of a property from each item in the Array
     * <pre><code>
    // Example:
    Ext.pluck(Ext.query("p"), "className"); // [el1.className, el2.className, ..., elN.className]
     * </code></pre>
     * @param {Array|NodeList} arr The Array of items to pluck the value from.
     * @param {String} prop The property name to pluck from each element.
     * @return {Array} The value from each item in the Array.
     */

/**
     * Recursively flattens into 1-d Array. Injects Arrays inline.
     * @param {Array} arr The array to flatten
     * @return {Array} The new, flattened array.
     */

/**
     * Removes a DOM node from the document.
     */

/**
     * Return the dom node for the passed String (id), dom node, or Ext.Element.
     * Optional 'strict' flag is needed for IE since it can return 'name' and
     * 'id' elements by using getElementById.
     * Here are some examples:
     * <pre><code>
    // gets dom node based on id
    var elDom = Ext.getDom('elId');
    // gets dom node based on the dom node
    var elDom1 = Ext.getDom(elDom);
    // If we don&#39;t know if we are working with an
    // Ext.Element or a dom node use Ext.getDom
    function(el){
    var dom = Ext.getDom(el);
    // do something with the dom node
    }
     * </code></pre>
     * <b>Note</b>: the dom node to be found actually needs to exist (be rendered, etc)
     * when this method is called to be successful.
     * @param {Mixed} el
     * @return HTMLElement
     */

/**
     * Returns the current HTML document object as an {@link Ext.Element}.
     * @return Ext.Element The document
     */

/**
     * Returns the current document body as an {@link Ext.Element}.
     * @return Ext.Element The document body
     */

/**
     * Returns the maximum value in the Array
     * @param {Array|NodeList} arr The Array from which to select the maximum value.
     * @param {Function} comp (optional) a function to perform the comparision which determines maximization.
     *                   If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1
     * @return {Object} The maximum value in the Array.
     */

/**
     * Returns the minimum value in the Array.
     * @param {Array|NodeList} arr The Array from which to select the minimum value.
     * @param {Function} comp (optional) a function to perform the comparision which determines minimization.
     *                   If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1
     * @return {Object} The minimum value in the Array.
     */

/**
     * Returns the type of object that is passed in. If the object passed in is null or undefined it
     * return false otherwise it returns one of the following values:<div class="mdetail-params"><ul>
     * <li><b>string</b>: If the object passed is a string</li>
     * <li><b>number</b>: If the object passed is a number</li>
     * <li><b>boolean</b>: If the object passed is a boolean value</li>
     * <li><b>date</b>: If the object passed is a Date object</li>
     * <li><b>function</b>: If the object passed is a function reference</li>
     * <li><b>object</b>: If the object passed is an object</li>
     * <li><b>array</b>: If the object passed is an array</li>
     * <li><b>regexp</b>: If the object passed is a regular expression</li>
     * <li><b>element</b>: If the object passed is a DOM Element</li>
     * <li><b>nodelist</b>: If the object passed is a DOM NodeList</li>
     * <li><b>textnode</b>: If the object passed is a DOM text node and contains something other than whitespace</li>
     * <li><b>whitespace</b>: If the object passed is a DOM text node and contains only whitespace</li>
     * </ul></div>
     * @param {Mixed} object
     * @return {String}
     */

/**
     * Returns true if the passed object is a JavaScript date object, otherwise false.
     * @param {Object} object The object to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript 'primitive', a string, number or boolean.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript Function, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript Object, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a JavaScript array, otherwise false.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a boolean.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a number. Returns false for non-finite numbers.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is a string.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is an HTMLElement
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Returns true if the passed value is not undefined.
     * @param {Mixed} value The value to test
     * @return {Boolean}
     */

/**
     * Takes an encoded URL and and converts it to an object. Example: <pre><code>
    Ext.urlDecode("foo=1&bar=2"); // returns {foo: "1", bar: "2"}
    Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", false); // returns {foo: "1", bar: ["2", "3", "4"]}
    </code></pre>
     * @param {String} string
     * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).
     * @return {Object} A literal with members
     */

/**
     * Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return "foo=1&bar=2".  Optionally, property values can be arrays, instead of keys and the resulting string that's returned will contain a name/value pair for each array value.
     * @param {Object} o
     * @param {String} pre (optional) A prefix to add to the url encoded string
     * @return {String}
     */

/**
     * This is shorthand reference to {@link Ext.ComponentMgr#get}.
     * Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}
     * @param {String} id The component {@link Ext.Component#id id}
     * @return Ext.Component The Component, <tt>undefined</tt> if not found, or <tt>null</tt> if a
     * Class was found.
    */

/**
     * True if the browser is in strict (standards-compliant) mode, as opposed to quirks mode
     * @type Boolean
     */

/**
     * True if the detected browser is Chrome.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 6.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 7.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer 8.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer running in non-strict mode.
     * @type Boolean
     */

/**
     * True if the detected browser is Internet Explorer.
     * @type Boolean
     */

/**
     * True if the detected browser is Opera.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 2.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 3.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari 4.x.
     * @type Boolean
     */

/**
     * True if the detected browser is Safari.
     * @type Boolean
     */

/**
     * True if the detected browser uses WebKit.
     * @type Boolean
     */

/**
     * True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).
     * @type Boolean
     */

/**
     * True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).
     * @type Boolean
     */

/**
     * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).
     * @type Boolean
     */

/**
     * True if the detected platform is Adobe Air.
     * @type Boolean
     */

/**
     * True if the detected platform is Linux.
     * @type Boolean
     */

/**
     * True if the detected platform is Mac OS.
     * @type Boolean
     */

/**
     * True if the detected platform is Windows.
     * @type Boolean
     */

/**
     * True if the page is running over SSL
     * @type Boolean
     */

/**
     * True if the {@link Ext.Fx} Class is available
     * @type Boolean
     * @property enableFx
     */

/**
     * True to automatically purge event listeners during garbageCollection (defaults to false).
     * @type Boolean
     */

/**
     * True to automatically uncache orphaned Ext.Elements periodically (defaults to true)
     * @type Boolean
     */

/**
     * True when the document is fully initialized and ready for action
     * @type Boolean
     */

/**
     * URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images. 
     * In older versions of IE, this defaults to "http://extjs.com/s.gif" and you should change this to a URL on your server.
     * For other browsers it uses an inline data URL.
     * @type String
     */

/**
     * URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
     * the IE insecure content warning (<tt>'about:blank'</tt>, except for IE in secure mode, which is <tt>'javascript:""'</tt>).
     * @type String
     */

/**
     * Utility method for getting the width of the browser scrollbar. This can differ depending on
     * operating system settings, such as the theme or font size.
     * @param {Boolean} force (optional) true to force a recalculation of the value.
     * @return {Number} The width of the scrollbar.
     */

/**
     * Utility method for validating that a value is numeric, returning the specified default value if it is not.
     * @param {Mixed} value Should be a number, but any type will be handled appropriately
     * @param {Number} defaultValue The value to return if the original value is non-numeric
     * @return {Number} Value, if numeric, else defaultValue
     */

/**
     * checks if an extension item has been registered already
     *
     * @param {String} extension
     * @param {String} xtype panel xtype
     */

/**
     * checks if an item has been registered already
     *
     * @param {String} contentType
     * @return {Bool}
     */

/**
     * checks if an item has been registered already
     *
     * @param {String} type
     * @param {String} key
     * @return {Bool}
     */

/**
     * default grants
     *
     * @return Array
     */

/**
     * fetch items from Filemanager registry
     */

/**
     * get container grants for specific container
     *
     * @param {Tine.Tinebase.Model.Container} container
     * @return Array
     */

/**
     * register grants or grants function for given model
     *
     * @param {Record/String} modelName
     * @param {Array|Function} grants
     */

/**
     * registers a handler
     *
     * @param {String} contentType
     * @param {String} xtype panel xtype
     */

/**
     * registers a handler
     *
     * @param {String} extension
     * @param {String} xtype panel xtype
     */

/**
     * registers a handler
     *
     * @param {String} type
     * @param {String} key
     * @param {String} value
     */

/**
     * returns a xtype
     *
     * @param {String} extension
     * @param {String} xtype panel xtype
     */

/**
     * returns a xtype for a contentType
     *
     * @param {String} contentType
     * @return {String}
     */

/**
     * returns a xtype for a key
     *
     * @param {String} type
     * @param {String} key
     * @return {String}
     */

/**
    * A reusable empty function
    * @property
    * @type Function
    */

/**
   * @cfg filesProperty
   * @type String
   */

/**
   * @cfg {Array} additionalFields
   * additional fields for the quota form
   */

/**
   * @cfg {Array} data of Tine.Tinebase.Model.Container
   * Container to manage grants for
   */

/**
   * @cfg {Array} operators allowed operators
   */

/**
   * @cfg {Array} requiredGrants
   * grants which are required to select nodes
   */

/**
   * @cfg {Boolean}
   * always show the admin grant (default: false)
   */

/**
   * @cfg {Boolean} allowMultiple
   * allow to select multiple fiels at once (source mode only)
   */

/**
   * @cfg {Function} handler
   */

/**
   * @cfg {String|RegExp}
   * A constraint allows to alter the selection behaviour of the picker, for example only allow to select files.
   * By default, file and folder are allowed to be selected, the concrete implementation needs to define it's purpose
   */

/**
   * @cfg {String} batchID of current upload
   */

/**
   * @cfg {String} defaultOperator default operator, one of <tt>{@link #operators} (defaults to equals)
   */

/**
   * @cfg {String} defaultValue default value (defaults to all)
   */

/**
   * @cfg {String} field path
   */

/**
   * @cfg {String} file name
   */

/**
   * @cfg {String} file type
   */

/**
   * @cfg {String} fileName
   * @property {String} fileName
   * (initial) fileName
   */

/**
   * @cfg {String} files
   * @property {String} files
   * (initial) files
   * files to be saved
   */

/**
   * @cfg {String} mode one of source|target
   */

/**
   * @cfg {String} windowTitle
   * title text when openWindow is used
   */

/**
   * @cfg {Tine.Felamimail.Model.Account}
   * 
   * TODO use node record?
   */

/**
   * @cfg {Tine.Tinebase.Application} app
   */

/**
   * @cfg {Tine.widgets.dialog.EditDialog}
   */

/**
   * @cfg {Tine.widgets.grid.GridPanel}
   */

/**
   * @param {Array} promises        List of promises to batch
   * @returns {Promise<any[]>}
   */

/**
   * @param {Object} dragOverEvent
   *
   * tree - The TreePanel
   * target - The node being targeted for the drop
   * data - The drag data from the drag source
   * point - The point of the drop - append, above or below
   * source - The drag source
   * rawEvent - Raw mouse event
   * dropNode - Drop node(s) provided by the source.
   * cancel - Set this to true to signal drop not allowed.
   */

/**
   * @private
   */

/**
   * @returns {*}
   */

/**
   * @returns {Tine.Filemanager.NodeTreePanel}
   */

/**
   * @type SelectionModel
   */

/**
   * @type Tine.Filemanager.DownloadLinkGridPanel
   */

/**
   * @type Tine.Filemanager.QuickLookRegistry
   */

/**
   * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
   * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
   * <pre><code>
  var cls = 'my-class', text = 'Some text';
  var s = String.format('&lt;div class="{0}">{1}&lt;/div>', cls, text);
  // s now contains the string: '&lt;div class="my-class">Some text&lt;/div>'
   * </code></pre>
   * @param {String} string The tokenized string to be formatted
   * @param {String} value1 The value to replace token {0}
   * @param {String} value2 Etc...
   * @return {String} The formatted string
   * @static
   */

/**
   * An empty function by default, but provided so that you can perform a custom action before the initial
   * drag event begins and optionally cancel it.
   * @param {Object} data An object containing arbitrary data to be shared with drop targets
   * @param {Event} e The event object
   * @return {Boolean} isValid True if the drag event is valid, else false to cancel
   */

/**
   * App which triggered this action
   */

/**
   * App which triggered this action (passed to preview panel)
   */

/**
   * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped onto
   * the drop node.  The default implementation returns false, so it should be overridden to provide the
   * appropriate processing of the drop event and return true so that the drag source's repair action does not run.
   * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from
   * {@link #getTargetFromEvent} for this node)
   * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
   * @param {Event} e The event
   * @param {Object} data An object containing arbitrary data supplied by the drag source
   * @return {Boolean} True if the drop was valid, else false
   */

/**
   * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
   * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  // executes immediately:
  sayHi('Fred');
  // executes after 2 seconds:
  sayHi.defer(2000, this, ['Fred']);
  // this syntax is sometimes useful for deferring
  // execution of an anonymous function:
  (function(){
  alert('Anonymous');
  }).defer(100);
  </code></pre>
   * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
   * <b>If omitted, defaults to the browser window.</b>
   * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
   * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
   * if a number the args are inserted at the specified position
   * @return {Number} The timeout id that can be used with clearTimeout
   */

/**
   * Capture space to toggle document preview
   */

/**
   * Check if selection fits current constraint
   * @returns {boolean}
   */

/**
   * Checks if a single node matches the constraints
   *
   * @param node
   * @returns {boolean}
   */

/**
   * Checks whether or not the current number is within a desired range.  If the number is already within the
   * range it is returned, otherwise the min or max value is returned depending on which side of the range is
   * exceeded.  Note that this method returns the constrained value but does not change the current number.
   * @param {Number} min The minimum number in the range
   * @param {Number} max The maximum number in the range
   * @return {Number} The constrained value if outside the range, otherwise the current value
   */

/**
   * Checks whether or not the specified object exists in the array.
   * @param {Object} o The object to check for
   * @param {Number} from (Optional) The index at which to begin the search
   * @return {Number} The index of o in the array (or -1 if it is not found)
   */

/**
   * Constructor.
   */

/**
   * Create a combined function call sequence of the original function + the passed function.
   * The resulting function returns the results of the original function.
   * The passed fcn is called with the parameters of the original function. Example usage:
   * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  sayHi('Fred'); // alerts "Hi, Fred"
  var sayGoodbye = sayHi.createSequence(function(name){
  alert('Bye, ' + name);
  });
  sayGoodbye('Fred'); // both alerts show
  </code></pre>
   * @param {Function} fcn The function to sequence
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
   * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
   * @return {Function} The new function
   */

/**
   * Create a new filepicker and register listener
   * @returns {*}
   */

/**
   * Creates a delegate (callback) that sets the scope to obj.
   * Call directly on any function. Example: <code>this.myFunction.createDelegate(this, [arg1, arg2])</code>
   * Will create a function that is automatically scoped to obj so that the <tt>this</tt> variable inside the
   * callback points to obj. Example usage:
   * <pre><code>
  var sayHi = function(name){
  // Note this use of "this.text" here.  This function expects to
  // execute within a scope that contains a text property.  In this
  // example, the "this" variable is pointing to the btn object that
  // was passed in createDelegate below.
  alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
  }
  var btn = new Ext.Button({
  text: 'Say Hi',
  renderTo: Ext.getBody()
  });
  // This callback will execute in the scope of the
  // button instance. Clicking the button alerts
  // "Hi, Fred. You clicked the "Say Hi" button."
  btn.on('click', sayHi.createDelegate(btn, ['Fred']));
  </code></pre>
   * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the function is executed.
   * <b>If omitted, defaults to the browser window.</b>
   * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
   * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
   * if a number the args are inserted at the specified position
   * @return {Function} The new function
   */

/**
   * Creates a new pop up dialog/window (acc. configuration)
   *
   * @returns {null}
   */

/**
   * Creates namespaces to be used for scoping variables and classes so that they are not global.
   * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
   * <pre><code>
  Ext.namespace('Company', 'Company.data');
  Ext.namespace('Company.data'); // equivalent and preferable to above syntax
  Company.Widget = function() { ... }
  Company.data.CustomStore = function(config) { ... }
  </code></pre>
   * @param {String} namespace1
   * @param {String} namespace2
   * @param {String} etc
   * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
   * @method ns
   */

/**
   * Customized column model for the grid
   * @returns {*}
   */

/**
   * Escapes the passed string for ' and \
   * @param {String} string The string to escape
   * @return {String} The escaped string
   * @static
   */

/**
   * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
   *
   * NOTE: path does not consist of id's starting from the second depth
   *
   * @param {String} path
   * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
   * @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with
   * (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded.
   */

/**
   * Filemanager
   */

/**
   * Fires if no previews are available
   */

/**
   * Get translated application title of this application
   *
   * @return {String}
   */

/**
   * If a node was selected
   * @param nodes
   */

/**
   * If an invalid node was selected
   */

/**
   * Layout
   */

/**
   * Node record to preview
   */

/**
   * Pads the left side of a string with a specified character.  This is especially useful
   * for normalizing number and date strings.  Example usage:
   * <pre><code>
  var s = String.leftPad('123', 5, '0');
  // s now contains the string: '00123'
   * </code></pre>
   * @param {String} string The original string
   * @param {Number} size The total length of the output string
   * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ")
   * @return {String} The padded string
   * @static
   */

/**
   * Password used to protect downloadlink
   */

/**
   * Removes the specified object from the array.  If the object is not found nothing happens.
   * @param {Object} o The object to remove
   * @return {Array} this array
   */

/**
   * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
   * @param {String} path
   * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
   * @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with
   * (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node.
   */

/**
   * The version of the framework
   * @type String
   */

/**
   * This should only be called on non-detached scopes
   * @internal
   */

/**
   * Tine.Filemanager.Model.DownloadLink
   */

/**
   * Tine.widgets.account.PickerGridPanel config values
   */

/**
   * Tine.widgets.tree.FilterPlugin
   * returns a filter plugin to be used in a grid
   */

/**
   * Updates selected element and triggers an event
   */

/**
   * after grid renderd
   */

/**
   * bus notified about record changes
   */

/**
   * called before store queries for data
   */

/**
   * called when the store gets updated, e.g. from editgrid
   * 
   * @param {Ext.data.store} store
   * @param {Tine.Tinebase.data.Record} record
   * @param {String} operation
   */

/**
   * called when tree selection changes
   *
   * @param {} sm     SelectionModel
   * @param {Ext.tree.TreeNode} node
   */

/**
   * canonical name
   * @cfg {String} canonicalName
   */

/**
   * check action constraints for given nodes
   * 
   * @param {String} action (create|delete|move|copy) 
   * @param {Record} targetNode
   * @param {Array}  sourceNodes
   * @param {Object} options
   * @return {Boolean}
   */

/**
   * check if node path is in current grid panel
   * @param path
   * @returns {boolean}
   */

/**
   * check if record can be edited
   *
   * @param row
   * @returns {boolean}
   */

/**
   * check if record can be edited
   *
   * @returns {boolean}
   * @param ed
   */

/**
   * checkes if user has requested grant for given node
   *
   * @param {Tine.Filemanager.Model.Node} node
   * @param {Array} grants
   * @return bool
   */

/**
   * checks whether pause button shuold be enabled or disabled
   * 
   * @param action
   * @param grants
   * @param records
   */

/**
   * checks whether resume button shuold be enabled or disabled
   * 
   * @param action
   * @param grants
   * @param records
   */

/**
   * clone a tree node / create a node from grid node
   *
   * @param node
   * @returns {Ext.tree.AsyncTreeNode}
   */

/**
   * config values
   * @private
   */

/**
   * convert filesystem path to treePath
   *
   * NOTE: only the first depth gets converted!
   *       fs pathes of not yet loaded tree nodes can't be converted!
   *
   * @param {String} containerPath
   * @return {String} tree path
   */

/**
   * copy/move folder/files to a folder
   *
   * @param items files/folders to copy
   *
   * @param target
   * @param move
   * @param showConfirmDialog
   * @param params
   */

/**
   * creating folder
   * 
   * @param name      folder name
   * @param options   additional options
   * @returns
   */

/**
   * display file/directory in mainscreen
   * /#/Filemanager/showNode/shared/someFolder/someFile
   */

/**
   * exception handler for this proxy
   * 
   * @param {Tine.Exception} exception
   */

/**
   * executed after record got updated from proxy
   * -> we don't have a real record here
   * 
   * @private
   */

/**
   * executed when record is loaded
   * @private
   */

/**
   * expand folder node
   *
   * @param {Sting | Tine.Filemanager.Model.Node} path
   */

/**
   * fetch/manage preview panels for records by content-type
   */

/**
   * filemanager
   */

/**
   * files/folder got dropped on node
   *
   * @param {Object} dropEvent
   * @private
   */

/**
   * fm specific delete handler
   */

/**
   * folder or file?
   */

/**
   * generic apply changes handler
   * @param {Boolean} closeWindow
   */

/**
   * get action toolbar
   *
   * @return {Ext.Toolbar}
   */

/**
   * get record by data path
   * @param data
   * @returns {string}
   */

/**
   * get the right contextMenu
   */

/**
   * gets currently displayed node in case a path filter is set
   * NOTE: this data is unresolved as it comes from filter and not through json convert!
   *
   * @return {Object}
   */

/**
   * go up one folder
   *
   * @param {Ext.Component} button
   * @param {Ext.EventObject} event
   */

/**
   * grid on load handler
   *
   * @param store
   * @param records
   * @param options
   */

/**
   * grid row doubleclick handler
   *
   * @param {Tine.Filemanager.NodeGridPanel} grid
   * @param {} row record
   * @param {Ext.EventObjet} e
   */

/**
   * handels tree drop of object from outside the browser
   *
   * @param fileSelector
   * @param targetNodeId
   */

/**
   * helper function for users e.g. FilePickerDialog / SelectionDialog/FilemanagerPlugin
   * can be used after a final selection to check if a file exists (which might be hidden due to paging etc)
   * 
   * @return {Promise<unknown>}
   */

/**
   * holds Ids of record preview panels (index is record ID)
   */

/**
   * init actions and toolbars
   */

/**
   * init actions with actionToolbar, contextMenu and actionUpdater
   * @private
   */

/**
   * init buttons
   */

/**
   * init ext grid panel
   * @private
   */

/**
   * init grid columns
   */

/**
   * init panel
   */

/**
   * init record to edit
   * -> we don't have a real record here
   */

/**
   * initial path
   * @cfg {String} initialPath
   */

/**
   * initiates tree context menus
   *
   * @private
   */

/**
   * inits this cmp
   * @private
   */

/**
   * inserts a quota Message when using old Browsers with html4upload
   */

/**
   * is automatically called in generic GridPanel
   */

/**
   * load everything from server
   * @returns {Object} root node definition
   */

/**
   * monitor upload tasks
   * 
   * - cross window : if yes , duplicated window should not proceed upload at all
   */

/**
   * navigate previews
   *
   * @param e
   */

/**
   * on pause
   * @param {} button
   * @param {} event
   */

/**
   * on remove handler
   *
   * @param {} button
   * @param {} event
   */

/**
   * on resume
   * @param {} button
   * @param {} event
   */

/**
   * on store load exception
   *
   * @param {Tine.Tinebase.data.RecordProxy} proxy
   * @param {String} type
   * @param {Object} error
   * @param {Object} options
   */

/**
   * on update after edit
   *
   * @param {String|Tine.Tinebase.data.Record} record
   * @param {String} mode
   */

/**
   * overwrite update toolbars function (we don't have record grants yet)
   * 
   * @private
   */

/**
   * populate grid store
   *
   * @param {} record
   */

/**
   * preform the initial load of grid data
   */

/**
   * register constraint action provider
   * @param {Function} provider function with same signature as checkConstraints
   */

/**
   * remove handler
   * 
   * @param {} button
   * @param {} event
   */

/**
   * returns add action / test
   * 
   * - handle both file and folder upload action
   *
   * @return {Object} add action config
   */

/**
   * returns cm
   * 
   * @return Ext.grid.ColumnModel
   * @private
   * 
   * TODO    add more columns
   */

/**
   * returns dialog
   * 
   * NOTE: when this method gets called, all initalisation is done.
   * 
   * @return {Object}
   * @private
   * 
   */

/**
   * returns dialog
   * @return {Object}
   * @private
   */

/**
   * returns filter toolbar -> supress OR filters
   * @private
   */

/**
   * returns params for async request
   *
   * @param {Ext.tree.TreeNode} node
   * @return {Object}
   */

/**
   * returns true if node can accept contents
   *
   * @param nodeAttributes
   * @returns boolean
   */

/**
   * returns view row class
   */

/**
   * searches all (lightweight) records matching filter
   *
   * @param   {Object} filter
   * @param   {Object} paging
   * @param   {Object} options
   * @return  {Number} Ext.Ajax transaction id
   * @success {Object} root:[records], totalcount: number
   */

/**
   * select tree node(s)
   * 
   * @param {String} value
   */

/**
   * show context menu
   *
   * @param {Ext.tree.TreeNode} node
   * @param {Ext.EventObject} event
   */

/**
   * status column renderer
   * @param {string} value
   * @return {string}
   */

/**
   * that's the context menu handler
   * @param {} grid
   * @param {} row
   * @param {} e
   */

/**
   * updates given record with nodeData from from response
   */

/**
   * upload files
   * 
   * @param {} params Request parameters
   * @param [] uploadKeyArray
   * @param Boolean addToGridStore
   */

/**
   * upload new files and add to store
   *
   * - handle both folder and files
   * 
   * @param {ux.BrowsePlugin} fileSelector
   * @param event
   */

/**
   * value renderer
   * 
   * @param {Ext.data.Record} filter line
   * @param {Ext.Element} element to render to 
   */

/**
   * virtual nodes are part of the tree but don't exists / are editable
   *
   * NOTE: only "real" virtual node is node with path "otherUsers". all other nodes exist
   *
   * @returns {boolean}
   */

/**
  * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
  * Call directly on any function. Example: <code>myFunction.createCallback(arg1, arg2)</code>
  * Will create a function that is bound to those 2 args. <b>If a specific scope is required in the
  * callback, use {@link #createDelegate} instead.</b> The function returned by createCallback always
  * executes in the window scope.
  * <p>This method is required when you want to pass arguments to a callback function.  If no arguments
  * are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn).
  * However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function
  * would simply execute immediately when the code is parsed. Example usage:
  * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  // clicking the button alerts "Hi, Fred"
  new Ext.Button({
  text: 'Say Hi',
  renderTo: Ext.getBody(),
  handler: sayHi.createCallback('Fred')
  });
  </code></pre>
  * @return {Function} The new function
  */

/**
  * Creates an interceptor function. The passed function is called before the original one. If it returns false,
  * the original one is not called. The resulting function returns the results of the original function.
  * The passed function is called with the parameters of the original function. Example usage:
  * <pre><code>
  var sayHi = function(name){
  alert('Hi, ' + name);
  }
  sayHi('Fred'); // alerts "Hi, Fred"
  // create a new function that validates input without
  // directly modifying the original function:
  var sayHiToFriend = sayHi.createInterceptor(function(name){
  return name == 'Brian';
  });
  sayHiToFriend('Fred');  // no alert
  sayHiToFriend('Brian'); // alerts "Hi, Brian"
  </code></pre>
  * @param {Function} fcn The function to call before the original
  * @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the passed function is executed.
  * <b>If omitted, defaults to the scope in which the original function is called or the browser window.</b>
  * @return {Function} The new function
  */

/**
 * @class Array
 */

/**
 * @class Ext
 * Ext core utilities and functions.
 * @singleton
 */

/**
 * @class Ext
 */

/**
 * @class Function
 * These functions are available on every Function object (any JavaScript function).
 */

/**
 * @class Number
 */

/**
 * @class String
 * These functions are available as static methods on the JavaScript String object.
 */

/**
 * @class String
 * These functions are available on every String object.
 */

/**
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.DownloadLinkDialog
 * @extends     Tine.widgets.dialog.EditDialog
 * 
 * <p>Sieve Filter Dialog</p>
 * <p>This dialog is for editing sieve filters (rules).</p>
 * <p>
 * </p>
 * 
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * 
 * @param       {Object} config
 * @constructor
 * Create a new RulesDialog
 */

/**
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.NodeEditDialog
 * @extends     Tine.widgets.dialog.EditDialog
 *
 * <p>Node Compose Dialog</p>
 * <p></p>
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 *
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Filemanager.NodeEditDialog
 */

/**
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.UsagePanel
 * @extends     Ext.Panel
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 *
 * @param       {Object} config
 * @constructor
 */

/**
 * @namespace   Tine.Filemanager.Model
 * @class       Tine.Filemanager.Model.DownloadLink
 * @extends     Tine.Tinebase.data.Record
 * Example record definition
 */

/**
 * @namespace   Tine.Filemanager.Model
 * @class       Tine.Filemanager.Model.Node
 * @extends     Tine.Tinebase.data.Record
 * Example record definition
 * 
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 */

/**
 * @namespace   Tine.widgets.container
 * @class       Tine.Filemanager.PathFilterModel
 * @extends     Tine.widgets.grid.FilterModel
 * 
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * 
 * @TODO make valueRenderer a path picker widget
 */

/**
 * @namespace Tine.Filemanager
 * @class Tine.Filemanager.Application
 * @extends Tine.Tinebase.Application
 */

/**
 * @namespace Tine.Filemanager
 * @class Tine.Filemanager.MainScreen
 * @extends Tine.widgets.MainScreen
 */

/**
 * @namespace Tine.Filemanager
 * @class Tine.Filemanager.NodeTreePanel
 * @extends Tine.widgets.container.TreePanel
 *
 * @author Martin Jatho <m.jatho@metaways.de>
 */

/**
 * @namespace Tine.Filemanager
 * @class Tine.Filemanager.QuickLookRegistry
 * @singleton
 *
 * @todo think about adding a generalized registry / @see Tine.Tinebase.ExceptionHandlerRegistry and others
 */

/**
 * @singleton
 */

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */

/**
 * Container Grants grid
 * 
 * @namespace   Tine.widgets.container
 * @class       Tine.widgets.container.GrantsDialog
 * @extends     Tine.widgets.dialog.EditDialog
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2011 Metaways Infosystems GmbH (http://www.metaways.de)
 * @constructor
 * @param {Object} config The configuration options.
 */

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */

/**
 * Copies all the properties of config to obj.
 * @param {Object} obj The receiver of the properties
 * @param {Object} config The source of the properties
 * @param {Object} defaults A different object that will also be applied for default values
 * @return {Object} returns obj
 * @member Ext apply
 */

/**
 * Creates a new pop up dialog/window (acc. configuration)
 *
 * @returns {null}
 */

/**
 * DownloadLink Edit Popup
 * 
 * @param   {Object} config
 * @return  {Ext.ux.Window}
 */

/**
 * Execute promise which is provided as a separate function in order to make a clean/original promise call.
 * If there was an error, log it and return rejected promise execution so it might be used again for retrial
 *
 * @param {Object} [logger]     Custom logger that can be provided
 * @returns {function(*=): Promise<T | {rejectedPromise: *, error: any, status: string}>}
 */

/**
 * File grid panel
 *
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.NodeGridPanel
 * @extends     Tine.widgets.grid.GridPanel
 *
 * <p>Node Grid Panel</p>
 * <p><pre>
 * </pre></p>
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Martin Jatho <m.jatho@metaways.de>
 * @copyright   Copyright (c) 2007-2011 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Filemanager.FileGridPanel
 */

/**
 * File grid panel
 * 
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.DownloadLinkGridPanel
 * @extends     Tine.widgets.grid.GridPanel
 * 
 * <p>DownloadLink Grid Panel</p>
 * <p><pre>
 * </pre></p>
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2014 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Filemanager.FileGridPanel
 */

/**
 * File picker dialog
 * 
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.FilePickerDialog
 * @extends     Tine.Tinebase.dialog.Dialog
 * @constructor
 * @param       {Object} config The configuration options.
 */

/**
 * FilePicker component.
 *
 * Standalone file picker for selecting a node or a folder from _Filemanager_.
 * If you need a generic picker including up/download, attachments, ... use {Tine.Tinebase.widgets.file.SelectionDialog}
 */

/**
 * Filemanager Edit Popup
 *
 * @param   {Object} config
 * @return  {Ext.ux.Window}
 */

/**
 * For provided list of promises and `raceTimeoutInMs` method will execute promises in parallel and wait for the
 * response for certain amount of time. After time is out (based on `raceTimeoutInMs`) caller may decide what response
 * to receive. By default method returns only promises that "won" the timeout race. Otherwise it can return all
 * reflected promises including promises that "lost" the race.
 *
 * @param {Array} listOfPromises                  A list of promises to race against time
 * @param {Number} [raceTimeoutInMs]              The time in milliseconds that each promise will race against
 * @param {String} [raceTimeoutMessage]           A custom message provided for promise which "lost" the race
 * @param {(
 * 'ONLY_RESOLVED' | 'ONLY_WINNER_PROMISES' | 'ALL'
 * )} responseMode                                Different mode will provide different responses,
 *                                                depending on caller requirements.
 * @returns {Promise<any[]>}
 */

/**
 * Namespace alloted for extensions to the framework.
 * @property ux
 * @type Object
 */

/**
 * Node selection combo box
 * 
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.SearchCombo
 * @extends     Ext.form.TriggerField
 * 
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Alexander Stintzing <a.stintzing@metaways.de>
 * @author      Michael Spahn <m.spahn@metaways.de>
 * @copyright   Copyright (c) 2012-2017 Metaways Infosystems GmbH (http://www.metaways.de)
 * 
 * @param       {Object} config
 * @constructor
 * Create a new Tine.Filemanager.SearchCombo
 */

/**
 * Recursive Filter
 *
 * @namespace   Tine.Filemanager
 * @class       Tine.Filemanager.RecursiveFilter
 * @extends     Ext.Toolbar
 *
 * @param       {Object} config
 * @constructor
 */

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */

/**
 * This method resolves all promises without failing, logs an error if there is logger provided and displays a final status of executed promise.
 * It can be "resolved" or "rejected". If "rejected", it also provides a reference to rejected function that returns a promise.
 * The purpose is to continue with the execution of all promises even if some of them were rejected
 *
 * @param {Array} listOfPromises      Array of promises, which are mapped into reflect function
 * @param {Object} [logger]           Custom logger that can be provided
 * @returns {Promise<any[]>}
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Ching En Cheng <c.cheng@metaways.de>
 * @copyright   Copyright (c) 2025 Metaways Infosystems GmbH (http://www.metaways.de)
 *
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Ching En Cheng <c.cheng@metaways.de>
 * @copyright   Copyright (c) 2025 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiss <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2017-2018 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2022 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Cornelius Weiß <c.weiss@metaways.de>
 * @copyright   Copyright (c) 2025 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Tine 2.0
 *
 * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
 * @author      Philipp Schüle <p.schuele@metaways.de>
 * @copyright   Copyright (c) 2017-2018 Metaways Infosystems GmbH (http://www.metaways.de)
 */

/**
 * Trims whitespace from either end of a string, leaving spaces within the string intact.  Example:
 * <pre><code>
var s = '  foo bar  ';
alert('-' + s + '-');         //alerts "- foo bar -"
alert('-' + s.trim() + '-');  //alerts "-foo bar-"
</code></pre>
 * @return {String} The trimmed string
 */

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */

/**
 * Utility function that allows you to easily switch a string between two alternating values.  The passed value
 * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If
 * they are already different, the first value passed in is returned.  Note that this method returns the new value
 * but does not change the current string.
 * <pre><code>
// alternate sort directions
sort = sort.toggle('ASC', 'DESC');

// instead of conditional logic:
sort = (sort == 'ASC' ? 'DESC' : 'ASC');
</code></pre>
 * @param {String} value The value to compare to the current string
 * @param {String} other The new value to use if the string already equals the first value passed in
 * @return {String} The new value
 */

/**
 * creat folder task
 *
 * - create node in NodeGridPanel
 * @param targetFolderPath
 * @param folders
 * @param existNodeList
 * @returns {Promise<{path, taskId: *}>}
 */

/**
 * create new folder, needs a single folder selection with addGrant
 */

/**
 * create sorted folders from files
 *
 * @param files
 */

/**
 * create tasks for folder creation and file uploads
 *
 * - the priority of folder creation is based on deep level
 
 * @param targetFolderPath
 * @param files
 * @returns {Promise<[]>}
 */

/**
 * create upload file tasks
 *
 * - create node in NodeGridPanel
 * @param targetFolderPath
 * @param filesToUpload
 * @param existNodeList
 * @returns {Promise<void>}
 */

/**
 * download file/folder into browser
 *
 * @param record
 * @param revision
 * @returns {Ext.ux.file.Download}
 *
 */

/**
 * download link backend
 */

/**
 * filter plugin for container tree
 * 
 * @namespace Tine.widgets.tree
 * @class     Tine.Filemanager.PathFilterPlugin
 * @extends   Tine.widgets.grid.FilterPlugin
 */

/**
 * generic exception handler for filemanager
 * 
 * @namespace Tine.Filemanager
 * @param {Tine.Exception} exception
 * @param {Object} request
 */

/**
 * get files to upload from specific folder path
 *
 * @param files
 * @param folder
 */

/**
 * get folder dependency paths
 *
 * @returns {*}
 * @param targetFolderPath
 * @param path
 */

/**
 * grants by model registry
 *
 * @type {{defaultGrants, getByContainer, register}}
 */

/**
 * helper for disabled field
 *
 * @param action
 * @param grants
 * @param records
 * @param isFilterSelect
 * @param filteredContainers
 * @returns {*}
 */

/**
 * one file node with download grant
 */

/**
 * one file node with readGrant
 */

/**
 * one node with publish grant
 * 
 * - user needs both publishGrant and downloadGrant to execute this action.
 */

/**
 * one or multiple file nodes currently upload paused
 */

/**
 * one or multiple file nodes currently uploaded
 */

/**
 * one or multiple file nodes currently uploaded or upload paused
 * @TODO deletes node as well?
 */

/**
 * one or multiple nodes with read, edit AND deleteGrant
 */

/**
 * one or multiple nodes, all need deleteGrant
 */

/**
 * resolve uploadId for file
 *
 * @param targetFolderPath
 * @param files
 */

/**
 * show native file select, upload files, create nodes
 * a single directory node with create grant has to be selected
 * for this action to be active
 * 
 * - allow open node edit dialog with only readGrant,
 * - most panels are readonly if user has no editGrant
 */

/**
 * single file or directory node with editGrant
 */

/**
 * single file or directory node with readGrant
 */

/**
 * upload(files)
 *
 * uploadFiles does:
 * - sorts out which folders to create
 * - creates the uploadFolder and uploadFiles tasks with deps
 * - upload(Folder/File) tasks post messages with postal message bus
 * - gridPanel/treePanel listens to message bus and adds/update files and folders
 * - files have progress and info about transitional state (the (empty) file is not yet created)
 * - folders have transitional state only (not yet created, just in uploadManager)
 */

/**
 Returns the number of milliseconds between this date and date
 @param {Date} date (optional) Defaults to now
 @return {Number} The diff in milliseconds
 @member Date getElapsed
 */

/** Built-in value references. */

/** Detect free variable `global` from Node.js. */

/** Detect free variable `self`. */

/** Used for built-in method references. */

/** `Object#toString` result references. */

/***/

/*use SoftQuota*/

//         // arg - does not trigger tree children reload!

//         Tine.Filemanager.nodeBackend.loadRecord(record);

//         var record = this.initialConfig.selections[0];

//        atm. the server can't cope with it -> see #490, #484

//        this.onRecordLoad();

//       for focus to work (e.g. iOS dosn't show keyborad)

//     app: 'Filemanager',

//     handler: function() {

//     iconCls: 'x-tbar-loading',

//     text: 'Reload', // _('Reload'),

//     }

//    loadRecord: false,

//  * reload

//  */

//  Clear previous selection

//  get moved around. Make sure all root level vnodes inherit el.

// #1153: fast path should not be taken for non-stable (v-for) fragments

// #2078 in the case of <component :is="vnode" ref="extra"/>

// #2080 if the stable fragment has a key, it's a <template v-for> that may

// #2134 or if it's a component root, it may also get moved around

// #2715 the previous fragment could've been a BAILed one as a result

// #3666, avoid reference pollution when reusing vnode

// #8326: extend call and options.name access are considered side-effects

// (#4815)

// - #1942 if hmr is enabled with sfc component

// - In the case of a Fragment, we need to provide the actual parent

// - In the case of a component, it could contain anything.

// - In the case of different nodes, there is going to be a replacement

// - vite#872 non-sfc component used by sfc component

// /**

// 3rd party modules

// 5 minutes

// @TODO validate filename

// @TODO: enable box for non admins if not hasOwnNotificationSettings

// @TODO: fixme - ux problems with filterselect / initialData

// @TODO: rethink: do I need delte on the record or parent?

// @see http://www.stucox.com/blog/you-cant-detect-a-touchscreen/

// @see https://stackoverflow.com/questions/17989777/detect-if-ios-is-using-webapp/40932301#40932301

// Append our div, do our calculation and then remove it

// CONCATENATED MODULE: ./ux/form/FieldTriggerPlugin.js

// CONCATENATED MODULE: ./ux/vue/PersonaContainer/PersonaContainer.vue?vue&type=script&setup=true&lang=js

// CONCATENATED MODULE: ./ux/vue/PersonaContainer/helpers.js

// DIN A4 and so on

// EXPORTS

// EXTERNAL MODULE: ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js

// EXTERNAL MODULE: ./node_modules/@vue/shared/dist/shared.esm-bundler.js

// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js

// Exports

// Filemanager_Exception_DestinationIsOwnChild

// Filemanager_Exception_DestinationIsSameNode

// Filemanager_Exception_Quarantined

// For old IE

// Hide filter toolbar

// IE returns elements with the 'name' and 'id' attribute.

// If no constraints apply, skip here

// If selection doesn't fullfil constraint, we don't throw a selectionChange event

// If there is no admin grant, only allow to edit the own record

// If url is already wrapped in quotes, remove them

// In case there is no own setting, we don't need to persist current values we just empty it

// In order to make Suspense tree-shakable, we need to avoid importing it

// In other cases, the parent container is not actually used so we

// Marker for special handling inside the renderer. We are not using a ===

// Minimum information to proceed here

// Module

// Move PURE marker to new line to workaround compiler discarding it

// NOTE we have to encode the path here because it might contain quotes or other bad chars

// NOTE: atm the activity records are stored as Tinebase_Model_Tree_Node records

// NOTE: custom fields of Tree_Nodes are inherited but mc can't show it

// NOTE: fm tree is initially loaded from grid!

// NOTE: path filter throws an error in not existent

// NOTE: qtip dosn't work, but implementing is not worth the effort...

// NOTE: some browsers require user interaction (like click events)

// NOTE: this could also be solved withe the useGrant method!

// NOTE: we can't use export / import syntax as es6 modules require strict mode and this code can't cope with it

// NOTE: we don't expand here any longer - macos and win don't do it either

// Need to add 2 to ensure we leave enough space

// Open preview on space if a node is selected and the node type equals file

// Remove properties

// See https://drafts.csswg.org/css-values-3/#urls

// Should url be wrapped?

// Special case to return head of iframe instead of iframe itself

// The use of `Object#toString` avoids issues with the `typeof` operator

// These should technically only be non-null on mounted VNodes. However,

// This will throw an exception if access to iframe is blocked

// Tine.Filemanager.nodeActions.Reload = {

// Tine.Filemanager.nodeActions.UploadFiles = {};

// When reloaded the server is supposed to send the correct inherited values

// _('Copy')

// _('Create Folder')

// _('Delete')

// _('Edit Properties')

// _('Move')

// _('Open the Data Safe')

// _('Preview')

// _('Publish')

// _('Rename')

// _('Save locally')

// _('System Link')

// a server-rendered async wrapper is already in resolved state

// actionType: 'add',

// actionType: 'edit',

// activities and tags

// add / remount node

// add grant for target required

// add grant required

// allways start with an empty filter set!

// also exclude jsdom

// also try camelCase event handler (#2249)

// always force full diff in dev

// always prepare parent's acl node

// anchor may have changed if it's in a fragment

// anchor will not be used if this is hydration, so only need to

// and converted to camelCase (#955)

// and it will never need to change.

// android chrome

// announce delete before server delete to improve ux

// apparently config might be empty for shared folders

// appear

// as the component is being moved.

// as the path of all children changed as well

// assets

// attachments preview

// avoid a block node from tracking itself

// browser environment to avoid the timer handle stalling test runner exit

// by Rollup, so we have to wrap it in a pure-annotated IIFE.

// check directly on KeepAlive in the renderer, because importing it directly

// check filtered node if nothing is selected

// check if already in

// check instance[type] first which is resolved for options API

// checks for null and undefined

// component doesn't need to update, it needs to persist the instance on to

// component may have been moved before resolve.

// component nodes also should always be patched, because even if the

// consider the comment placeholder case.

// cope with attachments

// copy 'real' data to a node record NOTE: not a full record as we have no record reader here

// copy arguments first

// create method call params

// css module (injected by vue-loader)

// delete grant required

// deprecated

// directly in the renderer. The renderer checks for the __isSuspense flag

// do not use basename() here -> recursion!

// do nothing, other nodes has been moved already

// don't allow any actions 

// don't polute global namspace if no one else did

// don't save these records. Add them to the parents' record store

// due to cross-origin restrictions

// due to type annotation

// edit grant required

// emit

// enter

// existing patch flag to be reliable and need to add the FULL_PROPS flag.

// extends Tine.widgets.tree.ContextMenu

// fallback tree will not have suspense context

// fast paths only.

// fill potential gaps in folder list as we don't have mkdir -p

// fixme: NodeTreePanel fetches grid via app registry

// for Object prototype breakers

// for camelCase

// for kebab-case

// generic node actions - work on selections grid/tree nodes

// get uniq folder tree

// global properties

// global registration

// grants-grid only - checkboxes have own state

// grid only actions - work on node which is displayed (this.currentFolderNode)

// handle late devtools injection - only do this if we are in an actual

// has current parent block

// here to prevent dependency on Date.js

// hfit?

// i18n._('Add')

// i18n._('Admin')

// i18n._('Delete')

// i18n._('Download')

// i18n._('Edit')

// i18n._('Export')

// i18n._('Permission to download files')

// i18n._('Publish')

// i18n._('Read')

// i18n._('Save locally')

// i18n._('Show in Filemanager')

// i18n._('Sync')

// i18n._('The grant to add records to this container')

// i18n._('The grant to administrate this container')

// i18n._('The grant to delete records in this container')

// i18n._('The grant to edit records in this container')

// i18n._('The grant to export records from this container')

// i18n._('The grant to read records of this container')

// i18n._('The grant to synchronize records with this container')

// if state change -> reload

// if the vnode is cloned with extra props, we can no longer assume its

// if the vnode itself already has a ref, cloneVNode will need to merge

// if this is not a hydration, instance.subTree will be the comment

// import a list of modules into the list

// in Safari 9 which returns 'object' for typed arrays and other constructors.

// in case of path change we need to reload the node (children) as well

// inheritAttrs

// init actions

// initialLoadAfterRender: false,

// inpired by a similar function in mootools library

// internal

// internals.

// istanbul ignore if

// istanbul ignore next

// it's possible the original props was passed in as kebab-case

// iterable protocol

// iterator protocol

// just pass the block element here to avoid a DOM parentNode call.

// key attached in the `createSlots` helper, respect that

// leave

// legacy for reload action

// lifecycle

// lifecycle hooks

// local modules

// local registration

// local resolved assets

// make args available, in function below

// manage runtime depended grants

// mark this expansion as done and check if all are done

// ngettext('Download Link', 'Download Links', n); gettext('Download Link');

// no "this" reference for friendly out of scope calls

// no suspense so unmount hooks fire now

// node core modules

// node specific checks (@TODO what about folders with quarantined contents?)

// not using enums here because it results in computed properties

// note: preserve flag for fragments since they use the flag for children

// note: the exception process needs to be completed before load parent node

// note: we are moving the render call into an async callback,

// objects

// of renderSlot() with no valid children

// of the Fragment itself so it can move its children.

// oldVNode may be an errored async setup() component inside Suspense

// on a vnode's type and calls the `process` method, passing in renderer

// on rowcontextmenu handler

// on selectionchange handler

// only cache other properties when instance has declared (thus stable)

// only folders allowed in virtual folders

// only show if we have a contributing filter

// overwrite default 503 handling and add a link to the wiki

// parent may have changed if it's in a teleport

// pass undefined as the old value when it's changed for the first time

// placeholder.

// post-create lifecycle registrations are noops during SSR (except for serverPrefetch)

// presence of a patch flag indicates this node needs patching on updates.

// preserve space for triggers

// prevent to send accountName here

// private

// props

// props default value

// provide / inject

// prune post-render after `current` has been updated

// public API

// register grants for nodes

// remove content filters if indexing is not enabled

// remove css image flicker

// remove the component if it wasn't buffered

// removes temporarily added items

// require('./GrantsPanel');

// reset own filter

// resolved props and emits options

// return the list of modules as css string

// run default updater

// safari and chrome use the non std. fileX props

// set all grants and mask other checkboxes

// simple cache for applying multiple behaviors to same selector does query multiple times

// slot content array of a dynamic conditional slot may have a branch

// some envs mock window but not fully

// somehow once a month

// sort folder by deep level

// sort new/edited record

// sourceNode != targetNode && source != direct children of target

// state

// suspense related

// the EVENTS flag is only for hydration and if it is the only flag, the

// the leading comma is intentional so empty string "" is also included

// the next vnode so that it can be properly unmounted later.

// the refs so the single vnode can be set on multiple refs

// them since them being non-null during a mount doesn't affect the logic as

// they *should* be copied for kept-alive vnodes. So we just always copy

// they will simply be overwritten.

// this is important for paging and sort header!

// this.defaultContainerPath = Tine.Tinebase.container.getMyFileNodePath();

// this.hasOwnNotificationSettings.setDisabled(!featureEnabled || !hasRequiredGrant || (hasOwnNotificationSettings && !hasAdminGrant))

// this.updateActions(sm, node);

// to be immediately set

// to be set immediately

// try to generate the id here which is used for grid update

// undefined = never times out

// unique to Safari 2

// update record in store to prevent concurrency problems

// update the latest filter here, make sure each gridPanel have their own latest filter

// use 'interna' Ext we create and export here

// use default secured doc preview panel

// user record

// vnode should not be considered dynamic due to handler caching.

// watch

// we do a strict check to return the element with only the id attribute

// when user delete virtual node , make sure delete the related tasks in localstorage

// which also requires the correct parent container

// which means it won't track dependencies - but it's ok because

// which will not have a mounted element

// will be set synchronously right after creation

// works on IE10/11 and Surface

// would prevent it from being tree-shaken.

// };

//@TODO

//@TODO implement selection vs ctxNode if multiselect is allowed

//@TODO it should be possible to register audio/* video/*

//const useOriginalSizeLimit = 30 * 1024 * 1024; // @TODO have pref or conf, but do we really need this for native browser preview ?

//private

//todo: if record is virtual , disable all actions except the delete action
