@teambit/bundler/dist/dev-server.service.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DevServerService = void 0;
function _chalk() {
  const data = _interopRequireDefault(require("chalk"));
  _chalk = function () {
    return data;
  };
  return data;
}
function _lodash() {
  const data = require("lodash");
  _lodash = function () {
    return data;
  };
  return data;
}
function _cliHighlight() {
  const data = _interopRequireDefault(require("cli-highlight"));
  _cliHighlight = function () {
    return data;
  };
  return data;
}
function _path() {
  const data = require("path");
  _path = function () {
    return data;
  };
  return data;
}
function _pMapSeries() {
  const data = _interopRequireDefault(require("p-map-series"));
  _pMapSeries = function () {
    return data;
  };
  return data;
}
function _componentServer() {
  const data = require("./component-server");
  _componentServer = function () {
    return data;
  };
  return data;
}
function _dedupEnvs() {
  const data = require("./dedup-envs");
  _dedupEnvs = function () {
    return data;
  };
  return data;
}
function _getEntry() {
  const data = require("./get-entry");
  _getEntry = function () {
    return data;
  };
  return data;
}
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
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); }
class DevServerService {
  constructor(pubsub, dependencyResolver,
  /**
   * browser runtime slot
   */
  runtimeSlot, devServerTransformerSlot) {
    this.pubsub = pubsub;
    this.dependencyResolver = dependencyResolver;
    this.runtimeSlot = runtimeSlot;
    this.devServerTransformerSlot = devServerTransformerSlot;
    _defineProperty(this, "name", 'dev server');
  }
  async render(env, context) {
    const descriptor = await this.getDescriptor(env, context);
    const name = `${_chalk().default.green('configured dev server:')} ${descriptor?.id} (${descriptor?.displayName} @ ${descriptor?.version})`;
    const configLabel = _chalk().default.green('dev server config:');
    const configObj = descriptor?.config ? (0, _cliHighlight().default)(descriptor?.config, {
      language: 'javascript',
      ignoreIllegals: true
    }) : '';
    return `${name}\n${configLabel}\n${configObj}`;
  }
  async getDescriptor(environment, context) {
    if (!environment.env.getDevServer || !context) return undefined;
    const mergedContext = await this.buildContext(context[0], []);
    const devServer = environment.env.getDevServer(mergedContext);
    return {
      id: devServer.id || '',
      displayName: devServer.displayName || '',
      icon: devServer.icon || '',
      config: devServer.displayConfig ? devServer.displayConfig() : '',
      version: devServer.version ? devServer.version() : '?'
    };
  }
  transform(env, envContext) {
    // Old env
    if (!env?.preview) return undefined;
    const preview = env.preview()(envContext);
    return {
      getDevEnvId: () => {
        return preview.getDevEnvId();
      },
      getDevServer: context => {
        return preview.getDevServer(context)(envContext);
      }
    };
  }

  // async run(context: ExecutionContext): Promise<ComponentServer[]> {
  //   const devServerContext = await this.buildContext(context);
  //   const devServer: DevServer = context.env.getDevServer(devServerContext);
  //   const port = await selectPort();
  //   // TODO: refactor to replace with a component server instance.
  //   return new ComponentServer(this.pubsub, context, port, devServer);
  // }

  async runOnce(contexts, {
    dedicatedEnvDevServers
  }) {
    const groupedEnvs = await (0, _dedupEnvs().dedupEnvs)(contexts, this.dependencyResolver, dedicatedEnvDevServers);

    // TODO: (gilad) - change this back to promise all once we make the preview pre-bundle to run before that loop
    const servers = await (0, _pMapSeries().default)(Object.entries(groupedEnvs), async ([id, contextList]) => {
      const mainContext = contextList.find(context => context.envDefinition.id === id) || contextList[0];
      const additionalContexts = contextList.filter(context => context.envDefinition.id !== id);
      const devServerContext = await this.buildContext(mainContext, additionalContexts);
      const devServer = await devServerContext.envRuntime.env.getDevServer(devServerContext);
      const transformedDevServer = this.transformDevServer(devServer, {
        envId: id
      });
      return new (_componentServer().ComponentServer)(this.pubsub, devServerContext, [3300, 3400], transformedDevServer);
    });
    return servers;
  }
  mergeContext() {}
  getComponentsFromContexts(contexts) {
    return (0, _lodash().flatten)(contexts.map(context => {
      return context.components;
    }));
  }

  /**
   * builds the execution context for the dev server.
   */
  async buildContext(context, additionalContexts = []) {
    context.relatedContexts = additionalContexts.map(ctx => ctx.envDefinition.id);
    context.components = context.components.concat(this.getComponentsFromContexts(additionalContexts));
    const peers = await this.dependencyResolver.getPreviewHostDependenciesFromEnv(context.envDefinition.env);
    const hostRootDir = context.envRuntime.envAspectDefinition?.aspectPath;
    const entry = await (0, _getEntry().getEntry)(context, this.runtimeSlot);
    const componentDirectoryMap = {};
    context.components.forEach(component => {
      // @ts-ignore this is usually a workspace component here so it has a workspace
      const workspace = component.workspace;
      if (!workspace) return;
      componentDirectoryMap[component.id.toString()] = workspace.componentDir(component.id);
    });
    return Object.assign(context, {
      entry,
      componentDirectoryMap,
      // don't start with a leading "/" because it generates errors on Windows
      rootPath: `preview/${context.envRuntime.id}`,
      publicPath: `${_path().sep}public`,
      hostRootDir,
      hostDependencies: peers,
      aliasHostDependencies: true
    });
  }
  transformDevServer(devServer, {
    envId
  }) {
    return this.devServerTransformerSlot.values().reduce((updatedDevServer, transformFn) => transformFn(updatedDevServer, {
      envId
    }), devServer);
  }
}
exports.DevServerService = DevServerService;

//# sourceMappingURL=dev-server.service.js.map