@jerryan/pi-hashline-edit 0.7.0

package/src/file-kind.ts

@@ -0,0 +1,167 @@
+import { open as fsOpen, stat as fsStat } from "fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+
+const IMAGE_MIME_TYPES = new Set<string>([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+]);
+
+const TEXT_LIKE_MIME_TYPES = new Set<string>([
+  "application/rtf",
+  "application/xml",
+  "application/x-ms-regedit",
+]);
+
+function isTextLikeMimeType(mimeType: string): boolean {
+  return mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+}
+
+const FILE_TYPE_SNIFF_BYTES = 8192;
+
+export type FileKind =
+  | { kind: "directory" }
+  | { kind: "image"; mimeType: string }
+  | { kind: "text" }
+  | { kind: "binary"; description: string };
+
+export type LoadedFile =
+  | { kind: "directory" }
+  | { kind: "image"; mimeType: string }
+  | { kind: "text"; text: string }
+  | { kind: "binary"; description: string };
+
+function hasNullByte(buffer: Uint8Array): boolean {
+  return buffer.includes(0);
+}
+
+function decodeUtf8Chunk(decoder: TextDecoder, buffer: Uint8Array): string | null {
+  try {
+    return decoder.decode(buffer, { stream: true });
+  } catch (error: unknown) {
+    if (error instanceof TypeError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function finishUtf8(decoder: TextDecoder): string | null {
+  try {
+    return decoder.decode();
+  } catch (error: unknown) {
+    if (error instanceof TypeError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export async function loadFileKindAndText(filePath: string): Promise<LoadedFile> {
+  const pathStat = await fsStat(filePath);
+  if (pathStat.isDirectory()) {
+    return { kind: "directory" };
+  }
+  if (!pathStat.isFile()) {
+    return {
+      kind: "binary",
+      description: "unsupported file type",
+    };
+  }
+
+  const fileHandle = await fsOpen(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+    const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
+    if (bytesRead === 0) {
+      return { kind: "text", text: "" };
+    }
+
+    const sample = buffer.subarray(0, bytesRead);
+    const detectedMimeType = (await fileTypeFromBuffer(sample))?.mime;
+    if (detectedMimeType !== undefined && !isTextLikeMimeType(detectedMimeType)) {
+      if (IMAGE_MIME_TYPES.has(detectedMimeType)) {
+        return { kind: "image", mimeType: detectedMimeType };
+      }
+      return {
+        kind: "binary",
+        description: detectedMimeType,
+      };
+    }
+    if (hasNullByte(sample)) {
+      return {
+        kind: "binary",
+        description: "null bytes detected",
+      };
+    }
+
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const parts: string[] = [];
+    const sampleText = decodeUtf8Chunk(decoder, sample);
+    if (sampleText === null) {
+      return {
+        kind: "binary",
+        description: "invalid UTF-8",
+      };
+    }
+    parts.push(sampleText);
+
+    let position = bytesRead;
+    while (true) {
+      const { bytesRead: chunkBytesRead } = await fileHandle.read(
+        buffer,
+        0,
+        FILE_TYPE_SNIFF_BYTES,
+        position,
+      );
+      if (chunkBytesRead === 0) {
+        break;
+      }
+
+      const chunk = buffer.subarray(0, chunkBytesRead);
+      if (hasNullByte(chunk)) {
+        return {
+          kind: "binary",
+          description: "null bytes detected",
+        };
+      }
+      const chunkText = decodeUtf8Chunk(decoder, chunk);
+      if (chunkText === null) {
+        return {
+          kind: "binary",
+          description: "invalid UTF-8",
+        };
+      }
+      parts.push(chunkText);
+      position += chunkBytesRead;
+    }
+
+    const tail = finishUtf8(decoder);
+    if (tail === null) {
+      return {
+        kind: "binary",
+        description: "invalid UTF-8",
+      };
+    }
+    parts.push(tail);
+
+    return { kind: "text", text: parts.join("") };
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+export async function classifyFileKind(filePath: string): Promise<FileKind> {
+  const loaded = await loadFileKindAndText(filePath);
+  switch (loaded.kind) {
+    case "directory":
+      return loaded;
+    case "image":
+      return loaded;
+    case "binary":
+      return loaded;
+    case "text":
+      return { kind: "text" };
+  }
+}

package/src/fs-write.ts

@@ -0,0 +1,76 @@
+import { randomUUID } from "crypto";
+import { lstat, mkdir, readlink, rename, stat, writeFile } from "fs/promises";
+import { dirname, join, parse, resolve, sep } from "path";
+
+export async function resolveMutationTargetPath(path: string): Promise<string> {
+  const absolutePath = resolve(path);
+  const { root } = parse(absolutePath);
+  const parts = absolutePath.slice(root.length).split(sep).filter((part) => part.length > 0);
+  const visitedSymlinks = new Set<string>();
+
+  async function resolveFromParts(currentPath: string, remainingParts: string[]): Promise<string> {
+    if (remainingParts.length === 0) {
+      return currentPath;
+    }
+
+    const [nextPart, ...tail] = remainingParts;
+    const candidatePath = join(currentPath, nextPart);
+
+    try {
+      const candidateStats = await lstat(candidatePath);
+      if (!candidateStats.isSymbolicLink()) {
+        return resolveFromParts(candidatePath, tail);
+      }
+
+      if (visitedSymlinks.has(candidatePath)) {
+        const error = new Error(`Too many symbolic links while resolving ${path}`) as NodeJS.ErrnoException;
+        error.code = "ELOOP";
+        throw error;
+      }
+      visitedSymlinks.add(candidatePath);
+
+      const linkTargetPath = resolve(dirname(candidatePath), await readlink(candidatePath));
+      const targetParts = linkTargetPath
+        .slice(parse(linkTargetPath).root.length)
+        .split(sep)
+        .filter((part) => part.length > 0);
+      return resolveFromParts(parse(linkTargetPath).root, [...targetParts, ...tail]);
+    } catch (error: unknown) {
+      if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+        return join(candidatePath, ...tail);
+      }
+      throw error;
+    }
+  }
+
+  return resolveFromParts(root, parts);
+}
+
+export async function writeFileAtomically(
+  path: string,
+  content: string,
+): Promise<void> {
+  const targetPath = await resolveMutationTargetPath(path);
+
+  let existingStats: Awaited<ReturnType<typeof stat>> | null = null;
+  try {
+    existingStats = await stat(targetPath);
+  } catch (error: unknown) {
+    if ((error as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+
+  if (existingStats && existingStats.nlink > 1) {
+    await writeFile(targetPath, content, "utf-8");
+    return;
+  }
+
+  const dir = dirname(targetPath);
+  const tempPath = join(dir, `.tmp-${randomUUID()}`);
+  await mkdir(dir, { recursive: true });
+  const mode = existingStats ? existingStats.mode & 0o7777 : 0o600;
+  await writeFile(tempPath, content, { encoding: "utf-8", flag: "wx", mode });
+
+  await rename(tempPath, targetPath);
+}