linc-profile-generic-react/dist/index.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 _ = require('underscore');
const path = require('path');
const webpack = require('webpack');
const fs = require('fs-extra');
const writePkg = require('write-pkg');

const server_config = require('../webpack/webpack.config.server.js');
const client_config = require('../webpack/webpack.config.client.js');
const createStrategy = require('./strategy');
const generateServerStrategy = require('./generateServerStrategy');
const generateClient = require('./generateClient');
const generateIncludes = require('./generateIncludes');

const PROJECT_DIR = process.cwd();
const DIST_DIR = path.resolve(PROJECT_DIR, 'dist');
const MODULES_DIR = path.resolve(PROJECT_DIR, 'node_modules');
const LIB_DIR = path.resolve(DIST_DIR, 'lib');
const packageJson = require(path.resolve(PROJECT_DIR, 'package.json'));
const CONFIG_FILENAME = 'src/linc.config.js';
const CONFIG_FILE = path.resolve(PROJECT_DIR, CONFIG_FILENAME);

let stdin = process.stdin;
let stdout = process.stdout;

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

const getDependencies = () => {
  const nodeModuleDir = path.resolve(PROJECT_DIR, 'node_modules');
  const deps = Object.assign({}, packageJson.dependencies, packageJson.devDependencies);
  return mapValues(deps, (_, name) => {
    const pjf = path.resolve(nodeModuleDir, name, 'package.json');
    const pj = require(pjf);
    return pj.version;
  });
};

const runWebpack = (config, options) => {
  return new Promise((resolve, reject) => {
    config = config(options);
    webpack(config, (err, stats) => {
      if (err) return reject(err);
      const errors = stats.toJson('errors-only').errors.toString();
      if (errors) return reject(errors);
      resolve();
    });
  });
};

const copyStatic = (() => {
  var _ref = _asyncToGenerator(function* () {
    const src = packageJson.linc && packageJson.linc.staticDir;
    if (src) {
      const dirname = path.basename(src);
      const dest = path.resolve(DIST_DIR, 'static', dirname);
      console.log(`Copying ${src} to ${dest}`);
      return fs.copy(src, dest, {
        overwrite: true,
        dereference: true,
        preserveTimestamps: true
      });
    }
  });

  return function copyStatic() {
    return _ref.apply(this, arguments);
  };
})();

const makeBabelAbsolute = babelOptions => {
  if (Array.isArray(babelOptions)) {
    babelOptions[0] = path.resolve(MODULES_DIR, babelOptions[0]);
    return babelOptions;
  } else {
    return path.resolve(MODULES_DIR, babelOptions);
  }
};

const mergeOptions = (acc, curr) => {
  acc.alias = Object.assign({}, acc.alias, curr.alias);
  if (curr.babel && curr.babel.presets) {
    const presets = curr.babel.presets.map(makeBabelAbsolute);
    acc.babel.presets = acc.babel.presets.concat(presets);
  }
  if (curr.babel && curr.babel.plugins) {
    const plugins = curr.babel.plugins.map(makeBabelAbsolute);
    acc.babel.plugins = acc.babel.plugins.concat(plugins);
  }
  if (Array.isArray(curr.plugins)) {
    acc.plugins = acc.plugins.concat(curr.plugins);
  } else if (curr.plugins) {
    acc.plugins.push(curr.plugins);
  }
  return acc;
};

const getConfigFragments = strategy => {
  const all = strategy.libs.map(lib => {
    try {
      return require(`./libs/config_client/${lib}`).configFragment;
    } catch (e) {}
  }).filter(e => !!e);

  const empty = { imports: [], values: [] };
  return all.reduce((acc, curr) => {
    if (curr.imports) acc.imports.push(curr.imports);
    if (curr.values) acc.values = acc.values.concat(curr.values);
    return acc;
  }, empty);
};

const getWebpackOptions = (strategy, env) => {
  const all = strategy.libs.map(lib => {
    try {
      return require(`./libs/config_client/${lib}`).webpackConfig;
    } catch (e) {}
  }).filter(e => !!e);

  const empty = { alias: {}, babel: { presets: [], plugins: [] }, plugins: [] };
  const options = all.map(e => e(DIST_DIR)[env]).reduce(mergeOptions, empty);
  return options;
};

const readOnce = () => new Promise(resolve => {
  stdin.once('data', resolve);
});

const ask = (() => {
  var _ref2 = _asyncToGenerator(function* (question, suggestion) {
    stdout.write(`${question} `);

    let answer = yield readOnce();
    if (answer) {
      answer = answer.toString().trim();
      if (answer.length > 0) {
        return answer;
      }
    }
    stdout.write(`${suggestion}\n`);
    return ask(question, suggestion);
  });

  return function ask(_x, _x2) {
    return _ref2.apply(this, arguments);
  };
})();

const getSourceDir = (() => {
  var _ref3 = _asyncToGenerator(function* () {
    stdin.resume();
    const srcDir = yield ask('Directory containing your source code:', 'Please provide a valid directory.');
    stdin.pause();
    return srcDir;
  });

  return function getSourceDir() {
    return _ref3.apply(this, arguments);
  };
})();

const configLines = {
  top: ['const config = {', "    // polyfills: 'default,fetch,Symbol,Symbol.iterator,Array.prototype.find',", '    // requestExtendedUserInfo: true,'],
  bottom: ['};', '', 'export default config']
};

const getOption = (() => {
  var _ref4 = _asyncToGenerator(function* (opt, memo, lvl) {
    const indent = '    '.repeat(lvl + 1);
    const keys = Object.keys(opt);

    // Lookahead to see if we've reached the innermost level
    const o = opt[keys[0]];
    const ks = Object.keys(o);
    if (typeof o[ks[0]] === 'object') {
      // We can go a level deeper
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          let k = _step.value;

          memo.values = memo.values.concat(`${indent}${k}: {`);
          yield getOption(opt[k], memo, lvl + 1);
          memo.values = memo.values.concat(`${indent}},`);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    } else {
      let isRequired = false;
      // Yep, innermost level
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = keys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          let k = _step2.value;

          let optn = opt[k];
          let s;
          if (optn.required) {
            isRequired = true;
            s = `${indent}${k}: ${optn.example ? optn.example : optn.default}`;
          } else {
            if (optn.example) {
              s = `${indent}// ${k}: ${optn.example}`;
            } else if (optn.default) {
              s = `${indent}// ${k}: ${optn.default}`;
            }
          }
          if (s) {
            memo.values = memo.values.concat(`${s},`);
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

      memo.required.push(isRequired);
    }
  });

  return function getOption(_x3, _x4, _x5) {
    return _ref4.apply(this, arguments);
  };
})();

const createConfigFileContents = (() => {
  var _ref5 = _asyncToGenerator(function* (all) {
    const memo = {
      required: [],
      values: configLines.top
    };
    var _iteratorNormalCompletion3 = true;
    var _didIteratorError3 = false;
    var _iteratorError3 = undefined;

    try {
      for (var _iterator3 = all.values[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
        let x = _step3.value;

        yield getOption(x, memo, 0);
      }
    } catch (err) {
      _didIteratorError3 = true;
      _iteratorError3 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion3 && _iterator3.return) {
          _iterator3.return();
        }
      } finally {
        if (_didIteratorError3) {
          throw _iteratorError3;
        }
      }
    }

    memo.values = memo.values.concat(configLines.bottom);

    // This creates a list of imports, where the imports for non-required
    // options are commented out.
    const imports = _.reduce(all.imports, function (m, v, i) {
      // From example configuration
      v.forEach(function (o) {
        m.push(memo.required[i] ? o : `// ${o}`);
      });
      return m;
    }, []);

    return [imports.join('\n'), '', memo.values.join('\n'), ''].join('\n');
  });

  return function createConfigFileContents(_x6) {
    return _ref5.apply(this, arguments);
  };
})();

const writeFile = (file, contents) => new Promise((resolve, reject) => {
  return fs.writeFile(file, contents, err => {
    if (err) return reject(err);

    stdout.write(`**\n** Created new config file ${file}\n**\n`);
    return resolve();
  });
});

const hasConfigFile = () => fs.existsSync(CONFIG_FILE);

const createConfigFile = (() => {
  var _ref6 = _asyncToGenerator(function* (strategy) {
    // Don't do anything if config file exists
    if (!hasConfigFile()) {
      const all = getConfigFragments(strategy);
      const configFileContents = yield createConfigFileContents(all);
      writeFile(CONFIG_FILE, configFileContents);
    }
  });

  return function createConfigFile(_x7) {
    return _ref6.apply(this, arguments);
  };
})();

const postBuild = (() => {
  var _ref7 = _asyncToGenerator(function* () {
    const linc = packageJson.linc || {};
    if (!linc.sourceDir) {
      linc.sourceDir = yield getSourceDir();
      yield writePkg(packageJson);
    }
  });

  return function postBuild() {
    return _ref7.apply(this, arguments);
  };
})();

const build = (() => {
  var _ref8 = _asyncToGenerator(function* (opts, callback) {
    if (!callback) {
      callback = opts;
    } else {
      stdin = opts.stdin || stdin;
      stdout = opts.stdout || stdout;
    }

    const strategy = yield createStrategy(getDependencies());
    yield createConfigFile(strategy);
    yield generateClient(path.resolve(DIST_DIR, 'client.js'), strategy);
    const serverStrategy = generateServerStrategy(path.resolve(DIST_DIR, 'server-strategy.js'), strategy);
    console.log('Creating a client package. This can take a minute or two..');
    const staticCopy = copyStatic();
    yield runWebpack(client_config, getWebpackOptions(strategy, 'client'));
    console.log('Created client package');

    yield generateIncludes(path.resolve(LIB_DIR, 'includes.js'), path.resolve(LIB_DIR, 'includes'));

    console.log('Now working on server package');
    yield serverStrategy;
    yield runWebpack(server_config, getWebpackOptions(strategy, 'server'));
    yield staticCopy;
    console.log('Created server package');

    console.log('Running post build operations');
    yield postBuild();

    console.log('We have created an overview of your bundles in dist/bundle-report.html');

    callback();
  });

  return function build(_x8, _x9) {
    return _ref8.apply(this, arguments);
  };
})();

module.exports = build;
//# sourceMappingURL=index.js.map