@oh-my-pi/pi-utils 14.0.4 → 14.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "14.0.4",
+	"version": "14.1.0",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -38,7 +38,7 @@
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3",
-		"@oh-my-pi/pi-natives": "14.0.4"
+		"@oh-my-pi/pi-natives": "14.1.0"
 	},
 	"engines": {
 		"bun": ">=1.3.7"

package/src/abortable.ts

@@ -43,23 +43,24 @@ export function createAbortableStream<T>(stream: ReadableStream<T>, signal?: Abo
  * @param pr - Function returning a promise to run
  * @returns Promise resolving as `pr` would, or rejecting on abort
  */
-export function untilAborted<T>(signal: AbortSignal | undefined | null, pr: () => Promise<T>): Promise<T> {
-	if (!signal) return pr();
+export function untilAborted<T>(
+	signal: AbortSignal | undefined | null,
+	pr: Promise<T> | (() => Promise<T>),
+): Promise<T> {
+	if (!signal) return typeof pr === "function" ? pr() : pr;
 	if (signal.aborted) return Promise.reject(new AbortError(signal));
 
 	const { promise, resolve, reject } = Promise.withResolvers<T>();
 	const onAbort = () => reject(new AbortError(signal));
 	signal.addEventListener("abort", onAbort, { once: true });
-	const cleanup = () => signal.removeEventListener("abort", onAbort);
 
 	void (async () => {
 		try {
-			const out = await pr();
-			resolve(out);
+			resolve(await (typeof pr === "function" ? pr() : pr));
 		} catch (err) {
 			reject(err);
 		} finally {
-			cleanup();
+			signal.removeEventListener("abort", onAbort);
 		}
 	})();
 

package/src/env.ts

@@ -100,9 +100,9 @@ export function isBunTestRuntime(): boolean {
 	return Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test";
 }
 
-const TRUTHY: Dict<boolean> = { "1": true, TRUE: true, YES: true, ON: true };
+const TRUTHY: Dict<boolean> = { "1": true, Y: true, TRUE: true, YES: true, ON: true };
 export function $flag(name: string, def: boolean = false): boolean {
 	const value = $env[name];
 	if (!value) return def;
-	return !!TRUTHY[value];
+	return TRUTHY[value] === true;
 }

package/src/index.ts

@@ -21,6 +21,7 @@ export * as ptree from "./ptree";
 export { AbortError, ChildProcess, Exception, NonZeroExitError } from "./ptree";
 export * from "./snowflake";
 export * from "./stream";
+export * from "./tab-spacing";
 export * from "./temp";
 export * from "./type-guards";
 export * from "./which";

package/src/mermaid-ascii.ts

@@ -17,13 +17,13 @@ export function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOpti
 /**
  * Extract mermaid code blocks from markdown text.
  */
-export function extractMermaidBlocks(markdown: string): { source: string; hash: bigint }[] {
-	const blocks: { source: string; hash: bigint }[] = [];
+export function extractMermaidBlocks(markdown: string): { source: string; hash: bigint | number }[] {
+	const blocks: { source: string; hash: bigint | number }[] = [];
 	const regex = /```mermaid\s*\n([\s\S]*?)```/g;
 
 	for (let match = regex.exec(markdown); match !== null; match = regex.exec(markdown)) {
 		const source = match[1].trim();
-		const hash = Bun.hash.xxHash64(source);
+		const hash = Bun.hash(source);
 		blocks.push({ source, hash });
 	}
 

package/src/tab-spacing.ts

@@ -0,0 +1,312 @@
+/**
+ * Default tab width (display / tab expansion) and per-file width from `.editorconfig`.
+ * Mirrors former `pi-natives` `indent` + `text` default-tab-width behavior (no N-API).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isEnoent } from "./fs-error";
+
+export const MIN_TAB_WIDTH = 1;
+export const MAX_TAB_WIDTH = 16;
+export const DEFAULT_TAB_WIDTH = 3;
+
+const EDITORCONFIG_NAME = ".editorconfig";
+
+let defaultTabWidth = DEFAULT_TAB_WIDTH;
+
+const editorConfigCache = new Map<string, ParsedEditorConfig>();
+const editorConfigChainCache = new Map<string, ChainEntry[]>();
+const indentationCache = new Map<string, number>();
+
+interface EditorConfigSection {
+	pattern: string;
+	properties: Map<string, string>;
+}
+
+interface ParsedEditorConfig {
+	root: boolean;
+	sections: EditorConfigSection[];
+}
+
+interface ChainEntry {
+	dir: string;
+	parsed: ParsedEditorConfig;
+}
+
+const enum IndentStyle {
+	Space,
+	Tab,
+}
+
+type IndentSize = { kind: "spaces"; n: number } | { kind: "tab" };
+
+interface EditorConfigMatch {
+	indentStyle?: IndentStyle;
+	indentSize?: IndentSize;
+	tabWidth?: number;
+}
+
+function clampTabWidth(value: number): number {
+	return Math.min(MAX_TAB_WIDTH, Math.max(MIN_TAB_WIDTH, Math.trunc(value)));
+}
+
+function parsePositiveInteger(raw: string | undefined): number | undefined {
+	if (raw === undefined) return undefined;
+	if (!/^\d+$/.test(raw)) return undefined;
+	const parsed = Number.parseInt(raw, 10);
+	if (parsed === 0) return undefined;
+	return clampTabWidth(parsed);
+}
+
+function fixUnclosedBraces(pattern: string): string {
+	const opens = [...pattern].filter(c => c === "{").length;
+	const closes = [...pattern].filter(c => c === "}").length;
+	if (opens > closes) {
+		return pattern + "}".repeat(opens - closes);
+	}
+	return pattern;
+}
+
+/** Match `crates/pi-natives/src/glob_util.rs` `build_glob_pattern`. */
+function buildGlobPattern(globStr: string, recursive: boolean): string {
+	const normalized = globStr.replace(/\\/g, "/");
+	const pattern =
+		!recursive || normalized.includes("/") || normalized.startsWith("**") ? normalized : `**/${normalized}`;
+	return fixUnclosedBraces(pattern);
+}
+
+function globMatches(pattern: string, relativePath: string): boolean {
+	try {
+		const g = new Bun.Glob(pattern);
+		return g.match(relativePath);
+	} catch {
+		return false;
+	}
+}
+
+function matchesEditorConfigPattern(pattern: string, relativePath: string): boolean {
+	const normalized = pattern.replace(/^\/+/, "");
+	if (!normalized) {
+		return false;
+	}
+
+	const candidates = normalized.includes("/")
+		? [buildGlobPattern(normalized, false)]
+		: [buildGlobPattern(normalized, false), buildGlobPattern(normalized, true)];
+
+	for (const p of candidates) {
+		if (globMatches(p, relativePath)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function parseEditorConfigFile(content: string): ParsedEditorConfig {
+	const parsed: ParsedEditorConfig = { root: false, sections: [] };
+	let currentSectionIdx: number | undefined;
+
+	for (const rawLine of content.split(/\n/)) {
+		const line = rawLine.trim();
+		if (line === "") continue;
+		if (line.startsWith("#") || line.startsWith(";")) continue;
+
+		if (line.startsWith("[") && line.endsWith("]") && line.length >= 2) {
+			const secPattern = line.slice(1, -1).trim();
+			if (secPattern === "") {
+				currentSectionIdx = undefined;
+				continue;
+			}
+			parsed.sections.push({ pattern: secPattern, properties: new Map() });
+			currentSectionIdx = parsed.sections.length - 1;
+			continue;
+		}
+
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+		const key = line.slice(0, eq).trim().toLowerCase();
+		const value = line
+			.slice(eq + 1)
+			.trim()
+			.toLowerCase();
+		if (key === "") continue;
+
+		if (currentSectionIdx !== undefined) {
+			parsed.sections[currentSectionIdx]!.properties.set(key, value);
+		} else if (key === "root") {
+			parsed.root = value === "true";
+		}
+	}
+
+	return parsed;
+}
+
+function parseCachedEditorConfig(configPath: string): ParsedEditorConfig | undefined {
+	const key = path.resolve(configPath);
+	const hit = editorConfigCache.get(key);
+	if (hit !== undefined) {
+		return hit;
+	}
+
+	let content: string;
+	try {
+		content = fs.readFileSync(key, "utf8");
+	} catch (err) {
+		if (isEnoent(err)) return undefined;
+		throw err;
+	}
+	const parsed = parseEditorConfigFile(content);
+	editorConfigCache.set(key, parsed);
+	return parsed;
+}
+
+function resolveFilePath(projectDir: string, file: string): string {
+	if (path.isAbsolute(file)) {
+		return path.normalize(path.resolve(file));
+	}
+	return path.normalize(path.resolve(projectDir, file));
+}
+
+/** Like `pathdiff::diff_paths` + forward slashes (see `indent.rs`). */
+function relativePathUnified(baseDir: string, absoluteFile: string): string {
+	const base = path.resolve(baseDir);
+	const file = path.resolve(absoluteFile);
+	const rel = path.relative(base, file);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) {
+		return ".";
+	}
+	return rel.replace(/\\/g, "/");
+}
+
+function collectEditorConfigChain(startDir: string): ChainEntry[] {
+	const key = path.resolve(startDir);
+	const cached = editorConfigChainCache.get(key);
+	if (cached !== undefined) {
+		return cached;
+	}
+
+	const chain: ChainEntry[] = [];
+	let cursor = key;
+	for (;;) {
+		const configPath = path.join(cursor, EDITORCONFIG_NAME);
+		const parsed = parseCachedEditorConfig(configPath);
+		if (parsed !== undefined) {
+			chain.push({ dir: cursor, parsed });
+			if (parsed.root) {
+				break;
+			}
+		}
+
+		const parent = path.dirname(cursor);
+		if (parent === cursor) {
+			break;
+		}
+		cursor = parent;
+	}
+
+	chain.reverse();
+	editorConfigChainCache.set(key, chain);
+	return chain;
+}
+
+function resolveEditorConfigMatch(absoluteFile: string): EditorConfigMatch | undefined {
+	const fileDir = path.dirname(absoluteFile);
+	const chain = collectEditorConfigChain(fileDir);
+	if (chain.length === 0) {
+		return undefined;
+	}
+
+	const match: EditorConfigMatch = {};
+	for (const { dir, parsed } of chain) {
+		const relativePath = relativePathUnified(dir, absoluteFile);
+		for (const section of parsed.sections) {
+			if (!matchesEditorConfigPattern(section.pattern, relativePath)) {
+				continue;
+			}
+
+			const style = section.properties.get("indent_style");
+			if (style === "space") {
+				match.indentStyle = IndentStyle.Space;
+			} else if (style === "tab") {
+				match.indentStyle = IndentStyle.Tab;
+			}
+
+			const rawSize = section.properties.get("indent_size");
+			if (rawSize === "tab") {
+				match.indentSize = { kind: "tab" };
+			} else if (rawSize !== undefined) {
+				const n = parsePositiveInteger(rawSize);
+				if (n !== undefined) {
+					match.indentSize = { kind: "spaces", n };
+				}
+			}
+
+			const tw = parsePositiveInteger(section.properties.get("tab_width"));
+			if (tw !== undefined) {
+				match.tabWidth = tw;
+			}
+		}
+	}
+
+	if (match.indentStyle === undefined && match.indentSize === undefined && match.tabWidth === undefined) {
+		return undefined;
+	}
+	return match;
+}
+
+function resolveEditorConfigTabWidth(match: EditorConfigMatch | undefined, fallback: number): number | undefined {
+	if (match === undefined) return undefined;
+
+	if (match.indentSize?.kind === "spaces") {
+		return match.indentSize.n;
+	}
+
+	if (match.indentSize?.kind === "tab") {
+		if (match.tabWidth !== undefined) {
+			return match.tabWidth;
+		}
+		return fallback;
+	}
+
+	if (match.tabWidth !== undefined) {
+		return match.tabWidth;
+	}
+
+	if (match.indentStyle === IndentStyle.Tab) {
+		return fallback;
+	}
+
+	return undefined;
+}
+
+export function getDefaultTabWidth(): number {
+	return defaultTabWidth;
+}
+
+export function setDefaultTabWidth(width: number): void {
+	defaultTabWidth = clampTabWidth(width);
+}
+
+/**
+ * Visible tab width in columns for `file` (from `.editorconfig` + default), or the default when `file` is omitted.
+ */
+export function getIndentation(file?: string | null, projectDir?: string | null): number {
+	const fallback = defaultTabWidth;
+	if (file === undefined || file === null || file === "") {
+		return fallback;
+	}
+
+	const cwd = projectDir ?? process.cwd();
+	const absoluteFile = resolveFilePath(cwd, file);
+	const absKey = absoluteFile;
+	const cached = indentationCache.get(absKey);
+	if (cached !== undefined) {
+		return cached;
+	}
+
+	const editorMatch = resolveEditorConfigMatch(absoluteFile);
+	const resolved = resolveEditorConfigTabWidth(editorMatch, fallback) ?? fallback;
+	const clamped = clampTabWidth(resolved);
+	indentationCache.set(absKey, clamped);
+	return clamped;
+}

package/src/which.ts

@@ -12,6 +12,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
+type CacheKey = string | bigint | number;
+
 // Tools shipped by Xcode / Command Line Tools that callers actually look up.
 // Keeps the set small so darwinWhich can fast-reject non-Xcode commands without
 // touching the filesystem.  Only needs entries for binaries that live *exclusively*
@@ -146,7 +148,7 @@ function getMacosToolPaths(): Map<string, string> {
 }
 
 // Map: cache key -> resolved binary path or null (not found)
-const toolCache = new Map<string | bigint, string | null>();
+const toolCache = new Map<CacheKey, string | null>();
 
 /**
  * Cache policy for which lookups.
@@ -194,12 +196,12 @@ function darwinWhich(command: string, _options?: Bun.WhichOptions): string | nul
 export const whichFresh = os.platform() === "darwin" ? darwinWhich : Bun.which;
 
 // Derive stable cache key from command and lookup options
-function cacheKey(command: string, options?: Bun.WhichOptions): string | bigint {
+function cacheKey(command: string, options?: Bun.WhichOptions): CacheKey {
 	if (!options) return command;
 	if (!options.cwd && !options.PATH) return command;
-	let h = Bun.hash.xxHash64(command);
-	if (options.cwd) h = Bun.hash.xxHash64(options.cwd, h);
-	if (options.PATH) h = Bun.hash.xxHash64(options.PATH, h);
+	let h = Bun.hash(command);
+	if (options.cwd) h = Bun.hash(options.cwd, h);
+	if (options.PATH) h = Bun.hash(options.PATH, h);
 	return h;
 }
 
@@ -212,7 +214,7 @@ function cacheKey(command: string, options?: Bun.WhichOptions): string | bigint
  */
 export function $which(command: string, options?: WhichOptions): string | null {
 	const cachePolicy = options?.cache ?? WhichCachePolicy.Cached;
-	let key: string | bigint | undefined;
+	let key: CacheKey | undefined;
 
 	if (cachePolicy !== WhichCachePolicy.Bypass) {
 		key = cacheKey(command, options);