@epubook/core 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,7 +1,550 @@
-export { B as BundleError, E as Epub, d as EsbuildOptions, F as Fragment, H as Html, c as Image, I as Item, a as ManifestItem, b as ManifestItemRef, P as PackageDocument, R as Rollup, S as Style, X as XHTMLBuilder, h } from './shared/core.c365bf12.mjs';
-import 'fast-xml-parser';
-import 'pathe';
-import 'node:fs';
-import 'node:crypto';
-import 'defu';
-import 'fflate';
+import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createDefu } from 'defu';
+import * as path$1 from 'pathe';
+import { strToU8 } from 'fflate';
+import { XMLBuilder } from 'fast-xml-parser';
+import { promises, existsSync, mkdirSync } from 'node:fs';
+
+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;
+}
+
+const MIMETYPE = "application/epub+zip";
+const ImageGif = "image/gif";
+const ImageJpeg = "image/jpeg";
+const ImagePng = "image/png";
+const ImageSvg = "image/svg+xml";
+const ImageWebp = "image/webp";
+const TextCSS = "text/css";
+const TextXHTML = "application/xhtml+xml";
+function getImageMediaType(file) {
+  const ext = path.extname(file);
+  switch (ext) {
+    case ".gif":
+      return ImageGif;
+    case ".jpg":
+    case ".jpeg":
+      return ImageJpeg;
+    case ".png":
+      return ImagePng;
+    case ".svg":
+      return ImageSvg;
+    case ".webp":
+      return ImageWebp;
+    default:
+      return void 0;
+  }
+}
+
+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;
+  }
+  relative(from) {
+    return path$1.relative(path$1.dirname(from), 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 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 promises.readFile(src, "utf-8");
+    return new Style(dst, content);
+  }
+  async bundle() {
+    return strToU8(this.content);
+  }
+}
+class Image extends Item {
+  constructor(file, type, data) {
+    super(file, type);
+    this.data = data;
+  }
+  static async read(file, src) {
+    const content = await promises.readFile(src);
+    const media = getImageMediaType(src);
+    if (media) {
+      return new Image(file, media, content);
+    } else {
+      return void 0;
+    }
+  }
+  async bundle() {
+    return this.data;
+  }
+}
+class HTML extends Item {
+  constructor(file, content) {
+    super(file, TextXHTML);
+    this.content = content;
+  }
+  static async read(src, dst) {
+    if (!src.endsWith(".xhtml")) {
+      return void 0;
+    }
+    const content = await promises.readFile(src, "utf-8");
+    return new HTML(dst, content);
+  }
+  async bundle() {
+    return strToU8(this.content);
+  }
+}
+
+const builder = new XMLBuilder({
+  format: true,
+  ignoreAttributes: false,
+  suppressUnpairedNode: false,
+  unpairedTags: ["link"]
+});
+class XHTML extends Item {
+  constructor(file, meta, content) {
+    super(file, TextXHTML);
+    this._meta = meta;
+    this._content = content;
+  }
+  meta() {
+    return this._meta;
+  }
+  title() {
+    return this._meta.title;
+  }
+  language() {
+    return this._meta.language;
+  }
+  content() {
+    return this._content;
+  }
+  async bundle() {
+    return strToU8(this._content);
+  }
+}
+class XHTMLBuilder {
+  constructor(filename) {
+    this._meta = {
+      language: "en",
+      title: ""
+    };
+    this._head = [];
+    this._body = [];
+    this._filename = filename;
+    this._meta.title = path$1.basename(filename);
+  }
+  language(value) {
+    this._meta.language = value;
+    return this;
+  }
+  title(value) {
+    this._meta.title = value;
+    return this;
+  }
+  style(...list) {
+    for (const href of list) {
+      if (typeof href === "string") {
+        this._head.push({
+          tag: "link",
+          attrs: {
+            href,
+            rel: "stylesheet",
+            type: TextCSS
+          },
+          children: [""]
+        });
+      } else {
+        this._head.push({
+          tag: "link",
+          attrs: {
+            href: href.relative(this._filename),
+            rel: "stylesheet",
+            type: TextCSS
+          },
+          children: [""]
+        });
+      }
+    }
+    return this;
+  }
+  head(...node) {
+    this._head.push(...node);
+    return this;
+  }
+  body(...node) {
+    this._body.push(...node);
+    return this;
+  }
+  build() {
+    const content = builder.build({
+      html: {
+        "@_xmlns": "http://www.w3.org/1999/xhtml",
+        "@_xmlns:epub": "http://www.idpf.org/2007/ops",
+        "@_lang": this._meta.language,
+        "@_xml:lang": this._meta.language,
+        head: {
+          title: this._meta.title,
+          ...list(this._head)
+        },
+        body: list(this._body)
+      }
+    });
+    return new XHTML(this._filename, this._meta, content);
+    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(list2) {
+      const obj = {};
+      const nodes = list2.flatMap((n) => n.tag === Fragment ? n.children ?? [] : [n]);
+      for (const c of nodes) {
+        if (typeof c === "string") {
+          if (obj["#text"]) {
+            obj["#text"] += c;
+          } else {
+            obj["#text"] = c;
+          }
+        } else if (c.tag in obj) {
+          obj[c.tag].push(build(c));
+        } else {
+          obj[c.tag] = [build(c)];
+        }
+      }
+      return obj;
+    }
+  }
+}
+
+class Toc extends XHTML {
+  constructor(file, meta, content) {
+    super(file, meta, content);
+    this.update({ properties: "nav" });
+  }
+  static from(xhtml) {
+    return new Toc(xhtml.filename(), xhtml.meta(), xhtml.content());
+  }
+  static generate(file, nav, { title = "Nav", heading = 1, titleAttrs = {}, builder } = {}) {
+    if (!builder) {
+      builder = new XHTMLBuilder(file);
+    }
+    const root = {
+      tag: "nav",
+      attrs: {
+        "epub:type": "toc"
+      },
+      children: []
+    };
+    root.children.push(h("h" + heading, titleAttrs, title));
+    root.children.push(/* @__PURE__ */ h("ol", null, list(nav)));
+    return builder.body(root);
+    function list(items) {
+      return items.map(
+        (i) => "page" in i ? /* @__PURE__ */ h("li", { ...i.attrs }, /* @__PURE__ */ h("a", { href: i.page.filename() }, i.title)) : "list" in i ? /* @__PURE__ */ h("li", { ...i.attrs }, /* @__PURE__ */ h("span", null, i.title), /* @__PURE__ */ h("ol", null, list(i.list))) : false
+      );
+    }
+  }
+}
+
+const defu = 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 = 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());
+  }
+  // --- navigation ---
+  spine() {
+    return this._spine;
+  }
+  setSpine(items) {
+    this._spine.splice(0, this._spine.length, ...items.map((i) => i.itemref()));
+    return this;
+  }
+  toc() {
+    return this._toc;
+  }
+  setToc(nav, option = {}) {
+    const toc = Toc.generate("nav.xhtml", nav, option);
+    if (!option.builder) {
+      toc.title(option.title ?? "Nav").language(this._metadata.language);
+    }
+    this._toc = Toc.from(toc.build());
+    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];
+  }
+  item(...items) {
+    for (const item of items) {
+      this.opfs[0].addItem(item);
+    }
+    return this;
+  }
+  toc(nav, option = {}) {
+    this.opfs[0].setToc(nav, option);
+    return this;
+  }
+  spine(...items) {
+    this.opfs[0].setSpine(items);
+    return this;
+  }
+  async bundle() {
+    const { bundle } = await import('./chunks/index.mjs');
+    return await bundle(this);
+  }
+  async writeFile(file) {
+    const buffer = await this.bundle();
+    const dir = path$1.dirname(file);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    await promises.writeFile(file, buffer);
+  }
+}
+
+class BundleError extends Error {
+  constructor(msg) {
+    super(msg);
+  }
+}
+
+const UnbuildPreset = ({
+  inject = true
+} = {}) => ({
+  rollup: {
+    esbuild: {
+      jsxFactory: inject ? "__epubook_core.h" : "h",
+      jsxFragment: inject ? "__epubook_core.Fragment" : "Fragment",
+      loaders: {
+        ".js": "js",
+        ".ts": "ts",
+        ".jsx": "jsx",
+        ".tsx": "tsx"
+      }
+    }
+  },
+  hooks: {
+    "rollup:options"(_options, config) {
+      const plugins = config.plugins;
+      if (inject && Array.isArray(plugins)) {
+        plugins.push(Rollup());
+      }
+    }
+  }
+});
+function Rollup() {
+  return {
+    name: "epubook:inject-tsx",
+    transform(code, id) {
+      if (id.endsWith(".tsx")) {
+        return `import * as __epubook_core from '@epubook/core';
+` + code;
+      }
+    }
+  };
+}
+
+export { BundleError, Epub, Fragment, HTML, Image, ImageGif, ImageJpeg, ImagePng, ImageSvg, ImageWebp, Item, MIMETYPE, ManifestItem, ManifestItemRef, PackageDocument, Rollup, Style, TextCSS, TextXHTML, Toc, UnbuildPreset, XHTML, XHTMLBuilder, getImageMediaType, h };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epubook/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "",
   "keywords": [
     "ebook",
@@ -39,15 +39,15 @@
     "pathe": "^1.1.0"
   },
   "devDependencies": {
-    "rollup": "^3.17.3",
+    "rollup": "^3.18.0",
     "vitest": "^0.29.2"
   },
   "engines": {
-    "node": ">=v16.19.0"
+    "node": ">=v18.14.2"
   },
   "scripts": {
     "build": "unbuild",
-    "format": "prettier --write src/**/*.ts test/**/*.ts",
+    "format": "prettier --write src/**/*.{ts,tsx} test/**/*.{ts,tsx}",
     "test": "vitest",
     "test:ci": "vitest --run",
     "typecheck": "tsc --noEmit"