@epubook/core 0.0.2

package/dist/shared/core.2c388ac3.cjs

@@ -0,0 +1,490 @@
+'use strict';
+
+const fastXmlParser = require('fast-xml-parser');
+const path = require('pathe');
+const node_fs = require('node:fs');
+const node_crypto = require('node:crypto');
+const defu$1 = require('defu');
+const fflate = require('fflate');
+
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+const MIMETYPE = "application/epub+zip";
+const ImageJpeg = "image/jpeg";
+const ImagePng = "image/png";
+const ImageWebp = "image/webp";
+const TextCSS = "text/css";
+const XHTML = "application/xhtml+xml";
+
+const builder = new fastXmlParser.XMLBuilder({
+  format: true,
+  ignoreAttributes: false,
+  suppressUnpairedNode: false,
+  unpairedTags: ["link"]
+});
+class XHTMLBuilder {
+  constructor() {
+    this.info = {
+      language: "en",
+      title: ""
+    };
+    this._head = [];
+    this._body = [];
+  }
+  language(value) {
+    this.info.language = value;
+    return this;
+  }
+  title(value) {
+    this.info.title = value;
+    return this;
+  }
+  style(href) {
+    this._head.push({
+      tag: "link",
+      attrs: {
+        href,
+        rel: "stylesheet",
+        type: TextCSS
+      },
+      children: [""]
+    });
+    return this;
+  }
+  body(node) {
+    this._body.push(node);
+    return this;
+  }
+  build() {
+    function build(node) {
+      const attrs = Object.fromEntries(
+        Object.entries(node.attrs ?? {}).map(([key, value]) => ["@_" + key, value])
+      );
+      const obj = {
+        ...attrs
+      };
+      if (Array.isArray(node.children)) {
+        const text = node.children.filter((c) => typeof c === "string");
+        const nodes = node.children.filter((c) => typeof c !== "string");
+        if (text.length > 0) {
+          obj["#text"] = text[0];
+        }
+        Object.assign(obj, list(nodes));
+      }
+      return obj;
+    }
+    function list(nodes) {
+      const obj = {};
+      for (const c of nodes) {
+        if (c.tag in obj) {
+          obj[c.tag].push(build(c));
+        } else {
+          obj[c.tag] = [build(c)];
+        }
+      }
+      return obj;
+    }
+    return builder.build({
+      html: {
+        "@_xmlns": "http://www.w3.org/1999/xhtml",
+        "@_xmlns:epub": "http://www.idpf.org/2007/ops",
+        "@_lang": this.info.language,
+        "@_xml:lang": this.info.language,
+        head: {
+          title: this.info.title,
+          ...list(this._head)
+        },
+        body: list(this._body)
+      }
+    });
+  }
+}
+const Fragment = "Fragment";
+function h(tag, attrs = {}, ...children) {
+  const sub = children.flatMap(
+    (c) => typeof c === "object" && !Array.isArray(c) && c.tag === Fragment ? c.children ?? [] : c
+  ).filter((c) => c !== void 0 && c !== null && c !== false);
+  const o = {
+    tag,
+    attrs: attrs ?? {},
+    children: sub
+  };
+  return o;
+}
+
+function buildTocNav(nav) {
+  const builder = new XHTMLBuilder();
+  const root = {
+    tag: "nav",
+    attrs: {
+      "epub:type": "toc"
+    },
+    children: []
+  };
+  if (nav.title && nav.heading) {
+    root.children.push(h("h" + nav.heading, {}, nav.title));
+  }
+  root.children.push(/* @__PURE__ */ h("ol", null, list(nav.list)));
+  return builder.title(nav.title ?? "Toc").body(root);
+  function list(items) {
+    return items.map((i) => /* @__PURE__ */ h("li", null, i.href ? /* @__PURE__ */ h("a", { href: i.href }, i.text) : /* @__PURE__ */ h("span", null, i.text), "list" in i && i.list && /* @__PURE__ */ h("ol", null, list(i.list))));
+  }
+}
+
+class ManifestItem {
+  constructor(href, id) {
+    this.optional = {};
+    this._href = href;
+    this._id = id;
+  }
+  update(info) {
+    for (const [key, value] of Object.entries(info)) {
+      if (!!value) {
+        this.optional[key] = value;
+      }
+    }
+    return this;
+  }
+  href() {
+    return this._href;
+  }
+  id() {
+    return this._id;
+  }
+  fallback() {
+    return this.optional.fallback;
+  }
+  mediaOverlay() {
+    return this.optional.mediaOverlay;
+  }
+  mediaType() {
+    return this.optional.mediaType;
+  }
+  properties() {
+    return this.optional.properties;
+  }
+  ref() {
+    return new ManifestItemRef(this._id);
+  }
+}
+class ManifestItemRef {
+  constructor(idref) {
+    this.optional = {};
+    this._idref = idref;
+  }
+  update(info) {
+    for (const [key, value] of Object.entries(info)) {
+      if (!!value) {
+        this.optional[key] = value;
+      }
+    }
+    return this;
+  }
+  idref() {
+    return this._idref;
+  }
+  id() {
+    return this.optional.id;
+  }
+  linear() {
+    return this.optional.linear;
+  }
+  properties() {
+    return this.optional.properties;
+  }
+}
+class Item {
+  constructor(file, mediaType) {
+    this.file = file;
+    this.mediaType = mediaType;
+  }
+  filename() {
+    return this.file;
+  }
+  update(info) {
+    if (info.properties) {
+      this._properties = info.properties;
+    }
+    return this;
+  }
+  id() {
+    return this.file.replace(/\/|\\/g, "_").replace(/\.[\w]+$/, "");
+  }
+  manifest() {
+    return new ManifestItem(this.file, this.id()).update({
+      mediaType: this.mediaType,
+      properties: this._properties
+    });
+  }
+  itemref() {
+    return this.manifest().ref();
+  }
+}
+class Html extends Item {
+  constructor(file, content) {
+    super(file, XHTML);
+    this.content = content;
+  }
+  static async read(src, dst) {
+    if (!src.endsWith(".xhtml")) {
+      return void 0;
+    }
+    const content = await node_fs.promises.readFile(src, "utf-8");
+    return new Html(dst, content);
+  }
+  async bundle() {
+    return fflate.strToU8(this.content);
+  }
+}
+class Style extends Item {
+  constructor(file, content) {
+    super(file, TextCSS);
+    this.content = content;
+  }
+  static async read(src, dst) {
+    if (!src.endsWith(".css")) {
+      return void 0;
+    }
+    const content = await node_fs.promises.readFile(src, "utf-8");
+    return new Style(dst, content);
+  }
+  async bundle() {
+    return fflate.strToU8(this.content);
+  }
+}
+class Image extends Item {
+  constructor(file, type, data) {
+    super(file, type);
+    this.data = data;
+  }
+  static async read(src, dst) {
+    const content = await node_fs.promises.readFile(src);
+    const media = this.getExtMediaType(src);
+    if (media) {
+      return new Image(dst, media, content);
+    } else {
+      return void 0;
+    }
+  }
+  async bundle() {
+    return this.data;
+  }
+  static getExtMediaType(file) {
+    const ext = path__namespace.extname(file);
+    if (ext === "jpg" || ext === "jpeg") {
+      return ImageJpeg;
+    } else if (ext === "png") {
+      return ImagePng;
+    } else if (ext === "webp") {
+      return ImageWebp;
+    } else {
+      return void 0;
+    }
+  }
+}
+
+const defu = defu$1.createDefu((obj, key, value) => {
+  if (obj[key] instanceof Date && value instanceof Date) {
+    obj[key] = value;
+    return true;
+  }
+});
+class PackageDocument {
+  constructor(file) {
+    this.SpecVersion = "3.0";
+    this._uniqueIdentifier = "uuid";
+    this._identifier = node_crypto.randomUUID();
+    this._metadata = {
+      title: "",
+      language: "zh-CN",
+      contributor: [],
+      coverage: "",
+      creator: {
+        name: "unknown",
+        uid: "creator"
+      },
+      date: /* @__PURE__ */ new Date(),
+      description: "",
+      format: "",
+      publisher: "",
+      relation: "",
+      rights: "",
+      source: "",
+      subject: "",
+      type: "",
+      lastModified: /* @__PURE__ */ new Date()
+    };
+    this._items = [];
+    this._spine = [];
+    this.file = file;
+  }
+  filename() {
+    return this.file;
+  }
+  version() {
+    return this.SpecVersion;
+  }
+  // --- metadata ---
+  update(info) {
+    this._metadata = defu(info, this._metadata);
+    return this;
+  }
+  title() {
+    return this._metadata.title;
+  }
+  language() {
+    return this._metadata.language;
+  }
+  creator() {
+    return this._metadata.creator;
+  }
+  metadata() {
+    return this._metadata;
+  }
+  // --- manifest ---
+  addItem(item) {
+    this._items.push(item);
+    return this;
+  }
+  items() {
+    const l = [...this._items];
+    if (this._toc) {
+      l.push(this._toc);
+    }
+    return l;
+  }
+  manifest() {
+    return this.items().map((i) => i.manifest());
+  }
+  setSpine(items) {
+    this._spine.splice(0, this._spine.length, ...items.map((i) => i.itemref()));
+    return this;
+  }
+  spine() {
+    return this._spine;
+  }
+  // --- navigation ---
+  toc(nav, title) {
+    const content = buildTocNav({
+      heading: 2,
+      title,
+      list: nav.map(
+        (i) => Array.isArray(i.item) ? { text: i.text, list: i.item.map((i2) => ({ href: i2.item.filename(), text: i2.text })) } : { href: i.item.filename(), text: i.text }
+      )
+    }).language(this._metadata.language).build();
+    this._toc = new Html("nav.xhtml", content).update({ properties: "nav" });
+    return this;
+  }
+  // --- identifier ---
+  uniqueIdentifier() {
+    return this._uniqueIdentifier;
+  }
+  identifier() {
+    return this._identifier;
+  }
+  setIdentifier(identifier, uniqueIdentifier = "uuid") {
+    this._identifier = identifier;
+    this._uniqueIdentifier = uniqueIdentifier;
+  }
+}
+
+class Epub {
+  constructor(meta = {}) {
+    /**
+     * See: https://www.w3.org/TR/epub-33/#sec-package-doc
+     *
+     * Now, it only supports single opf (OEBPS/content.opf)
+     *
+     * @returns list of package documents
+     */
+    this.opfs = [new PackageDocument("OEBPS/content.opf")];
+    this.opfs[0].update(meta);
+  }
+  packages() {
+    return this.opfs;
+  }
+  main() {
+    return this.opfs[0];
+  }
+  addItem(...items) {
+    for (const item of items) {
+      this.opfs[0].addItem(item);
+    }
+    return this;
+  }
+  toc(nav, title) {
+    this.opfs[0].toc(nav, title);
+    return this;
+  }
+  spine(...items) {
+    this.opfs[0].setSpine(items);
+    return this;
+  }
+  async bundle() {
+    const { bundle } = await import('../chunks/index.cjs');
+    return await bundle(this);
+  }
+  async writeFile(file) {
+    const buffer = await this.bundle();
+    const dir = path__namespace.dirname(file);
+    if (!node_fs.existsSync(dir)) {
+      node_fs.mkdirSync(dir, { recursive: true });
+    }
+    await node_fs.promises.writeFile(file, buffer);
+  }
+}
+
+class BundleError extends Error {
+  constructor(msg) {
+    super(msg);
+  }
+}
+
+const EsbuildOptions = {
+  jsxFactory: "h",
+  jsxFragment: "fragment",
+  loaders: {
+    ".js": "js",
+    ".ts": "ts",
+    ".jsx": "jsx",
+    ".tsx": "tsx"
+  }
+};
+function Rollup() {
+  return {
+    name: "epubook:inject-tsx",
+    transform(code, id) {
+      if (id.endsWith(".tsx")) {
+        return `import { h, fragment } from '@epubook/core';
+` + code;
+      }
+    }
+  };
+}
+
+exports.BundleError = BundleError;
+exports.Epub = Epub;
+exports.EsbuildOptions = EsbuildOptions;
+exports.Fragment = Fragment;
+exports.Html = Html;
+exports.Image = Image;
+exports.Item = Item;
+exports.MIMETYPE = MIMETYPE;
+exports.ManifestItem = ManifestItem;
+exports.ManifestItemRef = ManifestItemRef;
+exports.PackageDocument = PackageDocument;
+exports.Rollup = Rollup;
+exports.Style = Style;
+exports.XHTMLBuilder = XHTMLBuilder;
+exports.h = h;