bit-bin/dist/consumer/component-ops/load-flattened-dependencies.js

<a href="https://opensource.org/licenses/Apache-2.0"><img alt="apache" src="https://img.shields.io/badge/License-Apache%202.0-blue.svg"></a> <a href="https://github.com/teambit/bit/blob/master/CONTRIBUTING.md"><img alt="prs" src="https://img.shields.io/b

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

function _bluebird() {
  const data = require("bluebird");

  _bluebird = function () {
    return data;
  };

  return data;
}

function _ramda() {
  const data = _interopRequireDefault(require("ramda"));

  _ramda = function () {
    return data;
  };

  return data;
}

function _pMapSeries() {
  const data = _interopRequireDefault(require("p-map-series"));

  _pMapSeries = function () {
    return data;
  };

  return data;
}

function _componentDependencies() {
  const data = _interopRequireDefault(require("../../scope/component-dependencies"));

  _componentDependencies = function () {
    return data;
  };

  return data;
}

function _bitIds() {
  const data = _interopRequireDefault(require("../../bit-id/bit-ids"));

  _bitIds = function () {
    return data;
  };

  return data;
}

function _constants() {
  const data = require("../../constants");

  _constants = function () {
    return data;
  };

  return data;
}

function loadFlattenedDependenciesForCapsule(_x, _x2) {
  return _loadFlattenedDependenciesForCapsule.apply(this, arguments);
}

function _loadFlattenedDependenciesForCapsule() {
  _loadFlattenedDependenciesForCapsule = (0, _bluebird().coroutine)(function* (consumer, component) {
    const dependencies = yield loadManyDependencies(component.dependencies.getAllIds());
    const devDependencies = yield loadManyDependencies(component.devDependencies.getAllIds());
    const extensionDependencies = yield loadManyDependencies(component.extensions.extensionsBitIds);
    yield loadFlattened(dependencies);
    yield loadFlattened(devDependencies);
    yield loadFlattened(extensionDependencies);
    return new (_componentDependencies().default)({
      component,
      dependencies,
      devDependencies,
      extensionDependencies
    });

    function loadManyDependencies(_x3) {
      return _loadManyDependencies.apply(this, arguments);
    }

    function _loadManyDependencies() {
      _loadManyDependencies = (0, _bluebird().coroutine)(function* (dependenciesIds) {
        return (0, _pMapSeries().default)(dependenciesIds, dep => loadDependency(dep));
      });
      return _loadManyDependencies.apply(this, arguments);
    }

    function loadDependency(_x4) {
      return _loadDependency.apply(this, arguments);
    }

    function _loadDependency() {
      _loadDependency = (0, _bluebird().coroutine)(function* (dependencyId) {
        const componentMap = consumer.bitMap.getComponentIfExist(dependencyId);

        const couldBeModified = componentMap && componentMap.origin !== _constants().COMPONENT_ORIGINS.NESTED;

        if (couldBeModified) {
          return consumer.loadComponentForCapsule(dependencyId);
        } // for capsule, a dependency might have been installed as a package in the workspace, and as
        // such doesn't have a componentMap, which result in not stripping the sharedDir.
        // using the loadComponentWithDependenciesFromModel, all dependencies are loaded and their
        // shared dir is stripped. (see e2e-test of 'isolating with capsule' in dependencies-as-packages.e2e file)


        const componentWithDependenciesFromModel = yield consumer.loadComponentWithDependenciesFromModel(dependencyId, false);
        return componentWithDependenciesFromModel.component.clone();
      });
      return _loadDependency.apply(this, arguments);
    }

    function loadFlattened(_x5) {
      return _loadFlattened.apply(this, arguments);
    }

    function _loadFlattened() {
      _loadFlattened = (0, _bluebird().coroutine)(function* (deps) {
        if (_ramda().default.isEmpty(deps)) return;
        yield loadFlattenedFromModel(deps);
        yield loadFlattenedFromFsRecursively(deps);
      });
      return _loadFlattened.apply(this, arguments);
    }

    function loadFlattenedFromModel(_x6) {
      return _loadFlattenedFromModel.apply(this, arguments);
    }

    function _loadFlattenedFromModel() {
      _loadFlattenedFromModel = (0, _bluebird().coroutine)(function* (deps) {
        const dependenciesFromModel = deps.filter(d => !d.loadedFromFileSystem);
        const flattenedIdsFromModel = dependenciesFromModel.map(d => d.flattenedDependencies);
        const flattenedFromModel = yield loadManyDependencies(_ramda().default.flatten(flattenedIdsFromModel));
        deps.push(...flattenedFromModel);
      });
      return _loadFlattenedFromModel.apply(this, arguments);
    }

    function loadFlattenedFromFsRecursively(_x7) {
      return _loadFlattenedFromFsRecursively.apply(this, arguments);
    }

    function _loadFlattenedFromFsRecursively() {
      _loadFlattenedFromFsRecursively = (0, _bluebird().coroutine)(function* (components) {
        const currentIds = _bitIds().default.fromArray(components.map(c => c.id));

        const ids = _ramda().default.flatten(components.filter(c => c.loadedFromFileSystem).map(c => c.getAllDependenciesIds()));

        const idsUniq = _bitIds().default.uniqFromArray(ids);

        const newIds = idsUniq.filter(id => !currentIds.has(id));
        if (_ramda().default.isEmpty(newIds)) return;
        const deps = yield loadManyDependencies(newIds);
        if (_ramda().default.isEmpty(deps)) return;
        components.push(...deps);
        yield loadFlattened(components);
      });
      return _loadFlattenedFromFsRecursively.apply(this, arguments);
    }
  });
  return _loadFlattenedDependenciesForCapsule.apply(this, arguments);
}