@thinql/parse/dist/cjs/types/_Node.js

Parse ThinQL queries to ASTs

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.attributeSetsMap = exports.registerType = void 0;

var _util = require("util");

var _mapValues = _interopRequireDefault(require("../utils/mapValues.js"));

var _MemoizedWeakMap = _interopRequireDefault(require("../utils/MemoizedWeakMap.js"));

var _Token = _interopRequireDefault(require("../utils/Token.js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const types = {};

const registerType = nodeClass => {
  types[nodeClass.name] = nodeClass;
};

exports.registerType = registerType;
const attributeSetsMap = new _MemoizedWeakMap.default();
exports.attributeSetsMap = attributeSetsMap;
const tokensMap = new WeakMap();

class _Node {
  static fromJSON(object) {
    if (object && object.$type) {
      const {
        $type: type,
        $token: token,
        ...attributes
      } = token;
      const Type = types[type];
      return new Type((0, _mapValues.default)(attributes, _Node.fromJSON), token);
    } else {
      return object;
    }
  }

  constructor(attributes, token = null) {
    for (const key of Object.keys(attributes)) {
      if (attributes[key] === undefined) {
        throw new Error(`attributes[${key}] is undefined`);
      }
    }

    attributeSetsMap.set(this, attributes);

    let _token = token instanceof _Node ? token.$token : token;

    if (_token && !(_token instanceof _Token.default)) {
      _token = new _Token.default(_token);
    }

    tokensMap.set(this, _token);
  }

  get $token() {
    return tokensMap.get(this);
  }

  get $type() {
    return this.constructor.name;
  }

  [_util.inspect.custom](depth, options) {
    const {
      $type: type,
      $token: token
    } = this;
    let displayType = options.stylize(type, 'special');

    if (token) {
      const displayToken = options.stylize(`[${token.line}:${token.col}]`);
      displayType = `${displayType} ${displayToken}`;
    }

    if (depth < 0) {
      return displayType;
    }

    const body = (0, _util.inspect)(attributeSetsMap.get(this), { ...options,
      depth: options.depth == null || options.depth === Infinity ? null : options.depth - 1
    });
    return `${displayType} ${body}`;
  }

  toJSON(options = {}) {
    const {
      includeTokens = false
    } = options;
    const {
      $token,
      $type
    } = this;
    const attributes = attributeSetsMap.get(this);

    const toJson = value => {
      if (value instanceof _Node) {
        return value.toJSON(options);
      } else {
        return value;
      }
    };

    const object = {
      $type,
      ...Object.keys(attributes).reduce((result, key) => {
        const value = attributes[key];

        if (Array.isArray(value)) {
          result[key] = value.map(toJson);
        } else {
          result[key] = toJson(value);
        }

        return result;
      }, {})
    };

    if (includeTokens && $token) {
      object.$token = $token;
    }

    return object;
  }

}

exports.default = _Node;
//# sourceMappingURL=_Node.js.map