preconstruct/lib/dev.js

"use strict";

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

var _project = require("./project");

var _logger = require("./logger");

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

var babel = _interopRequireWildcard(require("@babel/core"));

var fs = _interopRequireWildcard(require("fs-extra"));

var _path = _interopRequireDefault(require("path"));

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

let tsExtensionPattern = /tsx?$/;

function cjsOnlyReexportTemplate(pathToSource) {
  return `// 👋 hey!!
// you might be reading this and seeing .esm in the filename
// and being confused why there is commonjs below this filename
// DON'T WORRY!
// this is intentional
// it's only commonjs with \`preconstruct dev\`
// when you run \`preconstruct build\`, it will be ESM
// why is it commonjs?
// we need to re-export every export from the source file
// but we can't do that with ESM without knowing what the exports are (because default exports aren't included in export/import *)
// and they could change after running \`preconstruct dev\` so we can't look at the file without forcing people to
// run preconstruct dev again which wouldn't be ideal
// this solution could change but for now, it's working

module.exports = require("${pathToSource}")
`;
}

async function getTypeSystem(entrypoint) {
  let content = await fs.readFile(entrypoint.source, "utf8");

  if (tsExtensionPattern.test(entrypoint.source)) {
    return ["typescript", content];
  } // TODO: maybe we should write the flow symlink even if there isn't an 
  // comment so that if someone adds an  comment they don't have to run preconstruct dev again


  if (content.includes("@flow")) {
    return ["flow", content];
  }

  return [null, content];
}

async function writeFlowFile(typeSystemPromise, entrypoint) {
  let [typeSystem, content] = await typeSystemPromise;
  if (typeSystem === null) return;

  let cjsDistPath = _path.default.join(entrypoint.directory, entrypoint.main);

  if (typeSystem === "flow") {
    await fs.symlink(entrypoint.source, cjsDistPath + ".flow");
  }

  if (typeSystem === "typescript") {
    let ast = await babel.parseAsync(content, {
      filename: entrypoint.source,
      sourceType: "module",
      cwd: entrypoint.package.project.directory
    });
    let hasDefaultExport = false;

    for (let statement of ast.program.body) {
      if (statement.type === "ExportDefaultDeclaration" || statement.type === "ExportNamedDeclaration" && statement.specifiers.some(specifier => specifier.type === "ExportSpecifier" && specifier.exported.name === "default")) {
        hasDefaultExport = true;
        break;
      }
    }

    await fs.writeFile(cjsDistPath + ".ts", (0, _utils.tsTemplate)(hasDefaultExport, _path.default.relative(_path.default.dirname(cjsDistPath), entrypoint.source).replace(/\.tsx?$/, "")));
  }
}

async function dev(projectDir) {
  let project = await _project.Project.create(projectDir);
  project.packages.forEach(({
    entrypoints
  }) => entrypoints.forEach(x => x.strict()));
  (0, _logger.info)("project is valid!");
  let promises = [];
  await Promise.all(project.packages.map(pkg => {
    return Promise.all(pkg.entrypoints.map(async _entrypoint => {
      let entrypoint = _entrypoint.strict();

      let typeSystemPromise = getTypeSystem(entrypoint);
      await fs.remove(_path.default.join(entrypoint.directory, "dist"));
      await fs.ensureDir(_path.default.join(entrypoint.directory, "dist"));
      let promises = [writeFlowFile(typeSystemPromise, entrypoint), fs.writeFile(_path.default.join(entrypoint.directory, entrypoint.main), `'use strict';

let unregister = require('${require.resolve("@preconstruct/hook")}').___internalHook('${project.directory}');

module.exports = require('${entrypoint.source}');

unregister();
`)];

      if (entrypoint.module) {
        promises.push(fs.writeFile(_path.default.join(entrypoint.directory, entrypoint.module), cjsOnlyReexportTemplate(entrypoint.source)));
      }

      let browserField = entrypoint.browser;

      if (browserField) {
        for (let key of Object.keys(browserField)) {
          promises.push(fs.writeFile(_path.default.join(entrypoint.directory, browserField[key]), cjsOnlyReexportTemplate(entrypoint.source)));
        }
      }

      let rnField = entrypoint.reactNative;

      if (rnField) {
        for (let key of Object.keys(rnField)) {
          promises.push(fs.writeFile(_path.default.join(entrypoint.directory, rnField[key]), cjsOnlyReexportTemplate(entrypoint.source)));
        }
      }

      return Promise.all(promises);
    }));
  }));
  await Promise.all(promises);
  (0, _logger.success)("created links!");
}