serializer/src/main.ts

const merge = Object.assign;

const STOP_CRAWLING = {};

/**
 * Check if the argument is an instance of a class
 */
function isObject(value: any): boolean {
    return value instanceof Object && !Array.isArray(value);
}

/**
 * Recursively crawl through an object, yielding any defined value found along the way
 * 
 * If *replace* is set to true, the current object is replaced (in array or object attribute) by the result of the callback
 * 
 * *memo* is used to prevent circular references to be traversed
 */
function crawl(obj: any, callback: (item: any) => any, replace = false, memo: any[] = []) {
    if (isObject(obj)) {
        if (memo.indexOf(obj) >= 0) {
            return obj;
        } else {
            memo.push(obj);
        }
    }

    if (obj !== undefined && obj !== null && typeof obj != "function") {
        let result = callback(obj);

        if (result === STOP_CRAWLING) {
            return;
        }

        if (Array.isArray(obj)) {
            let subresult = obj.map(value => crawl(value, callback, replace, memo));
            if (replace) {
                subresult.forEach((value, index) => {
                    obj[index] = value;
                });
            }
        } else if (obj instanceof Object) {
            let subresult: any = {};
            for (let key in obj) {
                subresult[key] = crawl(obj[key], callback, replace, memo);
            }
            if (replace) {
                merge(obj, subresult);
            }
        }

        return result;
    } else {
        return obj;
    }
}

/**
 * Get the class name of an object.
 */
function classname(obj: Object): string {
    return (<any>obj.constructor).name;
}

/**
 * A deep serializer of javascript objects.
 */
export class Serializer {
    private namespace: any;
    private ignored: string[] = [];

    constructor(namespace: any) {
        this.namespace = namespace;
    }

    /**
     * Add a class to the ignore list
     */
    addIgnoredClass(name: string) {
        this.ignored.push(name);
    }

    /**
     * Construct an object from a constructor name
     */
    private constructObject(ctype: string): Object {
        if (ctype == "Object") {
            return {};
        } else {
            let cl = this.namespace[ctype];
            if (cl) {
                return Object.create(cl.prototype);
            } else {
                console.error("Can't find class", ctype);
                return {};
            }
        }
    }

    /**
     * Serialize an object to a string
     */
    serialize(obj: any): string {
        // Collect objects
        var objects: Object[] = [];
        var stats: any = {};
        crawl(obj, value => {
            if (isObject(value)) {
                var vtype = classname(value);
                if (vtype != "" && this.ignored.indexOf(vtype) < 0) {
                    stats[vtype] = (stats[vtype] || 0) + 1;
                    if (objects.indexOf(value) < 0) {
                        objects.push(value);
                    }
                    return value;
                } else {
                    return STOP_CRAWLING;
                }
            } else {
                return value;
            }
        });
        //console.log("Serialize stats", stats);

        // Serialize objects list, transforming deeper objects to links
        var fobjects = objects.map(value => <Object>{ $c: classname(value), $f: merge({}, value) });
        return JSON.stringify(fobjects, (key, value) => {
            if (key != "$f" && isObject(value) && !value.hasOwnProperty("$c") && !value.hasOwnProperty("$i")) {
                return { $i: objects.indexOf(value) };
            } else {
                return value;
            }
        });
    }

    /**
     * Unserialize a string to an object
     */
    unserialize(data: string): any {
        // Unserialize objects list
        var fobjects = JSON.parse(data);

        // Reconstruct objects
        var objects = fobjects.map((objdata: any) => merge(this.constructObject(objdata['$c']), objdata['$f']));

        // Reconnect links
        crawl(objects, value => {
            if (value instanceof Object && value.hasOwnProperty('$i')) {
                return objects[value['$i']];
            } else {
                return value;
            }
        }, true);

        // Post unserialize hooks
        crawl(objects[0], value => {
            if (value instanceof Object && typeof value.postUnserialize === "function") {
                value.postUnserialize();
            }
        });

        // First object was the root
        return objects[0];
    }
}