@storyteller-platform/epub 0.5.1 → 0.6.0

package/dist/adapters/tmpfs.d.ts

@@ -0,0 +1,29 @@
+import { EpubStorageAdapter, EpubListEntry } from './interface.js';
+
+/**
+ * Extracts an EPUB archive to a temp directory and serves all I/O off
+ * the real filesystem.
+ * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
+ */
+declare class TmpFsAdapter implements EpubStorageAdapter {
+    readonly rootPath: string;
+    static readonly kind: "extracted-dir";
+    static readonly capabilities: {
+        readonly writable: true;
+    };
+    static init(source: string | Uint8Array): Promise<TmpFsAdapter>;
+    static initEmpty(): Promise<TmpFsAdapter>;
+    private constructor();
+    read(path: string): Promise<Uint8Array>;
+    read(path: string, encoding: "utf-8"): Promise<string>;
+    write(path: string, data: Uint8Array): Promise<void>;
+    write(path: string, data: string, encoding: "utf-8"): Promise<void>;
+    remove(path: string): Promise<void>;
+    archiveLength(path: string): Promise<number>;
+    list(): AsyncIterable<EpubListEntry>;
+    duplicate(): Promise<TmpFsAdapter>;
+    serialize(targetPath: string): Promise<void>;
+    dispose(): void;
+}
+
+export { TmpFsAdapter };

package/dist/adapters/tmpfs.js

@@ -0,0 +1,178 @@
+import {
+  __callDispose,
+  __using
+} from "../chunk-BIEQXUOY.js";
+import { randomUUID } from "node:crypto";
+import { createWriteStream, rmSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { pipeline } from "node:stream/promises";
+import { fromBuffer, open } from "yauzl-promise";
+import { ZipFile } from "yazl";
+import { dirname, join, sep } from "@storyteller-platform/path";
+const MP3_FILE_EXTENSIONS = [".mp3"];
+const MPEG4_FILE_EXTENSIONS = [".mp4", ".m4a", ".m4b"];
+const AAC_FILE_EXTENSIONS = [".aac"];
+const OGG_FILE_EXTENSIONS = [".ogg", ".oga", ".mogg"];
+const OPUS_FILE_EXTENSIONS = [".opus"];
+const WAVE_FILE_EXTENSIONS = [".wav"];
+const AIFF_FILE_EXTENSIONS = [".aiff"];
+const FLAC_FILE_EXTENSIONS = [".flac"];
+const ALAC_FILE_EXTENSIONS = [".alac"];
+const WEBM_FILE_EXTENSIONS = [".weba"];
+const AUDIO_FILE_EXTENSIONS = [
+  ...MP3_FILE_EXTENSIONS,
+  ...AAC_FILE_EXTENSIONS,
+  ...MPEG4_FILE_EXTENSIONS,
+  ...OPUS_FILE_EXTENSIONS,
+  ...OGG_FILE_EXTENSIONS,
+  ...WAVE_FILE_EXTENSIONS,
+  ...AIFF_FILE_EXTENSIONS,
+  ...FLAC_FILE_EXTENSIONS,
+  ...ALAC_FILE_EXTENSIONS,
+  ...WEBM_FILE_EXTENSIONS
+];
+function isAudioFile(filenameOrExt) {
+  return AUDIO_FILE_EXTENSIONS.some((ext) => filenameOrExt.endsWith(ext));
+}
+function mintRootPath() {
+  return join(tmpdir(), `storyteller-platform-epub-${randomUUID()}.epub`);
+}
+class TmpFsAdapter {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+  static kind = "extracted-dir";
+  static capabilities = { writable: true };
+  static async init(source) {
+    const rootPath = mintRootPath();
+    try {
+      var _stack = [];
+      try {
+        const zipfile = typeof source === "string" ? await open(source) : await fromBuffer(Buffer.from(source));
+        const stack = __using(_stack, new AsyncDisposableStack(), true);
+        stack.defer(async () => {
+          await zipfile.close();
+        });
+        for await (const entry of zipfile) {
+          if (entry.filename.endsWith(sep)) {
+            continue;
+          }
+          const writePath = join(rootPath, entry.filename);
+          const readStream = await entry.openReadStream();
+          await mkdir(dirname(writePath), { recursive: true });
+          const writeStream = createWriteStream(writePath);
+          await pipeline(readStream, writeStream);
+        }
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        var _promise = __callDispose(_stack, _error, _hasError);
+        _promise && await _promise;
+      }
+    } catch (error) {
+      rmSync(rootPath, { force: true, recursive: true });
+      throw error;
+    }
+    return new TmpFsAdapter(rootPath);
+  }
+  static async initEmpty() {
+    const rootPath = mintRootPath();
+    await mkdir(rootPath, { recursive: true });
+    return new TmpFsAdapter(rootPath);
+  }
+  async read(path, encoding) {
+    return await readFile(path, encoding);
+  }
+  async write(path, data, encoding) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, data, encoding);
+  }
+  async remove(path) {
+    await rm(path);
+  }
+  async archiveLength(path) {
+    try {
+      const st = await stat(path);
+      return st.size;
+    } catch {
+      return 0;
+    }
+  }
+  async *list() {
+    const entries = await readdir(this.rootPath, {
+      recursive: true,
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (entry.isDirectory()) continue;
+      const absolutePath = join(entry.parentPath, entry.name);
+      yield {
+        absolutePath,
+        relativePath: absolutePath.replace(`${this.rootPath}${sep}`, "")
+      };
+    }
+  }
+  async duplicate() {
+    const newRoot = mintRootPath();
+    try {
+      await cp(this.rootPath, newRoot, { recursive: true });
+    } catch (error) {
+      rmSync(newRoot, { force: true, recursive: true });
+      throw error;
+    }
+    return new TmpFsAdapter(newRoot);
+  }
+  async serialize(targetPath) {
+    var _stack = [];
+    try {
+      const tmpArchivePath = join(
+        tmpdir(),
+        `storyteller-platform-epub-${randomUUID()}`
+      );
+      const { promise, resolve } = Promise.withResolvers();
+      const zipfile = new ZipFile();
+      const writeStream = createWriteStream(tmpArchivePath);
+      writeStream.on("close", () => {
+        resolve();
+      });
+      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
+      });
+      for await (const entry of this.list()) {
+        if (entry.relativePath === "mimetype") continue;
+        zipfile.addFile(entry.absolutePath, entry.relativePath, {
+          compress: !isAudioFile(entry.absolutePath)
+        });
+      }
+      zipfile.end();
+      await promise;
+      await cp(tmpArchivePath, targetPath);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  }
+  dispose() {
+    rmSync(this.rootPath, { recursive: true, force: true });
+  }
+}
+export {
+  TmpFsAdapter
+};