screw-up 1.5.0 → 1.7.0

package/dist/{packageMetadata-C2Yob7-F.js → packageMetadata-CTjfzPVl.js}

@@ -1,16 +1,16 @@
 /*!
  * name: screw-up
- * version: 1.5.0
+ * version: 1.7.0
  * description: Simply package metadata inserter on Vite plugin
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/screw-up.git
- * git.commit.hash: 72fd5b88656bc400ba3fed500895826208e23217
+ * git.commit.hash: 0865d5a2d4d1e89be8dae4b6abeba1393a767707
  */
 import { existsSync } from "fs";
 import * as fs from "fs/promises";
-import { readFile } from "fs/promises";
-import { dirname, join } from "path";
+import fs__default, { readFile } from "fs/promises";
+import path, { dirname, join } from "path";
 import { glob } from "glob";
 import * as git from "isomorphic-git";
 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
@@ -1651,6 +1651,195 @@ function requireDayjs_min() {
 }
 var dayjs_minExports = requireDayjs_min();
 const dayjs = /* @__PURE__ */ getDefaultExportFromCjs(dayjs_minExports);
+const parsePackedRefs = async (packedRefsPath) => {
+  try {
+    const content = await fs__default.readFile(packedRefsPath, "utf-8");
+    const lines = content.split("\n");
+    const tags = [];
+    for (const line2 of lines) {
+      if (line2.startsWith("#") || !line2.trim()) continue;
+      const match = line2.match(/^[0-9a-f]{40}\s+refs\/tags\/(.+)$/);
+      if (match) {
+        const tagName = match[1];
+        if (!tagName.endsWith("^{}")) {
+          tags.push(tagName);
+        }
+      }
+    }
+    return tags;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+const readLooseTags = async (refsTagsPath) => {
+  try {
+    const entries = await fs__default.readdir(refsTagsPath, { withFileTypes: true });
+    const tags = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        tags.push(entry.name);
+      }
+    }
+    return tags;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+const listTagsFast = async (repoPath) => {
+  const gitDir = path.join(repoPath, ".git");
+  const gitStat = await fs__default.stat(gitDir).catch(() => null);
+  let actualGitDir = gitDir;
+  if (gitStat == null ? void 0 : gitStat.isFile()) {
+    const content = await fs__default.readFile(gitDir, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (match) {
+      actualGitDir = path.isAbsolute(match[1]) ? match[1] : path.join(repoPath, match[1]);
+    }
+  }
+  const [packedTags, looseTags] = await Promise.all([
+    parsePackedRefs(path.join(actualGitDir, "packed-refs")),
+    readLooseTags(path.join(actualGitDir, "refs", "tags"))
+  ]);
+  const allTags = /* @__PURE__ */ new Set([...packedTags, ...looseTags]);
+  return Array.from(allTags).sort();
+};
+const resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
+  const startTime = Date.now();
+  const gitDir = path.join(repoPath, ".git");
+  const result = /* @__PURE__ */ new Map();
+  const gitStat = await fs__default.stat(gitDir).catch(() => null);
+  let actualGitDir = gitDir;
+  if (gitStat == null ? void 0 : gitStat.isFile()) {
+    const content = await fs__default.readFile(gitDir, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (match) {
+      actualGitDir = path.isAbsolute(match[1]) ? match[1] : path.join(repoPath, match[1]);
+    }
+  }
+  const tagSet = new Set(tagNames);
+  const packedRefsStart = Date.now();
+  try {
+    const content = await fs__default.readFile(
+      path.join(actualGitDir, "packed-refs"),
+      "utf-8"
+    );
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line2 = lines[i];
+      if (line2.startsWith("#") || !line2.trim()) continue;
+      const match = line2.match(/^([0-9a-f]{40})\s+refs\/tags\/(.+)$/);
+      if (match && tagSet.has(match[2])) {
+        const tagName = match[2];
+        const oid = match[1];
+        let commitOid = oid;
+        if (i + 1 < lines.length && lines[i + 1].startsWith("^")) {
+          commitOid = lines[i + 1].substring(1, 41);
+        }
+        result.set(tagName, { oid, commitOid });
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  logger.debug(
+    `[fast-tags] read packed-refs: ${Date.now() - packedRefsStart}ms`
+  );
+  const remainingTags = tagNames.filter((tag) => !result.has(tag));
+  if (remainingTags.length > 0) {
+    const looseRefsStart = Date.now();
+    await Promise.all(
+      remainingTags.map(async (tagName) => {
+        const looseRefPath = path.join(actualGitDir, "refs", "tags", tagName);
+        try {
+          const hash = await fs__default.readFile(looseRefPath, "utf-8");
+          const oid = hash.trim();
+          let commitOid = oid;
+          try {
+            const { execSync } = require("child_process");
+            const objectType = execSync(
+              `git -C "${repoPath}" cat-file -t ${oid}`,
+              { encoding: "utf-8" }
+            ).trim();
+            if (objectType === "tag") {
+              const tagContent = execSync(
+                `git -C "${repoPath}" cat-file -p ${oid}`,
+                { encoding: "utf-8" }
+              );
+              const objectMatch = tagContent.match(/^object ([0-9a-f]{40})$/m);
+              if (objectMatch) {
+                commitOid = objectMatch[1];
+              }
+            }
+          } catch (error) {
+            logger.debug(
+              `[fast-tags] Could not determine object type for ${tagName}: ${error}`
+            );
+          }
+          result.set(tagName, { oid, commitOid });
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      })
+    );
+    logger.debug(
+      `[fast-tags] read loose refs: ${Date.now() - looseRefsStart}ms`
+    );
+  }
+  const totalTime = Date.now() - startTime;
+  logger.debug(`[fast-tags] resolveTagsBatchWithCommit total: ${totalTime}ms`);
+  logger.debug(`[fast-tags] Resolved ${result.size}/${tagNames.length} tags`);
+  return result;
+};
+const buildCompleteTagCache = async (repoPath, parseVersion2, logger) => {
+  const totalStart = Date.now();
+  const cache = /* @__PURE__ */ new Map();
+  const listStart = Date.now();
+  const tags = await listTagsFast(repoPath);
+  logger.debug(`[git-ops] listTagsFast: ${Date.now() - listStart}ms`);
+  logger.debug(`[git-ops] Found ${tags.length} tags`);
+  const resolveStart = Date.now();
+  const tagData = await resolveTagsBatchWithCommit(repoPath, tags, logger);
+  logger.debug(
+    `[git-ops] resolveTagsBatchWithCommit: ${Date.now() - resolveStart}ms`
+  );
+  const buildStart = Date.now();
+  for (const tagName of tags) {
+    const data = tagData.get(tagName);
+    if (!data) continue;
+    const { commitOid } = data;
+    const version2 = parseVersion2(tagName);
+    const tagInfo = {
+      name: tagName,
+      hash: commitOid,
+      version: version2
+    };
+    if (!cache.has(commitOid)) {
+      cache.set(commitOid, []);
+    }
+    cache.get(commitOid).push(tagInfo);
+  }
+  logger.debug(`[git-ops] build cache map: ${Date.now() - buildStart}ms`);
+  const sortStart = Date.now();
+  for (const tags2 of cache.values()) {
+    tags2.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  logger.debug(`[git-ops] sort tags: ${Date.now() - sortStart}ms`);
+  logger.debug(
+    `[git-ops] buildCompleteTagCache total: ${Date.now() - totalStart}ms`
+  );
+  logger.debug(`[git-ops] Built cache with ${cache.size} unique commits`);
+  return cache;
+};
 const parseVersionComponent = (value) => {
   const num = parseInt(value, 10);
   return num < 0 || num > 65535 ? void 0 : num;
@@ -1776,120 +1965,8 @@ const getCurrentCommit = async (repositoryPath) => {
     return void 0;
   }
 };
-const buildTagCache = async (repositoryPath) => {
-  const cache = {
-    commitToTags: /* @__PURE__ */ new Map(),
-    initialized: true
-  };
-  try {
-    const tags = await git.listTags({ fs, dir: repositoryPath });
-    await Promise.all(
-      tags.map(async (tagName) => {
-        try {
-          const tagOid = await git.resolveRef({
-            fs,
-            dir: repositoryPath,
-            ref: `refs/tags/${tagName}`
-          });
-          const version2 = parseVersion(tagName);
-          const tagInfo = {
-            name: tagName,
-            hash: tagOid,
-            // This will be updated for annotated tags
-            version: version2 && isValidVersion(version2) ? version2 : void 0
-          };
-          if (!cache.commitToTags.has(tagOid)) {
-            cache.commitToTags.set(tagOid, []);
-          }
-          cache.commitToTags.get(tagOid).push({ ...tagInfo, hash: tagOid });
-          try {
-            const tagObject = await git.readTag({
-              fs,
-              dir: repositoryPath,
-              oid: tagOid
-            });
-            if (tagObject && tagObject.tag.object) {
-              const commitOid = tagObject.tag.object;
-              const lightweightTags = cache.commitToTags.get(tagOid);
-              if (lightweightTags) {
-                const index = lightweightTags.findIndex(
-                  (t) => t.name === tagName
-                );
-                if (index >= 0) {
-                  lightweightTags.splice(index, 1);
-                  if (lightweightTags.length === 0) {
-                    cache.commitToTags.delete(tagOid);
-                  }
-                }
-              }
-              if (!cache.commitToTags.has(commitOid)) {
-                cache.commitToTags.set(commitOid, []);
-              }
-              cache.commitToTags.get(commitOid).push({ ...tagInfo, hash: commitOid });
-            }
-          } catch (e) {
-          }
-        } catch (e) {
-        }
-      })
-    );
-  } catch (e) {
-  }
-  return cache;
-};
-const getRelatedTagsFromCache = (cache, commitHash) => {
-  if (!cache.initialized) {
-    return [];
-  }
-  return cache.commitToTags.get(commitHash) || [];
-};
-const getRelatedTagsForVersioning = async (repositoryPath, commitHash) => {
-  try {
-    const tags = await git.listTags({ fs, dir: repositoryPath });
-    const tagInfos = [];
-    for (const tagName of tags) {
-      try {
-        const tagOid = await git.resolveRef({
-          fs,
-          dir: repositoryPath,
-          ref: `refs/tags/${tagName}`
-        });
-        if (tagOid === commitHash) {
-          const version2 = parseVersion(tagName);
-          if (version2 && isValidVersion(version2)) {
-            tagInfos.push({
-              name: tagName,
-              hash: commitHash,
-              version: version2
-            });
-          }
-        } else {
-          try {
-            const tagObject = await git.readTag({
-              fs,
-              dir: repositoryPath,
-              oid: tagOid
-            });
-            if (tagObject && tagObject.tag.object === commitHash) {
-              const version2 = parseVersion(tagName);
-              if (version2 && isValidVersion(version2)) {
-                tagInfos.push({
-                  name: tagName,
-                  hash: commitHash,
-                  version: version2
-                });
-              }
-            }
-          } catch (e) {
-          }
-        }
-      } catch (e) {
-      }
-    }
-    return tagInfos;
-  } catch (e) {
-    return [];
-  }
+const getRelatedTagsFromMap = (commitToTags, commitHash) => {
+  return commitToTags.get(commitHash) || [];
 };
 const getRelatedBranches = async (repositoryPath, commitHash) => {
   try {
@@ -1931,7 +2008,7 @@ const getModifiedFiles = async (repositoryPath) => {
 const formatModifiedFile = (modifiedFile) => {
   return `'${modifiedFile[0]}':${modifiedFile[1]}:${modifiedFile[2]}:${modifiedFile[3]}`;
 };
-const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache) => {
+const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, commitToTags) => {
   const scheduledStack = [];
   let version2 = { major: 0, minor: 0, build: 1, original: "0.0.1" };
   let currentCommit = commit;
@@ -1940,7 +2017,7 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
       version2 = reachedCommits.get(currentCommit.hash);
       break;
     }
-    const relatedTags = tagCache ? getRelatedTagsFromCache(tagCache, currentCommit.hash) : await getRelatedTagsForVersioning(cwd, currentCommit.hash);
+    const relatedTags = getRelatedTagsFromMap(commitToTags, currentCommit.hash);
     const versionCandidates = relatedTags.filter((tag) => tag.version && isValidVersion(tag.version)).filter((tag) => tag.version.minor !== void 0).sort((a, b) => compareVersions(a.version, b.version));
     if (versionCandidates.length >= 1) {
       version2 = versionCandidates[0].version;
@@ -1976,7 +2053,7 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
           cwd,
           parents[index],
           reachedCommits,
-          tagCache
+          commitToTags
         );
         if (alternateParentVersion && compareVersions(alternateParentVersion, version2) < 0) {
           version2 = alternateParentVersion;
@@ -1989,28 +2066,44 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
   return version2;
 };
 const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logger) => {
+  const startTime = Date.now();
   const metadata = {};
   let gitRootPath;
   try {
     gitRootPath = await git.findRoot({ fs, filepath: repositoryPath });
   } catch (e) {
+    logger.debug(
+      `[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`
+    );
     return metadata;
   }
   try {
     const currentCommit = await getCurrentCommit(gitRootPath);
     if (!currentCommit) {
+      logger.debug(
+        `[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`
+      );
       return metadata;
     }
-    const tagCache = await buildTagCache(gitRootPath);
+    const buildStart = Date.now();
+    const commitToTags = await buildCompleteTagCache(
+      gitRootPath,
+      (tagName) => {
+        const version22 = parseVersion(tagName);
+        return version22 && isValidVersion(version22) ? version22 : void 0;
+      },
+      logger
+    );
     logger.debug(
-      `Built tag cache with ${tagCache.commitToTags.size} commit entries`
+      `[screw-up] buildCompleteTagCache: ${Date.now() - buildStart}ms`
     );
+    logger.debug(`Built tag map with ${commitToTags.size} commits`);
     const reachedCommits = /* @__PURE__ */ new Map();
     let version2 = await lookupVersionLabelRecursive(
       gitRootPath,
       currentCommit,
       reachedCommits,
-      tagCache
+      commitToTags
     );
     const gitMetadata = { tags: [], branches: [] };
     metadata.git = gitMetadata;
@@ -2035,7 +2128,7 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
       date: dayjs(currentCommit.date).format("YYYY-MM-DDTHH:mm:ssZ[Z]"),
       message: currentCommit.message
     };
-    const relatedTags = getRelatedTagsFromCache(tagCache, currentCommit.hash);
+    const relatedTags = getRelatedTagsFromMap(commitToTags, currentCommit.hash);
     gitMetadata.tags = relatedTags.map((tag) => tag.name);
     const relatedBranches = await getRelatedBranches(
       gitRootPath,
@@ -2045,6 +2138,7 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
   } catch (error) {
     logger.warn(`Failed to extract git metadata: ${error}`);
   }
+  logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
   return metadata;
 };
 const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) => {
@@ -2061,11 +2155,11 @@ const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) =>
   };
 };
 const name = "screw-up";
-const version = "1.5.0";
+const version = "1.7.0";
 const author = "Kouji Matsui (@kekyo@mi.kekyo.net)";
 const license = "MIT";
 const repository_url = "https://github.com/kekyo/screw-up.git";
-const git_commit_hash = "72fd5b88656bc400ba3fed500895826208e23217";
+const git_commit_hash = "0865d5a2d4d1e89be8dae4b6abeba1393a767707";
 const packageMetadata = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   author,
@@ -2088,4 +2182,4 @@ export {
   resolvePackageMetadata as r,
   version as v
 };
-//# sourceMappingURL=packageMetadata-C2Yob7-F.js.map
+//# sourceMappingURL=packageMetadata-CTjfzPVl.js.map