@coat/cli/build/lockfiles/write-lockfiles.js

TODO: See #3

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.writeGlobalLockfile = writeGlobalLockfile;
exports.writeLocalLockfile = writeLocalLockfile;
var _fsExtra = _interopRequireDefault(require("fs-extra"));
var _immer = require("immer");
var _path = _interopRequireDefault(require("path"));
var _constants = require("../constants");
var _yaml = require("../file-types/yaml");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function stripEmptyPropertiesGlobal(lockfile) {
  return (0, _immer.produce)(lockfile, draft => {
    if (!lockfile.files.length) {
      delete draft.files;
    } else {
      var _draft$files;
      // Only place the "once" property if it is true
      (_draft$files = draft.files) === null || _draft$files === void 0 ? void 0 : _draft$files.forEach(file => {
        if ("once" in file && !file.once) {
          // eslint-disable-next-line no-param-reassign
          delete file.once;
        }
      });
    }
    if (!Object.keys(lockfile.setup).length) {
      draft === null || draft === void 0 ? true : delete draft.setup;
    }
    if (!lockfile.scripts.length) {
      delete draft.scripts;
    }
    if (!lockfile.dependencies.dependencies.length) {
      var _draft$dependencies;
      (_draft$dependencies = draft.dependencies) === null || _draft$dependencies === void 0 ? true : delete _draft$dependencies.dependencies;
    }
    if (!lockfile.dependencies.devDependencies.length) {
      var _draft$dependencies2;
      (_draft$dependencies2 = draft.dependencies) === null || _draft$dependencies2 === void 0 ? true : delete _draft$dependencies2.devDependencies;
    }
    if (!lockfile.dependencies.peerDependencies.length) {
      var _draft$dependencies3;
      (_draft$dependencies3 = draft.dependencies) === null || _draft$dependencies3 === void 0 ? true : delete _draft$dependencies3.peerDependencies;
    }
    if (!lockfile.dependencies.optionalDependencies.length) {
      var _draft$dependencies4;
      (_draft$dependencies4 = draft.dependencies) === null || _draft$dependencies4 === void 0 ? true : delete _draft$dependencies4.optionalDependencies;
    }

    // If no dependency key exists, the dependencies
    // property should also be deleted
    if (!Object.keys(draft.dependencies).length) {
      delete draft.dependencies;
    }
  });
}
function stripEmptyPropertiesLocal(lockfile) {
  return (0, _immer.produce)(lockfile, draft => {
    if (!lockfile.files.length) {
      delete draft.files;
    } else {
      var _draft$files2;
      // Only place the "once" property if it is true
      (_draft$files2 = draft.files) === null || _draft$files2 === void 0 ? void 0 : _draft$files2.forEach(file => {
        if ("once" in file && !file.once) {
          // eslint-disable-next-line no-param-reassign
          delete file.once;
        }
      });
    }
    if (draft.setup && !Object.keys(draft.setup).length) {
      delete draft.setup;
    }
  });
}
async function writeLockfile(coatLockfile, lockfilePath, context) {
  const lockfileContent = _yaml.yamlFileFunctions.polish(coatLockfile, lockfilePath, context);
  await _fsExtra.default.outputFile(lockfilePath, lockfileContent);
}

/**
 * Strips all unnecessary properties from the provided lockfile and
 * writes the result to the global lockfile location:
 * project-dir/coat.lock
 *
 * @param coatLockfile The new global lockfile that should be written to the disk
 * @param context The context of the current coat project
 */
async function writeGlobalLockfile(coatLockfile, context) {
  const lockfilePath = _path.default.join(context.cwd, _constants.COAT_GLOBAL_LOCKFILE_PATH);
  // Strip properties to not save empty properties onto the disk
  const leanLockfile = stripEmptyPropertiesGlobal(coatLockfile);
  await writeLockfile(leanLockfile, lockfilePath, context);
}

/**
 * Strips all unnecessary properties from the provided lockfile and
 * writes the result to the local lockfile location:
 * project-dir/.coat/coat.lock
 *
 * @param coatLockfile The new local lockfile that should be written to the disk
 * @param context The context of the current coat project
 */
async function writeLocalLockfile(coatLockfile, context) {
  const lockfilePath = _path.default.join(context.cwd, _constants.COAT_LOCAL_LOCKFILE_PATH);
  // Strip properties to not save empty properties onto the disk
  const leanLockfile = stripEmptyPropertiesLocal(coatLockfile);
  await writeLockfile(leanLockfile, lockfilePath, context);
}