@storyteller-platform/epub 0.4.0 → 0.4.2

package/dist/index.js

@@ -1,18 +1,87 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 import { randomUUID } from "node:crypto";
-import { rmSync } from "node:fs";
-import { cp, writeFile } from "node:fs/promises";
+import { createWriteStream, rmSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { PortablePath, npath, ppath } from "@yarnpkg/fslib";
-import { DEFAULT_COMPRESSION_LEVEL, ZipFS } from "@yarnpkg/libzip";
+import * as util from "node:util";
 import { Mutex } from "async-mutex";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 import memoize from "mem";
 import { lookup } from "mime-types";
 import { nanoid } from "nanoid";
+import yauzl from "yauzl";
+import { ZipFile } from "yazl";
+import { dirname, join, resolve } from "@storyteller-platform/path";
+function promisify(api) {
+  return function(arg, options) {
+    return new Promise(function(resolve2, reject) {
+      api(arg, options, function(err, response) {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(response);
+      });
+    });
+  };
+}
+const unzipFromBuffer = promisify(
+  (arg, options, callback) => {
+    yauzl.fromBuffer(arg, options, callback);
+  }
+);
+const unzipFromPath = promisify(
+  (arg, options, callback) => {
+    yauzl.open(arg, options, callback);
+  }
+);
 class Epub {
-  constructor(zipFs, zipPath, inputPath) {
-    this.zipFs = zipFs;
-    this.zipPath = zipPath;
+  constructor(extractPath, inputPath) {
+    this.extractPath = extractPath;
     this.inputPath = inputPath;
     this.readXhtmlItemContents = memoize(
       this.readXhtmlItemContents.bind(this),
@@ -189,11 +258,10 @@ ${JSON.stringify(element, null, 2)}`
     creators,
     contributors
   }, additionalMetadata = []) {
-    const tmp = npath.join(
+    const extractPath = join(
       tmpdir(),
-      `storyteller-platform-epub-${randomUUID()}.epub`
+      `storyteller-platform-epub-${randomUUID()}`
     );
-    const zipFs = new ZipFS(npath.toPortablePath(tmp), { create: true });
     const encoder = new TextEncoder();
     const container = encoder.encode(`<?xml version="1.0"?>
 <container>
@@ -202,11 +270,8 @@ ${JSON.stringify(element, null, 2)}`
   </rootfiles>
 </container>
 `);
-    await zipFs.mkdirpPromise(ppath.join(PortablePath.root, "META-INF"));
-    await zipFs.writeFilePromise(
-      ppath.join(PortablePath.root, "META-INF", "container.xml"),
-      container
-    );
+    await mkdir(join(extractPath, "META-INF"), { recursive: true });
+    await writeFile(join(extractPath, "META-INF", "container.xml"), container);
     const packageDocument = encoder.encode(`<?xml version="1.0"?>
 <package unique-identifier="pub-id" dir="${language.textInfo.direction}" xml:lang=${language.toString()} version="3.0">
   <metadata>
@@ -217,12 +282,9 @@ ${JSON.stringify(element, null, 2)}`
   </spine>
 </package>
 `);
-    await zipFs.mkdirpPromise(ppath.join(PortablePath.root, "OEBPS"));
-    await zipFs.writeFilePromise(
-      ppath.join(PortablePath.root, "OEBPS", "content.opf"),
-      packageDocument
-    );
-    const epub = new this(zipFs, tmp, path);
+    await mkdir(join(extractPath, "OEBPS"));
+    await writeFile(join(extractPath, "OEBPS", "content.opf"), packageDocument);
+    const epub = new this(extractPath, path);
     const metadata = [
       {
         id: "pub-id",
@@ -260,35 +322,66 @@ ${JSON.stringify(element, null, 2)}`
    */
   // eslint-disable-next-line @typescript-eslint/require-await
   static async from(pathOrData) {
-    const tmp = npath.join(
-      tmpdir(),
-      `storyteller-platform-epub-${randomUUID()}.epub`
-    );
-    if (typeof pathOrData !== "string") {
-      await writeFile(tmp, pathOrData);
-    } else {
-      await cp(pathOrData, tmp);
+    var _stack = [];
+    try {
+      const extractPath = join(
+        tmpdir(),
+        `storyteller-platform-epub-${randomUUID()}.epub`
+      );
+      const zipfile = typeof pathOrData === "string" ? await unzipFromPath(pathOrData, { lazyEntries: true }) : await unzipFromBuffer(Buffer.from(pathOrData), { lazyEntries: true });
+      const stack = __using(_stack, new DisposableStack());
+      stack.defer(() => {
+        zipfile.close();
+      });
+      const { promise, resolve: resolve2 } = Promise.withResolvers();
+      zipfile.on("end", () => {
+        resolve2();
+      });
+      const openReadStream = util.promisify(zipfile.openReadStream.bind(zipfile));
+      zipfile.readEntry();
+      zipfile.on("entry", async (entry) => {
+        if (entry.fileName.endsWith("/")) {
+          zipfile.readEntry();
+        } else {
+          const writePath = join(extractPath, entry.fileName);
+          const readStream = await openReadStream(entry);
+          await mkdir(dirname(writePath), { recursive: true });
+          await new Promise((resolvePipe) => {
+            const writePath2 = join(extractPath, entry.fileName);
+            const writeStream = createWriteStream(writePath2);
+            writeStream.on("finish", () => {
+              resolvePipe();
+            });
+            readStream.pipe(writeStream);
+          }).finally(() => {
+            zipfile.readEntry();
+          });
+        }
+      });
+      await promise;
+      return new this(
+        extractPath,
+        typeof pathOrData === "string" ? pathOrData : void 0
+      );
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
-    const zipFs = new ZipFS(npath.toPortablePath(tmp));
-    return new this(
-      zipFs,
-      tmp,
-      typeof pathOrData === "string" ? pathOrData : void 0
-    );
   }
   async removeEntry(href) {
     const rootfile = await this.getRootfile();
     const filename = this.resolveHref(rootfile, href);
-    await this.zipFs.removePromise(filename);
+    await rm(filename);
   }
   async getFileData(path, encoding) {
-    return await this.zipFs.readFilePromise(path, encoding);
+    return await readFile(path, encoding);
   }
   async getRootfile() {
     var _a;
     if (this.rootfile !== null) return this.rootfile;
     const containerString = await this.getFileData(
-      ppath.join(PortablePath.root, "META-INF", "container.xml"),
+      join(this.extractPath, "META-INF", "container.xml"),
       "utf-8"
     );
     if (!containerString)
@@ -320,7 +413,7 @@ ${JSON.stringify(element, null, 2)}`
       throw new Error(
         "Failed to parse EPUB container.xml: Found no rootfile element"
       );
-    this.rootfile = ppath.resolve(PortablePath.root, fullPath);
+    this.rootfile = resolve(this.extractPath, fullPath);
     return this.rootfile;
   }
   migratePackageDocument(packageDocument) {
@@ -803,7 +896,11 @@ ${JSON.stringify(element, null, 2)}`
     if (!primaryLanguage) return null;
     const locale = primaryLanguage.value;
     if (!locale || locale.toLowerCase() === "und") return null;
-    return new Intl.Locale(locale);
+    try {
+      return new Intl.Locale(locale);
+    } catch {
+      return null;
+    }
   }
   /**
    * Update the Epub's language metadata entry.
@@ -1443,8 +1540,8 @@ ${JSON.stringify(element, null, 2)}`
    * Returns a Zip Entry path for an HREF
    */
   resolveHref(from, href) {
-    const startPath = ppath.dirname(from);
-    return ppath.resolve(PortablePath.root, startPath, href);
+    const startPath = dirname(from);
+    return resolve(this.extractPath, startPath, href);
   }
   async readItemContents(id, encoding) {
     const rootfile = await this.getRootfile();
@@ -1490,8 +1587,8 @@ ${JSON.stringify(element, null, 2)}`
     return Epub.getXhtmlTextContent(body);
   }
   async writeEntryContents(path, contents, encoding) {
-    await this.zipFs.mkdirpPromise(ppath.dirname(path));
-    await this.zipFs.writeFilePromise(path, contents, encoding);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, contents, encoding);
   }
   async writeItemContents(id, contents, encoding) {
     const rootfile = await this.getRootfile();
@@ -1581,8 +1678,8 @@ ${JSON.stringify(element, null, 2)}`
         contents
       )
     ) : contents;
-    await this.zipFs.mkdirpPromise(ppath.dirname(filename));
-    await this.zipFs.writeFilePromise(filename, data);
+    await mkdir(dirname(filename), { recursive: true });
+    await writeFile(filename, data);
   }
   /**
    * Update the manifest entry for an existing item.
@@ -1733,11 +1830,10 @@ ${JSON.stringify(element, null, 2)}`
     });
   }
   discardAndClose() {
-    this.zipFs.discardAndClose();
     this.rootfile = null;
     this.manifest = null;
     this.spine = null;
-    rmSync(this.zipPath, { recursive: true, force: true });
+    rmSync(this.extractPath, { recursive: true, force: true });
   }
   /**
    * Write the current contents of the Epub to a new
@@ -1748,32 +1844,62 @@ ${JSON.stringify(element, null, 2)}`
    * timestamp.
    */
   async saveAndClose() {
-    if (!this.inputPath) {
-      throw new Error("In-memory EPUB files cannot be saved to disk");
-    }
-    await this.replaceMetadata(
-      (entry) => entry.properties["property"] === "dcterms:modified",
-      {
-        type: "meta",
-        properties: { property: "dcterms:modified" },
-        // We need UTC with integer seconds, but toISOString gives UTC with ms
-        value: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+/, "")
+    var _stack = [];
+    try {
+      if (!this.inputPath) {
+        throw new Error("In-memory EPUB files cannot be saved to disk");
       }
-    );
-    this.zipFs.level = 0;
-    await this.zipFs.writeFilePromise(
-      ppath.join(PortablePath.root, "mimetype"),
-      "application/epub+zip",
-      "utf-8"
-    );
-    this.zipFs.level = DEFAULT_COMPRESSION_LEVEL;
-    this.zipFs.saveAndClose();
-    await cp(this.zipPath, this.inputPath, { force: true });
+      await this.replaceMetadata(
+        (entry) => entry.properties["property"] === "dcterms:modified",
+        {
+          type: "meta",
+          properties: { property: "dcterms:modified" },
+          // We need UTC with integer seconds, but toISOString gives UTC with ms
+          value: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+/, "")
+        }
+      );
+      const tmpArchivePath = join(
+        tmpdir(),
+        `storyteller-platform-epub-${randomUUID()}`
+      );
+      const { promise, resolve: resolve2 } = Promise.withResolvers();
+      const zipfile = new ZipFile();
+      const writeStream = createWriteStream(tmpArchivePath);
+      writeStream.on("close", () => {
+        resolve2();
+      });
+      const stack = __using(_stack, new AsyncDisposableStack(), true);
+      stack.defer(async () => {
+        writeStream.close();
+        await rm(tmpArchivePath, { force: true });
+      });
+      zipfile.outputStream.pipe(writeStream);
+      zipfile.addBuffer(Buffer.from("application/epub+zip"), "mimetype", {
+        compress: false
+      });
+      const entries = await readdir(this.extractPath, {
+        recursive: true,
+        withFileTypes: true
+      });
+      for (const entry of entries) {
+        if (entry.name === "mimetype" || entry.isDirectory()) continue;
+        zipfile.addFile(
+          join(entry.parentPath, entry.name),
+          join(entry.parentPath, entry.name).replace(`${this.extractPath}/`, "")
+        );
+      }
+      zipfile.end();
+      await promise;
+      await cp(tmpArchivePath, this.inputPath);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
   }
   [Symbol.dispose]() {
-    if (this.zipFs.ready) {
-      this.discardAndClose();
-    }
+    this.discardAndClose();
   }
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storyteller-platform/epub",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,6 +32,7 @@
     "@tsconfig/strictest": "^2.0.5",
     "@types/mime-types": "^2",
     "@types/node": "^24.0.0",
+    "@types/yazl": "^3",
     "markdown-toc": "^1.2.0",
     "remark-toc": "^9.0.0",
     "tsup": "^8.5.0",
@@ -44,14 +45,15 @@
   "dependencies": {
     "@storyteller-platform/fs": "^0.1.3",
     "@storyteller-platform/path": "^0.1.1",
-    "@yarnpkg/fslib": "^3.1.3",
-    "@yarnpkg/libzip": "^3.2.2",
+    "@types/yauzl": "^2.10.3",
     "@zip.js/zip.js": "^2.0.0",
     "async-mutex": "^0.5.0",
     "fast-xml-parser": "^4.0.0",
     "mem": "^8.0.0",
     "mime-types": "^3.0.1",
-    "nanoid": "^5.1.5"
+    "nanoid": "^5.1.5",
+    "yauzl": "^3.2.0",
+    "yazl": "^3.3.1"
   },
   "publishConfig": {
     "access": "public",