@fml-inc/fml 0.7.0 → 0.8.0-rc.2

package/dist/chunk-7V7G7NVF.js

@@ -0,0 +1,142 @@
+// src/repo.ts
+import { execFile, execFileSync } from "child_process";
+var REPO_CACHE = /* @__PURE__ */ new Map();
+var ASYNC_REPO_CACHE = /* @__PURE__ */ new Map();
+var GIT_TIMEOUT_MS = 5e3;
+var POSITIVE_REPO_CACHE_TTL_MS = 3e4;
+var NEGATIVE_REPO_CACHE_TTL_MS = 1e3;
+var MAX_REPO_CACHE_ENTRIES = 256;
+function cachedRepo(cwd) {
+  const entry = REPO_CACHE.get(cwd);
+  if (!entry) return { hit: false };
+  if (entry.expiresAtMs <= Date.now()) {
+    REPO_CACHE.delete(cwd);
+    return { hit: false };
+  }
+  REPO_CACHE.delete(cwd);
+  REPO_CACHE.set(cwd, entry);
+  return { hit: true, value: entry.value };
+}
+function cacheRepo(cwd, value) {
+  REPO_CACHE.delete(cwd);
+  while (REPO_CACHE.size >= MAX_REPO_CACHE_ENTRIES) {
+    const oldest = REPO_CACHE.keys().next().value;
+    if (oldest === void 0) break;
+    REPO_CACHE.delete(oldest);
+  }
+  REPO_CACHE.set(cwd, {
+    value,
+    expiresAtMs: Date.now() + (value === null ? NEGATIVE_REPO_CACHE_TTL_MS : POSITIVE_REPO_CACHE_TTL_MS)
+  });
+}
+function git(cwd, args, timeoutMs) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function gitAsync(cwd, args, signal) {
+  return new Promise((resolve, reject) => {
+    try {
+      execFile(
+        "git",
+        ["-C", cwd, ...args],
+        {
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS,
+          windowsHide: true,
+          ...signal ? { signal } : {}
+        },
+        (error, stdout) => {
+          if (signal?.aborted) {
+            reject(signal.reason ?? new Error("Repository lookup aborted"));
+            return;
+          }
+          resolve(error ? null : stdout.trim() || null);
+        }
+      );
+    } catch (error) {
+      if (signal?.aborted) {
+        reject(signal.reason ?? error);
+        return;
+      }
+      resolve(null);
+    }
+  });
+}
+function repositorySlug(remote) {
+  const ssh = remote.match(/^[^@]+@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (ssh?.[1]) return ssh[1];
+  try {
+    const url = new URL(remote);
+    const slug = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+    return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(slug) ? slug : null;
+  } catch {
+    return null;
+  }
+}
+function resolveRepoFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value;
+  const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
+  const repo = remote ? repositorySlug(remote) : null;
+  const result = repo ? {
+    repo,
+    branch: git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], timeoutMs)
+  } : null;
+  cacheRepo(cwd, result);
+  return result;
+}
+function resolveRepositorySlugFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value?.repo ?? null;
+  const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
+  return remote ? repositorySlug(remote) : null;
+}
+function resolveRepositoryRootFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
+  return git(cwd, ["rev-parse", "--show-toplevel"], timeoutMs);
+}
+async function resolveRepoFromCwdAsync(cwd, signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new Error("Repository lookup aborted");
+  }
+  const cached = cachedRepo(cwd);
+  if (cached.hit) return cached.value;
+  const cachedResolution = ASYNC_REPO_CACHE.get(cwd);
+  if (cachedResolution) return await cachedResolution;
+  const resolution = (async () => {
+    const remote = await gitAsync(cwd, ["remote", "get-url", "origin"], signal);
+    const repo = remote ? repositorySlug(remote) : null;
+    const result = repo ? {
+      repo,
+      branch: await gitAsync(
+        cwd,
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        signal
+      )
+    } : null;
+    cacheRepo(cwd, result);
+    return result;
+  })();
+  ASYNC_REPO_CACHE.set(cwd, resolution);
+  try {
+    return await resolution;
+  } finally {
+    if (ASYNC_REPO_CACHE.get(cwd) === resolution) {
+      ASYNC_REPO_CACHE.delete(cwd);
+    }
+  }
+}
+
+export {
+  resolveRepoFromCwd,
+  resolveRepositorySlugFromCwd,
+  resolveRepositoryRootFromCwd,
+  resolveRepoFromCwdAsync
+};