devflare 1.0.0-next.20 → 1.0.0-next.21

package/dist/index-3edvz3hs.js

@@ -0,0 +1,124 @@
+import {
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles,
+  findFilesSync
+} from "./index-qwgr4q7s.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/utils/entrypoint-discovery.ts
+import { readFileSync } from "fs";
+var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
+function findEntrypointClasses(code) {
+  const classes = [];
+  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const discovered = [];
+  try {
+    const files = findFilesSync(pattern, { cwd });
+    for (const file of files) {
+      try {
+        const code = readFileSync(file, "utf-8");
+        const classNames = findEntrypointClasses(code);
+        for (const className of classNames) {
+          discovered.push({ className, filePath: file });
+        }
+      } catch {}
+    }
+  } catch {}
+  return discovered;
+}
+async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const fs = await import("node:fs/promises");
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findEntrypointClasses(code);
+      for (const className of classNames) {
+        discovered.push({ className, filePath });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+
+// src/utils/resolve-package.ts
+import { resolve, dirname } from "pathe";
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+var NOT_FOUND_CODES = new Set(["MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND"]);
+function isNotFoundError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  return typeof code === "string" && NOT_FOUND_CODES.has(code);
+}
+function resolveSpecifier(specifier, fromDir) {
+  const fromFileUrl = pathToFileURL(resolve(fromDir, "package.json")).href;
+  const importMetaResolve = import.meta.resolve;
+  if (typeof importMetaResolve === "function") {
+    try {
+      const resolved = importMetaResolve(specifier, fromFileUrl);
+      if (typeof resolved === "string") {
+        return resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved;
+      }
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  try {
+    const require_ = createRequire(fromFileUrl);
+    return require_.resolve(specifier);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function resolvePackageSpecifier(specifier, fromDir) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
+    return resolve(fromDir, specifier);
+  }
+  const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+  const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
+  const pkgJsonPath = resolveSpecifier(`${parts}/package.json`, fromDir);
+  if (!pkgJsonPath) {
+    return resolve(fromDir, specifier);
+  }
+  const pkgDir = dirname(pkgJsonPath);
+  if (subpath) {
+    const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+    const exportPath = pkgJson.exports?.[`./${subpath}`];
+    if (exportPath) {
+      const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
+      return resolve(pkgDir, targetPath);
+    }
+    const directPath = resolve(pkgDir, `${subpath}.ts`);
+    if (existsSync(directPath))
+      return directPath;
+    const withExt = resolve(pkgDir, subpath);
+    if (existsSync(withExt))
+      return withExt;
+    if (existsSync(`${withExt}.ts`))
+      return `${withExt}.ts`;
+    if (existsSync(`${withExt}.js`))
+      return `${withExt}.js`;
+  }
+  return pkgDir;
+}
+
+export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };