@hadl-labs/changelog-github 0.1.0 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { ChangelogFunctions } from "@changesets/types";
+declare const changelogFunctions: ChangelogFunctions;
+export default changelogFunctions;

package/dist/index.js

@@ -0,0 +1,579 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// node_modules/node-fetch/browser.js
+var require_browser = __commonJS((exports2, module2) => {
+  var getGlobal = function() {
+    if (typeof self !== "undefined") {
+      return self;
+    }
+    if (typeof window !== "undefined") {
+      return window;
+    }
+    if (typeof global !== "undefined") {
+      return global;
+    }
+    throw new Error("unable to locate global object");
+  };
+  var globalObject = getGlobal();
+  module2.exports = exports2 = globalObject.fetch;
+  if (globalObject.fetch) {
+    exports2.default = globalObject.fetch.bind(globalObject);
+  }
+  exports2.Headers = globalObject.Headers;
+  exports2.Request = globalObject.Request;
+  exports2.Response = globalObject.Response;
+});
+
+// node_modules/dataloader/index.js
+var require_dataloader = __commonJS((exports2, module2) => {
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  var DataLoader = function() {
+    function DataLoader2(batchLoadFn, options) {
+      _classCallCheck(this, DataLoader2);
+      if (typeof batchLoadFn !== "function") {
+        throw new TypeError("DataLoader must be constructed with a function which accepts " + ("Array<key> and returns Promise<Array<value>>, but got: " + batchLoadFn + "."));
+      }
+      this._batchLoadFn = batchLoadFn;
+      this._options = options;
+      this._promiseCache = getValidCacheMap(options);
+      this._queue = [];
+    }
+    DataLoader2.prototype.load = function load(key) {
+      var _this = this;
+      if (key === null || key === undefined) {
+        throw new TypeError("The loader.load() function must be called with a value," + ("but got: " + String(key) + "."));
+      }
+      var options = this._options;
+      var shouldBatch = !options || options.batch !== false;
+      var shouldCache = !options || options.cache !== false;
+      var cacheKeyFn = options && options.cacheKeyFn;
+      var cacheKey = cacheKeyFn ? cacheKeyFn(key) : key;
+      if (shouldCache) {
+        var cachedPromise = this._promiseCache.get(cacheKey);
+        if (cachedPromise) {
+          return cachedPromise;
+        }
+      }
+      var promise = new Promise(function(resolve, reject) {
+        _this._queue.push({ key, resolve, reject });
+        if (_this._queue.length === 1) {
+          if (shouldBatch) {
+            enqueuePostPromiseJob(function() {
+              return dispatchQueue(_this);
+            });
+          } else {
+            dispatchQueue(_this);
+          }
+        }
+      });
+      if (shouldCache) {
+        this._promiseCache.set(cacheKey, promise);
+      }
+      return promise;
+    };
+    DataLoader2.prototype.loadMany = function loadMany(keys) {
+      var _this2 = this;
+      if (!Array.isArray(keys)) {
+        throw new TypeError("The loader.loadMany() function must be called with Array<key> " + ("but got: " + keys + "."));
+      }
+      return Promise.all(keys.map(function(key) {
+        return _this2.load(key);
+      }));
+    };
+    DataLoader2.prototype.clear = function clear(key) {
+      var cacheKeyFn = this._options && this._options.cacheKeyFn;
+      var cacheKey = cacheKeyFn ? cacheKeyFn(key) : key;
+      this._promiseCache.delete(cacheKey);
+      return this;
+    };
+    DataLoader2.prototype.clearAll = function clearAll() {
+      this._promiseCache.clear();
+      return this;
+    };
+    DataLoader2.prototype.prime = function prime(key, value) {
+      var cacheKeyFn = this._options && this._options.cacheKeyFn;
+      var cacheKey = cacheKeyFn ? cacheKeyFn(key) : key;
+      if (this._promiseCache.get(cacheKey) === undefined) {
+        var promise = value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+        this._promiseCache.set(cacheKey, promise);
+      }
+      return this;
+    };
+    return DataLoader2;
+  }();
+  var enqueuePostPromiseJob = typeof process === "object" && typeof process.nextTick === "function" ? function(fn) {
+    if (!resolvedPromise) {
+      resolvedPromise = Promise.resolve();
+    }
+    resolvedPromise.then(function() {
+      return process.nextTick(fn);
+    });
+  } : setImmediate || setTimeout;
+  var resolvedPromise;
+  function dispatchQueue(loader) {
+    var queue = loader._queue;
+    loader._queue = [];
+    var maxBatchSize = loader._options && loader._options.maxBatchSize;
+    if (maxBatchSize && maxBatchSize > 0 && maxBatchSize < queue.length) {
+      for (var i = 0;i < queue.length / maxBatchSize; i++) {
+        dispatchQueueBatch(loader, queue.slice(i * maxBatchSize, (i + 1) * maxBatchSize));
+      }
+    } else {
+      dispatchQueueBatch(loader, queue);
+    }
+  }
+  function dispatchQueueBatch(loader, queue) {
+    var keys = queue.map(function(_ref) {
+      var key = _ref.key;
+      return key;
+    });
+    var batchLoadFn = loader._batchLoadFn;
+    var batchPromise = batchLoadFn(keys);
+    if (!batchPromise || typeof batchPromise.then !== "function") {
+      return failedDispatch(loader, queue, new TypeError("DataLoader must be constructed with a function which accepts " + "Array<key> and returns Promise<Array<value>>, but the function did " + ("not return a Promise: " + String(batchPromise) + ".")));
+    }
+    batchPromise.then(function(values) {
+      if (!Array.isArray(values)) {
+        throw new TypeError("DataLoader must be constructed with a function which accepts " + "Array<key> and returns Promise<Array<value>>, but the function did " + ("not return a Promise of an Array: " + String(values) + "."));
+      }
+      if (values.length !== keys.length) {
+        throw new TypeError("DataLoader must be constructed with a function which accepts " + "Array<key> and returns Promise<Array<value>>, but the function did " + "not return a Promise of an Array of the same length as the Array " + "of keys." + (`
+
+Keys:
+` + String(keys)) + (`
+
+Values:
+` + String(values)));
+      }
+      queue.forEach(function(_ref2, index) {
+        var { resolve, reject } = _ref2;
+        var value = values[index];
+        if (value instanceof Error) {
+          reject(value);
+        } else {
+          resolve(value);
+        }
+      });
+    }).catch(function(error) {
+      return failedDispatch(loader, queue, error);
+    });
+  }
+  function failedDispatch(loader, queue, error) {
+    queue.forEach(function(_ref3) {
+      var { key, reject } = _ref3;
+      loader.clear(key);
+      reject(error);
+    });
+  }
+  function getValidCacheMap(options) {
+    var cacheMap = options && options.cacheMap;
+    if (!cacheMap) {
+      return new Map;
+    }
+    var cacheFunctions = ["get", "set", "delete", "clear"];
+    var missingFunctions = cacheFunctions.filter(function(fnName) {
+      return cacheMap && typeof cacheMap[fnName] !== "function";
+    });
+    if (missingFunctions.length !== 0) {
+      throw new TypeError("Custom cacheMap missing methods: " + missingFunctions.join(", "));
+    }
+    return cacheMap;
+  }
+  module2.exports = DataLoader;
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_src);
+
+// node_modules/@changesets/get-github-info/dist/changesets-get-github-info.esm.js
+var import_node_fetch = __toESM(require_browser(), 1);
+var import_dataloader = __toESM(require_dataloader(), 1);
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly)
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1;i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0;i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0;i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0)
+        continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key))
+        continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+var _excluded = ["repo"];
+var _excluded2 = ["repo"];
+var validRepoNameRegex = /^[\w.-]+\/[\w.-]+$/;
+function makeQuery(repos) {
+  return `
+      query {
+        ${Object.keys(repos).map((repo, i) => `a${i}: repository(
+            owner: ${JSON.stringify(repo.split("/")[0])}
+            name: ${JSON.stringify(repo.split("/")[1])}
+          ) {
+            ${repos[repo].map((data) => data.kind === "commit" ? `a${data.commit}: object(expression: ${JSON.stringify(data.commit)}) {
+            ... on Commit {
+            commitUrl
+            associatedPullRequests(first: 50) {
+              nodes {
+                number
+                url
+                mergedAt
+                author {
+                  login
+                  url
+                }
+              }
+            }
+            author {
+              user {
+                login
+                url
+              }
+            }
+          }}` : `pr__${data.pull}: pullRequest(number: ${data.pull}) {
+                    url
+                    author {
+                      login
+                      url
+                    }
+                    mergeCommit {
+                      commitUrl
+                      abbreviatedOid
+                    }
+                  }`).join(`
+`)}
+          }`).join(`
+`)}
+        }
+    `;
+}
+var GHDataLoader = new import_dataloader.default(async (requests) => {
+  if (!process.env.GITHUB_TOKEN) {
+    throw new Error("Please create a GitHub personal access token at https://github.com/settings/tokens/new with `read:user` and `repo:status` permissions and add it as the GITHUB_TOKEN environment variable");
+  }
+  let repos = {};
+  requests.forEach((_ref) => {
+    let {
+      repo
+    } = _ref, data2 = _objectWithoutProperties(_ref, _excluded);
+    if (repos[repo] === undefined) {
+      repos[repo] = [];
+    }
+    repos[repo].push(data2);
+  });
+  const data = await import_node_fetch.default("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `Token ${process.env.GITHUB_TOKEN}`
+    },
+    body: JSON.stringify({
+      query: makeQuery(repos)
+    })
+  }).then((x) => x.json());
+  if (data.errors) {
+    throw new Error(`An error occurred when fetching data from GitHub
+${JSON.stringify(data.errors, null, 2)}`);
+  }
+  if (!data.data) {
+    throw new Error(`An error occurred when fetching data from GitHub
+${JSON.stringify(data)}`);
+  }
+  let cleanedData = {};
+  Object.keys(repos).forEach((repo, index) => {
+    let output = {
+      commit: {},
+      pull: {}
+    };
+    cleanedData[repo] = output;
+    Object.entries(data.data[`a${index}`]).forEach(([field, value]) => {
+      if (field[0] === "a") {
+        output.commit[field.substring(1)] = value;
+      } else {
+        output.pull[field.replace("pr__", "")] = value;
+      }
+    });
+  });
+  return requests.map((_ref2) => {
+    let {
+      repo
+    } = _ref2, data2 = _objectWithoutProperties(_ref2, _excluded2);
+    return cleanedData[repo][data2.kind][data2.kind === "pull" ? data2.pull : data2.commit];
+  });
+});
+async function getInfo(request) {
+  if (!request.commit) {
+    throw new Error("Please pass a commit SHA to getInfo");
+  }
+  if (!request.repo) {
+    throw new Error("Please pass a GitHub repository in the form of userOrOrg/repoName to getInfo");
+  }
+  if (!validRepoNameRegex.test(request.repo)) {
+    throw new Error(`Please pass a valid GitHub repository in the form of userOrOrg/repoName to getInfo (it has to match the "${validRepoNameRegex.source}" pattern)`);
+  }
+  const data = await GHDataLoader.load(_objectSpread2({
+    kind: "commit"
+  }, request));
+  let user = null;
+  if (data.author && data.author.user) {
+    user = data.author.user;
+  }
+  let associatedPullRequest = data.associatedPullRequests && data.associatedPullRequests.nodes && data.associatedPullRequests.nodes.length ? data.associatedPullRequests.nodes.sort((a, b) => {
+    if (a.mergedAt === null && b.mergedAt === null) {
+      return 0;
+    }
+    if (a.mergedAt === null) {
+      return 1;
+    }
+    if (b.mergedAt === null) {
+      return -1;
+    }
+    a = new Date(a.mergedAt);
+    b = new Date(b.mergedAt);
+    return a > b ? 1 : a < b ? -1 : 0;
+  })[0] : null;
+  if (associatedPullRequest) {
+    user = associatedPullRequest.author;
+  }
+  return {
+    user: user ? user.login : null,
+    pull: associatedPullRequest ? associatedPullRequest.number : null,
+    links: {
+      commit: `[\`${request.commit.slice(0, 7)}\`](${data.commitUrl})`,
+      pull: associatedPullRequest ? `[#${associatedPullRequest.number}](${associatedPullRequest.url})` : null,
+      user: user ? `[@${user.login}](${user.url})` : null
+    }
+  };
+}
+async function getInfoFromPullRequest(request) {
+  if (request.pull === undefined) {
+    throw new Error("Please pass a pull request number");
+  }
+  if (!request.repo) {
+    throw new Error("Please pass a GitHub repository in the form of userOrOrg/repoName to getInfo");
+  }
+  if (!validRepoNameRegex.test(request.repo)) {
+    throw new Error(`Please pass a valid GitHub repository in the form of userOrOrg/repoName to getInfo (it has to match the "${validRepoNameRegex.source}" pattern)`);
+  }
+  const data = await GHDataLoader.load(_objectSpread2({
+    kind: "pull"
+  }, request));
+  let user = data === null || data === undefined ? undefined : data.author;
+  let commit = data === null || data === undefined ? undefined : data.mergeCommit;
+  return {
+    user: user ? user.login : null,
+    commit: commit ? commit.abbreviatedOid : null,
+    links: {
+      commit: commit ? `[\`${commit.abbreviatedOid.slice(0, 7)}\`](${commit.commitUrl})` : null,
+      pull: `[#${request.pull}](https://github.com/${request.repo}/pull/${request.pull})`,
+      user: user ? `[@${user.login}](${user.url})` : null
+    }
+  };
+}
+
+// src/index.ts
+var changelogFunctions = {
+  getDependencyReleaseLine: async (changesets, dependenciesUpdated, options) => {
+    if (!options.repo) {
+      throw new Error(`Please provide a repo to this changelog generator like this:
+"changelog": ["@changesets/changelog-github", { "repo": "org/repo" }]`);
+    }
+    if (dependenciesUpdated.length === 0)
+      return "";
+    const changesetLink = `- Updated dependencies [${(await Promise.all(changesets.map(async (cs) => {
+      if (cs.commit) {
+        let { links } = await getInfo({
+          repo: options["repo"],
+          commit: cs.commit
+        });
+        return links.commit;
+      }
+      return null;
+    }))).filter((_) => _).join(", ")}]:`;
+    const updatedDepenenciesList = dependenciesUpdated.map((dependency) => `  - ${dependency.name}@${dependency.newVersion}`);
+    return [changesetLink, ...updatedDepenenciesList].join(`
+`);
+  },
+  getReleaseLine: async (changeset, _type, options) => {
+    if (!options || !options["repo"]) {
+      throw new Error(`Please provide a repo to this changelog generator like this:
+"changelog": ["@changesets/changelog-github", { "repo": "org/repo" }]`);
+    }
+    let prFromSummary;
+    let commitFromSummary;
+    let usersFromSummary = [];
+    let clickupLinks = [];
+    const replacedChangelog = changeset.summary.replace(/^\s*(?:pr|pull|pull\s+request):\s*#?(\d+)/im, (_, pr) => {
+      let num = Number(pr);
+      if (!isNaN(num))
+        prFromSummary = num;
+      return "";
+    }).replace(/^\s*commit:\s*([^\s]+)/im, (_, commit) => {
+      commitFromSummary = commit;
+      return "";
+    }).replace(/^\s*(?:author|user):\s*@?([^\s]+)/gim, (_, user) => {
+      usersFromSummary.push(user);
+      return "";
+    }).replace(/^\s*clickup:\s*(https:\/\/app\.clickup\.com\/t\/[^\s]+)/gim, (_, link) => {
+      clickupLinks.push(link);
+      return "";
+    }).trim();
+    const [firstLine, ...futureLines] = replacedChangelog.split(`
+`).map((l) => l.trimRight());
+    const links = await (async () => {
+      if (prFromSummary !== undefined) {
+        let { links: links2 } = await getInfoFromPullRequest({
+          repo: options["repo"],
+          pull: prFromSummary
+        });
+        if (commitFromSummary) {
+          const shortCommitId = commitFromSummary.slice(0, 7);
+          links2 = {
+            ...links2,
+            commit: `[\`${shortCommitId}\`](https://github.com/${options["repo"]}/commit/${commitFromSummary})`
+          };
+        }
+        return links2;
+      }
+      const commitToFetchFrom = commitFromSummary || changeset.commit;
+      if (commitToFetchFrom) {
+        let { links: links2 } = await getInfo({
+          repo: options["repo"],
+          commit: commitToFetchFrom
+        });
+        return links2;
+      }
+      return {
+        commit: null,
+        pull: null,
+        user: null
+      };
+    })();
+    const users = usersFromSummary.length ? usersFromSummary.map((userFromSummary) => `[@${userFromSummary}](https://github.com/${userFromSummary})`).join(", ") : links.user;
+    const clickupPart = clickupLinks.length > 0 ? ` ClickUp: ${clickupLinks.map((link) => {
+      const taskId = link.split("/").pop();
+      return `[${taskId}](${link})`;
+    }).join(", ")}` : "";
+    const prefix = [
+      links.pull === null ? "" : ` ${links.pull}`,
+      links.commit === null ? "" : ` ${links.commit}`,
+      users === null ? "" : ` Thanks ${users}!`,
+      clickupPart
+    ].join("");
+    return `
+
+-${prefix ? `${prefix} -` : ""} ${firstLine}
+${futureLines.map((l) => `  ${l}`).join(`
+`)}`;
+  }
+};
+var src_default = changelogFunctions;

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "@hadl-labs/changelog-github",
-  "version": "0.1.0",
-  "module": "src/index.ts",
-  "types": "src/index.ts",
-  "type": "module",
+  "version": "0.4.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
+    "build": "bun build src/index.ts --outdir dist --format cjs && tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "format": "prettier --check --log-level warn --cache --cache-strategy content '**/*.{js,ts,tsx,css,yml,yaml,json}'",
     "format:write": "prettier --write --log-level warn --cache --cache-strategy content '**/*.{js,ts,tsx,css,yml,yaml,json}'",
-    "check-updates": "npx npm-check-updates --format group --interactive"
+    "check-updates": "npx npm-check-updates --format group --interactive",
+    "release": "bun run build && changeset publish"
   },
   "dependencies": {
     "@changesets/get-github-info": "^0.6.0",
-    "@changesets/types": "^6.1.0"
+    "@changesets/types": "^6.1.0",
+    "@tsconfig/strictest": "^2.0.7"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",

package/.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
-  "changelog": ["@changesets/changelog-github", { "repo": "hadl-labs/changelog-github" }],
-  "commit": false,
-  "fixed": [],
-  "linked": [],
-  "access": "restricted",
-  "baseBranch": "master",
-  "updateInternalDependencies": "patch",
-  "ignore": []
-}