jdat

A wrapper for an array of models with a JQuery like syntax

jdat

A wrapper for an array of models with a JQuery like syntax

$ npm install jdat

jdat will add methods to an object prototype:

var jdat = require('jdat');
 
var HeroClass = function(arr){
  this.models = arr;
}
 
HeroClass.prototype.halfspeed = function(){
  return this.models[0].speed/2;
}
 
 
jdat({
  // the prototype we will extend 
  proto:HeroClass.prototype,
  // the field of the prototype that contains an array of models 
  field:'models',
  // the field of each model that is a child array of models 
  childfield:'children',
  // a function to return a new instance from an array of models 
  spawn:function(data){
    return new HeroClass(data);
  }
})
 
 
var herodata = [{
  name:'Superman',
  speed:9,
  children:[...]
},{
  name:'Spiderman',
  speed:8,
  children:[...]
},{
  name:'SilverSurfer',
  speed:11,
  children:[...]
}]
 
 
var heroes = new HeroClass(herodata);
 
var speeds = heroes.map(function(hero){
  return hero.get(0).speed;
})
 
var silver = heroes.eq(2);
 
silver.children().forEach(function(silverchild){
  // silverchild is a HeroClass with the children as models 
})
 
heroes
  .descendents()
  .each(function(instance){
    console.log(instance.get(0).name);
  })

Assign the jdat methods to a prototype - the options are:

  • proto - the prototype we will extend
  • models - the field of the prototype that contains an array of models
  • childfield - the field of each model that is a child array of models
  • spawn - a function to return a new instance from an array of models

Return an instance containing all children of the models in the array:

testdata.children().forEach(function(instance){
  console.log(instance.models[0].name);
})
 
// Superman 

Return an instance containing all descendents of the models in the array:

testdata.descendents().forEach(function(instance){
  console.log(instance.models[0].name);
})
 
// Superman & children names 
// Spiderman & children names 
// SilverSurfer & children names 

Run a function over each of the descendents turned into a new instance:

testdata.recurse(function(instance){
  console.log(instance.models[0].name);
})
 
// Superman & children names 
// Spiderman & children names 
// SilverSurfer & children names 

Loop over each model in the array and pass a spawned instance to a function:

testdata.each(function(item){
  console.log(item.models[0].name);
})
 
// Superman 
// Spiderman 
// SilverSurfer 

Loop over each model in the array and pass a spawned instance to a function and return the mapped results:

var names = testdata.map(function(item){
  return item.models[0].name.toUpperCase();
})
 
// SUPERMAN 
// SPIDERMAN 
// SILVERSURFER 

Return an instance of the class with the model from 'index' as the only model in the array:

var secondone = testdata.eq(1);
 
console.log(secondone.models[0].name);
 
// Spiderman 

Return an instance with only the first model in its collection:

var first = testdata.first();
 
console.log(first.models[0].name);
 
// Superman 

Return an instance with only the last model in its collection:

var first = testdata.last();
 
console.log(first.models[0].name);
 
// SilverSurfer 

Return the raw model in the model array at 'index':

var secondmodel = testdata.get(1);
 
console.log(secondmodel.name);
 
// Spiderman 

Return the length of the model array

var count = testdata.count();
 
console.log(count);
 
// 3 

Return an instance that has a copy (JSON.stringify / JSON.parse) of the models:

var newone = testdata.clone();

Use the factory function to return new instances of the class with different data:

var newone = testdata.spawn([{
    name:'otherdata'
}])

Return an array of instances each with only one model in their array:

var instances = testdata.instances();
 
console.log(instances.length);
 
// 3 

MIT