@teambit/bundler/dist/bundler.main.runtime.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BundlerMain = void 0;
function _pubsub() {
  const data = require("@teambit/pubsub");
  _pubsub = function () {
    return data;
  };
  return data;
}
function _cli() {
  const data = require("@teambit/cli");
  _cli = function () {
    return data;
  };
  return data;
}
function _dependencyResolver() {
  const data = require("@teambit/dependency-resolver");
  _dependencyResolver = function () {
    return data;
  };
  return data;
}
function _envs() {
  const data = require("@teambit/envs");
  _envs = function () {
    return data;
  };
  return data;
}
function _graphql() {
  const data = require("@teambit/graphql");
  _graphql = function () {
    return data;
  };
  return data;
}
function _harmony() {
  const data = require("@teambit/harmony");
  _harmony = function () {
    return data;
  };
  return data;
}
function _bundler() {
  const data = require("./bundler.aspect");
  _bundler = function () {
    return data;
  };
  return data;
}
function _events() {
  const data = require("./events");
  _events = function () {
    return data;
  };
  return data;
}
function _devServer() {
  const data = require("./dev-server.graphql");
  _devServer = function () {
    return data;
  };
  return data;
}
function _devServer2() {
  const data = require("./dev-server.service");
  _devServer2 = function () {
    return data;
  };
  return data;
}
function _bundler2() {
  const data = require("./bundler.service");
  _bundler2 = function () {
    return data;
  };
  return data;
}
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
/**
 * bundler extension.
 */
class BundlerMain {
  constructor(config,
  /**
   * Pubsub extension.
   */
  pubsub,
  /**
   * environments extension.
   */
  envs,
  /**
   * dev server service.
   */
  devService,
  /**
   * browser runtime slot.
   */
  runtimeSlot,
  /**
   * dev server transformer slot.
   */
  devServerTransformerSlot,
  /**
   * pre-dev-server operation slot.
   */
  onPreDevServerCreatedSlot, graphql) {
    this.config = config;
    this.pubsub = pubsub;
    this.envs = envs;
    this.devService = devService;
    this.runtimeSlot = runtimeSlot;
    this.devServerTransformerSlot = devServerTransformerSlot;
    this.onPreDevServerCreatedSlot = onPreDevServerCreatedSlot;
    this.graphql = graphql;
    /**
     * component servers.
     */
    _defineProperty(this, "_componentServers", []);
  }
  async addNewDevServers(newCompsWithoutDevServers) {
    const newComponents = newCompsWithoutDevServers.filter(component => {
      return !this.getComponentServer(component);
    });
    if (newComponents.length === 0) {
      return [];
    }
    await Promise.all(this.onPreDevServerCreatedSlot.values().map(subscriberFn => subscriberFn(newComponents)));
    return this.devServer(newComponents, {
      configureProxy: true
    });
  }
  async devServer(components, opts = {}) {
    const envRuntime = await this.envs.createEnvironment(components);
    const servers = await envRuntime.runOnce(this.devService, {
      dedicatedEnvDevServers: this.config.dedicatedEnvDevServers
    });
    if (opts.configureProxy) {
      this.pubsub.pub(_bundler().BundlerAspect.id, new (_events().NewDevServersCreatedEvent)(servers, Date.now(), this.graphql, true));
    }
    this._componentServers = servers;
    this.indexByComponent();
    return servers;
  }

  /**
   * get a dev server instance containing a component.
   * @param component
   */
  getComponentServer(component) {
    if (!this._componentServers) return undefined;
    const envId = this.envs.getEnvId(component);
    const server = this._componentServers.find(componentServer => componentServer.context.relatedContexts.includes(envId) || componentServer.context.id === envId);
    return server;
  }

  /**
   * compute entry files for bundling components in a given execution context.
   */
  async computeEntries(context) {
    const slotEntries = await Promise.all(this.runtimeSlot.values().map(async browserRuntime => browserRuntime.entry(context)));
    const slotPaths = slotEntries.reduce((acc, current) => {
      acc = acc.concat(current);
      return acc;
    });
    return slotPaths;
  }

  /**
   * register a new browser runtime environment.
   * @param browserRuntime
   */
  registerTarget(browserRuntime) {
    browserRuntime.map(runtime => {
      return this.runtimeSlot.register(runtime);
    });
    return this;
  }

  /**
   * register a new dev server transformer.
   * @param devServerTransformer
   */
  registerDevServerTransformer(devServerTransformer) {
    this.devServerTransformerSlot.register(devServerTransformer);
    return this;
  }

  /**
   * register a new pre-dev-server compiler.
   * @param onPreDevServerCreated
   */
  registerOnPreDevServerCreated(onPreDevServerCreated) {
    this.onPreDevServerCreatedSlot.register(onPreDevServerCreated);
    return this;
  }
  indexByComponent() {}
  static async provider([pubsub, envs, graphql, dependencyResolver], config, [runtimeSlot, devServerTransformerSlot, onPreDevServerCreatedSlot]) {
    const devServerService = new (_devServer2().DevServerService)(pubsub, dependencyResolver, runtimeSlot, devServerTransformerSlot);
    const bundler = new BundlerMain(config, pubsub, envs, devServerService, runtimeSlot, devServerTransformerSlot, onPreDevServerCreatedSlot, graphql);
    envs.registerService(devServerService, new (_bundler2().BundlerService)());
    graphql.register(() => (0, _devServer().devServerSchema)(bundler, graphql));
    return bundler;
  }
}
exports.BundlerMain = BundlerMain;
_defineProperty(BundlerMain, "slots", [_harmony().Slot.withType(), _harmony().Slot.withType(), _harmony().Slot.withType()]);
_defineProperty(BundlerMain, "runtime", _cli().MainRuntime);
_defineProperty(BundlerMain, "dependencies", [_pubsub().PubsubAspect, _envs().EnvsAspect, _graphql().GraphqlAspect, _dependencyResolver().DependencyResolverAspect]);
_defineProperty(BundlerMain, "defaultConfig", {
  dedicatedEnvDevServers: []
});
_bundler().BundlerAspect.addRuntime(BundlerMain);

//# sourceMappingURL=bundler.main.runtime.js.map