What is jsTree?
jsTree is jquery plugin, that provides interactive trees. It is absolutely free, open source and distributed under the MIT license. jsTree is easily extendable, themable and configurable, it supports HTML & JSON data sources and AJAX loading.
jsTree functions properly in either box-model (content-box or border-box), can be loaded as an AMD module, and has a built in mobile theme for responsive design, that can easily be customized. It uses jQuery's event system, so binding callbacks on various events in the tree is familiar and easy.
Just a few of the features worth noting:
- drag & drop support
- keyboard navigation
- inline edit, create and delete
- tri-state checkboxes
- fuzzy searching
- customizable node types
- Root node 1
- initially selected
- custom icon URL
- initially open
- Another node
- Custom icon class (bootstrap)
- Root node 2
Getting Started - everything at a glance
-
Download jsTree
All the files you need are in the
dist/
folder of the download. -
Include a jsTree theme
Themes can be autloaded too, but it is best for performance to include the CSS file.
<link rel="stylesheet" href="dist/themes/default/style.min.css" />
-
Setup a container
This is the element where you want the tree to appear, a
<div>
is enough. This example has a nested<ul>
as there is no other data source configured (such as JSON).<div id="jstree_demo_div"></div>
-
Include jQuery
jsTree requires 1.9.0 or greater in your webpage.
<script src="dist/libs/jquery.js"></script>
-
Include jsTree
For production include the minified version:
dist/jstree.min.js
, there is a development version too:dist/jstree.js
<script src="dist/jstree.min.js"></script>
-
Create an instance
Once the DOM is ready you can start creating jstree instances.
$(function () { $('#jstree_demo_div').jstree(); });
-
Listen for events
jsTree uses events to notify you when something changes while users (or you) interact with the tree. So binding to jstree events is as easy binding to a click. There is a list of events and what information they provide in the API documentation.
$('#jstree_demo_div').on("changed.jstree", function (e, data) { console.log(data.selected); });
-
Interact with your instances
Once an instance is ready you can invoke methods on it. There is a list of available methods in the API documentation. The three examples below do exactly the same thing
$('button').on('click', function () { $('#jstree').jstree(true).select_node('child_node_1'); $('#jstree').jstree('select_node', 'child_node_1'); $.jstree.reference('#jstree').select_node('child_node_1'); });
Configuring instances
Creating an instance as described in the overview does not modify any of the defaults:
$('#jstree').jstree();
You can change the defaults for all future instances:
$.jstree.defaults.core.themes.variant = "large";
$('#jstree').jstree();
But most of the time you will want to change the defaults only for the instance that is being created. This is achieved by passing in a config object when creating the instance:
$('#jstree').jstree({
"plugins" : [ "wholerow", "checkbox" ]
});
As seen in the previous example - there is one special key in the config object named plugins
. It is an array of strings, which contain the names of the plugins you want active on that instance.
All options that do not depend on a plugin are contained in a key of the config object named core
, the options for each plugin are contained within a key with the same name as the plugin:
$('#jstree').jstree({
"core" : {
"themes" : {
"variant" : "large"
}
},
"checkbox" : {
"keep_selected_style" : false
},
"plugins" : [ "wholerow", "checkbox" ]
});
You can have a look at all the options and their default values. This list is what you can configure on each instance.
For example, by default the tree allows multiple selection as stated in $.jstree.defaults.core.multiple
, to overwrite that make sure your config object contains "core" : { "multiple" : false }
. If you have multiple overrides for the same key (like "core"
here), group them:
$("#jstree").jstree({
"core" : {
"multiple" : false,
"animation" : 0
}
});
Populating a tree using HTML
Basic markup
jsTree can turn a regular unordered list into a tree. The minimal required markup is a <ul>
node with some nested <li>
nodes with some text inside.
You should have a container wrapping the <ul>
and create the instance on that container. Like so:$('#html1').jstree();
.
<div id="html1">
<ul>
<li>Root node 1</li>
<li>Root node 2</li>
</ul>
</div>
- Root node 1
- Root node 2
Nodes with children
To create a node with child nodes simpy nest an <ul>
.
Internally jstree converts the text to a link, so if there already is a link in the markup jstree won't mind. Like Child node 2
.
Clicking on the link however will not direct the user to a new page, to do that - intercept the changed.jstree
event and act accordingly.
Keep reading for the section on handling events.
<div id="html1">
<ul>
<li>Root node 1
<ul>
<li>Child node 1</li>
<li><a href="#">Child node 2</a></li>
</ul>
</li>
</ul>
</div>
- Root node 1
- Child node 1
- Child node 2
Setting initial state with classes
To make a node initially selected you can set the jstree-clicked
class on the <a>
element.
Similarly you can set the jstree-open
class on any <li>
element to make it initially extended, so that its children are visible.
It is a good idea to give your nodes unique IDs by adding the id
attribute to any <li>
element. This will be useful if you need to sync with a backend as you will get the ID back in any events jstree triggers.
…
<li class="jstree-open" id="node_1">Root</li>
<ul>
<li>
<a href="#" class="jstree-clicked">Child</a>
</li>
</ul>
</li>
…
- Root
Setting initial state with data attribute
You can also set the state on a node using a data-jstree
attribute.
You can use any combination of the following: opened
, selected
, disabled
, icon
.
Specifying an address (anything containing a /
) will display that image as the node icon. Using a string will apply that class to the <i>
element that is used to represent the icon.
For example if you are using Twitter Bootstrap you can use "icon" : "glyphicon glyphicon-leaf"
to display a leaf icon.
<li data-jstree='{"opened":true,"selected":true}'>Root
<ul>
<li data-jstree='{"disabled":true}'>Child</li>
<li data-jstree='{"icon":"http://jstree.com/tree.png"}'>
Child</li>
<li data-jstree='{"icon":"glyphicon glyphicon-leaf"}'>
Child</li>
</ul>
</li>
- Root
- Child
- Child
- Child
Loading with AJAX
You can also use AJAX to populate the tree with HTML your server returns. The format remains the same as the above, the only difference is that the HTML is not inside the container, but returned from the server.
To take advantage of this option you need to use the $.jstree.defaults.core.data
config option.
Just use a standard jQuery-like AJAX config and jstree will automatically make an AJAX request populate the tree with the response.
Add a class of jstree-closed
to any LI node you return and do not nest an UL node and jstree will make another AJAX call as soon as the user opens this node.
In addition to the standard jQuery ajax options here you can supply functions for data
and url
, the functions will be run in the current instance's scope and a param will be passed indicating which node is being loaded, the return value of those functions will be used as URL and data respectively.
$('#tree').jstree({
'core' : {
'data' : {
'url' : 'ajax_nodes.html',
'data' : function (node) {
'url' : 'ajax_nodes.html',
'data' : function (node) {
return { 'id' : node.id };
}
}
}
});
// Example response:
<ul>
<li>Node 1</li>
<li class="jstree-closed">Node 2</li>
</ul>
Populating the tree using JSON
The format
jsTree needs a specific format to work with JSON. In the standard syntax no fields are required - pass only what you need. Keep in mind you will be able to access any additional properties you specify - jsTree won't touch them and you will be able to use them later on.
To change the icon of the node use the icon
property. Specifying a string containing a /
will display that image as the node icon. Using any other string will apply that class to the <i>
element that is used to represent the icon. You can use boolean false
to make jsTree render the node with no icon.
You can set the state on a node using the state
property. Use any combination of the following: opened
, selected
, disabled
.
Both li_attr
and a_attr
are passed directly to jQuery's attr function.
When using AJAX set children
to boolean true
and jsTree will render the node as closed and make an additional request for that node when the user opens it.
Any nested children should either be objects following the same format, or plain strings (in which case the string is used for the node's text and everything else is autogenerated).
// Expected format of the node (there are no required fields)
{
id : "string" // will be autogenerated if omitted
text : "string" // node text
icon : "string" // string for custom
state : {
opened : boolean // is the node open
disabled : boolean // is the node disabled
selected : boolean // is the node selected
},
children : [] // array of strings or objects
li_attr : {} // attributes for the generated LI node
a_attr : {} // attributes for the generated A node
}
Alternative JSON format
If you do not want to use the nested children
approach, you can use the alternative syntax where each node object has two required fields: id
& parent
and no children
property (everything else remains the same).
jsTree will automatically build the hierarchy. To indicate a node should be a root node set its parent
property to "#"
.
This should be used mainly when you render the whole tree at once and is useful when data is stored in a database using adjacency.
// Alternative format of the node (id & parent are required)
{
id : "string" // required
parent : "string" // required
text : "string" // node text
icon : "string" // string for custom
state : {
opened : boolean // is the node open
disabled : boolean // is the node disabled
selected : boolean // is the node selected
},
li_attr : {} // attributes for the generated LI node
a_attr : {} // attributes for the generated A node
}
Using JSON
To populate the tree with a JSON object you need to use the $.jstree.defaults.core.data
config option.
The expected format is an array of nodes, where each node should be an object as described above or a simple string (in which case the string is used for the node's text property and everything else is autogenerated). Any nested nodes are supplied in the same manner in the children
property of their parent.
$('#using_json').jstree({ 'core' : {
'data' : [
'Simple root node',
{
'text' : 'Root node 2',
'state' : {
'opened' : true,
'selected' : true
},
'children' : [
{ 'text' : 'Child 1' },
'Child 2'
]
}
]
} });
Using the alternative JSON format
$('#using_json_2').jstree({ 'core' : {
'data' : [
{ "id" : "ajson1", "parent" : "#", "text" : "Simple root node" },
{ "id" : "ajson2", "parent" : "#", "text" : "Root node 2" },
{ "id" : "ajson3", "parent" : "ajson2", "text" : "Child 1" },
{ "id" : "ajson4", "parent" : "ajson2", "text" : "Child 2" },
]
} });
Using AJAX
You can also use AJAX to populate the tree with JSON your server returns. The format remains the same as the above, the only difference is that the JSON is not inside the config object, but returned from the server.
To take advantage of this option you need to use the $.jstree.defaults.core.data
config option.
Just use a standard jQuery-like AJAX config and jstree will automatically make an AJAX request populate the tree with the response.
In addition to the standard jQuery ajax options here you can supply functions for data
and url
, the functions will be run in the current instance's scope and a param will be passed indicating which node is being loaded, the return value of those functions will be used as URL and data respectively.
If you do not return correct json headers from the server, at least set the dataType
jQuery AJAX option to "json"
.
$('#tree').jstree({
'core' : {
'data' : {
'url' : function (node) {
return node.id === '#' ?
'ajax_roots.json' :
'ajax_children.json';
},
'data' : function (node) {
return { 'id' : node.id };
}
}
});
Using a function
You can supply a function too. That function will receive two arguments - the node being loaded and a callback function to call with the children for that node once you are ready.
$('#tree').jstree({
'core' : {
'data' : function (obj, cb) {
cb.call(this,
['Root 1', 'Root 2']);
}
}});
Listening for events
jsTree triggers various events on the container. You can review the list of all events to know what to listen for.
To get more information about the event inspect its data
argument.
In most cases where a node is involved you will get the whole node object passed in. If you get an ID string somewhere and want to inspect the node just use .get_node().
$('#jstree')
// listen for event
.on('changed.jstree', function (e, data) {
var i, j, r = [];
for(i = 0, j = data.selected.length; i < j; i++) {
r.push(data.instance.get_node(data.selected[i]).text);
}
$('#event_result').html('Selected: ' + r.join(', '));
})
// create the instance
.jstree();
- Root 1
- Child 1
- Child 2
- Root 2
- Child 3
- Child 4
Invoking methods on an instance
true
To invoke a method on an instance you must obtain a reference of the instance and invoke the method. The example shows how to obtain a reference and invoke a method.
Check the API for a list of available methods.
// 3 ways of doing the same thing
$('#jstree').jstree(true)
.select_node('mn1');
$('#jstree')
.jstree('select_node', 'mn2');
$.jstree.reference('#jstree')
.select_node('mn3');
- Node 1
- Node 2
- Node 3
Basic AJAX demo
demo
folder of the downloadFilebrowser demo
Database demo
Plugins?
jsTree has some functionality moved out of the core so you can only use it when you need it. To enable a plugin use the plugins
config option and add that plugin's name to the array.
For example enabling all the plugins can be done this way:"plugins" : [ "checkbox", "contextmenu", "dnd", "search", "sort", "state", "types", "unique", "wholerow" ]
Here is a quick overview for each one.
Checkbox plugin
This plugin renders checkbox icons in front of each node, making multiple selection much easier.
It also supports tri-state behavior, meaning that if a node has a few of its children checked it will be rendered as undetermined, and state will be propagated up. You can also fine tune the cascading options with the cascade config option.
Keep in mind when cascading checkbox will check even disabled nodes.
Undetermined state is automatically calculated, but if you are using AJAX and loading on demand and want to render a node as underemined pass "undetermined" : true
in its state.
You can find all the checkbox plugin config options in the API.
$(function () {
$("#plugins1").jstree({
"checkbox" : {
"keep_selected_style" : false
},
"plugins" : [ "checkbox" ]
});
});
- Root node
- Child node 1
- Child node 2
Contextmenu plugin
This plugin makes it possible to right click nodes and shows a list of configurable actions in a menu.
You can find all the contextmenu plugin config options in the API.
$(function () {
$("#plugins2").jstree({
"core" : {
// so that create works
"check_callback" : true
},
"plugins" : [ "contextmenu" ]
});
});
- Root node
- Context click me
Drag & drop plugin
This plugin makes it possible to drag and drop tree nodes and rearrange the tree.
You can find all the dnd plugin config options in the API.
$(function () {
$("#plugins3").jstree({
"core" : {
"check_callback" : true
},
"plugins" : [ "dnd" ]
});
});
- Root node
- Child node 1
- Child node 2
- Root node 2
Search plugin
This plugin adds the possibility to search for items in the tree and even to show only matching nodes.
You can find all the search plugin config options in the API.
$(function () {
$("#plugins4").jstree({
"plugins" : [ "search" ]
});
var to = false;
$('#plugins4_q').keyup(function () {
if(to) { clearTimeout(to); }
to = setTimeout(function () {
var v = $('#plugins4_q').val();
$('#plugins4').jstree(true).search(v);
}, 250);
});
});
- Root node
- Child node 1
- Child node 2
- Root node 2
Sort plugin
This plugin automatically arranges all sibling nodes according to a comparison config option function, which defaults to alphabetical order.
$(function () {
$("#plugins5").jstree({
"plugins" : [ "sort" ]
});
});
- Root node
- 2
- 1
- 3
- 0
- Root node 2
State plugin
This plugin saves all opened and selected nodes in the user's browser, so when returning to the same tree the previous state will be restored.
You can find all the state plugin config options in the API. Make a selection and refresh this page to see the change persisted.
$(function () {
$("#plugins6").jstree({
"state" : { "key" : "demo2" },
"plugins" : [ "state" ]
});
});
- Root node
- A
- few
- more
- nodes
- Root node 2
Types plugin
This plugin makes it possible to add predefined types for groups of nodes, which means to easily control nesting rules and icon for each group.
To set a node's type you can use set_type
or supply a type
property with the node's data.
You can find all the types plugin config options & functions in the API.
$(function () {
$("#plugins7").jstree({
"types" : {
"default" : {
"icon" : "glyphicon glyphicon-flash"
},
"demo" : {
"icon" : "glyphicon glyphicon-ok"
}
},
"plugins" : [ "types" ]
});
});
- Root node
- Node
- Root node 2
Unique plugin
Enforces that no nodes with the same name can coexist as siblings. This plugin has no options, it just prevents renaming and moving nodes to a parent, which already contains a node with the same name.
$(function () {
$("#plugins8").jstree({
"core" : {
"check_callback" : true
},
"plugins" : [ "unique", "dnd" ]
});
});
- Root node
- Node
- Root node 2
- Node
Wholerow plugin
Makes each node appear block level which makes selection easier. May cause slow down for large trees in old browsers.
$(function () {
$("#plugins9").jstree({
"plugins" : [ "wholerow" ]
});
});
- Root node
- Node
- Root node 2