README
virtualize-tree
Generic manager of tree data.
Virtualize tree data for of directories, nodes or any other data type this library can work with nodejs and browser.
- installation
- basic usage
- add root tree
- add item into tree
- find item
- update item
- remove item
- loop tree
installation
npm i --save virtualize-tree
basic usage
Typescript
import {VirtualizeTree, VirtualizeTreeProperties} from 'virtualize-tree';
interface Directory {
name: string;
size: number;
}
const propertiesVirtualizeTree: VirtualizeTreeProperties<Directory> = {
isEqual: function(directory1: Directory, directory2: Directory): boolean {
return (directory1.name === directory2.name && directory1.size === directory2.size);
}
};
const directoryTree = new VirtualizeTree(propertiesVirtualizeTree);
JavaScript
import {VirtualizeTree} from 'virtualize-tree';
const propertiesVirtualizeTree = {
isEqual: function(directory1, directory2) {
return (directory1.name === directory2.name && directory1.size === directory2.size);
}
};
const directoryTree = new VirtualizeTree(propertiesVirtualizeTree);
Javascript (CommonJS)
const {VirtualizeTree} = require('virtualize-tree');
const propertiesVirtualizeTree = {
isEqual: function(directory1, directory2) {
return (directory1.name === directory2.name && directory1.size === directory2.size);
}
};
const directoryTree = new VirtualizeTree(propertiesVirtualizeTree);
add root tree
const directoryRoot: Directory = {
name: "foobar",
size: 1024
};
directoryTree.registerRoot(directoryRoot);
add item into tree
const firstDirectory: Directory = {
name: "docs",
size: 512
};
directoryTree.add(directoryRoot, firstDirectory)
.then((hasBeenAdded: boolean): void => {
if(hasBeenAdded) {
console.log(`${child.name} directory has been added into ${directoryRoot.name} directory`);
} else {
console.error(`oops, ${directoryRoot.name} not exists into tree`);
}
});
find item
the Virtualize tree use a wrap for add the items into tree during a find item or during a loop of tree, you receive the wrap of item that is a VirtualizeTreeContainer
interface VirtualizeTreeContainer<Item> {
/**
* @var {Item} item - ref to natural item
*/
item: Item;
/**
* @var {number} deep - deep level this item, root is `0`
*/
deep: number;
/**
* @var {Item} parent - ref to parent **container item** only root is `null`
*/
parent: VirtualizeTreeContainer<Item> | null;
/**
* @var {VirtualizeTreeContainer<Item>[] | null} childrens - list of childrens **container items** for this item
*/
childrens: VirtualizeTreeContainer<Item>[] | null;
};
const directoryToSearch = {
name: "docs",
size: 512
};
directoryTree.find(directoryToSearch)
.then((wrapDirectoryFind: Promise<VirtualizeTreeContainer<Directory>> | null): void => {
if(wrapDirectoryFind) {
// wrapDirectoryFind.parent is null as long as wrapDirectoryFind is tree root
console.log(`${wrapDirectoryFind.item.name} has been find to deep level ${wrapDirectoryFind.deep}, has ${wrapDirectoryFind.parent?.item.name} as parent directory`)
} else {
console.log(`${directoryToSearch} is not into tree`);
}
});
update item
const lastDirectory: Directory = {
name: "foobar",
size: 42
};
directoryTree.update(lastDirectory, {
name: "new foobar",
size: 43
})
.then((hasChange: boolean): void => {
if(hasChange) {
console.log('last directory has been update');
} else {
console.log('last directory not exists into tree')
}
});
Note: the update
method should be use as long as not know if item to update exists into tree,
else update directly property item
of VirtualizeTreeContainer<Item>
the update are apply into tree by object reference
directoryTree.find({
name: "foobar",
size: 42
})
.then((directory: VirtualizeTreeContainer<Directory> | null): void => {
if(directory) {
directory.item = {
name: "new foobar",
size: 43
};
} else {
console.log(`${directory.name} not exists into tree`);
}
});
remove item
Can remove any item of tree from method remove(item: Item): Promise<boolean>
during remove a item VirtualizeTree use isEqual
callback from properties of constructor for verify equality between 2 items.
const directoryToRemove: Directory = {
name: "foobar",
size: 42
};
directoryTree.remove(directoryToRemove)
.then((hasRemove: boolean): void => {
if(hasRemove) {
console.log(`directory ${directoryToRemove.name} has been remove of tree`);
} else {
console.log(`directory ${directoryToRemove.name} has not been find into tree`);
}
});
loop tree
VirtualizeTree provide a generic class for loop a tree (LoopTree
) that implement Symbol.asyncIterator method, from async function
you can use for...await
loop with instance of LoopTree
import {LoopTree, LoopTreeProperties} from 'virtualize-tree/LoopTree';
const loopTreeProperties: LoopTreeProperties<VirtualizeTreeContainer<Directory>> = {
tree: directoryTree.containerRoot
};
const looper = new LoopTree(loopTreeProperties);
(async () => {
for await(const wrapDirectory of looper) {
// wrapDirectory: VirtualizeTreeContainer<Directory>
console.log(wrapDirectory);
const directory: Directory = wrapDirectory.item;
}
})();
Alternative way loop the tree directly from instance of tree is use method foreach(callback: (item: VirtualizeTreeContainer<Item>) => void): void
directoryTree.forEach((wrapDirectory: VirtualizeTreeContainer<Directory>): void => {
const directory: Directory = wrapDirectory.item;
/* ... */
});