devflare 1.0.0-next.7 → 1.0.0-next.71

package/dist/_chunks/resolve-package-DeJUGxoE.js

@@ -0,0 +1,152 @@
+import { a as findFilesSync, i as findFiles, n as DEFAULT_ENTRYPOINT_PATTERN } from "./glob-DRw9sbfF.js";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, resolve } from "pathe";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { readFileSync as readFileSync$1 } from "fs";
+//#region src/utils/entrypoint-discovery.ts
+/**
+* Regex pattern to find WorkerEntrypoint class exports
+* Matches: export class ClassName extends WorkerEntrypoint
+*/
+const ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
+/**
+* Find WorkerEntrypoint classes in source code
+* @param code - Source code to search
+* @returns Array of class names found
+*/
+function findEntrypointClasses(code) {
+	const classes = [];
+	ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
+	let match = ENTRYPOINT_CLASS_PATTERN.exec(code);
+	while (match !== null) {
+		classes.push(match[1]);
+		match = ENTRYPOINT_CLASS_PATTERN.exec(code);
+	}
+	return classes;
+}
+/**
+* Discover entrypoint classes from a glob pattern synchronously.
+* Respects `.gitignore` automatically.
+*
+* @param cwd - Working directory for glob resolution
+* @param pattern - Glob pattern for entrypoint files (default: recursive `ep.*.{ts,js}` matching)
+* @returns Array of discovered entrypoints
+*/
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+	const discovered = [];
+	try {
+		const files = findFilesSync(pattern, { cwd });
+		for (const file of files) try {
+			const classNames = findEntrypointClasses(readFileSync$1(file, "utf-8"));
+			for (const className of classNames) discovered.push({
+				className,
+				filePath: file
+			});
+		} catch {}
+	} catch {}
+	return discovered;
+}
+/**
+* Discover entrypoint classes from ep.*.ts files using glob pattern (async).
+* Respects .gitignore automatically.
+*
+* @param cwd - Working directory for glob
+* @param pattern - Glob pattern for ep.*.ts files (default: **​/ep.*.{ts,js})
+* @returns Array of discovered entrypoints
+*/
+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 classNames = findEntrypointClasses(await fs.readFile(filePath, "utf-8"));
+		for (const className of classNames) discovered.push({
+			className,
+			filePath
+		});
+	} catch {}
+	return discovered;
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const NOT_FOUND_CODES = new Set([
+	"MODULE_NOT_FOUND",
+	"ERR_MODULE_NOT_FOUND",
+	"ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+function isNotFoundError(error) {
+	if (!error || typeof error !== "object") return false;
+	const code = error.code;
+	return typeof code === "string" && NOT_FOUND_CODES.has(code);
+}
+/**
+* Find a package's own `package.json` by walking `node_modules` up the tree,
+* exactly like Node's directory resolution — and crucially WITHOUT consulting
+* the package's `exports` map (a package need not expose `./package.json`).
+*/
+function findPackageJsonByWalk(packageName, fromDir) {
+	let dir = resolve(fromDir);
+	while (true) {
+		const candidate = resolve(dir, "node_modules", packageName, "package.json");
+		if (existsSync(candidate)) return realpathSync(candidate);
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Resolve `specifier` from `fromDir` using ESM-first resolution.
+*
+* Chain:
+*   1. `import.meta.resolve` (Bun exposes this synchronously for ESM packages)
+*   2. `createRequire(fromDir).resolve` (CommonJS fallback)
+*
+* Only swallows MODULE_NOT_FOUND / ERR_MODULE_NOT_FOUND. Any other error
+* (syntax, permission, etc.) is re-thrown.
+*/
+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 {
+		return createRequire(fromFileUrl).resolve(specifier);
+	} catch (error) {
+		if (isNotFoundError(error)) return null;
+		throw error;
+	}
+}
+/**
+* Resolve a package specifier to a filesystem path
+* Handles workspace packages like '@devflare/case11-do-shared/devflare.config'
+*
+* @param specifier - Package specifier (e.g., '@scope/pkg/path' or './relative/path')
+* @param fromDir - Directory to resolve relative paths from
+* @returns Resolved filesystem path
+*/
+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 = findPackageJsonByWalk(parts, fromDir) ?? resolveSpecifier(`${parts}/package.json`, fromDir);
+	if (!pkgJsonPath) return resolve(fromDir, specifier);
+	const pkgDir = dirname(pkgJsonPath);
+	if (subpath) {
+		const exportPath = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).exports?.[`./${subpath}`];
+		if (exportPath) return resolve(pkgDir, typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import);
+		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;
+}
+//#endregion
+export { discoverEntrypointsAsync as n, discoverEntrypointsSync as r, resolvePackageSpecifier as t };

package/dist/_chunks/rolldown-runtime-CvQ6eiug.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };