@clazic/kordoc 2.6.0 → 2.7.0

package/dist/{chunk-TS3F57LY.js → chunk-3FTA6V7S.js}

@@ -7,7 +7,7 @@ import {
   precheckZipSize,
   sanitizeHref,
   toArrayBuffer
-} from "./chunk-TND4YFBV.js";
+} from "./chunk-USE7IDLV.js";
 import {
   parsePageRange
 } from "./chunk-MOL7MDBG.js";
@@ -9836,19 +9836,250 @@ var ConvertError = class extends Error {
   }
 };
 
-// src/convert/libreoffice.ts
-var libreConvert = libre.convert;
-async function assertSofficeAvailable() {
-  const { runCommand } = await import("./utils-F66K7PXH.js");
+// src/convert/installer.ts
+import { homedir } from "os";
+import { join as join2, delimiter } from "path";
+import { mkdir, access, symlink, rm } from "fs/promises";
+import { createWriteStream } from "fs";
+import { spawn } from "child_process";
+var installInFlight = null;
+var CACHE_DIR = join2(homedir(), ".cache", "kordoc", "libreoffice");
+var VERSION_FILE = join2(CACHE_DIR, "version");
+var PACKAGES = {
+  darwin: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/mac/x86_64/LibreOffice_24.8.4_MacOS_x86-64.dmg",
+    binPath: "LibreOffice.app/Contents/MacOS/soffice",
+    sizeMb: 300
+  },
+  linux: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/deb/x86_64/LibreOffice_24.8.4_Linux_x86-64_deb.tar.gz",
+    binPath: "opt/libreoffice24.8/program/soffice",
+    sizeMb: 200
+  },
+  win32: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/win/x86_64/LibreOffice_24.8.4_Win_x86-64.msi",
+    binPath: "LibreOffice/program/soffice.exe",
+    sizeMb: 350
+  }
+};
+async function findInPath() {
+  return new Promise((resolve2) => {
+    const child = spawn("soffice", ["--version"], { stdio: "ignore" });
+    child.on("close", (code) => resolve2(code === 0 ? "soffice" : null));
+    child.on("error", () => resolve2(null));
+  });
+}
+async function findInCache() {
+  const cachedBin = join2(CACHE_DIR, "bin", "soffice");
   try {
-    await runCommand("soffice", ["--version"]);
+    await access(cachedBin);
+    return cachedBin;
   } catch {
+    return null;
+  }
+}
+async function findInDefaultPaths() {
+  const platform = process.platform;
+  const paths = [];
+  if (platform === "darwin") {
+    paths.push(
+      "/Applications/LibreOffice.app/Contents/MacOS/soffice",
+      "/opt/homebrew/bin/soffice",
+      "/usr/local/bin/soffice"
+    );
+  } else if (platform === "linux") {
+    paths.push(
+      "/usr/bin/soffice",
+      "/usr/lib/libreoffice/program/soffice"
+    );
+  } else if (platform === "win32") {
+    const pf = process.env["ProgramFiles"] ?? "C:\\Program Files";
+    const pf86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+    paths.push(
+      join2(pf, "LibreOffice", "program", "soffice.exe"),
+      join2(pf86, "LibreOffice", "program", "soffice.exe")
+    );
+  }
+  for (const p of paths) {
+    try {
+      await access(p);
+      return p;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function downloadWithProgress(url, dest, totalBytes, onProgress) {
+  const response = await fetch(url);
+  if (!response.body) throw new Error("\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: response body \uC5C6\uC74C");
+  const file = createWriteStream(dest);
+  const reader = response.body.getReader();
+  let downloaded = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      file.write(value);
+      downloaded += value.length;
+      onProgress?.(downloaded, totalBytes);
+    }
+  } finally {
+    file.end();
+    reader.releaseLock();
+  }
+}
+async function installForPlatform(pkg, onProgress) {
+  const platform = process.platform;
+  await mkdir(CACHE_DIR, { recursive: true });
+  const downloadPath = join2(CACHE_DIR, `download-${Date.now()}`);
+  await downloadWithProgress(pkg.url, downloadPath, pkg.sizeMb * 1024 * 1024, onProgress);
+  try {
+    if (platform === "darwin") {
+      return await installMacOS(pkg, downloadPath);
+    } else if (platform === "linux") {
+      return await installLinux(pkg, downloadPath);
+    } else if (platform === "win32") {
+      return await installWindows(pkg, downloadPath);
+    }
+  } catch (err) {
+    await rm(downloadPath, { force: true });
+    throw err;
+  }
+  throw new ConvertError("UNSUPPORTED_PLATFORM", `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`);
+}
+async function installMacOS(pkg, downloadPath) {
+  const mountPoint = `/Volumes/LibreOffice_${Date.now()}`;
+  await new Promise((resolve2, reject) => {
+    const child = spawn("hdiutil", ["attach", "-nobrowse", "-mountpoint", mountPoint, downloadPath]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("dmg \uB9C8\uC6B4\uD2B8 \uC2E4\uD328")));
+  });
+  try {
+    const appSource = join2(mountPoint, "LibreOffice.app");
+    const appDest = join2(CACHE_DIR, "LibreOffice.app");
+    await new Promise((resolve2, reject) => {
+      const child = spawn("cp", ["-R", appSource, appDest]);
+      child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(".app \uBCF5\uC0AC \uC2E4\uD328")));
+    });
+  } finally {
+    await new Promise((resolve2) => {
+      const child = spawn("hdiutil", ["detach", mountPoint]);
+      child.on("close", () => resolve2());
+    });
+  }
+  await rm(downloadPath, { force: true });
+  return await createSymlink(join2(CACHE_DIR, pkg.binPath));
+}
+async function installLinux(pkg, downloadPath) {
+  const extractDir = join2(CACHE_DIR, `extract-${Date.now()}`);
+  await mkdir(extractDir, { recursive: true });
+  await new Promise((resolve2, reject) => {
+    const child = spawn("tar", ["xzf", downloadPath, "-C", extractDir]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("\uC555\uCD95 \uD574\uC81C \uC2E4\uD328")));
+  });
+  const debsDir = join2(extractDir, "DEBS");
+  try {
+    await access(debsDir);
+    const entries = await (await import("fs/promises")).readdir(debsDir);
+    for (const entry of entries) {
+      if (entry.endsWith(".deb")) {
+        await new Promise((resolve2, reject) => {
+          const child = spawn("dpkg-deb", ["-x", join2(debsDir, entry), CACHE_DIR]);
+          child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${entry} \uCD94\uCD9C \uC2E4\uD328`)));
+        });
+      }
+    }
+  } catch {
+  }
+  await rm(downloadPath, { force: true });
+  await rm(extractDir, { recursive: true, force: true });
+  return await createSymlink(join2(CACHE_DIR, pkg.binPath));
+}
+async function installWindows(pkg, downloadPath) {
+  await new Promise((resolve2, reject) => {
+    const child = spawn("msiexec", ["/a", downloadPath, "/qn", `TARGETDIR=${CACHE_DIR}`]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("MSI \uC124\uCE58 \uC2E4\uD328")));
+  });
+  await rm(downloadPath, { force: true });
+  return join2(CACHE_DIR, pkg.binPath);
+}
+async function createSymlink(actualBin) {
+  const binDir = join2(CACHE_DIR, "bin");
+  await mkdir(binDir, { recursive: true });
+  const linkBin = join2(binDir, "soffice");
+  try {
+    await symlink(actualBin, linkBin);
+  } catch {
+  }
+  process.env.PATH = `${binDir}${delimiter}${process.env.PATH}`;
+  return linkBin;
+}
+async function installLibreOffice(onProgress) {
+  const platform = process.platform;
+  const pkg = PACKAGES[platform];
+  if (!pkg) {
     throw new ConvertError(
+      "UNSUPPORTED_PLATFORM",
+      `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uC218\uB3D9\uC73C\uB85C LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.`
+    );
+  }
+  return await installForPlatform(pkg, onProgress);
+}
+async function resolveSoffice(emitter, autoInstall = true) {
+  emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
+  const inPath = await findInPath();
+  if (inPath) {
+    emitter.validate("soffice_found", "\uC2DC\uC2A4\uD15C PATH\uC5D0\uC11C LibreOffice \uBC1C\uACAC", { sofficePath: inPath });
+    return inPath;
+  }
+  const inCache = await findInCache();
+  if (inCache) {
+    emitter.validate("soffice_found", "\uCE90\uC2DC\uB41C LibreOffice \uBC1C\uACAC", { sofficePath: inCache });
+    return inCache;
+  }
+  const inDefault = await findInDefaultPaths();
+  if (inDefault) {
+    emitter.validate("soffice_found", "\uAE30\uBCF8 \uACBD\uB85C\uC5D0\uC11C LibreOffice \uBC1C\uACAC", { sofficePath: inDefault });
+    return inDefault;
+  }
+  if (!autoInstall) {
+    emitter.error(
+      "validate",
       "SOFFICE_NOT_FOUND",
-      "soffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694."
+      "LibreOffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      "\uC218\uB3D9\uC73C\uB85C \uC124\uCE58\uD558\uAC70\uB098 autoInstallLibreOffice: true \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uC138\uC694."
     );
+    throw new ConvertError("SOFFICE_NOT_FOUND", "LibreOffice\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
   }
+  if (installInFlight) {
+    return installInFlight;
+  }
+  emitter.install("install_start", "LibreOffice \uC790\uB3D9 \uC124\uCE58\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4...");
+  installInFlight = (async () => {
+    try {
+      const installed = await installLibreOffice((downloaded, total) => {
+        const percent = Math.round(downloaded / total * 100);
+        emitter.install("download_progress", `\uB2E4\uC6B4\uB85C\uB4DC \uC911... ${percent}%`, {
+          percent,
+          downloadedBytes: downloaded,
+          totalBytes: total
+        });
+      });
+      emitter.install("install_complete", "\uC124\uCE58 \uC644\uB8CC", { installedPath: installed });
+      return installed;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      emitter.install("install_failed", "\uC124\uCE58 \uC2E4\uD328", { error: errorMsg });
+      throw err;
+    } finally {
+      installInFlight = null;
+    }
+  })();
+  return installInFlight;
 }
+
+// src/convert/libreoffice.ts
+var libreConvert = libre.convert;
 async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
   return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
@@ -9872,6 +10103,54 @@ async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
   });
 }
 
+// src/convert/events.ts
+var ConvertEventEmitter = class {
+  listener = null;
+  /** 이벤트 리스너 등록 */
+  setListener(listener) {
+    this.listener = listener;
+  }
+  /** 이벤트 발송 */
+  emit(event) {
+    try {
+      this.listener?.(event);
+    } catch {
+    }
+  }
+  /** 타입 안전한 헬퍼: detect 이벤트 */
+  detect(stage, message, meta) {
+    this.emit({ type: "detect", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: validate 이벤트 */
+  validate(stage, message, meta) {
+    this.emit({ type: "validate", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: install 이벤트 */
+  install(stage, message, meta) {
+    this.emit({ type: "install", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: convert 진행 이벤트 */
+  progress(percent, message) {
+    this.emit({ type: "convert", stage: "convert_progress", message, percent });
+  }
+  /** 타입 안전한 헬퍼: convert 시작 */
+  convertStart(message) {
+    this.emit({ type: "convert", stage: "convert_start", message, percent: 0 });
+  }
+  /** 타입 안전한 헬퍼: convert 완료 */
+  convertDone(message) {
+    this.emit({ type: "convert", stage: "convert_done", message, percent: 100 });
+  }
+  /** 타입 안전한 헬퍼: 완료 이벤트 */
+  complete(result) {
+    this.emit({ type: "complete", stage: "success", message: "\uBCC0\uD658 \uC644\uB8CC", result });
+  }
+  /** 타입 안전한 헬퍼: 에러 이벤트 */
+  error(stage, code, message, suggestion) {
+    this.emit({ type: "error", stage, code, message, recoverable: true, suggestion });
+  }
+};
+
 // src/convert/index.ts
 var isConverting = false;
 var queue = [];
@@ -9896,81 +10175,129 @@ async function acquireConvertLock() {
   });
 }
 async function convertToPdf(input, options) {
-  let buffer;
-  try {
-    if (typeof input === "string") {
-      buffer = await readFile(input);
-    } else if (Buffer.isBuffer(input)) {
-      buffer = input;
-    } else {
-      buffer = Buffer.from(input);
-    }
-  } catch (err) {
-    return {
-      success: false,
-      code: "PARSE_ERROR",
-      error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
-      stage: "detect"
-    };
-  }
-  const MAX_FILE_SIZE = 500 * 1024 * 1024;
-  if (buffer.length > MAX_FILE_SIZE) {
-    return {
-      success: false,
-      code: "FILE_TOO_LARGE",
-      error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`,
-      stage: "detect"
-    };
+  const emitter = new ConvertEventEmitter();
+  if (options?.onEvent) {
+    emitter.setListener(options.onEvent);
   }
-  const format = detectFormat(toArrayBuffer(buffer));
-  if (format !== "hwp" && format !== "hwpx") {
-    return {
-      success: false,
-      code: "UNSUPPORTED_FORMAT",
-      error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
-      stage: "detect"
-    };
+  if (options?.onProgress) {
+    const legacyProgress = options.onProgress;
+    emitter.setListener((event) => {
+      if (event.type === "convert" && event.stage === "convert_progress") {
+        legacyProgress(event.percent, event.message);
+      }
+    });
   }
   try {
-    await assertSofficeAvailable();
-  } catch (err) {
-    if (err instanceof ConvertError) {
+    emitter.detect("reading", "\uC785\uB825 \uD30C\uC77C \uC77D\uB294 \uC911...");
+    let buffer;
+    try {
+      if (typeof input === "string") {
+        buffer = await readFile(input);
+      } else if (Buffer.isBuffer(input)) {
+        buffer = input;
+      } else {
+        buffer = Buffer.from(input);
+      }
+    } catch (err) {
+      emitter.error(
+        "detect",
+        "PARSE_ERROR",
+        `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`
+      );
       return {
         success: false,
-        code: err.code,
-        error: err.message,
-        stage: "validate"
+        code: "PARSE_ERROR",
+        error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
+        stage: "detect"
       };
     }
-    throw err;
-  }
-  const releaseLock = await acquireConvertLock();
-  try {
-    options?.onProgress?.(10, "convert");
-    const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
-    options?.onProgress?.(100, "done");
-    return {
-      success: true,
-      pdf: new Uint8Array(pdf),
-      sourceFormat: format
-    };
-  } catch (err) {
-    if (err instanceof ConvertError) {
+    const MAX_FILE_SIZE = 500 * 1024 * 1024;
+    if (buffer.length > MAX_FILE_SIZE) {
+      emitter.error(
+        "detect",
+        "FILE_TOO_LARGE",
+        `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`
+      );
+      return {
+        success: false,
+        code: "FILE_TOO_LARGE",
+        error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`,
+        stage: "detect"
+      };
+    }
+    const format = detectFormat(toArrayBuffer(buffer));
+    emitter.detect("format_detected", `\uD3EC\uB9F7 \uAC10\uC9C0 \uC644\uB8CC: ${format}`, { format });
+    if (format !== "hwp" && format !== "hwpx") {
+      emitter.error("detect", "UNSUPPORTED_FORMAT", `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`);
+      return {
+        success: false,
+        code: "UNSUPPORTED_FORMAT",
+        error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
+        stage: "detect"
+      };
+    }
+    emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
+    let sofficePath;
+    try {
+      sofficePath = await resolveSoffice(emitter, options?.autoInstallLibreOffice ?? true);
+    } catch (err) {
+      if (err instanceof ConvertError) {
+        return {
+          success: false,
+          code: err.code,
+          error: err.message,
+          stage: "validate"
+        };
+      }
+      throw err;
+    }
+    const releaseLock = await acquireConvertLock();
+    try {
+      emitter.convertStart("\uBCC0\uD658 \uC2DC\uC791...");
+      emitter.progress(10, "\uBCC0\uD658 \uC911...");
+      const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
+      emitter.progress(100, "\uBCC0\uD658 \uC644\uB8CC");
+      emitter.convertDone("\uBCC0\uD658 \uC644\uB8CC");
+      const result = {
+        success: true,
+        pdf: new Uint8Array(pdf),
+        sourceFormat: format
+      };
+      emitter.complete({
+        sourceFormat: format,
+        pdfSize: pdf.length
+      });
+      return result;
+    } catch (err) {
+      if (err instanceof ConvertError) {
+        emitter.error("convert", err.code, err.message);
+        return {
+          success: false,
+          code: err.code,
+          error: err.message,
+          stage: "convert"
+        };
+      }
+      const errorMsg = err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328";
+      emitter.error("convert", classifyError(err), errorMsg);
       return {
         success: false,
-        code: err.code,
-        error: err.message,
+        code: classifyError(err),
+        error: errorMsg,
         stage: "convert"
       };
+    } finally {
+      releaseLock();
     }
+  } catch (unexpectedErr) {
+    const errorMsg = unexpectedErr instanceof Error ? unexpectedErr.message : "\uC608\uC0C1\uCE58 \uBABB\uD55C \uC624\uB958";
+    emitter.error("convert", "PARSE_ERROR", errorMsg);
     return {
       success: false,
-      code: classifyError(err),
-      error: err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328",
+      code: "PARSE_ERROR",
+      error: errorMsg,
       stage: "convert"
     };
-  } finally {
-    releaseLock();
   }
 }
 
@@ -10358,4 +10685,4 @@ export {
 cfb/cfb.js:
   (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
 */
-//# sourceMappingURL=chunk-TS3F57LY.js.map
+//# sourceMappingURL=chunk-3FTA6V7S.js.map