motion/lib/runner/serverProcess.js

motion - moving development forward

'use strict';

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

let readScripts = function () {
  var ref = _asyncToGenerator(function* () {
    try {
      const dir = yield (0, _fns.readdir)(OPTS.outDir);
      const files = dir.filter(function (f) {
        return (/\.jsf?$/.test(f.name)
        );
      }); // filter sourcemaps
      const hasFiles = files.length;

      let paths = [];

      // deterministic order
      if (hasFiles) {
        paths = files.map(function (file) {
          return file.path;
        }).sort();

        let mainIndex = 0;

        paths.forEach(function (p, i) {
          if (/[Mm]ain\.jsf?$/.test(p)) mainIndex = i;
        });

        if (mainIndex !== -1) paths.move(mainIndex, 0);
      }

      return paths;
    } catch (e) {
      (0, _fns.handleError)(e);
    }
  });

  return function readScripts() {
    return ref.apply(this, arguments);
  };
}();

let getScripts = function () {
  var ref = _asyncToGenerator(function* (_ref) {
    let disableTools = _ref.disableTools;

    try {
      const files = yield readScripts();

      return ['<div id="_motiondevtools" class="_motiondevtools"></div>', newLine, '<!-- MOTION JS -->', '<script src="/__/react.dev.js"></script>', '<script src="/__/motion.dev.js"></script>', '<script>_MOTION_WEBSOCKET_PORT = ' + wport() + '</script>', '<script src="/__/devtools.dev.js"></script>', `
  <script>
    var Motion = exports['motion']
    Motion.init()
  </script>
`,

      // devtools
      disableTools ? '' : ['<script src="/__/tools/externals.js"></script>', '<script src="/__/tools/internals.js"></script>', '<script src="/__/tools/motiontools.js"></script>', `
  <script>
    Motion.run("motiontools", { node: "_motiondevtools" })
  </script>
`].join(newLine),
      // user files
      newLine, '<!-- APP -->', `
  <script>
    // set up for dev mode, essentially faking a closure on window
    Motion = Motion.run("${ OPTS.saneName }")
  </script>
`, '<script src="/__/externals.js" id="__motionExternals"></script>', '<script src="/__/internals.js" id="__motionInternals"></script>', scriptTags(files), '<script>Motion.start()</script>', '<!-- END APP -->'].join(newLine);
    } catch (e) {
      (0, _fns.handleError)(e);
    }
  });

  return function getScripts(_x) {
    return ref.apply(this, arguments);
  };
}();

let getPathsInDir = function () {
  var ref = _asyncToGenerator(function* (_dir) {
    const dir = yield (0, _fns.readdir)(_dir);
    if (!dir || !dir.length) return [];
    return dir.map(function (file) {
      return file.path;
    }).sort();
  });

  return function getPathsInDir(_x2) {
    return ref.apply(this, arguments);
  };
}();

let getStyles = function () {
  var ref = _asyncToGenerator(function* () {
    const styles = yield getPathsInDir(OPTS.styleDir);
    return styles.map(function (p) {
      return stylesheetLink(`styles/${ p }`);
    }).join(newLine);
  });

  return function getStyles() {
    return ref.apply(this, arguments);
  };
}();

let getExternalStyles = function () {
  var ref = _asyncToGenerator(function* () {
    try {
      const styles = yield getPathsInDir((0, _fns.p)(OPTS.deps.assetsDir, 'styles'));
      return styles.map(function (p) {
        return stylesheetLink(`externalStyles/${ p }`);
      }).join(newLine);
    } catch (e) {
      return [];
    }
  });

  return function getExternalStyles() {
    return ref.apply(this, arguments);
  };
}();

let makeTemplate = function () {
  var ref = _asyncToGenerator(function* (req) {
    try {
      const templatePath = (0, _fns.p)(OPTS.appDir, OPTS.template);
      const template = yield (0, _fns.readFile)(templatePath);
      const disableTools = devToolsDisabled(req);
      const scripts = yield getScripts({ disableTools });
      const styles = yield getStyles();
      const externalStyles = yield getExternalStyles();

      return template.replace('<!-- STYLES -->', styles).replace('<!-- EXTERNAL STYLES -->', externalStyles).replace('<!-- SCRIPTS -->', scripts);
    } catch (e) {
      (0, _fns.handleError)(e);
    }
  });

  return function makeTemplate(_x3) {
    return ref.apply(this, arguments);
  };
}();

exports.default = wport;

var _express = require('express');

var _express2 = _interopRequireDefault(_express);

var _cors = require('cors');

var _cors2 = _interopRequireDefault(_cors);

var _portfinder = require('portfinder');

var _portfinder2 = _interopRequireDefault(_portfinder);

var _motionClient = require('motion-client');

var _motionClient2 = _interopRequireDefault(_motionClient);

var _motionTools = require('motion-tools');

var _motionTools2 = _interopRequireDefault(_motionTools);

var _fns = require('./lib/fns');

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

global.print = console.log.bind(console);

const newLine = "\n";
let OPTS, PORT;

function wport() {
  return 2283 + parseInt(PORT, 10);
}

Array.prototype.move = function (from, to) {
  this.splice(to, 0, this.splice(from, 1)[0]);
};

function scriptTags(files) {
  return files.map(file => `<script src="/_/${ file }" class="__motionScript"></script>`).join(newLine);
}

function devToolsDisabled(req) {
  return OPTS.config && OPTS.config.tools === 'false' || req && req.query && req.query['!dev'];
}

const stylesheetLink = name => `<link rel="stylesheet" href="/__/${ name }" />`;

function run() {
  return new Promise((res, rej) => {
    var server = (0, _express2.default)({
      env: 'production'
    });

    server.use((0, _cors2.default)());
    server.use((req, res, next) => {
      res.header('Access-Control-Allow-Origin', '*');
      next();
    });

    const staticOpts = {
      redirect: false
    };

    // USER files
    // user js files at '/_/filename.js'
    server.use('/_', _express2.default.static('.motion/.internal/out'));
    // user non-js files
    server.use('/', _express2.default.static('.', staticOpts));
    // user static files...
    server.use('/_/static', _express2.default.static('.motion/static'));

    // INTERNAL files
    server.use('/__', _express2.default.static('.motion/.internal/deps'));
    server.use('/__/styles', _express2.default.static('.motion/.internal/styles'));
    server.use('/__/externalStyles', _express2.default.static('.motion/.internal/deps/assets/styles'));

    // tools.js
    server.use('/__/tools', _express2.default.static((0, _fns.p)((0, _motionTools2.default)(), 'build', '_')));
    // motion.js & react.js
    server.use('/__', _express2.default.static((0, _fns.p)((0, _motionClient2.default)(), 'dist')));

    server.get('*', function (req, res) {
      afterFirstBuild(_asyncToGenerator(function* () {
        try {
          const template = yield makeTemplate(req);
          res.send(template.replace(/\/static/g, '/_/static'));
        } catch (e) {
          print(e, e.stack);
        }
      }));
    });

    function afterFirstBuild(cb) {
      if (OPTS.hasRunInitialBuild) cb();else setTimeout(() => afterFirstBuild(cb), 150);
    }

    function serverListen(port) {
      PORT = port;
      server.listen(port, host);
      process.send(JSON.stringify({ host, port }));
    }

    const host = OPTS.config.host || 'localhost';
    const port = OPTS.config.port || OPTS.defaultPort;

    // if no specified port, find open one
    if (!OPTS.config.port) {
      _portfinder2.default.basePort = port;
      _portfinder2.default.getPort({ host }, (0, _fns.handleError)(serverListen));
    } else {
      serverListen(port);
    }
  });
}

let ran = false;

process.on('message', function (opts) {
  if (opts === 'EXIT') return process.exit(2);

  OPTS = JSON.parse(opts);

  if (ran) return;

  ran = true;
  run();
});
//# sourceMappingURL=serverProcess.js.map