dson

Dynamic Stateful Object Notation

JSON extension that preserves type information for sharing code between server and client

Example

shared-class.js

function ClassName(info) {
	this.info = info
}

DSON.register('$classname', ClassName)

server.js

var ClassName = require('./shared-class');

app.use(bodyParser({
	reviver: DSON.reviver
}));

app.get('/data', function(req, res){
	res.send({obj: new ClassName({hello: 'world'})})
})

client.js

var ClassName = require('./shared-class');

$.get('/data', function(data) {
	data = DSON.parse(data);
	console.log(data.obj instanceof ClassName) // => true
})

Pre-registered (can be overwritten)

Array $array — only used if there are non-numerical properties

var arr = ['asdf', {}, 6]

arr.special = true;

var copy = DSON.parse(DSON.stringify(arr));

console.log(arr.special) // => true

RegExp $regex

Date $date

Function $function

DSON.register(id, constructor, [serialize], [construct], [options])

@param	{String} 			id				unique identifier for serialization

@param	{Function} 			constructor		Constructor function

@param	{Function} 	(opt)	serialize		Serializing function 
											returns a value that the `construct` 
											function will be called with.
											default: 
											```
												function(obj) {
													return obj;
												}
											```
											
@param	{Function} 	(opt)	construct		Reconstructing function 
											returns the reconstructed object
											default: 
											```
												function(Constructor, value) {
													var obj = Object.create(Constructor.prototype);
													Constructor.apply(obj, Array.isArray(value) ? value : [value])
													return obj;
												}
											```
											
@param	{Object} 	(opt)	options			Hash of options 

		{Boolean}	[false]	noMerge			DSON will not automatically merge the object's
											own properties with the return value of the 
											`construct` function
											
		{Boolean}	[false]	collapse		If no own properties other than those returned
											by the `serialize` function, the result will be
											serialized as a basic JSON value.  e.g.:
											```
												function Collapsable(name) {
													this.name = name;
												};
												
												DSON.register('$collapsable', Collapsable, function(obj){
													return [obj.name]
												}, {
													collapse:true
												});
												DSON.stringify(new Collapseable('myName'))
													// => '["name"]' as opposed to '{"$collapsable": ["name"]}'
											```
											This option is mostly for internal use — You shouldn't need it.

		{Array}		[null]	exclude			List of properties that will not be serialized.  Differs fom 
											`noMerge` in that the properties will not be available during
											reconstruction.  If set to `true` all properties will be excluded