creevey/lib/server/messages.js

Cross-browser screenshot testing tool for Storybook with fancy UI Runner

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.emitWorkerMessage = emitWorkerMessage;
exports.emitTestMessage = emitTestMessage;
exports.emitWebpackMessage = emitWebpackMessage;
exports.emitDockerMessage = emitDockerMessage;
exports.emitShutdownMessage = emitShutdownMessage;
exports.sendTestMessage = sendTestMessage;
exports.sendDockerMessage = sendDockerMessage;
exports.sendShutdownMessage = sendShutdownMessage;
exports.subscribeOn = subscribeOn;

var _cluster = _interopRequireDefault(require("cluster"));

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

function emitMessage(message) {
  var _process$send, _process$send2, _process;

  if (_cluster.default.isWorker && !process.connected) return false;
  return (_process$send = (_process$send2 = (_process = process).send) === null || _process$send2 === void 0 ? void 0 : _process$send2.call(_process, message)) !== null && _process$send !== void 0 ? _process$send : // @ts-expect-error: wrong typings `process.emit` return boolean
  process.emit('message', message);
}

function emitWorkerMessage(message) {
  return emitMessage({
    scope: 'worker',
    ...message
  });
}

function emitTestMessage(message) {
  return emitMessage({
    scope: 'test',
    ...message
  });
}

function emitWebpackMessage(message) {
  return emitMessage({
    scope: 'webpack',
    ...message
  });
}

function emitDockerMessage(message) {
  return emitMessage({
    scope: 'docker',
    ...message
  });
}

function emitShutdownMessage() {
  return emitMessage({
    scope: 'shutdown'
  });
}

const handlers = Object.assign(Object.create(null), {
  worker: new Set(),
  test: new Set(),
  webpack: new Set(),
  docker: new Set(),
  shutdown: new Set()
});

const handler = message => {
  switch (message.scope) {
    case 'worker':
      return handlers.worker.forEach(h => h(message));

    case 'test':
      return handlers.test.forEach(h => h(message));

    case 'webpack':
      return handlers.webpack.forEach(h => h(message));

    case 'docker':
      return handlers.docker.forEach(h => h(message));

    case 'shutdown':
      return handlers.shutdown.forEach(h => h(message));
  }
};

process.on('message', handler);

function sendTestMessage(target, message) {
  var _target$send;

  (_target$send = target.send) === null || _target$send === void 0 ? void 0 : _target$send.call(target, {
    scope: 'test',
    ...message
  });
}

function sendDockerMessage(target, message) {
  var _target$send2;

  (_target$send2 = target.send) === null || _target$send2 === void 0 ? void 0 : _target$send2.call(target, {
    scope: 'docker',
    ...message
  });
}

function sendShutdownMessage(target) {
  var _target$send3;

  (_target$send3 = target.send) === null || _target$send3 === void 0 ? void 0 : _target$send3.call(target, {
    scope: 'shutdown'
  });
}

function subscribeOn(scope, handler) {
  switch (scope) {
    case 'worker':
      {
        const workerHandler = handler;
        handlers.worker.add(workerHandler);
        return () => handlers.worker.delete(workerHandler);
      }

    case 'test':
      {
        const testHandler = handler;
        handlers.test.add(testHandler);
        return () => handlers.test.delete(testHandler);
      }

    case 'webpack':
      {
        const webpackHandler = handler;
        handlers.webpack.add(webpackHandler);
        return () => handlers.webpack.delete(webpackHandler);
      }

    case 'docker':
      {
        const dockerHandler = handler;
        handlers.docker.add(dockerHandler);
        return () => handlers.docker.delete(dockerHandler);
      }

    case 'shutdown':
      {
        const shutdownHandler = handler;
        handlers.shutdown.add(shutdownHandler);
        return () => handlers.shutdown.delete(shutdownHandler);
      }
  }
}