linc-profile-generic-react/dist/generateClient.js

'use strict';

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"); }); }; }

const path = require('path');
const fse = require('fs-extra');

const steps = ['inits', 'getStatePromise', 'router', 'preRenders', 'render', 'afterRenders'];

const mapValues = (obj, iterator) => {
  const keys = Object.keys(obj);
  const mapped = {};
  keys.forEach(key => {
    mapped[key] = iterator(obj[key], key, obj);
  });
  return mapped;
};

const getImports = strategy => {
  const libs = strategy.libs.map(lib => requireLib(lib)).filter(e => e);
  const fragments = libs.map(module => module ? module.clientImportFragment : '');
  return fragments.join('\n');
};

const requireLib = module => {
  const file = path.resolve(__dirname, 'libs', 'config_client', module);
  try {
    return require(file);
  } catch (e) {
    return undefined;
  }
};

const createClientStrategy = strategy => {
  const clientStrategy = {};
  steps.forEach(step => {
    const module = strategy[step];
    if (typeof module === 'string') {
      clientStrategy[step] = requireLib(module);
    } else if (Array.isArray(module)) {
      clientStrategy[step] = module.map(name => requireLib(name)).filter(e => e);
    }
  });
  return clientStrategy;
};

const createClientCode = strategy => {
  const clientStrategy = createClientStrategy(strategy);

  let preRenderCode;
  if (clientStrategy.preRenders) {
    const preRenders = clientStrategy.preRenders.filter(e => e.preRenderFragment);
    const fragments = preRenders.map(preRender => preRender.preRenderFragment('renderComponent', 'store'));
    preRenderCode = fragments.join('\n');
  }

  const inits = clientStrategy.inits.map(init => init.initFragment()).filter(e => e);
  let runRender = 'main()';
  if (inits.length > 0) {
    runRender = `Promise.all([
  ${inits.join('\n')}
]).then(main())
    `;
  }

  return `
${getImports(strategy)}

import createConfig from 'linc-config-js'

const config = typeof createConfig === 'function' ? createConfig('CLIENT') : createConfig;

const serverState = (window && window.__INITIALSTATE__);
const initialState = config.state && config.state.parseServerState ? config.state.parseServerState(serverState) : serverState;
const userInfo = (window && window.__USER_INFO__) || {};

const main = () => {

  ${clientStrategy.getStatePromise.createStoreFragment('store', 'initialState')}
  const env = {store, userInfo, config};
  if(typeof config.init ==='function') {
      config.init(env);
  }

  ${clientStrategy.router.routerFragment('routeComponent', 'history')}
  let renderComponent = routeComponent
  ${preRenderCode || ''}
  ${clientStrategy.render.renderFragment('renderComponent', 'root')}
}

${runRender}

if (!config.disableServiceWorker && 'serviceWorker' in navigator) {
  navigator.serviceWorker.register('/serviceworker.js')
  .then(function(reg) {
    // registration worked
    console.log('Registration succeeded. Scope is ' + reg.scope);
  }).catch(function(error) {
    // registration failed
    console.log('Registration failed with ' + error);
  });
}
	`;
};

const generateClient = (() => {
  var _ref = _asyncToGenerator(function* (filename, strategy) {
    try {
      const code = createClientCode(strategy);
      yield fse.ensureFile(filename);
      return fse.writeFile(filename, code);
    } catch (e) {
      console.error("Couldn't create or write the client code.");
      console.error('Strategy: ', strategy);
      console.error(e);
      process.exit(-1);
    }
  });

  return function generateClient(_x, _x2) {
    return _ref.apply(this, arguments);
  };
})();

module.exports = generateClient;
//# sourceMappingURL=generateClient.js.map