@epubook/core 0.0.2 → 0.0.4

package/README.md

@@ -13,7 +13,7 @@ npm i @epubook/core
 ## Usage
 
 ```ts
-import { Epub } from '@epubook/core'
+import { Epub, HTML } from '@epubook/core'
 
 const book = new Epub({
   title: 'Test Book',
@@ -24,7 +24,9 @@ const book = new Epub({
   source: 'imagine'
 })
 
-// ...
+const page = new HTML('start.xhtml', '...')
+
+book.item(page).spine(page).toc([{ title: 'Start', page }])
 
 await book.writeFile('./test.epub')
 ```
@@ -53,24 +55,16 @@ Currently, it supports use [unbuild](https://github.com/unjs/unbuild) to transfo
 
 import { defineBuildConfig } from 'unbuild';
 
-import { EsbuildOptions, Rollup } from '@epubook/core';
+import { UnbuildPreset } from '@epubook/core';
 
 export default defineBuildConfig({
   entries: ['src/index'],
   declaration: true,
   clean: true,
   rollup: {
-    emitCJS: true,
-    esbuild: EsbuildOptions
+    emitCJS: true
   },
-  hooks: {
-    'rollup:options'(_options, config) {
-      const plugins = config.plugins;
-      if (Array.isArray(plugins)) {
-        plugins.push(Rollup());
-      }
-    }
-  }
+  preset: UnbuildPreset()
 });
 ```
 

package/dist/chunks/index.cjs

@@ -3,10 +3,11 @@
 const path = require('pathe');
 const fflate = require('fflate');
 const fastXmlParser = require('fast-xml-parser');
-const index = require('../shared/core.2c388ac3.cjs');
-require('node:fs');
+const index = require('../index.cjs');
+require('node:path');
 require('node:crypto');
 require('defu');
+require('node:fs');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null);
@@ -146,7 +147,7 @@ function makePackageDocument(opf) {
       {
         "@_refines": "#" + opf.creator().uid,
         "@_property": "file-as",
-        "#text": opf.creator()?.fileAs ?? ""
+        "#text": opf.creator()?.fileAs ?? opf.creator().name
       }
     ]
   };

package/dist/chunks/index.mjs

@@ -1,10 +1,11 @@
 import * as path from 'pathe';
 import * as fflate from 'fflate';
 import { XMLBuilder } from 'fast-xml-parser';
-import { M as MIMETYPE, B as BundleError } from '../shared/core.c365bf12.mjs';
-import 'node:fs';
+import { MIMETYPE, BundleError } from '../index.mjs';
+import 'node:path';
 import 'node:crypto';
 import 'defu';
+import 'node:fs';
 
 function toISO8601String(date) {
   function pad(n) {
@@ -130,7 +131,7 @@ function makePackageDocument(opf) {
       {
         "@_refines": "#" + opf.creator().uid,
         "@_property": "file-as",
-        "#text": opf.creator()?.fileAs ?? ""
+        "#text": opf.creator()?.fileAs ?? opf.creator().name
       }
     ]
   };

package/dist/index.cjs

@@ -1,26 +1,590 @@
 'use strict';
 
-const index = require('./shared/core.2c388ac3.cjs');
-require('fast-xml-parser');
-require('pathe');
-require('node:fs');
-require('node:crypto');
-require('defu');
-require('fflate');
-
-
-
-exports.BundleError = index.BundleError;
-exports.Epub = index.Epub;
-exports.EsbuildOptions = index.EsbuildOptions;
-exports.Fragment = index.Fragment;
-exports.Html = index.Html;
-exports.Image = index.Image;
-exports.Item = index.Item;
-exports.ManifestItem = index.ManifestItem;
-exports.ManifestItemRef = index.ManifestItemRef;
-exports.PackageDocument = index.PackageDocument;
-exports.Rollup = index.Rollup;
-exports.Style = index.Style;
-exports.XHTMLBuilder = index.XHTMLBuilder;
-exports.h = index.h;
+const path = require('node:path');
+const node_crypto = require('node:crypto');
+const defu$1 = require('defu');
+const path$1 = require('pathe');
+const fflate = require('fflate');
+const fastXmlParser = require('fast-xml-parser');
+const node_fs = require('node:fs');
+
+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 path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
+
+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__namespace.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__namespace$1.relative(path__namespace$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 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(file, src) {
+    const content = await node_fs.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 node_fs.promises.readFile(src, "utf-8");
+    return new HTML(dst, content);
+  }
+  async bundle() {
+    return fflate.strToU8(this.content);
+  }
+}
+
+const builder = new fastXmlParser.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 fflate.strToU8(this._content);
+  }
+}
+class XHTMLBuilder {
+  constructor(filename) {
+    this._meta = {
+      language: "en",
+      title: ""
+    };
+    this._head = [];
+    this._body = [];
+    this._filename = filename;
+    this._meta.title = path__namespace$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 = 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());
+  }
+  // --- 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.cjs');
+    return await bundle(this);
+  }
+  async writeFile(file) {
+    const buffer = await this.bundle();
+    const dir = path__namespace$1.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 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;
+      }
+    }
+  };
+}
+
+exports.BundleError = BundleError;
+exports.Epub = Epub;
+exports.Fragment = Fragment;
+exports.HTML = HTML;
+exports.Image = Image;
+exports.ImageGif = ImageGif;
+exports.ImageJpeg = ImageJpeg;
+exports.ImagePng = ImagePng;
+exports.ImageSvg = ImageSvg;
+exports.ImageWebp = ImageWebp;
+exports.Item = Item;
+exports.MIMETYPE = MIMETYPE;
+exports.ManifestItem = ManifestItem;
+exports.ManifestItemRef = ManifestItemRef;
+exports.PackageDocument = PackageDocument;
+exports.Rollup = Rollup;
+exports.Style = Style;
+exports.TextCSS = TextCSS;
+exports.TextXHTML = TextXHTML;
+exports.Toc = Toc;
+exports.UnbuildPreset = UnbuildPreset;
+exports.XHTML = XHTML;
+exports.XHTMLBuilder = XHTMLBuilder;
+exports.getImageMediaType = getImageMediaType;
+exports.h = h;