limina 0.1.1 → 0.1.2

package/chunks/{dep-C5gcXDHp.js → dep-DJz9JBTi.js}

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import ts from "typescript";
 import { pathToFileURL } from "node:url";
 
@@ -507,10 +507,17 @@ function toRelativePath(rootDir, absolutePath) {
 function normalizeSlashes(value) {
 	return value.replaceAll("\\", "/");
 }
+function normalizeAbsolutePathIdentity(value) {
+	const normalizedPath = normalize(value);
+	return normalizedPath.length > 1 && !/^[A-Za-z]:\/$/u.test(normalizedPath) ? normalizedPath.replace(/\/+$/u, "") : normalizedPath;
+}
 function isPathInsideDirectory(filePath, directoryPath) {
-	const normalizedFilePath = normalizeAbsolutePath(filePath);
-	const normalizedDirectoryPath = normalizeAbsolutePath(directoryPath);
-	return normalizedFilePath === normalizedDirectoryPath || normalizedFilePath.startsWith(`${normalizedDirectoryPath}/`);
+	const normalizedFilePath = normalizeComparableAbsolutePath(filePath);
+	const relativePath = relative(normalizeComparableAbsolutePath(directoryPath), normalizedFilePath);
+	return relativePath.length === 0 || relativePath !== ".." && !relativePath.startsWith("../") && !isAbsolute(relativePath);
+}
+function normalizeComparableAbsolutePath(value) {
+	return normalizeAbsolutePathIdentity(isAbsolute(value) ? value : resolve(value));
 }
 
 //#endregion
@@ -798,9 +805,109 @@ function resolveVueProjectExtensionsForChecker(options, packageName) {
 	return normalizeExtensions([...options.extensions ?? [], ...resolveVueProjectExtensions(options, packageName)]);
 }
 function resolveTypeScriptModuleName(options) {
+	return resolveTypeScriptModuleNameDetailed(options)?.resolvedFileName ?? null;
+}
+function resolveTypeScriptModuleNameDetailed(options) {
 	const resolved = ts.resolveModuleName(options.specifier, options.containingFile, options.compilerOptions, ts.sys).resolvedModule;
-	if (resolved?.resolvedFileName) return normalizeAbsolutePath(resolved.resolvedFileName);
-	return resolveRelativeModuleCandidate(options) ?? resolvePathMappedModuleCandidate(options);
+	if (resolved?.resolvedFileName) return {
+		isExternalLibraryImport: resolved.isExternalLibraryImport === true,
+		resolvedBy: "typescript",
+		resolvedFileName: normalizeAbsolutePath(resolved.resolvedFileName)
+	};
+	return resolveCheckerExtensionModuleName(options);
+}
+function resolveCheckerExtensionModuleName(options) {
+	const typeScriptExtensions = new Set(getTypeScriptCheckerExtensions());
+	const checkerOnlyExtensions = options.extensions.filter((extension) => !typeScriptExtensions.has(extension));
+	if (checkerOnlyExtensions.length === 0) return null;
+	const resolvedFileName = resolveRelativeModuleCandidate({
+		containingFile: options.containingFile,
+		extensions: checkerOnlyExtensions,
+		specifier: options.specifier
+	}) ?? resolvePathMappedModuleCandidate({
+		compilerOptions: options.compilerOptions,
+		extensions: checkerOnlyExtensions,
+		specifier: options.specifier
+	}) ?? resolvePackageExportModuleCandidate({
+		containingFile: options.containingFile,
+		extensions: checkerOnlyExtensions,
+		specifier: options.specifier
+	});
+	return resolvedFileName ? {
+		isExternalLibraryImport: false,
+		resolvedBy: "checker-extension",
+		resolvedFileName
+	} : null;
+}
+function resolvePackageExportModuleCandidate(options) {
+	const specifierParts = parsePackageSpecifier(options.specifier);
+	if (!specifierParts) return null;
+	const packageDirectory = findPackageDirectoryForImport({
+		containingFile: options.containingFile,
+		packageName: specifierParts.packageName
+	});
+	if (!packageDirectory) return null;
+	const targets = collectExportTargetsForSubpath(readPackageManifest(packageDirectory)?.exports, specifierParts.subpath);
+	for (const target of targets) {
+		if (!target.startsWith("./")) continue;
+		const targetPath = posix.resolve(packageDirectory, target.slice(2));
+		for (const candidatePath of candidatePathsForBasePath(targetPath, options.extensions)) {
+			const resolvedPath = resolveExistingFilePath(candidatePath);
+			if (resolvedPath) return resolvedPath;
+		}
+	}
+	return null;
+}
+function parsePackageSpecifier(specifier) {
+	if (specifier.length === 0 || specifier.startsWith(".") || specifier.startsWith("/")) return null;
+	const parts = specifier.split("/");
+	if (specifier.startsWith("@")) {
+		const scope = parts[0];
+		const name = parts[1];
+		if (!scope || !name) return null;
+		return {
+			packageName: `${scope}/${name}`,
+			subpath: parts.length > 2 ? `./${parts.slice(2).join("/")}` : "."
+		};
+	}
+	const packageName = parts[0];
+	return packageName ? {
+		packageName,
+		subpath: parts.length > 1 ? `./${parts.slice(1).join("/")}` : "."
+	} : null;
+}
+function findPackageDirectoryForImport(options) {
+	let currentDir = posix.dirname(options.containingFile);
+	for (;;) {
+		const packageDirectory = posix.join(currentDir, "node_modules", options.packageName);
+		if (existsSync(posix.join(packageDirectory, "package.json"))) return packageDirectory;
+		const parentDir = posix.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function readPackageManifest(packageDirectory) {
+	try {
+		return JSON.parse(readFileSync(posix.join(packageDirectory, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function collectStringTargets(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.flatMap(collectStringTargets);
+	if (isRecord(value)) return Object.values(value).flatMap(collectStringTargets);
+	return [];
+}
+function collectExportTargetsForSubpath(exportsField, subpath) {
+	if (exportsField === void 0) return subpath === "." ? ["./index"] : [subpath];
+	if (typeof exportsField === "string" || Array.isArray(exportsField)) return subpath === "." ? collectStringTargets(exportsField) : [];
+	if (!isRecord(exportsField)) return [];
+	if (!Object.keys(exportsField).some((key) => key === "." || key.startsWith("./"))) return subpath === "." ? collectStringTargets(exportsField) : [];
+	return collectStringTargets(exportsField[subpath]);
 }
 function mergeParsedProjectConfigs(parsedConfigs, extensions) {
 	const firstConfig = parsedConfigs[0];
@@ -834,11 +941,13 @@ function parseCheckerProjectConfigForContext(options) {
 	return cloneParsedCheckerProjectConfig(parsedConfig);
 }
 function resolveModuleNameWithCheckers(options) {
+	return resolveModuleNameWithCheckersDetailed(options)?.resolvedFileName ?? null;
+}
+function resolveModuleNameWithCheckersDetailed(options) {
 	const checkerPresets = options.context.checkerPresets.length > 0 ? options.context.checkerPresets : ["tsc"];
 	for (const preset of checkerPresets) {
-		const adapter = getCheckerAdapter(preset);
-		if (!adapter) continue;
-		const resolved = adapter.resolveModuleName({
+		if (!getCheckerAdapter(preset)) continue;
+		const resolved = resolveTypeScriptModuleNameDetailed({
 			compilerOptions: options.compilerOptions,
 			containingFile: options.containingFile,
 			extensions: options.context.extensions,
@@ -4122,4 +4231,4 @@ async function loadConfig(options = {}) {
 }
 
 //#endregion
-export { isRelativeSpecifier as A, isPathInsideDirectory as C, toRelativePath as D, toPosixPath as E, uniqueSortedStrings as F, uniqueTrimmedNonEmptySortedStrings as I, uniqueValues as L, isVirtualModuleSpecifier as M, posix as N, isBarePackageSpecifier as O, uniqueBy as P, resolveRelativeModuleCandidate as S, normalizeSlashes as T, resolveModuleNameWithCheckers as _, formatUnknownValue as a, resolveExistingFilePath as b, clearCheckerProjectConfigCache as c, getBuildCheckerSupportedExtensions as d, getCheckerAdapter as f, resolveCheckerProjectExtensions as g, parseCheckerProjectConfigForContext as h, loadConfig as i, isUrlOrDataOrFileSpecifier as j, isPackageImportSpecifier as k, collectMissingCheckerPeerDependencies as l, normalizeExtensions as m, getActiveCheckers as n, isNonEmptyString as o, getCheckerExtensions as p, isAutoCheckerConfigMode as r, isPlainRecord as s, defineConfig as t, formatMissingCheckerPeerDependencies as u, candidatePathsForBasePath as v, normalizeAbsolutePath as w, resolvePathMappedModuleCandidate as x, resolveBaseUrlModuleCandidate as y };
+export { isPackageImportSpecifier as A, resolveRelativeModuleCandidate as C, toPosixPath as D, normalizeSlashes as E, uniqueBy as F, uniqueSortedStrings as I, uniqueTrimmedNonEmptySortedStrings as L, isUrlOrDataOrFileSpecifier as M, isVirtualModuleSpecifier as N, toRelativePath as O, posix as P, uniqueValues as R, resolvePathMappedModuleCandidate as S, normalizeAbsolutePath as T, resolveModuleNameWithCheckers as _, formatUnknownValue as a, resolveBaseUrlModuleCandidate as b, clearCheckerProjectConfigCache as c, getBuildCheckerSupportedExtensions as d, getCheckerAdapter as f, resolveCheckerProjectExtensions as g, parseCheckerProjectConfigForContext as h, loadConfig as i, isRelativeSpecifier as j, isBarePackageSpecifier as k, collectMissingCheckerPeerDependencies as l, normalizeExtensions as m, getActiveCheckers as n, isNonEmptyString as o, getCheckerExtensions as p, isAutoCheckerConfigMode as r, isPlainRecord as s, defineConfig as t, formatMissingCheckerPeerDependencies as u, resolveModuleNameWithCheckersDetailed as v, isPathInsideDirectory as w, resolveExistingFilePath as x, candidatePathsForBasePath as y };

package/chunks/dep-mnWOqiGN.js

@@ -0,0 +1,244 @@
+//#region src/flow/render-model.ts
+const ANSI_RESET = "\x1B[0m";
+const ANSI_GREEN = "\x1B[32m";
+const ANSI_RED = "\x1B[31m";
+const ANSI_YELLOW = "\x1B[33m";
+const DEFAULT_TERMINAL_COLUMNS$1 = 80;
+const TERMINAL_FRAME_MARGIN_LINES = 1;
+const TERMINAL_FRAME_CONTEXT_LINES = 6;
+const OMITTED_LINES_MARKER = "│  ...";
+const ANSI_ESCAPE = String.fromCodePoint(27);
+const ANSI_PATTERN = new RegExp(String.raw`${ANSI_ESCAPE}\[[\d:;<=>?]*[\u0020-\u002F]*[\u0040-\u007E]`, "gu");
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const SPINNER_INTERVAL_MS = 80;
+const FLOW_SYMBOL_BY_STATUS = {
+	fail: "✕",
+	info: "│",
+	pass: "◆",
+	planned: "◇",
+	skip: "◇",
+	start: "◇",
+	warn: "▲"
+};
+function colorInteractiveSymbol(status, symbol) {
+	if (status === "pass") return `${ANSI_GREEN}${symbol}${ANSI_RESET}`;
+	if (status === "fail") return `${ANSI_RED}${symbol}${ANSI_RESET}`;
+	if (status === "warn") return `${ANSI_YELLOW}${symbol}${ANSI_RESET}`;
+	return symbol;
+}
+function formatElapsedTime(milliseconds) {
+	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
+	return `${(milliseconds / 1e3).toFixed(2)}s`;
+}
+function formatMessageWithElapsed(message, elapsedTimeMs) {
+	return typeof elapsedTimeMs === "number" ? `${message} (${formatElapsedTime(elapsedTimeMs)})` : message;
+}
+function indentMessage(message, depth) {
+	if (depth <= 0) return message;
+	return `${"  ".repeat(depth)}${message}`;
+}
+function formatInteractiveLine(status, message, depth, spinnerFrameIndex) {
+	const renderedMessage = indentMessage(message, depth);
+	return `${colorInteractiveSymbol(status, status === "start" ? SPINNER_FRAMES[spinnerFrameIndex % SPINNER_FRAMES.length] : FLOW_SYMBOL_BY_STATUS[status])}    ${renderedMessage}`;
+}
+function toTreeFlowStatus(status) {
+	switch (status) {
+		case "failed": return "fail";
+		case "passed": return "pass";
+		case "planned": return "planned";
+		case "running": return "start";
+		case "skipped": return "skip";
+	}
+	throw new Error(`Unsupported flow tree node status: ${status}`);
+}
+function isTreeNodeTerminal(node) {
+	return node.status === "failed" || node.status === "passed" || node.status === "skipped";
+}
+function areTreeNodeDescendantsTerminal(node) {
+	return node.children.every((child) => isTreeNodeTerminal(child) && areTreeNodeDescendantsTerminal(child));
+}
+function renderTreeNodeLine(node, spinnerFrameIndex) {
+	const elapsedTimeMs = isTreeNodeTerminal(node) && areTreeNodeDescendantsTerminal(node) ? node.elapsedTimeMs : void 0;
+	return formatInteractiveLine(toTreeFlowStatus(node.status), formatMessageWithElapsed(node.message, elapsedTimeMs), node.depth, spinnerFrameIndex);
+}
+function renderTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.flatMap((child) => renderTreeNodeLines(child, spinnerFrameIndex))];
+}
+function renderCompactTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.map((child) => renderTreeNodeLine(child, spinnerFrameIndex))];
+}
+function renderSnapshotLines(snapshot, spinnerFrameIndex) {
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		return snapshot.treeRoots.flatMap((root) => renderTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function renderCompactSnapshotLines(snapshot, spinnerFrameIndex) {
+	const flowLineDepths = snapshot.entries.filter((entry) => entry.kind === "flow-line").map((entry) => entry.depth);
+	const maxCompactFlowLineDepth = flowLineDepths.length > 0 ? Math.min(...flowLineDepths) + 1 : Number.POSITIVE_INFINITY;
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") {
+			if (entry.depth > maxCompactFlowLineDepth) return [];
+			return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		}
+		return snapshot.treeRoots.flatMap((root) => renderCompactTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function stripControlSequences(text) {
+	return text.replaceAll(ANSI_PATTERN, "").replaceAll("\r", "");
+}
+function countRenderedTerminalRows(line, columns) {
+	const text = stripControlSequences(line);
+	let column = 0;
+	let rows = 1;
+	for (const char of text) {
+		if (char === "\n") {
+			rows += 1;
+			column = 0;
+			continue;
+		}
+		column += 1;
+		if (column >= columns) {
+			rows += 1;
+			column = 0;
+		}
+	}
+	return rows;
+}
+function countRenderedRows(lines, dimensions) {
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS$1);
+	return lines.reduce((sum, line) => sum + countRenderedTerminalRows(line, columns), 0);
+}
+function fitsRenderedLines(lines, dimensions, options = {}) {
+	if (dimensions.rows === void 0) return true;
+	const contextLines = options.reserveContext && dimensions.rows > TERMINAL_FRAME_CONTEXT_LINES * 2 ? TERMINAL_FRAME_CONTEXT_LINES : 0;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES - contextLines);
+	return countRenderedRows(lines, dimensions) <= lineLimit;
+}
+function fitRenderedLinesToTerminal(lines, dimensions, options = {}) {
+	if (fitsRenderedLines(lines, dimensions) && !options.omittedLines) return lines;
+	if (dimensions.rows === void 0) return options.omittedLines ? addOmittedLinesMarker(lines) : lines;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES);
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS$1);
+	const lastLine = lines.at(-1);
+	const shouldPreserveOutro = lastLine?.startsWith("└  ") ?? false;
+	const bodyLineCount = lines.length - (shouldPreserveOutro ? 1 : 0);
+	const bodyLines = lines.slice(0, bodyLineCount);
+	const ellipsisRows = countRenderedTerminalRows(OMITTED_LINES_MARKER, columns);
+	const reservedRows = shouldPreserveOutro && lastLine ? countRenderedTerminalRows(lastLine, columns) : 0;
+	const availableBodyRows = Math.max(0, lineLimit - reservedRows);
+	const bodyRows = countRenderedRows(bodyLines, { columns });
+	const shouldShowOmissionMarker = (options.omittedLines === true || bodyRows > availableBodyRows) && availableBodyRows >= ellipsisRows;
+	const fittedLines = [];
+	let remainingRows = availableBodyRows;
+	if (shouldShowOmissionMarker) remainingRows -= ellipsisRows;
+	for (let index = 0; index < bodyLineCount && remainingRows > 0; index++) {
+		const line = lines[index];
+		const rowCount = countRenderedTerminalRows(line, columns);
+		if (rowCount > remainingRows) break;
+		fittedLines.push(line);
+		remainingRows -= rowCount;
+	}
+	if (shouldShowOmissionMarker) fittedLines.push(OMITTED_LINES_MARKER);
+	if (shouldPreserveOutro && lastLine && reservedRows <= lineLimit) fittedLines.push(lastLine);
+	if (fittedLines.length > 0) return fittedLines;
+	return lines.slice(0, 1);
+}
+function addOmittedLinesMarker(lines) {
+	if (lines.includes(OMITTED_LINES_MARKER)) return lines;
+	const lastLine = lines.at(-1);
+	if (lastLine?.startsWith("└  ")) return [
+		...lines.slice(0, -1),
+		OMITTED_LINES_MARKER,
+		lastLine
+	];
+	return [...lines, OMITTED_LINES_MARKER];
+}
+function renderSnapshotLinesForTerminal(snapshot, spinnerFrameIndex, dimensions) {
+	const shouldPreferCompact = snapshot.compactMode === "check-flow" && snapshot.outroMessage !== void 0;
+	const fullLines = renderSnapshotLines(snapshot, spinnerFrameIndex);
+	if (!shouldPreferCompact && fitsRenderedLines(fullLines, dimensions, { reserveContext: true })) return fullLines;
+	const compactLines = renderCompactSnapshotLines(snapshot, spinnerFrameIndex);
+	return fitRenderedLinesToTerminal(compactLines, dimensions, { omittedLines: compactLines.length < fullLines.length });
+}
+function hasRunningSnapshotWork(snapshot) {
+	const hasRunningTreeNode = (node) => node.status === "running" || node.children.some(hasRunningTreeNode);
+	return snapshot.entries.some((entry) => entry.kind === "flow-line" && entry.status === "start") || snapshot.treeRoots.some(hasRunningTreeNode);
+}
+function toWritableText(chunk) {
+	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString();
+	return chunk;
+}
+
+//#endregion
+//#region src/flow/terminal-frame.ts
+const DEFAULT_TERMINAL_COLUMNS = 80;
+var TerminalFrameTracker = class {
+	#column = 0;
+	#lineCount = 0;
+	#getColumns;
+	constructor(getColumns) {
+		this.#getColumns = getColumns;
+	}
+	get lineCount() {
+		return this.#lineCount;
+	}
+	record(chunk) {
+		const text = stripControlSequences(toWritableText(chunk));
+		const columns = Math.max(1, this.#getColumns());
+		for (const char of text) {
+			if (char === "\n") {
+				this.#lineCount += 1;
+				this.#column = 0;
+				continue;
+			}
+			this.#column += 1;
+			if (this.#column >= columns) {
+				this.#lineCount += 1;
+				this.#column = 0;
+			}
+		}
+	}
+	reset() {
+		this.#lineCount = 0;
+		this.#column = 0;
+	}
+	setLineCount(lineCount) {
+		this.#lineCount = Math.max(0, lineCount);
+		this.#column = 0;
+	}
+};
+function patchWriteStream(stream, onWrite) {
+	if (typeof stream?.write !== "function") return;
+	const originalWrite = stream.write;
+	const patchedWrite = (...args) => {
+		onWrite(args[0]);
+		return writeWithFlowArgs(originalWrite, args);
+	};
+	stream.write = patchedWrite;
+	return () => {
+		stream.write = originalWrite;
+	};
+}
+function writeWithFlowArgs(write, args) {
+	if (typeof args[1] === "string") return write(args[0], args[1], args[2]);
+	return write(args[0], args[1]);
+}
+
+//#endregion
+export { SPINNER_FRAMES as a, formatMessageWithElapsed as c, toTreeFlowStatus as d, toWritableText as f, writeWithFlowArgs as i, hasRunningSnapshotWork as l, TerminalFrameTracker as n, SPINNER_INTERVAL_MS as o, patchWriteStream as r, formatInteractiveLine as s, DEFAULT_TERMINAL_COLUMNS as t, renderSnapshotLinesForTerminal as u };