@storyteller-platform/epub 0.8.2 → 1.0.1

package/dist/epubcheck.d.ts

@@ -1,21 +0,0 @@
-export interface Location {
-    url: {
-        hierachical: boolean;
-        opaque: boolean;
-    };
-    path: string;
-    line: number;
-    column: number;
-    context: string | null;
-}
-export interface Message {
-    ID: string;
-    severity: "FATAL" | "ERROR" | "WARNING" | "INFO" | "USAGE";
-    message: string;
-    additionalLocations: number;
-    locations: Location[];
-}
-export interface Report {
-    messages: Message[];
-}
-export declare function epubcheck(epubFile: string): Promise<Report>;

package/dist/epubcheck.js

@@ -1,34 +0,0 @@
-import { execFile } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFile, unlink } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-import { scratchPath } from "@storyteller-platform/fs";
-const here = dirname(fileURLToPath(import.meta.url));
-const JAR = join(here, "vendors", "epubcheck-5.3.0", "epubcheck.jar");
-export async function epubcheck(epubFile) {
-    const output = scratchPath(`epubcheck-${randomUUID()}.json`);
-    const execFilePromise = promisify(execFile);
-    try {
-        await execFilePromise("java", [
-            "-jar",
-            JAR,
-            "--json",
-            output,
-            epubFile,
-        ]).catch((error) => {
-            if (error instanceof Error &&
-                error.message.includes("Check finished with errors")) {
-                // dont throw, just let the caller handle it
-                return;
-            }
-            throw error;
-        });
-        const json = await readFile(output, "utf8");
-        return JSON.parse(json);
-    }
-    finally {
-        await unlink(output).catch(() => { });
-    }
-}

package/dist/zip.d.ts

@@ -1,2 +0,0 @@
-import { type ZipFile } from "yauzl-promise";
-export declare function openZip(source: string | Uint8Array): Promise<ZipFile>;

package/dist/zip.js

@@ -1,137 +0,0 @@
-import { createReadStream } from "node:fs";
-import { open as openFile } from "node:fs/promises";
-import { Reader, fromBuffer, fromReader, open, } from "yauzl-promise";
-const EOCDR_SIGNATURE = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
-const EOCDR_SIZE = 22;
-const MAX_TAIL_SCAN = 1024 * 1024;
-function toBuffer(source) {
-    return Buffer.isBuffer(source)
-        ? source
-        : Buffer.from(source.buffer, source.byteOffset, source.byteLength);
-}
-function findArchiveEnd(tail, tailStart, fileSize) {
-    let searchFrom = tail.length - EOCDR_SIZE;
-    while (searchFrom >= 0) {
-        const index = tail.lastIndexOf(EOCDR_SIGNATURE, searchFrom);
-        if (index === -1)
-            return null;
-        const commentLength = tail.readUInt16LE(index + 20);
-        const end = tailStart + index + EOCDR_SIZE + commentLength;
-        if (end < fileSize)
-            return end;
-        searchFrom = index - 1;
-    }
-    return null;
-}
-async function readExactly(handle, length, position) {
-    const buffer = Buffer.allocUnsafe(length);
-    let offset = 0;
-    while (offset < length) {
-        const { bytesRead } = await handle.read(buffer, offset, length - offset, position + offset);
-        if (bytesRead === 0)
-            return null;
-        offset += bytesRead;
-    }
-    return buffer;
-}
-async function findFileArchiveEnd(path) {
-    let handle;
-    try {
-        handle = await openFile(path, "r");
-    }
-    catch {
-        return null;
-    }
-    try {
-        const { size } = await handle.stat();
-        const tailLength = Math.min(size, MAX_TAIL_SCAN);
-        if (tailLength < EOCDR_SIZE)
-            return null;
-        const tailStart = size - tailLength;
-        const tail = await readExactly(handle, tailLength, tailStart);
-        if (!tail)
-            return null;
-        return findArchiveEnd(tail, tailStart, size);
-    }
-    finally {
-        await handle.close();
-    }
-}
-/**
- * Basically sometimes EPUB 2s have some garbage at the end of the file after
- * the End of Central Directory Record, which leads to
- * `yauzl` throwing an "End of Central Directory Record not found" error
- *
- * This is an attempt to, when that error happens, try to read the file from the end and find the End of Central Directory Record, then clean up the garbage at the end of the file.
- */
-class TruncatedFileReader extends Reader {
-    path;
-    handle = null;
-    constructor(path) {
-        super();
-        this.path = path;
-    }
-    async _open() {
-        this.handle = await openFile(this.path, "r");
-        return {};
-    }
-    async _close() {
-        const handle = this.handle;
-        this.handle = null;
-        if (handle)
-            await handle.close();
-        return {};
-    }
-    async _read(start, length) {
-        if (!this.handle)
-            throw new Error(`reader for ${this.path} is not open`);
-        const buffer = await readExactly(this.handle, length, start);
-        if (!buffer) {
-            throw new Error(`unexpected end of file reading ${this.path}`);
-        }
-        return buffer;
-    }
-    _createReadStream(start, length) {
-        return createReadStream(this.path, { start, end: start + length - 1 });
-    }
-}
-async function openBufferZip(data) {
-    try {
-        return await fromBuffer(data);
-    }
-    catch (error) {
-        const tailStart = Math.max(0, data.length - MAX_TAIL_SCAN);
-        const end = findArchiveEnd(data.subarray(tailStart), tailStart, data.length);
-        if (end === null)
-            throw error;
-        try {
-            return await fromBuffer(data.subarray(0, end));
-        }
-        catch {
-            throw error;
-        }
-    }
-}
-async function openFileZip(path) {
-    try {
-        return await open(path);
-    }
-    catch (error) {
-        const end = await findFileArchiveEnd(path);
-        if (end === null)
-            throw error;
-        const reader = new TruncatedFileReader(path);
-        try {
-            return await fromReader(reader, end);
-        }
-        catch {
-            await reader._close().catch(() => undefined);
-            throw error;
-        }
-    }
-}
-export async function openZip(source) {
-    return typeof source === "string"
-        ? openFileZip(source)
-        : openBufferZip(toBuffer(source));
-}