/**
 * @class Ext.data.TreeStore
 * @extend Ext.data.Store
 * @alias store.tree
 *
 * The TreeStore is a store implementation that owns the {@link #cfg-root root node} of
 * a tree, and provides methods to load either local or remote data as child nodes of the root
 * and any descendant non-leaf node.
 *
 * The TreeStore must be used as the store of a {@link Ext.tree.Panel tree panel}.
 *
 * This class also relays many node events from the underlying node structure.
 *
 * # Using Models
 *
 * If no Model is specified, an implicit model will be created that extends {@link Ext.data.TreeModel}.
 * The standard Tree fields will also be copied onto the Model for maintaining their state. These fields are listed
 * in the {@link Ext.data.NodeInterface} documentation.
 *
 * # Reading Nested Data
 *
 * For the tree to read nested data, the {@link Ext.data.reader.Reader} must be configured with a root property,
 * so the reader can find nested data for each node (if a root is not specified, it will default to
 * 'children'). This will tell the tree to look for any nested tree nodes by the same keyword, i.e., 'children'.
 * If a root is specified in the config make sure that any nested nodes with children have the same name.
 * 
 * **Note:** Setting {@link #defaultRootProperty} accomplishes the same thing.
 * 
 * #rootProperty as a Function
 * You can pass a function as the data reader's rootProperty when the tree's dataset has 
 * mixed root properties. Child nodes can then be programmatically determined at read time.  
 * 
 * For example, the child nodes may be passed via the 'children' property 
 * name, though you may have a top-level root property of 'items'.  
 * 
 * See {@link Ext.data.reader.Reader#rootProperty rootProperty} for more information.
 *
 * #Filtering#
 * Filtering of nodes in a TreeStore is hierarchically top down by default. This means that if a non-leaf node does not
 * pass the filter, then it, and all its descendants are filtered *out* of the store.
 *
 * To reverse this, so that any node which passes the filter causes all its ancestors to be visible, configure
 * the `TreeStore` with '{@link #cfg-filterer filterer: 'bottomup'}`
 *
 * You may also programatically filter individual tree nodes by setting their `'visible'` field.
 *
 * Setting this to `false` filters the node out so that it will not appear in the UI. Setting it to `true`
 * filters the node in.
 *
 * Note that if performing several filter operations, it is best to {@link #method-suspendEvents}
 * on the store first, and when all nodes have been modified, {@link #method-resumeEvents} and fire the
 * {@link #event-refresh} event on the store.
 */
 
/**
 * @property {Boolean} [isTreeStore=true]
 * `true` in this class to identify an object as an instantiated TreeStore, or subclass thereof.
 */
 
/**
 * @cfg {Ext.data.TreeModel/Ext.data.NodeInterface/Object} root
 * @accessor
 * The root node for this store. For example:
 *
 *     root: {
 *         expanded: true,
 *         text: "My Root",
 *         children: [
 *             { text: "Child 1", leaf: true },
 *             { text: "Child 2", expanded: true, children: [
 *                 { text: "GrandChild", leaf: true }
 *             ] }
 *         ]
 *     }
 *
 * Setting the `root` config option is the same as calling {@link #setRootNode}.
 *
 * It's important to note that setting expanded to true on the root node will cause
 * the tree store to attempt to load.  This will occur regardless the value of
 * {@link Ext.data.ProxyStore#autoLoad autoLoad}. If you you do not want the store
 * to load on instantiation, ensure expanded is false and load the store when you're ready.
 *
 */
 
/**
 * @cfg {Boolean} [rootVisible=false]
 * `false` to not include the root node in this Stores collection.
 * @accessor
 */
 
/**
 * @cfg {String} [defaultRootProperty="children"]
 * @accessor
 */
 
/**
 * @cfg {String} [parentIdProperty]
 * This config allows node data to be returned from the server in linear format
 * without having to structure it into `children` arrays.
 *
 * This property specifies which property name in the raw node data yields the id of the parent node.
 *
 * For example the following data would be read into a geographic tree by
 * configuring the TreeStore with `parentIdProperty: 'parentId'`.
 *
 * The node data contains an upward link to a parent node.
 *
 *     data: [{
 *         name: 'North America',
 *         id: 'NA'
 *     }, {
 *         name: 'Unites States',
 *         id: 'USA',
 *         parentId: 'NA'
 *     }, {
 *         name: 'Redwood City',
 *         leaf: true,
 *         parentId: 'USA'
 *     }, {
 *         name: 'Frederick, MD',
 *         leaf: true,
 *         parentId: 'USA'
 *     }]
 *
 * @accessor
 */
 
/**
 * @cfg {Boolean} [clearOnLoad=true]
 * Remove previously existing child nodes before loading.
 * @accessor
 */
 
/**
 * @cfg {Boolean} [clearRemovedOnLoad=true]
 * If `true`, when a node is reloaded, any records in the {@link #removed} record
 * collection that were previously descendants of the node being reloaded will be
 * cleared from the {@link #removed} collection.
 * Only applicable if {@link #clearOnLoad} is `true`.
 * @accessor
 */
 
/**
 * @cfg {String} [nodeParam="node"]
 * The name of the parameter sent to the server which contains the identifier of the node.
 * @accessor
 */
 
/**
 * @cfg {String} [defaultRootId="root"]
 * The default root id.
 * @accessor
 */
 
/**
 * @cfg {String} [defaultRootText="Root"]
 * The default root text (if not specified)
 * @accessor
 */
 
/**
 * @cfg {Boolean} [folderSort=false]
 * Set to true to automatically prepend a leaf sorter.
 * @accessor
 */
 
/**
 * @cfg {Number} pageSize 
 * @hide
 * @accessor
 */
 
/**
 * @cfg {String} [filterer="topdown"]
 * The order in which to prioritize how filters are applied to nodes.
 *
 * The default, `'topdown'` means that if a parent node does *not* pass the filter, then the branch
 * ends there, and no descendant nodes are filtered in, even if they would pass the filter.
 *
 * By specifying `'bottomup'`, if a leaf node passes the filter, then all its ancestor nodes are filtered
 * in to allow it to be visible.
 * @since 6.0.2
 */
 
/**
 * @cfg {Boolean} [lazyFill=false]
 * Set to true to prevent child nodes from being loaded until the the node is
 * expanded or loaded explicitly.
 */
 
/**
 * @cfg {Object[]/String[]} fields
 * @inheritdoc Ext.data.Model#cfg-fields
 *
 * @localdoc **Note:** If you wish to create a Tree*Grid*, and configure your tree with a
 * {@link Ext.panel.Table#cfg-columns columns} configuration, it is possible to
 * define the set of fields you wish to use in the Store instead of configuring the
 * store with a {@link #cfg-model}.
 *
 * By default, the Store uses an {@link Ext.data.TreeModel}. If you configure
 * fields, it uses a subclass of {@link Ext.data.TreeModel} defined with the set of
 * fields that you specify (in addition to the fields which it uses for storing
 * internal state).
 */
 
/**
 * @event nodeappend
 * @inheritdoc Ext.data.NodeInterface#append
 */
/**
 * @event noderemove
 * @inheritdoc Ext.data.NodeInterface#remove
 */
/**
 * @event nodemove
 * @inheritdoc Ext.data.NodeInterface#move
 */
/**
 * @event nodeinsert
 * @inheritdoc Ext.data.NodeInterface#insert
 */
/**
 * @event nodebeforeappend
 * @inheritdoc Ext.data.NodeInterface#beforeappend
 */
/**
 * @event nodebeforeremove
 * @inheritdoc Ext.data.NodeInterface#beforeremove
 */
/**
 * @event nodebeforemove
 * @inheritdoc Ext.data.NodeInterface#beforemove
 */
/**
 * @event nodebeforeinsert
 * @inheritdoc Ext.data.NodeInterface#beforeinsert
 */
/**
 * @event nodeexpand
 * @inheritdoc Ext.data.NodeInterface#expand
 */
/**
 * @event nodecollapse
 * @inheritdoc Ext.data.NodeInterface#collapse
 */
/**
 * @event nodebeforeexpand
 * @inheritdoc Ext.data.NodeInterface#beforeexpand
 */
/**
 * @event nodebeforecollapse
 * @inheritdoc Ext.data.NodeInterface#beforecollapse
 */
/**
 * @event nodesort
 * @inheritdoc Ext.data.NodeInterface#sort
 */
 
 
/**
 * @event rootchange
 * Fires any time the tree's root node changes.
 * @param {Ext.data.TreeModel/Ext.data.NodeInterface} newRoot The new root
 * @param {Ext.data.TreeModel/Ext.data.NodeInterface} oldRoot The old root
 */
 
/**
 * @method getById
 * @inheritdoc Ext.data.LocalStore
 * @localdoc **NOTE:** TreeStore's getById method will only search nodes that
 * are expanded (all ancestor nodes are {@link Ext.data.NodeInterface#expanded
 * expanded}: true -- {@link Ext.data.NodeInterface#isExpanded isExpanded})
 *
 * See also {@link #getNodeById}
 */
 
/**
 * @method each
 * Calls the specified function for each {@link Ext.data.NodeInterface node} in the store.
 *
 * When store is filtered, only loops over the filtered records unless the `bypassFilters` parameter is `true`.
 *
 * @param {Function} fn The function to call. The {@link Ext.data.Model Record} is passed as the first parameter.
 * Returning `false` aborts and exits the iteration.
 * @param {Object} [scope] The scope (`this` reference) in which the function is executed.
 * Defaults to the current {@link Ext.data.NodeInterface node} in the iteration.
 * @param {Object/Boolean} [includeOptions] An object which contains options which
 * modify how the store is traversed. Alternatively, this parameter can be just the
 * `filtered` option.
 * @param {Boolean} [includeOptions.filtered] Pass `true` to include filtered out
 * nodes in the iteration.
 * @param {Boolean} [includeOptions.collapsed] Pass `true` to include nodes which are
 * descendants of collapsed nodes.
 */
 
/**
 * @method collect
 * Collects unique values for a particular dataIndex from this store.
 *
 * @param {String} dataIndex The property to collect
 * @param {Object/Boolean} [options] An object which contains options which modify how
 * the store is traversed. Or just the `allowNull` option.
 * @param {Boolean} [options.allowNull] Pass true to allow null, undefined or empty
 * string values.
 * @param {Boolean} [options.filtered] Pass `true` to collect from all records, even
 * ones which are filtered.
 * @param {Boolean} [options.collapsed] Pass `true` to include nodes which are
 * descendants of collapsed nodes.
 *
 * @param {Boolean} [filtered] If previous parameter (`options`) is just the
 * `allowNull` value, this parameter is the `filtered` option.
 *
 * @return {Object[]} An array of the unique values
 */
 
/**
 * @method getNodeById
 * Returns the record node by id regardless of visibility due to collapsed states;
 * all nodes present in the tree structure are available.
 * @param {String} id The id of the node to get.
 * @return {Ext.data.NodeInterface}
 */
 
/**
 * @method findNode
 * Finds the first matching node in the tree by a specific field value regardless of visibility
 * due to collapsed states; all nodes present in the tree structure are searched.
 *
 * @param {String} fieldName The name of the Record field to test.
 * @param {String/RegExp} value Either a string that the field value
 * should begin with, or a RegExp to test against the field.
 * @param {Boolean} [startsWith=true] Pass `false` to allow a match to start
 * anywhere in the string. By default the `value` will match only at the start
 * of the string.
 * @param {Boolean} [endsWith=true] Pass `false` to allow the match to end before
 * the end of the string. By default the `value` will match only at the end of the
 * string.
 * @param {Boolean} [ignoreCase=true] Pass `false` to make the `RegExp` case
 * sensitive (removes the 'i' flag).
 * @return {Ext.data.NodeInterface} The matched node or null
 */
 
/**
 * Marks this store as needing a load. When the current executing event handler exits,
 * this store will send a request to load using its configured {@link #proxy}.
 *
 * **Be aware that it is not usually valid for a developer to call this method on a TreeStore.**
 *
 * TreeStore loads are triggered by a load request from an existing {@link Ext.data.NodeInterface tree node},
 * when the node is expanding, and it has no locally defined children in its data.
 *
 * *Note:* Even for synchronous Proxy types such as {@link Ext.data.proxy.Memory memory proxy},
 * the result will *NOT* be available in the following line of code. You must use a callback
 * in the load options, or a {@link #event-load load listener}.
 *
 * @param {Object} [options] This is passed into the {@link Ext.data.operation.Operation Operation}
 * object that is created and then sent to the proxy's {@link Ext.data.proxy.Proxy#read} function.
 * The options can also contain a node, which indicates which node is to be loaded. If not specified, it will
 * default to the root node.
 * @param {Ext.data.NodeInterface} [options.node] The tree node to load. Defaults to the store's {@link #cfg-root root node}
 * @param {Function} [options.callback] A function which is called when the response arrives.
 * @param {Ext.data.Model[]} options.callback.records Array of records.
 * @param {Ext.data.operation.Operation} options.callback.operation The Operation itself.
 * @param {Boolean} options.callback.success `true` when operation completed successfully.
 * @method load
 */
 
/**
 * @method reload
 * Reloads the root node of this store.
 */
 
/**
 * @method flushLoad
 * Called when the event handler which called the {@link #method-load} method exits.
 */
 
/**
 * @method isVisible
 * @inheritdoc Ext.data.NodeStore#isVisible
 */
 
/**
 * @event load
 * Fires whenever the store reads data from a remote data source.
 * @param {Ext.data.TreeStore} this
 * @param {Ext.data.TreeModel[]} records An array of records.
 * @param {Boolean} successful True if the operation was successful.
 * @param {Ext.data.Operation} operation The operation that triggered this load.
 * @param {Ext.data.NodeInterface} node The node that was loaded.
 */