iddfs/dist/index.js

iterative deepening depth-first search (IDDFS) for JavaScript

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.search = search;
exports.default = getNode;
exports.getPath = getPath;

var _Strategy = _interopRequireDefault(require("./Strategy"));

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

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var defaults = {
  initialDepth: 0,
  maxDepth: Infinity
};

function dls(_x, _x2, _x3) {
  return _dls.apply(this, arguments);
}

function _dls() {
  _dls = _asyncToGenerator(function* (node, strategy, depthLimit) {
    var visited = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
    var depth = visited.length;
    strategy.onVisit(node, depth, visited);

    if (depth === depthLimit) {
      return strategy.isGoal(node) ? {
        node: node,
        path: visited
      } : null;
    }

    if (!strategy.shouldContinue(node, depth, depthLimit)) {
      return null;
    }

    var nodes = yield strategy.expand(node);
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var child = _step.value;
        var id = strategy.extractId(child);
        var visitedDepth = strategy.isVisited(child, visited);

        if (visitedDepth && visitedDepth >= depth) {
          continue;
        }

        var found = yield dls(child, strategy, depthLimit, visited.concat([id]));

        if (found !== null) {
          return found;
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    return null;
  });
  return _dls.apply(this, arguments);
}

function search(_x4) {
  return _search.apply(this, arguments);
}

function _search() {
  _search = _asyncToGenerator(function* (op) {
    var _defaults$op = _objectSpread({}, defaults, op),
        initialDepth = _defaults$op.initialDepth,
        maxDepth = _defaults$op.maxDepth,
        initialNode = _defaults$op.initialNode,
        strategyOptions = _objectWithoutProperties(_defaults$op, ["initialDepth", "maxDepth", "initialNode"]);

    var strategy = new _Strategy.default(strategyOptions);
    var initialNodeId = strategy.extractId(initialNode);

    for (var depthLimit = initialDepth; depthLimit <= maxDepth; depthLimit++) {
      var found = yield dls(initialNode, strategy, depthLimit + 1, [initialNodeId]);

      if (found !== null) {
        return found;
      }
    }

    return null;
  });
  return _search.apply(this, arguments);
}

function getNode(_x5) {
  return _getNode.apply(this, arguments);
}

function _getNode() {
  _getNode = _asyncToGenerator(function* (op) {
    var result = yield search(op);
    return result && result.node;
  });
  return _getNode.apply(this, arguments);
}

function getPath(_x6) {
  return _getPath.apply(this, arguments);
}

function _getPath() {
  _getPath = _asyncToGenerator(function* (op) {
    var result = yield search(op);
    return result && result.path;
  });
  return _getPath.apply(this, arguments);
}