@oh-my-pi/pi-natives 9.3.1 → 9.6.0

package/src/grep/file-reader.ts

@@ -1,51 +0,0 @@
-/**
- * Cross-platform file reader for grep.
- *
- * Uses mmap for files <= 4MB on platforms that support it,
- * falls back to reading into a reusable buffer otherwise.
- */
-import * as fs from "node:fs/promises";
-
-const MAX_MMAP_SIZE = 4 * 1024 * 1024; // 4MB
-export class FileReader {
-	#buffer: Buffer | null = null;
-	constructor(private readonly maxSize: number = MAX_MMAP_SIZE) {}
-	#getBuffer(size: number): Buffer {
-		if (!this.#buffer) {
-			this.#buffer = Buffer.allocUnsafe(this.maxSize);
-		}
-		return this.#buffer.subarray(0, size);
-	}
-
-	async read(filePath: string): Promise<Uint8Array | null> {
-		let fileSize: number;
-		try {
-			const stat = await fs.stat(filePath);
-			fileSize = stat.size;
-		} catch {
-			return null;
-		}
-
-		// Skip files larger than buffer size (only search first 4MB worth)
-		const readSize = Math.min(fileSize, this.maxSize);
-
-		// Try mmap for small files (fast path on Linux/macOS)
-		if (fileSize <= this.maxSize) {
-			try {
-				return Bun.mmap(filePath);
-			} catch {
-				// mmap not supported (Windows) or failed, fall through to read
-			}
-		}
-
-		// Fall back to reading into buffer
-		try {
-			await using handle = await fs.open(filePath, "r");
-			const buffer = this.#getBuffer(readSize);
-			const { bytesRead } = await handle.read(buffer, 0, readSize, 0);
-			return buffer.subarray(0, bytesRead);
-		} catch {
-			return null;
-		}
-	}
-}

package/src/grep/filters.ts

@@ -1,77 +0,0 @@
-import * as path from "node:path";
-
-export interface TypeFilter {
-	extensions?: string[];
-	names?: string[];
-}
-
-const TYPE_ALIASES: Record<string, TypeFilter> = {
-	js: { extensions: ["js", "jsx", "mjs", "cjs"] },
-	javascript: { extensions: ["js", "jsx", "mjs", "cjs"] },
-	ts: { extensions: ["ts", "tsx", "mts", "cts"] },
-	typescript: { extensions: ["ts", "tsx", "mts", "cts"] },
-	json: { extensions: ["json", "jsonc", "json5"] },
-	yaml: { extensions: ["yaml", "yml"] },
-	yml: { extensions: ["yaml", "yml"] },
-	toml: { extensions: ["toml"] },
-	md: { extensions: ["md", "markdown", "mdx"] },
-	markdown: { extensions: ["md", "markdown", "mdx"] },
-	py: { extensions: ["py", "pyi"] },
-	python: { extensions: ["py", "pyi"] },
-	rs: { extensions: ["rs"] },
-	rust: { extensions: ["rs"] },
-	go: { extensions: ["go"] },
-	java: { extensions: ["java"] },
-	kt: { extensions: ["kt", "kts"] },
-	kotlin: { extensions: ["kt", "kts"] },
-	c: { extensions: ["c", "h"] },
-	cpp: { extensions: ["cpp", "cc", "cxx", "hpp", "hxx", "hh"] },
-	cxx: { extensions: ["cpp", "cc", "cxx", "hpp", "hxx", "hh"] },
-	cs: { extensions: ["cs", "csx"] },
-	csharp: { extensions: ["cs", "csx"] },
-	php: { extensions: ["php", "phtml"] },
-	rb: { extensions: ["rb", "rake", "gemspec"] },
-	ruby: { extensions: ["rb", "rake", "gemspec"] },
-	sh: { extensions: ["sh", "bash", "zsh", "fish"] },
-	bash: { extensions: ["sh", "bash", "zsh"] },
-	zsh: { extensions: ["zsh"] },
-	fish: { extensions: ["fish"] },
-	html: { extensions: ["html", "htm"] },
-	css: { extensions: ["css"] },
-	scss: { extensions: ["scss"] },
-	sass: { extensions: ["sass"] },
-	less: { extensions: ["less"] },
-	xml: { extensions: ["xml"] },
-	docker: { names: ["dockerfile"] },
-	dockerfile: { names: ["dockerfile"] },
-	make: { names: ["makefile"] },
-	makefile: { names: ["makefile"] },
-};
-
-export function buildGlobPattern(glob?: string): string {
-	const trimmed = glob?.trim();
-	if (!trimmed) return "**/*";
-	const normalized = trimmed.replace(/\\/g, "/");
-	if (normalized.includes("/") || normalized.startsWith("**/")) return normalized;
-	return `**/${normalized}`;
-}
-
-export function resolveTypeFilter(type?: string): TypeFilter | undefined {
-	if (!type) return undefined;
-	const trimmed = type.trim();
-	if (!trimmed) return undefined;
-	const normalized = trimmed.toLowerCase();
-	const withoutDot = normalized.startsWith(".") ? normalized.slice(1) : normalized;
-	return TYPE_ALIASES[withoutDot] ?? { extensions: [withoutDot] };
-}
-
-export function matchesTypeFilter(filePath: string, filter?: TypeFilter): boolean {
-	if (!filter) return true;
-	const baseName = path.basename(filePath).toLowerCase();
-	if (filter.names?.some(name => name.toLowerCase() === baseName)) {
-		return true;
-	}
-	const ext = path.extname(baseName).slice(1).toLowerCase();
-	if (!ext) return false;
-	return filter.extensions?.includes(ext) ?? false;
-}

package/src/grep/worker.ts

@@ -1,212 +0,0 @@
-/**
- * Worker script for running wasm-bindgen grep.
- * Each worker loads its own WASM instance and processes requests.
- */
-
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { globPaths } from "@oh-my-pi/pi-utils";
-import { CompiledPattern } from "../../wasm/pi_natives";
-import { FileReader } from "./file-reader";
-import { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
-import type { GrepMatch, GrepOptions, GrepResult, WasmSearchResult, WorkerRequest, WorkerResponse } from "./types";
-
-function filterUndefined<T extends Record<string, unknown>>(obj: T): T {
-	const result = {} as T;
-	for (const [key, value] of Object.entries(obj)) {
-		if (value !== undefined) {
-			(result as Record<string, unknown>)[key] = value;
-		}
-	}
-	return result;
-}
-
-async function runGrep(request: GrepOptions): Promise<GrepResult> {
-	const searchPath = path.resolve(request.path);
-	const stat = await fs.stat(searchPath);
-	const isFile = stat.isFile();
-
-	using compiledPattern = new CompiledPattern(
-		filterUndefined({
-			pattern: request.pattern,
-			ignoreCase: request.ignoreCase,
-			multiline: request.multiline,
-			context: request.context,
-			maxColumns: request.maxColumns,
-			mode: request.mode === "content" || !request.mode ? "content" : "count",
-		}),
-	);
-
-	const matches: GrepMatch[] = [];
-	let totalMatches = 0;
-	let filesWithMatches = 0;
-	let filesSearched = 0;
-	let limitReached = false;
-	const maxCount = request.maxCount;
-	const globalOffset = request.offset ?? 0;
-	const typeFilter = resolveTypeFilter(request.type);
-	const globPattern = buildGlobPattern(request.glob);
-
-	const fileReader = new FileReader();
-	if (isFile) {
-		if (typeFilter && !matchesTypeFilter(searchPath, typeFilter)) {
-			return {
-				matches,
-				totalMatches,
-				filesWithMatches,
-				filesSearched,
-				limitReached: limitReached || undefined,
-			};
-		}
-
-		const content = await fileReader.read(searchPath);
-		if (!content) {
-			return {
-				matches,
-				totalMatches,
-				filesWithMatches,
-				filesSearched,
-				limitReached: limitReached || undefined,
-			};
-		}
-		filesSearched = 1;
-
-		const result = compiledPattern.search_bytes(
-			content,
-			maxCount,
-			globalOffset > 0 ? globalOffset : undefined,
-		) as WasmSearchResult;
-
-		if (!result.error && result.matchCount > 0) {
-			filesWithMatches = 1;
-			totalMatches = result.matchCount;
-
-			if (request.mode === "content" || !request.mode) {
-				for (const m of result.matches) {
-					matches.push({
-						path: searchPath,
-						lineNumber: m.lineNumber,
-						line: m.line,
-						contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
-						contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
-						truncated: m.truncated || undefined,
-					});
-				}
-			} else {
-				matches.push({
-					path: searchPath,
-					lineNumber: 0,
-					line: "",
-					matchCount: result.matchCount,
-				});
-			}
-
-			limitReached = result.limitReached || (maxCount !== undefined && totalMatches >= maxCount);
-		}
-	} else {
-		const paths = await globPaths(globPattern, {
-			cwd: searchPath,
-			dot: request.hidden ?? true,
-			onlyFiles: true,
-			gitignore: true,
-		});
-
-		for (const relativePath of paths) {
-			if (limitReached) break;
-			if (typeFilter && !matchesTypeFilter(relativePath, typeFilter)) {
-				continue;
-			}
-
-			const normalizedPath = relativePath.replace(/\\/g, "/");
-			const fullPath = path.join(searchPath, normalizedPath);
-
-			const content = await fileReader.read(fullPath);
-			if (!content) continue;
-
-			filesSearched++;
-
-			if (!compiledPattern.has_match_bytes(content)) {
-				continue;
-			}
-
-			const fileOffset = globalOffset > 0 ? Math.max(globalOffset - totalMatches, 0) : 0;
-			const remaining = maxCount !== undefined ? Math.max(maxCount - totalMatches, 0) : undefined;
-			if (remaining === 0) {
-				limitReached = true;
-				break;
-			}
-			const result = compiledPattern.search_bytes(
-				content,
-				remaining,
-				fileOffset > 0 ? fileOffset : undefined,
-			) as WasmSearchResult;
-
-			if (result.error) continue;
-
-			if (result.matchCount > 0) {
-				filesWithMatches++;
-				totalMatches += result.matchCount;
-
-				if (request.mode === "content" || !request.mode) {
-					for (const m of result.matches) {
-						matches.push({
-							path: normalizedPath,
-							lineNumber: m.lineNumber,
-							line: m.line,
-							contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
-							contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
-							truncated: m.truncated || undefined,
-						});
-					}
-				} else {
-					matches.push({
-						path: normalizedPath,
-						lineNumber: 0,
-						line: "",
-						matchCount: result.matchCount,
-					});
-				}
-
-				if (result.limitReached || (maxCount !== undefined && totalMatches >= maxCount)) {
-					limitReached = true;
-				}
-			}
-		}
-	}
-
-	return {
-		matches,
-		totalMatches,
-		filesWithMatches,
-		filesSearched,
-		limitReached: limitReached || undefined,
-	};
-}
-
-declare const self: Worker;
-
-self.addEventListener("message", async (e: MessageEvent<WorkerRequest>) => {
-	const msg = e.data;
-
-	switch (msg.type) {
-		case "init":
-			self.postMessage({ type: "ready", id: msg.id } satisfies WorkerResponse);
-			break;
-
-		case "grep":
-			try {
-				const result = await runGrep(msg.request);
-				self.postMessage({ type: "result", id: msg.id, result } satisfies WorkerResponse);
-			} catch (err) {
-				self.postMessage({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				} satisfies WorkerResponse);
-			}
-			break;
-
-		case "destroy":
-			break;
-	}
-});

package/src/html/worker.ts

@@ -1,40 +0,0 @@
-/**
- * Worker for HTML to Markdown conversion.
- * Uses WASM for actual conversion.
- */
-
-import { html_to_markdown } from "../../wasm/pi_natives";
-import type { HtmlRequest, HtmlResponse } from "./types";
-
-declare const self: Worker;
-
-function respond(msg: HtmlResponse): void {
-	self.postMessage(msg);
-}
-
-self.addEventListener("message", (e: MessageEvent<HtmlRequest>) => {
-	const msg = e.data;
-
-	switch (msg.type) {
-		case "init":
-			respond({ type: "ready", id: msg.id });
-			break;
-
-		case "destroy":
-			break;
-
-		case "convert": {
-			try {
-				const markdown = html_to_markdown(msg.html, msg.options);
-				respond({ type: "converted", id: msg.id, markdown });
-			} catch (err) {
-				respond({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-			break;
-		}
-	}
-});

package/src/image/types.ts

@@ -1,52 +0,0 @@
-/**
- * Types for image worker communication.
- */
-
-export type ImageRequest =
-	| { type: "init"; id: number }
-	| { type: "destroy" }
-	| {
-			type: "load";
-			id: number;
-			/** Image bytes (transferred, not copied) */
-			bytes: Uint8Array;
-	  }
-	| {
-			type: "resize";
-			id: number;
-			/** Handle returned from load */
-			handle: number;
-			width: number;
-			height: number;
-			filter: number;
-	  }
-	| {
-			type: "get_dimensions";
-			id: number;
-			handle: number;
-	  }
-	| {
-			type: "get_png";
-			id: number;
-			handle: number;
-	  }
-	| {
-			type: "get_jpeg";
-			id: number;
-			handle: number;
-			quality: number;
-	  }
-	| {
-			type: "free";
-			id: number;
-			handle: number;
-	  };
-
-export type ImageResponse =
-	| { type: "ready"; id: number }
-	| { type: "error"; id: number; error: string }
-	| { type: "loaded"; id: number; handle: number; width: number; height: number }
-	| { type: "resized"; id: number; handle: number; width: number; height: number }
-	| { type: "dimensions"; id: number; width: number; height: number }
-	| { type: "bytes"; id: number; bytes: Uint8Array }
-	| { type: "freed"; id: number };

package/src/image/worker.ts

@@ -1,152 +0,0 @@
-/**
- * Worker for image processing operations.
- * Uses WASM for actual processing, communicates via transferable buffers.
- */
-
-import { PhotonImage, type SamplingFilter, resize as wasmResize } from "../../wasm/pi_natives";
-import type { ImageRequest, ImageResponse } from "./types";
-
-declare const self: Worker;
-
-/** Map of handle -> PhotonImage */
-const images = new Map<number, PhotonImage>();
-let nextHandle = 1;
-
-function respond(msg: ImageResponse, transfer?: ArrayBufferLike[]): void {
-	if (transfer) {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		self.postMessage(msg, transfer as any);
-	} else {
-		self.postMessage(msg);
-	}
-}
-
-self.addEventListener("message", (e: MessageEvent<ImageRequest>) => {
-	const msg = e.data;
-
-	switch (msg.type) {
-		case "init":
-			respond({ type: "ready", id: msg.id });
-			break;
-
-		case "destroy":
-			for (const img of images.values()) {
-				img.free();
-			}
-			images.clear();
-			break;
-
-		case "load": {
-			try {
-				const img = PhotonImage.new_from_byteslice(msg.bytes);
-				const handle = nextHandle++;
-				images.set(handle, img);
-				respond({
-					type: "loaded",
-					id: msg.id,
-					handle,
-					width: img.get_width(),
-					height: img.get_height(),
-				});
-			} catch (err) {
-				respond({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-			break;
-		}
-
-		case "resize": {
-			const img = images.get(msg.handle);
-			if (!img) {
-				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
-				break;
-			}
-			try {
-				const filter = msg.filter as SamplingFilter;
-				const resized = wasmResize(img, msg.width, msg.height, filter);
-				const handle = nextHandle++;
-				images.set(handle, resized);
-				respond({
-					type: "resized",
-					id: msg.id,
-					handle,
-					width: resized.get_width(),
-					height: resized.get_height(),
-				});
-			} catch (err) {
-				respond({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-			break;
-		}
-
-		case "get_dimensions": {
-			const img = images.get(msg.handle);
-			if (!img) {
-				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
-				break;
-			}
-			respond({
-				type: "dimensions",
-				id: msg.id,
-				width: img.get_width(),
-				height: img.get_height(),
-			});
-			break;
-		}
-
-		case "get_png": {
-			const img = images.get(msg.handle);
-			if (!img) {
-				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
-				break;
-			}
-			try {
-				const bytes = img.get_bytes();
-				respond({ type: "bytes", id: msg.id, bytes }, [bytes.buffer]);
-			} catch (err) {
-				respond({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-			break;
-		}
-
-		case "get_jpeg": {
-			const img = images.get(msg.handle);
-			if (!img) {
-				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
-				break;
-			}
-			try {
-				const bytes = img.get_bytes_jpeg(msg.quality);
-				respond({ type: "bytes", id: msg.id, bytes }, [bytes.buffer]);
-			} catch (err) {
-				respond({
-					type: "error",
-					id: msg.id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-			break;
-		}
-
-		case "free": {
-			const img = images.get(msg.handle);
-			if (img) {
-				img.free();
-				images.delete(msg.handle);
-			}
-			respond({ type: "freed", id: msg.id });
-			break;
-		}
-	}
-});