@darkobits/re-pack/dist/lib/utils.js

Utility for managing NPM package contents.

import path from "path";
import fs from "fs-extra";
import ow from "ow";
import * as R from "ramda";
import { readPackageUp } from "read-package-up";
import semver from "semver";
import { temporaryDirectory } from "tempy";
import { REWRITE_FIELDS } from "../etc/constants.js";
import log from "./log.js";
async function getPackageInfo(cwd = process.cwd()) {
  const pkgInfo = await readPackageUp({ cwd });
  if (!pkgInfo)
    throw new Error(`${log.chalk.magenta("getPackageInfo")} Unable to locate package root from: ${log.chalk.green(cwd)}`);
  const root = path.dirname(pkgInfo.path);
  const json = pkgInfo.packageJson;
  return { json, root };
}
function isEmpty(value) {
  if (ow.isValid(value, ow.array))
    return R.none(R.identity, value);
  if (ow.isValid(value, ow.object))
    return R.none(R.identity, R.values(value));
  return R.isEmpty(value);
}
async function createPackDir(workspacePath) {
  const resolvedPackDir = workspacePath ? path.resolve(workspacePath) : temporaryDirectory();
  try {
    await fs.ensureDir(resolvedPackDir);
  } catch (err) {
    err.message = `${log.chalk.magenta("createPackDir")} Unable to create re-pack directory: ${err.message}`;
    throw err;
  }
  try {
    await fs.emptyDir(resolvedPackDir);
  } catch (err) {
    err.message = `${log.chalk.magenta("createPackDir")} Unable to ensure publish workspace is empty: ${err.message}`;
    throw err;
  }
  log.verbose(log.chalk.magenta("createPackDir"), `Created re-pack directory: ${log.chalk.green(resolvedPackDir)}`);
  return resolvedPackDir;
}
async function rewritePackageJson({ pkgJson, hoistDir, packDir }) {
  const rewriteField = (value) => {
    const relativePath = path.relative(hoistDir, value);
    if (relativePath)
      return `./${path.relative(hoistDir, value)}`;
    return relativePath;
  };
  try {
    const newPkgJson = R.reduce((acc, curField) => {
      if (!R.has(curField, acc))
        return acc;
      const curValue = pkgJson[curField];
      let newValue;
      if (ow.isValid(curValue, ow.string)) {
        newValue = rewriteField(curValue);
      } else if (ow.isValid(curValue, ow.array.ofType(ow.string))) {
        newValue = R.map(rewriteField, curValue);
      } else if (ow.isValid(curValue, ow.object.valuesOfType(ow.string))) {
        newValue = R.mapObjIndexed(rewriteField, curValue);
      } else {
        throw new Error(`Encountered unknown field in package.json: ${log.chalk.yellow(curField)}`);
      }
      if (isEmpty(newValue)) {
        log.verbose(log.chalk.magenta("rewritePackageJson"), `Omitting empty/superfluous field: ${log.chalk.yellow(curField)}.`);
        return R.dissoc(curField, acc);
      }
      return R.assoc(curField, newValue, acc);
    }, pkgJson, REWRITE_FIELDS);
    await fs.writeJson(path.resolve(packDir, "package.json"), newPkgJson, { spaces: 2 });
    log.verbose(log.chalk.magenta("rewritePackageJson"), `Wrote ${log.chalk.green("package.json")} to publish workspace.`);
  } catch (err) {
    throw new Error(`${log.chalk.magenta("rewritePackageJson")} Error re-writing package.json: ${err.message}`);
  }
}
function inferPublishTag(pkgVersion) {
  const parsed = semver.parse(pkgVersion, { includePrerelease: true });
  if (parsed && parsed.prerelease.length > 0 && typeof parsed.prerelease[0] === "string") {
    return parsed.prerelease[0];
  }
}
async function temporarilyRemoveProblematicPackageScripts(pkgInfo) {
  const pkgJsonPath = path.join(pkgInfo.root, "package.json");
  const clonedPackageJson = R.clone(pkgInfo.json);
  const prepareScript = R.path(["scripts", "prepare"], clonedPackageJson);
  if (prepareScript && clonedPackageJson.scripts) {
    log.warn(log.chalk.magenta("link"), `Blocking invocation of prepare script: ${log.chalk.green(`"${prepareScript}"`)}`);
    Reflect.deleteProperty(clonedPackageJson.scripts, "prepare");
  }
  const prepublishOnlyScript = R.path(["scripts", "prepublishOnly"], clonedPackageJson);
  if (prepublishOnlyScript && clonedPackageJson.scripts) {
    log.warn(log.chalk.magenta("link"), `Blocking invocation of prepublishOnly script: ${log.chalk.green(`"${prepublishOnlyScript}"`)}`);
    Reflect.deleteProperty(clonedPackageJson.scripts, "prepublishOnly");
  }
  await fs.writeJSON(pkgJsonPath, clonedPackageJson, { spaces: 2 });
  return async () => {
    await fs.writeJSON(pkgJsonPath, pkgInfo.json, { spaces: 2 });
  };
}
export {
  createPackDir,
  getPackageInfo,
  inferPublishTag,
  isEmpty,
  rewritePackageJson,
  temporarilyRemoveProblematicPackageScripts
};
//# sourceMappingURL=utils.js.map