unbag/dist/esm/commands/release/changelog.mjs

一个专门用来开发npm工具的包

import { useFs } from "../../utils/fs.mjs";
import { useLog } from "./../../utils/log.mjs";
import { useMessage } from "../../utils/message/index.mjs";
import { usePath } from "../../utils/path.mjs";
import { useTagPrefix } from "./utils.mjs";
import conventionalChangelog from "conventional-changelog";
const ReleaseChangelogConfigDefault = {
  filePath: "CHANGELOG.md",
  filePathResolve: async ({
    finalUserConfig
  }) => {
    const {
      root,
      release: {
        changelog: {
          filePath
        }
      }
    } = finalUserConfig;
    const path = usePath();
    const absolutePath = path.resolve(root, filePath);
    return absolutePath;
  },
  fileRead: async ({
    finalUserConfig
  }) => {
    const {
      release: {
        changelog: {
          filePathResolve
        }
      }
    } = finalUserConfig;
    const changelogFileAbsolutePath = await filePathResolve({
      finalUserConfig
    });
    const fs = useFs();
    const fileExist = await fs.pathExists(changelogFileAbsolutePath);
    const content = fileExist ? await fs.readFile(changelogFileAbsolutePath, "utf-8") : "";
    return changelogContentParser(content);
  },
  fileWrite: async ({
    finalUserConfig,
    changelogRes
  }) => {
    const {
      release: {
        changelog: {
          filePathResolve
        }
      }
    } = finalUserConfig;
    const changelogFileAbsolutePath = await filePathResolve({
      finalUserConfig
    });
    const fs = useFs();
    const changelogContent = changelogContentStringify(changelogRes);
    await fs.outputFile(changelogFileAbsolutePath, changelogContent);
  }
};
const streamToString = stream => {
  const chunks = [];
  return new Promise((resolve, reject) => {
    stream.on("data", chunk => chunks.push(Buffer.from(chunk)));
    stream.on("error", err => reject(err));
    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
  });
};
const ChangelogHeaderDividerTag = "\n\n[comment]: # (!!!ChangelogHeaderDividerTag!!!)\n\n";
const ChangelogFooterDividerTag = "\n\n[comment]: # (!!!ChangelogFooterDividerTag!!!)\n\n";
const changelogContentParser = content => {
  const result = {};
  const headerIndex = content.indexOf(ChangelogHeaderDividerTag);
  const footerIndex = content.indexOf(ChangelogFooterDividerTag);
  if (headerIndex > -1) {
    result.header = content.substring(0, headerIndex);
  }
  result.body = content.substring(headerIndex > -1 ? ChangelogHeaderDividerTag.length + headerIndex : 0, footerIndex > -1 ? footerIndex : void 0);
  if (footerIndex > -1) {
    result.footer = content.substring(footerIndex + ChangelogHeaderDividerTag.length);
  }
  return result;
};
const changelogContentStringify = content => {
  const {
    body,
    header,
    footer
  } = content;
  return "" + (header || "") + ChangelogHeaderDividerTag + (body || "") + ChangelogFooterDividerTag + (footer || "");
};
const changelog = async params => {
  const {
    finalUserConfig,
    bumpRes
  } = params;
  const log = useLog({
    finalUserConfig
  });
  const message = useMessage({
    locale: finalUserConfig.locale
  });
  log.info(message.release.changelog.generating());
  const {
    release: {
      dry,
      scope,
      preset,
      changelog: {
        fileRead,
        header,
        footer,
        fileWrite,
        fileWriteDisable,
        logAddChangesetDisable,
        scopeNoWriteDisable,
        genParserOpts,
        genWriterOpts
      }
    }
  } = finalUserConfig;
  const tagPrefix = await useTagPrefix({
    finalUserConfig
  });
  const parserOpts = await genParserOpts?.();
  const writerOpts = await genWriterOpts?.();
  const conventionalChangelogStream = conventionalChangelog({
    //@ts-ignore
    preset: {
      name: preset.path,
      ...preset.params
    },
    tagPrefix,
    transform: (commit, cb) => {
      if (scope?.name) {
        if (commit.scope === scope.name) {
          if (!scopeNoWriteDisable) {
            commit.scope = void 0;
          }
          cb(null, commit);
        } else {
          cb(null, void 0);
        }
      } else {
        cb(null, commit);
      }
    }
  }, {
    version: bumpRes.version
  }, void 0, parserOpts, writerOpts);
  const newChangeset = await streamToString(conventionalChangelogStream);
  const oldContent = await fileRead({
    finalUserConfig
  });
  const newContent = {
    header,
    footer,
    body: "" + newChangeset + "\n" + (oldContent?.body || "")
  };
  let _fileWriteDisable = fileWriteDisable;
  if (dry) {
    _fileWriteDisable = true;
    log.warn(message.release.dry.changelog.fileWriteDisable());
  }
  if (!logAddChangesetDisable) {
    log.warn(message.release.changelog.newChangeset({
      newChangeset
    }));
  }
  if (!_fileWriteDisable) {
    log.info(message.releaseChangelogFileWriting());
    await fileWrite({
      finalUserConfig,
      changelogRes: newContent
    });
    log.info(message.releaseChangelogFileWriteSuccess());
  } else {
    log.warn(message.releaseChangelogFileWriteDisable());
  }
  return newContent;
};
export { ReleaseChangelogConfigDefault, changelog, changelogContentParser, changelogContentStringify };