serializer/src/serializer.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];
  }
}