@epubook/core 0.0.2

package/dist/shared/core.c365bf12.mjs

@@ -0,0 +1,461 @@
+import { XMLBuilder } from 'fast-xml-parser';
+import * as path from 'pathe';
+import { promises, existsSync, mkdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { createDefu } from 'defu';
+import { strToU8 } from 'fflate';
+
+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 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 promises.readFile(src, "utf-8");
+    return new Html(dst, content);
+  }
+  async bundle() {
+    return 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 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(src, dst) {
+    const content = await 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.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 = 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());
+  }
+  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.mjs');
+    return await bundle(this);
+  }
+  async writeFile(file) {
+    const buffer = await this.bundle();
+    const dir = path.dirname(file);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    await 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;
+      }
+    }
+  };
+}
+
+export { BundleError as B, Epub as E, Fragment as F, Html as H, Item as I, MIMETYPE as M, PackageDocument as P, Rollup as R, Style as S, XHTMLBuilder as X, ManifestItem as a, ManifestItemRef as b, Image as c, EsbuildOptions as d, h };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@epubook/core",
+  "version": "0.0.2",
+  "description": "",
+  "keywords": [
+    "ebook",
+    "epub",
+    "epub-generator",
+    "epubook"
+  ],
+  "homepage": "https://github.com/yjl9903/epubook#readme",
+  "bugs": {
+    "url": "https://github.com/yjl9903/epubook/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yjl9903/epubook.git"
+  },
+  "license": "MIT",
+  "author": "XLor",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "defu": "^6.1.2",
+    "fast-xml-parser": "^4.1.3",
+    "fflate": "^0.7.4",
+    "pathe": "^1.1.0"
+  },
+  "devDependencies": {
+    "rollup": "^3.17.3",
+    "vitest": "^0.29.2"
+  },
+  "engines": {
+    "node": ">=v16.19.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "format": "prettier --write src/**/*.ts test/**/*.ts",
+    "test": "vitest",
+    "test:ci": "vitest --run",
+    "typecheck": "tsc --noEmit"
+  }
+}