@epubook/core 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 XLor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# @epubook/core
+
+The fundamental module of [epubook](https://github.com/yjl9903/epubook) for generating EPUB books.
+
+> 👷‍♂️ Still work in progress.
+
+## Installation
+
+```bash
+npm i @epubook/core
+```
+
+## Usage
+
+```ts
+import { Epub } from '@epubook/core'
+
+const book = new Epub({
+  title: 'Test Book',
+  date: new Date('2023-02-01T11:00:00.000Z'),
+  lastModified: new Date('2023-02-26T11:00:00.000Z'),
+  creator: 'XLor',
+  description: 'for test usage',
+  source: 'imagine'
+})
+
+// ...
+
+await book.writeFile('./test.epub')
+```
+
+### JSX
+
+You can use jsx to create XHTML node.
+
+```tsx
+// Your theme code ...
+
+import { XHTMLBuilder } from '@epubook/core'
+
+const builder = new XHTMLBuilder()
+
+builder
+  .body(<h1>Title</h1>)
+  .body(<p>This is a paragraph</p>)
+  .build()
+```
+
+Currently, it supports use [unbuild](https://github.com/unjs/unbuild) to transform JSX / TSX and bundle your library.
+
+```ts
+// build.config.ts
+
+import { defineBuildConfig } from 'unbuild';
+
+import { EsbuildOptions, Rollup } from '@epubook/core';
+
+export default defineBuildConfig({
+  entries: ['src/index'],
+  declaration: true,
+  clean: true,
+  rollup: {
+    emitCJS: true,
+    esbuild: EsbuildOptions
+  },
+  hooks: {
+    'rollup:options'(_options, config) {
+      const plugins = config.plugins;
+      if (Array.isArray(plugins)) {
+        plugins.push(Rollup());
+      }
+    }
+  }
+});
+```
+
+You can see [@epubook/theme-default](https://github.com/yjl9903/epubook/tree/main/packages/theme-default) for more details.
+
+## License
+
+MIT License © 2023 [XLor](https://github.com/yjl9903)

package/dist/chunks/index.cjs

@@ -0,0 +1,188 @@
+'use strict';
+
+const path = require('pathe');
+const fflate = require('fflate');
+const fastXmlParser = require('fast-xml-parser');
+const index = require('../shared/core.2c388ac3.cjs');
+require('node:fs');
+require('node:crypto');
+require('defu');
+
+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 fflate__namespace = /*#__PURE__*/_interopNamespaceDefault(fflate);
+
+function toISO8601String(date) {
+  function pad(n) {
+    if (n < 10) {
+      return "0" + n;
+    }
+    return n;
+  }
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate()) + "T" + pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + "Z";
+}
+
+async function bundle(epub) {
+  return new Promise(async (res, rej) => {
+    const opfs = epub.packages().map((opf) => [opf.filename(), fflate__namespace.strToU8(makePackageDocument(opf))]);
+    const items = {};
+    for (const opf of epub.packages()) {
+      const base = path__namespace.dirname(opf.filename());
+      for (const item of opf.items()) {
+        const name = path__namespace.join(base, item.filename());
+        if (name in items) {
+          continue;
+        }
+        items[name] = await item.bundle();
+      }
+    }
+    const abstractContainer = {
+      mimetype: fflate__namespace.strToU8(index.MIMETYPE),
+      "META-INF": {
+        "container.xml": fflate__namespace.strToU8(makeContainer(epub))
+      },
+      ...Object.fromEntries(opfs),
+      ...items
+    };
+    fflate__namespace.zip(
+      abstractContainer,
+      {
+        level: 0,
+        mtime: /* @__PURE__ */ new Date()
+      },
+      (err, data) => {
+        if (err) {
+          rej(err);
+        } else {
+          res(data);
+        }
+      }
+    );
+  });
+}
+function makeContainer(epub) {
+  const builder = new fastXmlParser.XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    suppressUnpairedNode: false,
+    unpairedTags: ["rootfile"]
+  });
+  const rootfile = epub.packages().map((p) => ({
+    "@_full-path": p.filename(),
+    "@_media-type": "application/oebps-package+xml",
+    "#text": ""
+  }));
+  return builder.build({
+    "?xml": { "#text": "", "@_version": "1.0", "@_encoding": "UTF-8" },
+    container: {
+      "@_version": "1.0",
+      "@_xmlns": "urn:oasis:names:tc:opendocument:xmlns:container",
+      rootfiles: [
+        {
+          rootfile
+        }
+      ]
+    }
+  });
+}
+function makePackageDocument(opf) {
+  if (opf.version() !== "3.0") {
+    throw new index.BundleError(`Unsupport EPUB spec ${opf.version()}`);
+  }
+  const builder = new fastXmlParser.XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    suppressUnpairedNode: false,
+    unpairedTags: ["item", "itemref"]
+  });
+  const optionalMetadata = {};
+  const optionalList = [
+    "contributor",
+    "coverage",
+    "format",
+    "publisher",
+    "relation",
+    "rights",
+    "source",
+    "subject",
+    "type"
+  ];
+  for (const key of optionalList) {
+    const m = opf.metadata();
+    if (!!m[key]) {
+      optionalMetadata["dc:" + key] = m[key];
+    }
+  }
+  const metadata = {
+    "@_xmlns:dc": "http://purl.org/dc/elements/1.1/",
+    "dc:identifier": {
+      "@_id": opf.uniqueIdentifier(),
+      "#text": opf.identifier()
+    },
+    "dc:title": opf.title(),
+    "dc:language": opf.language(),
+    "dc:creator": {
+      "@_id": opf.creator().uid,
+      "#text": opf.creator().name
+    },
+    "dc:date": toISO8601String(opf.metadata().date),
+    "dc:description": opf.metadata().description,
+    ...optionalMetadata,
+    meta: [
+      {
+        "@_property": "dcterms:modified",
+        "#text": toISO8601String(opf.metadata().lastModified)
+      },
+      {
+        "@_refines": "#" + opf.creator().uid,
+        "@_property": "file-as",
+        "#text": opf.creator()?.fileAs ?? ""
+      }
+    ]
+  };
+  function makeManifestItem(item) {
+    return {
+      "@_fallback": item.fallback(),
+      "@_href": item.href(),
+      "@_id": item.id(),
+      "@_media-overlay": item.mediaOverlay(),
+      "@_media-type": item.mediaType(),
+      "@_properties": item.properties()
+    };
+  }
+  function makeManifestItemRef(item) {
+    return {
+      "@_idref": item.idref()
+    };
+  }
+  return builder.build({
+    "?xml": { "#text": "", "@_version": "1.0", "@_encoding": "UTF-8" },
+    package: {
+      "@_xmlns": "http://www.idpf.org/2007/opf",
+      "@_xmlns:epub": "http://www.idpf.org/2007/ops",
+      "@_unique-identifier": opf.uniqueIdentifier(),
+      "@_version": opf.version(),
+      metadata,
+      manifest: {
+        item: opf.manifest().map((i) => makeManifestItem(i))
+      },
+      spine: {
+        itemref: opf.spine().map((ir) => makeManifestItemRef(ir))
+      }
+    }
+  });
+}
+
+exports.bundle = bundle;
+exports.makeContainer = makeContainer;
+exports.makePackageDocument = makePackageDocument;

package/dist/chunks/index.mjs

@@ -0,0 +1,170 @@
+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 'node:crypto';
+import 'defu';
+
+function toISO8601String(date) {
+  function pad(n) {
+    if (n < 10) {
+      return "0" + n;
+    }
+    return n;
+  }
+  return date.getUTCFullYear() + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate()) + "T" + pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + "Z";
+}
+
+async function bundle(epub) {
+  return new Promise(async (res, rej) => {
+    const opfs = epub.packages().map((opf) => [opf.filename(), fflate.strToU8(makePackageDocument(opf))]);
+    const items = {};
+    for (const opf of epub.packages()) {
+      const base = path.dirname(opf.filename());
+      for (const item of opf.items()) {
+        const name = path.join(base, item.filename());
+        if (name in items) {
+          continue;
+        }
+        items[name] = await item.bundle();
+      }
+    }
+    const abstractContainer = {
+      mimetype: fflate.strToU8(MIMETYPE),
+      "META-INF": {
+        "container.xml": fflate.strToU8(makeContainer(epub))
+      },
+      ...Object.fromEntries(opfs),
+      ...items
+    };
+    fflate.zip(
+      abstractContainer,
+      {
+        level: 0,
+        mtime: /* @__PURE__ */ new Date()
+      },
+      (err, data) => {
+        if (err) {
+          rej(err);
+        } else {
+          res(data);
+        }
+      }
+    );
+  });
+}
+function makeContainer(epub) {
+  const builder = new XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    suppressUnpairedNode: false,
+    unpairedTags: ["rootfile"]
+  });
+  const rootfile = epub.packages().map((p) => ({
+    "@_full-path": p.filename(),
+    "@_media-type": "application/oebps-package+xml",
+    "#text": ""
+  }));
+  return builder.build({
+    "?xml": { "#text": "", "@_version": "1.0", "@_encoding": "UTF-8" },
+    container: {
+      "@_version": "1.0",
+      "@_xmlns": "urn:oasis:names:tc:opendocument:xmlns:container",
+      rootfiles: [
+        {
+          rootfile
+        }
+      ]
+    }
+  });
+}
+function makePackageDocument(opf) {
+  if (opf.version() !== "3.0") {
+    throw new BundleError(`Unsupport EPUB spec ${opf.version()}`);
+  }
+  const builder = new XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    suppressUnpairedNode: false,
+    unpairedTags: ["item", "itemref"]
+  });
+  const optionalMetadata = {};
+  const optionalList = [
+    "contributor",
+    "coverage",
+    "format",
+    "publisher",
+    "relation",
+    "rights",
+    "source",
+    "subject",
+    "type"
+  ];
+  for (const key of optionalList) {
+    const m = opf.metadata();
+    if (!!m[key]) {
+      optionalMetadata["dc:" + key] = m[key];
+    }
+  }
+  const metadata = {
+    "@_xmlns:dc": "http://purl.org/dc/elements/1.1/",
+    "dc:identifier": {
+      "@_id": opf.uniqueIdentifier(),
+      "#text": opf.identifier()
+    },
+    "dc:title": opf.title(),
+    "dc:language": opf.language(),
+    "dc:creator": {
+      "@_id": opf.creator().uid,
+      "#text": opf.creator().name
+    },
+    "dc:date": toISO8601String(opf.metadata().date),
+    "dc:description": opf.metadata().description,
+    ...optionalMetadata,
+    meta: [
+      {
+        "@_property": "dcterms:modified",
+        "#text": toISO8601String(opf.metadata().lastModified)
+      },
+      {
+        "@_refines": "#" + opf.creator().uid,
+        "@_property": "file-as",
+        "#text": opf.creator()?.fileAs ?? ""
+      }
+    ]
+  };
+  function makeManifestItem(item) {
+    return {
+      "@_fallback": item.fallback(),
+      "@_href": item.href(),
+      "@_id": item.id(),
+      "@_media-overlay": item.mediaOverlay(),
+      "@_media-type": item.mediaType(),
+      "@_properties": item.properties()
+    };
+  }
+  function makeManifestItemRef(item) {
+    return {
+      "@_idref": item.idref()
+    };
+  }
+  return builder.build({
+    "?xml": { "#text": "", "@_version": "1.0", "@_encoding": "UTF-8" },
+    package: {
+      "@_xmlns": "http://www.idpf.org/2007/opf",
+      "@_xmlns:epub": "http://www.idpf.org/2007/ops",
+      "@_unique-identifier": opf.uniqueIdentifier(),
+      "@_version": opf.version(),
+      metadata,
+      manifest: {
+        item: opf.manifest().map((i) => makeManifestItem(i))
+      },
+      spine: {
+        itemref: opf.spine().map((ir) => makeManifestItemRef(ir))
+      }
+    }
+  });
+}
+
+export { bundle, makeContainer, makePackageDocument };

package/dist/index.cjs

@@ -0,0 +1,26 @@
+'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;

package/dist/index.d.ts

@@ -0,0 +1,212 @@
+import { Plugin } from 'rollup';
+import { RollupBuildOptions } from 'unbuild';
+
+declare const ImageGif = "image/gif";
+declare const ImageJpeg = "image/jpeg";
+declare const ImagePng = "image/png";
+declare const ImageSvg = "image/svg+xml";
+declare const ImageWebp = "image/webp";
+type ImageMediaType = typeof ImageGif | typeof ImageJpeg | typeof ImagePng | typeof ImageSvg | typeof ImageWebp;
+declare const TextCSS = "text/css";
+declare const XHTML = "application/xhtml+xml";
+type MediaType = ImageMediaType | typeof TextCSS | typeof XHTML;
+
+declare class ManifestItem {
+    private _href;
+    private _id;
+    private optional;
+    constructor(href: string, id: string);
+    update(info: typeof this$1.optional): this;
+    href(): string;
+    id(): string;
+    fallback(): string | undefined;
+    mediaOverlay(): string | undefined;
+    mediaType(): MediaType | undefined;
+    properties(): string | undefined;
+    ref(): ManifestItemRef;
+}
+declare class ManifestItemRef {
+    private _idref;
+    private optional;
+    constructor(idref: string);
+    update(info: typeof this$1.optional): this;
+    idref(): string;
+    id(): string | undefined;
+    linear(): string | undefined;
+    properties(): string | undefined;
+}
+declare abstract class Item {
+    private readonly file;
+    private readonly mediaType;
+    private _properties?;
+    constructor(file: string, mediaType: MediaType);
+    filename(): string;
+    update(info: Partial<{
+        properties: string;
+    }>): this;
+    id(): string;
+    manifest(): ManifestItem;
+    itemref(): ManifestItemRef;
+    abstract bundle(): Promise<Uint8Array>;
+}
+declare class Html extends Item {
+    private content;
+    constructor(file: string, content: string);
+    static read(src: string, dst: string): Promise<Html | undefined>;
+    bundle(): Promise<Uint8Array>;
+}
+declare class Style extends Item {
+    private content;
+    constructor(file: string, content: string);
+    static read(src: string, dst: string): Promise<Style | undefined>;
+    bundle(): Promise<Uint8Array>;
+}
+declare class Image extends Item {
+    private data;
+    constructor(file: string, type: ImageMediaType, data: Uint8Array);
+    static read(src: string, dst: string): Promise<Image | undefined>;
+    bundle(): Promise<Uint8Array>;
+    private static getExtMediaType;
+}
+
+interface Author {
+    name: string;
+    fileAs?: string;
+    role?: string;
+    uid?: string;
+}
+interface PackageDocumentMeta {
+    title: string;
+    language: string;
+    contributor: Author[];
+    coverage: string;
+    creator: Author;
+    date: Date;
+    description: string;
+    format: string;
+    publisher: string;
+    relation: string;
+    rights: string;
+    source: string;
+    subject: string;
+    type: string;
+    lastModified: Date;
+}
+declare class PackageDocument {
+    private readonly file;
+    private readonly SpecVersion;
+    private _uniqueIdentifier;
+    private _identifier;
+    private _metadata;
+    private _toc;
+    private _items;
+    private _spine;
+    constructor(file: string);
+    filename(): string;
+    version(): "3.0";
+    update(info: Partial<PackageDocumentMeta>): this;
+    title(): string;
+    language(): string;
+    creator(): Author;
+    metadata(): PackageDocumentMeta;
+    addItem(item: Item): this;
+    items(): Item[];
+    manifest(): ManifestItem[];
+    setSpine(items: Item[]): this;
+    spine(): ManifestItemRef[];
+    toc(nav: NavOption, title?: string): this;
+    uniqueIdentifier(): string;
+    identifier(): string;
+    setIdentifier(identifier: string, uniqueIdentifier?: string): void;
+}
+type NavOption = Array<{
+    text: string;
+    item: Html | Array<{
+        text: string;
+        item: Html;
+    }>;
+}>;
+
+declare class Epub {
+    /**
+     * 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
+     */
+    private opfs;
+    constructor(meta?: Partial<PackageDocumentMeta>);
+    packages(): PackageDocument[];
+    main(): PackageDocument;
+    addItem(...items: Item[]): this;
+    toc(nav: NavOption, title?: string): this;
+    spine(...items: Item[]): this;
+    bundle(): Promise<Uint8Array>;
+    writeFile(file: string): Promise<void>;
+}
+
+declare class BundleError extends Error {
+    constructor(msg: string);
+}
+
+interface Theme {
+    name: string;
+    pages: string[];
+    styles: string[];
+    images: string[];
+}
+
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends EpubIntrinsicElements {
+        }
+    }
+}
+interface XHTMLNode {
+    tag: string;
+    attrs?: Record<string, string>;
+    children?: Array<string | XHTMLNode>;
+}
+interface EpubIntrinsicElements {
+    nav: {};
+    ul: {};
+    ol: {};
+    li: {};
+    h1: {};
+    h2: {};
+    h3: {};
+    h4: {};
+    h5: {};
+    h6: {};
+    p: {};
+    pre: {};
+    span: {};
+    code: {};
+    a: {
+        href: string;
+    };
+}
+
+declare class XHTMLBuilder {
+    private info;
+    private _head;
+    private _body;
+    constructor();
+    language(value: string): this;
+    title(value: string): this;
+    style(href: string): this;
+    body(node: XHTMLNode): this;
+    build(): string;
+}
+declare const Fragment = "Fragment";
+declare function h(tag: string, attrs?: Record<string, string>, ...children: Array<string | XHTMLNode | Array<string | XHTMLNode>>): {
+    tag: string;
+    attrs: Record<string, string>;
+    children: (string | XHTMLNode)[];
+};
+
+declare const EsbuildOptions: Partial<RollupBuildOptions['esbuild']>;
+declare function Rollup(): Plugin;
+
+export { Author, BundleError, Epub, EpubIntrinsicElements, EsbuildOptions, Fragment, Html, Image, Item, ManifestItem, ManifestItemRef, NavOption, PackageDocument, PackageDocumentMeta, Rollup, Style, Theme, XHTMLBuilder, XHTMLNode, h };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+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';