ssr/lib/render.js

'use strict';

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

let renderFragment = (() => {
  var _ref = _asyncToGenerator(function* (createApp, routes, url, initialState, timeout, verbose) {
    const history = (0, _history.createMemoryHistory)();
    history.push(url);
    const context = {};
    const app = createApp({
      history,
      initialState
    });
    if (!existSSRModel(app)) {
      app.model(_ssrModel2.default);
    }
    app.router(function (options) {
      return _react2.default.createElement(
        _reactRouter.StaticRouter,
        { location: url, context: options.context },
        _react2.default.createElement(
          'div',
          null,
          routes
        )
      );
    });
    const asyncActions = getAsyncActions(app);
    const branch = (0, _utils.findRouteByUrl)(routes, url);
    if (branch.length === 0) {
      return {};
    }
    const sync = findSync(branch);
    if (!sync && asyncActions && asyncActions.length > 0) {
      const id = (0, _uid2.default)(10);
      app.use((0, _dvaServerSync2.default)(id, function (action) {
        if (asyncActions.indexOf(action.type) > -1) {
          return true;
        }
        return false;
      }, _block2.default));
      const appDOM = app.start()({
        context
      });
      if (verbose) {
        console.time(`${url}: async wait time`);
      }
      const result = yield new Promise(function (resolve, reject) {
        const timer = setTimeout(function () {
          reject(new Error('render timeout'));
        }, timeout);
        _block2.default.wait(id, function () {
          if (verbose) {
            console.timeEnd(`${url}: async wait time`);
          }
          clearTimeout(timer);
          const curState = appDOM.props.store.getState();
          const html = (0, _server.renderToStaticMarkup)(appDOM);
          resolve({ html, state: curState, context });
        });
      });
      return result;
    }
    const appDOM = app.start()({
      context
    });
    const html = (0, _server.renderToStaticMarkup)(appDOM);
    const curState = appDOM.props.store.getState();
    return { html, state: curState, context };
  });

  return function renderFragment(_x, _x2, _x3, _x4, _x5, _x6) {
    return _ref.apply(this, arguments);
  };
})();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _uid = require('uid');

var _uid2 = _interopRequireDefault(_uid);

var _reactRouter = require('react-router');

var _history = require('history');

var _lodash = require('lodash.merge');

var _lodash2 = _interopRequireDefault(_lodash);

var _server = require('react-dom/server');

var _ssrModel = require('./ssrModel');

var _ssrModel2 = _interopRequireDefault(_ssrModel);

var _utils = require('./utils');

var _dvaServerSync = require('./dvaServerSync');

var _dvaServerSync2 = _interopRequireDefault(_dvaServerSync);

var _block = require('./block');

var _block2 = _interopRequireDefault(_block);

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) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

function existSSRModel(app) {
  try {
    let model = null;
    app._models.forEach(m => {
      if (m.namespace === 'ssr') {
        model = m;
      }
    });
    return !!model;
  } catch (e) {
    return false;
  }
}

function getAsyncActions(app) {
  try {
    let actions = [];
    app._models.forEach(model => {
      if (model.effects) {
        actions = actions.concat(Object.keys(model.effects));
      }
    });
    return actions;
  } catch (e) {
    return [];
  }
}

function findSync(branch) {
  let sync = false;
  branch.forEach(b => {
    sync = !!b.props.sync;
  });
  return sync;
}

exports.default = (() => {
  var _ref2 = _asyncToGenerator(function* ({
    url, env, routes, renderFullPage, createApp, initialState, onRenderSuccess, timeout = 6000, verbose = true
  }) {
    try {
      if (verbose) {
        console.log(`[${url}]`);
        console.time(`${url}: render time`);
      }
      const state = (0, _lodash2.default)({}, initialState || {}, {
        ssr: {
          env
        }
      });
      const fragment = yield renderFragment(createApp, routes, url, state, timeout, verbose);
      if (verbose) {
        console.timeEnd(`${url}: render time`);
      }
      const context = fragment.context;
      if (!context) {
        return { code: 404, url, env };
      } else if (context.url) {
        return {
          code: 302, url, env, redirect: context.url
        };
      }
      const html = yield renderFullPage(fragment);
      if (onRenderSuccess) {
        yield onRenderSuccess({
          html, url, env, state: fragment.state
        });
      }
      return {
        code: 200, url, env, html
      };
    } catch (e) {
      console.error(e);
      return {
        code: 500, url, env, error: e
      };
    }
  });

  function render(_x7) {
    return _ref2.apply(this, arguments);
  }

  return render;
})();

module.exports = exports['default'];