limina 0.0.1

package/chunks/dep-jgc7X0zw.js

@@ -0,0 +1,377 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+
+//#region src/utils/path.ts
+function toPosixPath(value) {
+	return value.split(path.sep).join("/");
+}
+function normalizeAbsolutePath(value) {
+	return toPosixPath(path.resolve(value));
+}
+function toRelativePath(rootDir, absolutePath) {
+	const relativePath = toPosixPath(path.relative(rootDir, path.resolve(absolutePath)));
+	return relativePath.length === 0 ? "." : relativePath;
+}
+function toAbsolutePath(rootDir, workspacePath) {
+	return path.resolve(rootDir, workspacePath);
+}
+function normalizeWorkspacePath(rootDir, value) {
+	return toRelativePath(rootDir, value);
+}
+function normalizeSlashes(value) {
+	return value.replaceAll("\\", "/");
+}
+function isPathInsideDirectory(filePath, directoryPath) {
+	const normalizedFilePath = normalizeAbsolutePath(filePath);
+	const normalizedDirectoryPath = normalizeAbsolutePath(directoryPath);
+	return normalizedFilePath === normalizedDirectoryPath || normalizedFilePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+
+//#endregion
+//#region src/checkers.ts
+function createTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: options.executionKind === "build" ? [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false"
+		] : [
+			"-p",
+			relativeConfigPath,
+			"--noEmit"
+		],
+		command: options.commandOverride ?? "tsc",
+		label: options.executionKind === "build" ? `tsc -b ${relativeConfigPath}` : `tsc: ${relativeConfigPath}`
+	};
+}
+function createVueTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: options.executionKind === "build" ? [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false"
+		] : [
+			"-p",
+			relativeConfigPath,
+			"--noEmit"
+		],
+		command: "vue-tsc",
+		label: options.executionKind === "build" ? `${options.checker.name}: vue-tsc -b ${relativeConfigPath}` : `${options.checker.name}: vue-tsc -p ${relativeConfigPath}`
+	};
+}
+function createSvelteCheckCommandTarget(options) {
+	if (options.executionKind === "build") throw new Error(`Checker "${options.checker.name}" uses svelte-check, which does not support checker:build.`);
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: ["--tsconfig", relativeConfigPath],
+		command: "svelte-check",
+		label: `${options.checker.name}: svelte-check --tsconfig ${relativeConfigPath}`
+	};
+}
+const builtinCheckerAdapters = {
+	"svelte-check": {
+		createCommandTarget: createSvelteCheckCommandTarget,
+		defaultExtensions: [".svelte"],
+		graph: false,
+		packageName: "svelte-check",
+		preset: "svelte-check",
+		supportedExecutions: ["typecheck"]
+	},
+	tsc: {
+		createCommandTarget: createTscCommandTarget,
+		defaultExtensions: [
+			".ts",
+			".tsx",
+			".cts",
+			".mts",
+			".d.ts",
+			".d.cts",
+			".d.mts",
+			".json"
+		],
+		graph: true,
+		packageName: "typescript",
+		preset: "tsc",
+		supportedExecutions: ["typecheck", "build"]
+	},
+	"vue-tsc": {
+		createCommandTarget: createVueTscCommandTarget,
+		defaultExtensions: [".vue"],
+		graph: false,
+		packageName: "vue-tsc",
+		preset: "vue-tsc",
+		supportedExecutions: ["typecheck", "build"]
+	}
+};
+function isBuiltinCheckerPreset(value) {
+	return Object.hasOwn(builtinCheckerAdapters, value);
+}
+function getCheckerAdapter(preset) {
+	return isBuiltinCheckerPreset(preset) ? builtinCheckerAdapters[preset] : null;
+}
+function resolveCheckerPackageFromRoot(options) {
+	const requireFromRoot = createRequire(path.join(options.projectRootDir, "package.json"));
+	try {
+		return requireFromRoot.resolve(`${options.packageName}/package.json`);
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return options.packageName;
+		if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") return;
+		throw error;
+	}
+}
+function collectMissingCheckerPeerDependencies(options) {
+	const resolvePackage = options.resolvePackage ?? resolveCheckerPackageFromRoot;
+	const missingCheckersByPackage = /* @__PURE__ */ new Map();
+	for (const checker of options.checkers) {
+		const packageName = getCheckerAdapter(checker.preset)?.packageName;
+		if (!packageName) continue;
+		if (resolvePackage({
+			packageName,
+			projectRootDir: options.projectRootDir
+		})) continue;
+		const checkerNames = missingCheckersByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
+		checkerNames.add(checker.name);
+		missingCheckersByPackage.set(packageName, checkerNames);
+	}
+	return [...missingCheckersByPackage.entries()].map(([packageName, checkerNames]) => ({
+		checkerNames: [...checkerNames].sort((left, right) => left.localeCompare(right)),
+		packageName
+	})).sort((left, right) => left.packageName.localeCompare(right.packageName));
+}
+function formatMissingCheckerPeerDependencies(missingDependencies) {
+	const packageNames = missingDependencies.map((dependency) => dependency.packageName);
+	return [
+		"Missing checker peer dependencies:",
+		...missingDependencies.map((dependency) => {
+			const checkerList = dependency.checkerNames.map((checkerName) => `"${checkerName}"`).join(", ");
+			return `  - ${dependency.packageName} (used by checker ${checkerList})`;
+		}),
+		`Fix: pnpm add -D ${packageNames.join(" ")}`
+	].join("\n");
+}
+function getCheckerExtensions(checker) {
+	if (checker.extensions) return normalizeExtensions(checker.extensions);
+	const adapter = getCheckerAdapter(checker.preset);
+	if (adapter?.defaultExtensions) return normalizeExtensions(adapter.defaultExtensions);
+	throw new Error(`Checker preset "${checker.preset}" must declare non-empty extensions because it is not a built-in preset.`);
+}
+function getResolvedCheckers(config) {
+	const checkers = config.config?.checkers;
+	if (!checkers) return [];
+	return Object.entries(checkers).map(([name, checker]) => ({
+		entry: checker.entry.trim(),
+		extensions: getCheckerExtensions(checker),
+		name,
+		preset: checker.preset
+	})).sort((left, right) => left.name.localeCompare(right.name));
+}
+function normalizeExtensions(extensions) {
+	return [...new Set(extensions)].sort((left, right) => {
+		const lengthDelta = right.length - left.length;
+		return lengthDelta === 0 ? left.localeCompare(right) : lengthDelta;
+	});
+}
+
+//#endregion
+//#region src/config.ts
+function defineConfig(config) {
+	return config;
+}
+const nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0);
+const dotPrefixedStringSchema = nonEmptyStringSchema.refine((value) => value.startsWith("."));
+const checkerObjectSchema = z.looseObject({});
+const checkerConfigShapeSchema = z.looseObject({
+	entry: nonEmptyStringSchema,
+	extensions: z.array(dotPrefixedStringSchema).nonempty().optional(),
+	preset: nonEmptyStringSchema
+});
+const liminaConfigShapeSchema = z.looseObject({ config: z.looseObject({ checkers: z.record(z.string(), checkerConfigShapeSchema).optional() }).optional() });
+function formatUnknownValue(value) {
+	if (value === void 0) return "undefined";
+	return JSON.stringify(value);
+}
+function formatZodPath(pathSegments) {
+	return pathSegments.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${String(segment)}`).join("").replace(/^\./u, "");
+}
+function getValueAtPath(value, pathSegments) {
+	let current = value;
+	for (const segment of pathSegments) {
+		if (current === void 0 || current === null) return;
+		current = current[segment];
+	}
+	return current;
+}
+function formatLiminaConfigShapeIssue(value, issue) {
+	const pathSegments = issue.path;
+	const field = formatZodPath(pathSegments);
+	if (pathSegments.length === 0) return "limina config must export or return an object.";
+	if (field === "config") return [
+		"Invalid Limina config:",
+		"  field: config",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: config must be an object."
+	].join("\n");
+	if (field === "config.checkers") return [
+		"Invalid Limina checker config:",
+		"  field: config.checkers",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: config.checkers must be an object keyed by checker name."
+	].join("\n");
+	if (pathSegments[0] === "config" && pathSegments[1] === "checkers") {
+		const checkerName = pathSegments[2];
+		const checkerField = `config.checkers.${String(checkerName)}`;
+		if (pathSegments.length === 3) return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			"  reason: checker entries must be objects."
+		].join("\n");
+		if (pathSegments[3] === "preset") return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}.preset`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			"  reason: checker preset must be a non-empty string."
+		].join("\n");
+		if (pathSegments[3] === "entry") return [
+			"Invalid Limina checker entry config:",
+			`  field: ${checkerField}.entry`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			"  reason: checker entry must be a non-empty string path."
+		].join("\n");
+		if (pathSegments[3] === "extensions") {
+			const extensionsPath = pathSegments.slice(0, 4);
+			return [
+				"Invalid Limina checker config:",
+				`  field: ${checkerField}.extensions`,
+				`  value: ${formatUnknownValue(getValueAtPath(value, extensionsPath))}`,
+				"  reason: checker extensions must be a non-empty array of dot-prefixed strings."
+			].join("\n");
+		}
+	}
+	return [
+		"Invalid Limina config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+}
+function collectLiminaConfigShapeProblems(value) {
+	const result = liminaConfigShapeSchema.safeParse(value);
+	if (result.success) return [];
+	return result.error.issues.map((issue) => formatLiminaConfigShapeIssue(value, issue));
+}
+function collectCheckerConfigProblems(config) {
+	const problems = collectLiminaConfigShapeProblems(config);
+	if (!checkerObjectSchema.safeParse(config).success) return problems;
+	const checkers = config.config?.checkers;
+	if (checkers === void 0) return problems;
+	if (!checkerObjectSchema.safeParse(checkers).success) return problems;
+	for (const [checkerName, checker] of Object.entries(checkers)) {
+		const field = `config.checkers.${checkerName}`;
+		const checkerObjectResult = checkerObjectSchema.safeParse(checker);
+		if (!checkerObjectResult.success) continue;
+		const checkerRecord = checkerObjectResult.data;
+		const preset = checkerRecord.preset;
+		if (checkerRecord.extensions === void 0 && typeof preset === "string" && !isBuiltinCheckerPreset(preset)) problems.push([
+			"Invalid Limina checker config:",
+			`  field: ${field}.extensions`,
+			"  value: undefined",
+			"  reason: extensions may only be omitted for built-in presets."
+		].join("\n"));
+		if (Object.hasOwn(checkerRecord, "routes")) problems.push([
+			"Invalid Limina checker config:",
+			`  field: ${field}.routes`,
+			`  value: ${formatUnknownValue(checkerRecord.routes)}`,
+			"  reason: checker routes are not supported; move routes.build to entry and migrate routes.typecheck targets to tsconfig*.dts.json leaves reachable from that entry with local companions."
+		].join("\n"));
+		if (typeof preset !== "string" || preset.trim().length === 0) continue;
+		if (!getCheckerAdapter(preset)) {
+			problems.push([
+				"Unsupported Limina checker preset:",
+				`  field: ${field}.preset`,
+				`  value: ${formatUnknownValue(preset)}`,
+				"  reason: configured checker entries require a built-in checker adapter."
+			].join("\n"));
+			continue;
+		}
+	}
+	return problems;
+}
+function validateLiminaConfig(config) {
+	const problems = collectCheckerConfigProblems(config);
+	if (problems.length > 0) throw new Error(problems.join("\n\n"));
+}
+function getActiveCheckers(config) {
+	validateLiminaConfig(config);
+	return getResolvedCheckers(config);
+}
+function getActiveCheckerExtensions(config) {
+	return normalizeExtensions(getActiveCheckers(config).flatMap((checker) => checker.extensions));
+}
+function normalizeConfig(value) {
+	const config = value;
+	validateLiminaConfig(config);
+	return config;
+}
+function createConfigEnv(options) {
+	return {
+		command: options.command ?? "check",
+		mode: options.mode ?? process.env.NODE_ENV ?? "default"
+	};
+}
+function findPnpmWorkspaceRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(currentDir, "pnpm-workspace.yaml"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function findLiminaConfigPath(startDir, rootDir) {
+	let currentDir = path.resolve(startDir);
+	const workspaceRootDir = path.resolve(rootDir);
+	while (isPathInsideDirectory(currentDir, workspaceRootDir)) {
+		const candidatePath = path.join(currentDir, "limina.config.mjs");
+		if (existsSync(candidatePath)) return candidatePath;
+		if (currentDir === workspaceRootDir) return null;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+	return null;
+}
+function inferWorkspaceRoot(startDir) {
+	const rootDir = findPnpmWorkspaceRoot(startDir);
+	if (!rootDir) throw new Error([`Unable to infer Limina workspace root from ${startDir}:`, "no pnpm-workspace.yaml was found in this directory or its parents."].join(" "));
+	return rootDir;
+}
+function validateConfigPathInsideWorkspace(configPath, rootDir) {
+	if (isPathInsideDirectory(configPath, rootDir)) return;
+	throw new Error([`Unable to load Limina config at ${configPath}:`, `config file must be inside the governed pnpm workspace at ${rootDir}.`].join(" "));
+}
+async function resolveConfigExport(configExport, configEnv) {
+	return normalizeConfig(typeof configExport === "function" ? await configExport(configEnv) : await configExport);
+}
+async function loadConfig(options = {}) {
+	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+	const rootDir = inferWorkspaceRoot(cwd);
+	const configPath = options.configPath ? path.resolve(cwd, options.configPath) : findLiminaConfigPath(cwd, rootDir);
+	if (configPath) validateConfigPathInsideWorkspace(configPath, rootDir);
+	if (!configPath || !existsSync(configPath)) throw new Error(options.configPath ? `Unable to find limina config at ${configPath}` : `Unable to find limina config. Searched for limina.config.mjs from ${cwd} up to the pnpm workspace root at ${rootDir}.`);
+	return {
+		...await resolveConfigExport((await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`)).default, createConfigEnv(options)),
+		configPath,
+		rootDir
+	};
+}
+
+//#endregion
+export { validateLiminaConfig as a, getCheckerAdapter as c, normalizeSlashes as d, normalizeWorkspacePath as f, toRelativePath as h, loadConfig as i, isPathInsideDirectory as l, toPosixPath as m, getActiveCheckerExtensions as n, collectMissingCheckerPeerDependencies as o, toAbsolutePath as p, getActiveCheckers as r, formatMissingCheckerPeerDependencies as s, defineConfig as t, normalizeAbsolutePath as u };

package/chunks/dep-lkQg1P9Q.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+
+export {  };