epublib 0.0.0 → 0.1.1

package/dist/epub.js

@@ -0,0 +1,367 @@
+import AdmZip from "adm-zip";
+import { accessSync, constants } from "node:fs";
+import { basename, dirname, join, normalize, resolve } from "node:path/posix";
+import { satisfies, valid } from "semver";
+import { Temporal } from "temporal-polyfill";
+import z, {} from "zod";
+import { EpubContainerXML } from "./schemas/epub/containerXml.js";
+import { EpubBasicPackageOPF } from "./schemas/epub/packageOpf.js";
+import { Epub2PackageOPF, Epub2PackageOpfMetadataMeta, } from "./schemas/epub2/packageOpf.js";
+import { Epub3PackageOPF, Epub3PackageOpfMetadataMeta, } from "./schemas/epub3/packageOpf.js";
+import { BCP47LanguageTag, ISBN13 } from "./schemas/global.js";
+import { LOCRelator } from "./schemas/loc.js";
+import { sanitizeHTMLString } from "./utils/html.js";
+import { xmlParser } from "./utils/xml.js";
+export class EpubFile {
+    #filePath;
+    #zip;
+    #dev;
+    #containerXml;
+    #version;
+    #packageOpfPath;
+    #packageOpf;
+    get filePath() {
+        return this.#filePath;
+    }
+    get zip() {
+        return this.#zip;
+    }
+    get containerXml() {
+        return this.#containerXml;
+    }
+    get version() {
+        return this.#version;
+    }
+    get packageOpf() {
+        return this.#packageOpf;
+    }
+    #getContainerXml() {
+        const entry = this.#zip.getEntry("META-INF/container.xml");
+        if (entry === null) {
+            throw new Error(`Could not find "META-INF/container.xml" in epub "${this.#filePath}"`);
+        }
+        const rawData = xmlParser.parse(entry.getData());
+        const parsedData = EpubContainerXML.safeParse(rawData);
+        if (parsedData.success === false) {
+            if (this.#dev) {
+                console.error(z.prettifyError(parsedData.error));
+            }
+            throw new Error(`"META-INF/container.xml" in epub "${this.#filePath}" is malformed`);
+        }
+        return parsedData.data;
+    }
+    #getVersion() {
+        const entry = this.#zip.getEntry(this.#packageOpfPath);
+        if (entry === null) {
+            throw new Error(`Could not find "${this.#packageOpfPath}" in epub "${this.#filePath}"`);
+        }
+        const rawTextData = entry.getData().toString();
+        const rawData = xmlParser.parse(rawTextData.startsWith("<package ")
+            ? "<?xml version='1.0' encoding='utf-8'?> \n" + rawTextData
+            : rawTextData);
+        const parsedData = EpubBasicPackageOPF.safeParse(rawData);
+        if (parsedData.success === false) {
+            if (this.#dev) {
+                console.error(z.prettifyError(parsedData.error));
+            }
+            throw new Error(`"${this.#packageOpfPath}" in epub "${this.#filePath}" is malformed`);
+        }
+        return satisfies(valid(parsedData.data.package["@_version"] + ".0") ?? "0.0.0", "^3")
+            ? "3"
+            : "2";
+    }
+    #getPackageOpf() {
+        const entry = this.#zip.getEntry(this.#packageOpfPath);
+        if (entry === null) {
+            throw new Error(`Could not find "${this.#packageOpfPath}" in epub "${this.#filePath}"`);
+        }
+        const rawTextData = entry.getData().toString();
+        const rawData = xmlParser.parse(rawTextData.startsWith("<package ")
+            ? "<?xml version='1.0' encoding='utf-8'?> \n" + rawTextData
+            : rawTextData);
+        let parsedData;
+        if (this.#version === "3") {
+            parsedData = Epub3PackageOPF.safeParse(rawData);
+        }
+        else {
+            parsedData = Epub2PackageOPF.safeParse(rawData);
+        }
+        if (parsedData.success === false) {
+            if (this.#dev) {
+                console.error(z.prettifyError(parsedData.error));
+            }
+            throw new Error(`"${this.#packageOpfPath}" (EPUB v${this.#version}) in epub "${this.#filePath}" is malformed`);
+        }
+        return parsedData.data;
+    }
+    constructor(filePath, dev = false) {
+        this.#dev = dev;
+        const fp = normalize(resolve(filePath));
+        accessSync(fp, constants.R_OK | constants.W_OK);
+        this.#filePath = fp;
+        this.#zip = new AdmZip(fp);
+        this.#containerXml = this.#getContainerXml();
+        this.#packageOpfPath =
+            this.#containerXml.container.rootfiles.rootfile["@_full-path"];
+        this.#version = this.#getVersion();
+        this.#packageOpf = this.#getPackageOpf();
+    }
+    getCoverImage() {
+        function epub2get(t) {
+            const p = t.#packageOpf;
+            const metaCover = [
+                ...(p.package.metadata?.meta ?? []),
+                ...(p.package.metadata?.["opf:meta"] ?? []),
+            ].find((e) => e["@_name"] === "cover");
+            if (!metaCover || !metaCover?.["@_content"]) {
+                return undefined;
+            }
+            const manifestItem = p.package.manifest.item.find((e) => e["@_id"] === metaCover["@_content"]);
+            if (!manifestItem) {
+                return undefined;
+            }
+            const coverImagePath = join(dirname(t.#packageOpfPath), manifestItem["@_href"]);
+            const entry = t.#zip.getEntry(coverImagePath);
+            if (entry === null) {
+                throw new Error(`Could not find "${coverImagePath}" in epub "${t.#filePath}"`);
+            }
+            return new File([Buffer.from(entry.getData())], basename(coverImagePath), {
+                type: manifestItem["@_media-type"],
+            });
+        }
+        if (this.#version === "3") {
+            const coverImageItem = this.#packageOpf.package.manifest.item.find((e) => (e["@_properties"] ?? []).includes("cover-image"));
+            if (typeof coverImageItem === "undefined") {
+                return epub2get(this);
+            }
+            const coverImagePath = join(dirname(this.#packageOpfPath), coverImageItem["@_href"]);
+            const entry = this.#zip.getEntry(coverImagePath);
+            if (entry === null) {
+                throw new Error(`Could not find "${coverImagePath}" in epub "${this.#filePath}"`);
+            }
+            return new File([Buffer.from(entry.getData())], basename(coverImagePath), {
+                type: coverImageItem["@_media-type"],
+            });
+        }
+        else {
+            return epub2get(this);
+        }
+    }
+    getTitle() {
+        const t = this.#packageOpf.package.metadata["dc:title"]?.[0];
+        if (!t) {
+            throw new Error(`"${this.#packageOpfPath}" in epub (v${this.#version}) "${this.#filePath}" is missing at least one "dc:title" element`);
+        }
+        const out = {
+            title: t["#text"].trim(),
+            fileAs: undefined,
+        };
+        if (this.#version === "3") {
+            if (typeof t["@_id"] === "string") {
+                const metaFileAs = [
+                    ...(this.#packageOpf.package
+                        .metadata?.meta ?? []),
+                    ...(this.#packageOpf.package
+                        .metadata?.["opf:meta"] ?? []),
+                ].filter((e) => Epub3PackageOpfMetadataMeta.safeParse(e)?.success).find((e) => typeof e["@_refines"] === "string" &&
+                    e["@_refines"] === `#${t["@_id"]}` &&
+                    e["@_property"] === "file-as");
+                if (metaFileAs) {
+                    out.fileAs = metaFileAs["#text"].trim();
+                }
+            }
+        }
+        else {
+            const metaCalibreTitleSort = [
+                ...(this.#packageOpf.package.metadata
+                    ?.meta ?? []),
+                ...(this.#packageOpf.package
+                    .metadata?.["opf:meta"] ?? []),
+            ].filter((e) => Epub2PackageOpfMetadataMeta.safeParse(e)?.success).find((e) => e["@_name"] === "calibre:title_sort" &&
+                typeof e["@_content"] === "string");
+            if (metaCalibreTitleSort &&
+                typeof metaCalibreTitleSort["@_content"] === "string") {
+                out.fileAs = metaCalibreTitleSort["@_content"].trim();
+            }
+        }
+        if (typeof out.fileAs === "string" && out.fileAs === out.title) {
+            out.fileAs = undefined;
+        }
+        return out;
+    }
+    getISBN13() {
+        const isbnUrn = this.#packageOpf.package.metadata["dc:identifier"].find((e) => /^urn:isbn:\d{10,13}$/.test(e["#text"]))?.["#text"];
+        if (isbnUrn) {
+            return ISBN13.safeParse(isbnUrn.replace("urn:isbn:", ""))?.data;
+        }
+        const isbnOpfScheme = this.#packageOpf.package.metadata["dc:identifier"].find((e) => (e?.["@_opf:scheme"] ?? "").toLocaleUpperCase() === "ISBN")?.["#text"];
+        if (isbnOpfScheme) {
+            return ISBN13.safeParse(isbnOpfScheme)?.data;
+        }
+        const meta3 = [
+            ...(this.#packageOpf.package.metadata?.["meta"] ?? []),
+            ...(this.#packageOpf.package.metadata?.["opf:meta"] ?? []),
+        ].filter((e) => Epub3PackageOpfMetadataMeta.safeParse(e).success);
+        function identifier3isIsbn(id) {
+            const onixType = meta3.find((e) => e["@_property"] === "identifier-type" &&
+                e?.["@_refines"] === `#${id}` &&
+                e?.["@_scheme"] === "onix:codelist5");
+            if (onixType) {
+                const onixTypeValue = Number(onixType["#text"]);
+                return (!isNaN(onixTypeValue) &&
+                    (onixTypeValue === 2 || onixTypeValue === 15));
+            }
+            return false;
+        }
+        const isbnOnly = this.#packageOpf.package.metadata["dc:identifier"].filter((e) => /^\d{10,13}$/.test(e["#text"]));
+        for (const i of isbnOnly) {
+            if (typeof i["@_id"] === "string" && identifier3isIsbn(i["@_id"])) {
+                return ISBN13.parse(i["#text"].replace(/^urn:isbn:/, "").trim());
+            }
+            const a = ISBN13.safeParse(i["#text"].replace(/^urn:isbn:/, "").trim());
+            if (a.success) {
+                return a.data;
+            }
+        }
+        return undefined;
+    }
+    getLanguage() {
+        const dublinCoreLanguage = this.#packageOpf.package.metadata["dc:language"]?.[0];
+        if (!dublinCoreLanguage) {
+            throw new Error(`"${this.#packageOpfPath}" in epub (v${this.#version}) "${this.#filePath}" is missing at least one "dc:language" element`);
+        }
+        return BCP47LanguageTag.parse(dublinCoreLanguage["#text"]);
+    }
+    getCollection() {
+        function calibreGet(t) {
+            const m = [
+                ...(t.#packageOpf.package.metadata?.meta ?? []),
+                ...(t.#packageOpf.package.metadata?.["opf:meta"] ?? []),
+            ].filter((e) => Epub2PackageOpfMetadataMeta.safeParse(e)?.success);
+            const metaCalibreSeries = m.find((e) => e["@_name"] === "calibre:series" &&
+                typeof e["@_content"] === "string");
+            const metaCalibreSeriesIndex = m.find((e) => e["@_name"] === "calibre:series_index" &&
+                typeof e["@_content"] === "string");
+            if (metaCalibreSeries &&
+                typeof metaCalibreSeries["@_content"] === "string" &&
+                metaCalibreSeriesIndex &&
+                !isNaN(Number(metaCalibreSeriesIndex?.["@_content"] ?? "NaN"))) {
+                return {
+                    name: metaCalibreSeries["@_content"].trim(),
+                    position: Number(metaCalibreSeriesIndex["@_content"]),
+                };
+            }
+            return undefined;
+        }
+        if (this.#version === "3") {
+            const m = [
+                ...(this.#packageOpf.package.metadata?.meta ?? []),
+                ...(this.#packageOpf.package.metadata?.["opf:meta"] ?? []),
+            ].filter((e) => Epub3PackageOpfMetadataMeta.safeParse(e)?.success);
+            const collectionName = m.find((e) => e["@_property"] === "belongs-to-collection" &&
+                typeof e["@_id"] === "string");
+            if (collectionName) {
+                const collectionType = m.find((e) => e["@_refines"] === `#${collectionName["@_id"]}` &&
+                    e["@_property"] === "collection-type");
+                if ((collectionType && collectionType["#text"] === "series") ||
+                    typeof collectionType === "undefined") {
+                    const collectionPosition = m.find((e) => e["@_refines"] === `#${collectionName["@_id"]}` &&
+                        e["@_property"] === "group-position");
+                    if (collectionPosition &&
+                        !isNaN(Number(collectionPosition["#text"]))) {
+                        return {
+                            name: collectionName["#text"].trim(),
+                            position: Number(collectionPosition["#text"]),
+                        };
+                    }
+                }
+            }
+        }
+        return calibreGet(this);
+    }
+    getDate(config = { stripTime: true }) {
+        const dublinCodeDate = this.#packageOpf.package.metadata?.["dc:date"];
+        if (!dublinCodeDate) {
+            return undefined;
+        }
+        if (dublinCodeDate["#text"].length > 10) {
+            const i = Temporal.Instant.from(dublinCodeDate["#text"]);
+            if (config?.stripTime === false) {
+                const ts = i.toZonedDateTimeISO("utc").toString({
+                    offset: "never",
+                    fractionalSecondDigits: 0,
+                    timeZoneName: "never",
+                }) + "Z";
+                return ts.endsWith("T00:00:00Z")
+                    ? ts.replace("T00:00:00Z", "")
+                    : ts;
+            }
+            else {
+                return i
+                    .toZonedDateTimeISO("utc")
+                    .toString({
+                    offset: "never",
+                    fractionalSecondDigits: 0,
+                    timeZoneName: "never",
+                })
+                    .substring(0, 10);
+            }
+        }
+        return z.iso.date().safeParse(dublinCodeDate["#text"])?.data;
+    }
+    getPublisher() {
+        const m = this.#packageOpf.package.metadata?.["dc:publisher"]?.["#text"];
+        return m ? m.trim() : undefined;
+    }
+    getDescription(sanitizeHTML = true) {
+        const d = this.#packageOpf.package.metadata?.["dc:description"]?.["#text"];
+        if (d && sanitizeHTML === true) {
+            return sanitizeHTMLString(d);
+        }
+        return d;
+    }
+    getContributors(excludedRoles = ["bkp"]) {
+        const contributorElements = [
+            ...(this.#packageOpf.package.metadata?.["dc:creator"] ?? []),
+            ...(this.#packageOpf.package.metadata?.["dc:contributor"] ?? []),
+        ];
+        let out = [];
+        const meta3 = [
+            ...(this.#packageOpf.package.metadata?.["meta"] ?? []),
+            ...(this.#packageOpf.package.metadata?.["opf:meta"] ?? []),
+        ].filter((e) => Epub3PackageOpfMetadataMeta.safeParse(e).success);
+        for (const c of contributorElements) {
+            const m = {
+                name: c["#text"].trim(),
+                fileAs: undefined,
+                role: undefined,
+            };
+            if (typeof c["@_opf:file-as"] === "string") {
+                m.fileAs = c["@_opf:file-as"].trim();
+            }
+            if (typeof c["@_opf:role"] === "string") {
+                m.role = c["@_opf:role"];
+            }
+            if (typeof m.fileAs === "undefined" &&
+                typeof c["@_id"] === "string") {
+                const fileAsMeta = meta3.find((e) => e?.["@_refines"] === `#${c["@_id"]}` &&
+                    e["@_property"] === "file-as");
+                if (fileAsMeta) {
+                    m.fileAs = fileAsMeta["#text"].trim();
+                }
+            }
+            if (typeof m.role === "undefined" &&
+                typeof c["@_id"] === "string") {
+                const roleMeta = meta3.find((e) => e?.["@_refines"] === `#${c["@_id"]}` &&
+                    e["@_property"] === "role" &&
+                    e?.["@_scheme"] === "marc:relators");
+                if (roleMeta) {
+                    m.role = LOCRelator.safeParse(roleMeta["#text"].trim()).data;
+                }
+            }
+            out.push(m);
+        }
+        out = out.filter((e) => typeof e.role === "undefined" || !excludedRoles.includes(e.role));
+        return out.length > 0 ? out : undefined;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./epub.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+/* v8 ignore start */
+export * from "./epub.js";
+/* v8 ignore stop */

package/dist/schemas/epub/containerXml.d.ts

@@ -0,0 +1,18 @@
+import z from "zod";
+export declare const EpubContainerXML: z.ZodObject<{
+    "?xml": z.ZodObject<{
+        "@_version": z.ZodLiteral<"1.0">;
+    }, z.z.core.$strip>;
+    container: z.ZodObject<{
+        rootfiles: z.ZodObject<{
+            rootfile: z.ZodObject<{
+                "@_full-path": z.ZodString;
+                "@_media-type": z.ZodLiteral<"application/oebps-package+xml">;
+            }, z.z.core.$strip>;
+        }, z.z.core.$strip>;
+        "@_version": z.ZodLiteral<"1.0">;
+        "@_xmlns": z.ZodLiteral<"urn:oasis:names:tc:opendocument:xmlns:container">;
+    }, z.z.core.$strip>;
+}, z.z.core.$strip>;
+export type EpubContainerXML = z.infer<typeof EpubContainerXML>;
+//# sourceMappingURL=containerXml.d.ts.map

package/dist/schemas/epub/containerXml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerXml.d.ts","sourceRoot":"","sources":["../../../src/schemas/epub/containerXml.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;mBAY3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/epub/containerXml.js

@@ -0,0 +1,14 @@
+import z from "zod";
+export const EpubContainerXML = z.object({
+    "?xml": z.object({ "@_version": z.literal("1.0") }),
+    container: z.object({
+        rootfiles: z.object({
+            rootfile: z.object({
+                "@_full-path": z.string(),
+                "@_media-type": z.literal("application/oebps-package+xml"),
+            }),
+        }),
+        "@_version": z.literal("1.0"),
+        "@_xmlns": z.literal("urn:oasis:names:tc:opendocument:xmlns:container"),
+    }),
+});