wp-epub-gen 0.1.0

package/dist/parseContent.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * parseContent
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cheerio = require("cheerio");
+const diacritics_1 = require("diacritics");
+const mime = require("mime");
+const path = require("path");
+const uslug = require("uslug");
+const uuid_1 = require("uuid");
+function parseContent(content, index, epubConfigs) {
+    let chapter = Object.assign({}, content);
+    if (!chapter.filename) {
+        let titleSlug = uslug((0, diacritics_1.remove)(chapter.title || 'no title'));
+        chapter.href = `${index}_${titleSlug}.xhtml`;
+        chapter.filePath = path.join(epubConfigs.dir, 'OEBPS', chapter.href);
+    }
+    else {
+        let is_xhtml = chapter.filename.endsWith('.xhtml');
+        chapter.href = is_xhtml ? chapter.filename : `${chapter.filename}.xhtml`;
+        if (is_xhtml) {
+            chapter.filePath = path.join(epubConfigs.dir, 'OEBPS', chapter.filename);
+        }
+        else {
+            chapter.filePath = path.join(epubConfigs.dir, 'OEBPS', `${chapter.filename}.xhtml`);
+        }
+    }
+    chapter.id = `item_${index}`;
+    chapter.dir = path.dirname(chapter.filePath);
+    chapter.excludeFromToc = chapter.excludeFromToc || false;
+    chapter.beforeToc = chapter.beforeToc || false;
+    // fix author array
+    if (chapter.author && typeof chapter.author === 'string') {
+        chapter.author = [chapter.author];
+    }
+    else if (!chapter.author || !Array.isArray(chapter.author)) {
+        chapter.author = [];
+    }
+    let allowedAttributes = [
+        'content',
+        'alt',
+        'id',
+        'title',
+        'src',
+        'href',
+        'about',
+        'accesskey',
+        'aria-activedescendant',
+        'aria-atomic',
+        'aria-autocomplete',
+        'aria-busy',
+        'aria-checked',
+        'aria-controls',
+        'aria-describedat',
+        'aria-describedby',
+        'aria-disabled',
+        'aria-dropeffect',
+        'aria-expanded',
+        'aria-flowto',
+        'aria-grabbed',
+        'aria-haspopup',
+        'aria-hidden',
+        'aria-invalid',
+        'aria-label',
+        'aria-labelledby',
+        'aria-level',
+        'aria-live',
+        'aria-multiline',
+        'aria-multiselectable',
+        'aria-orientation',
+        'aria-owns',
+        'aria-posinset',
+        'aria-pressed',
+        'aria-readonly',
+        'aria-relevant',
+        'aria-required',
+        'aria-selected',
+        'aria-setsize',
+        'aria-sort',
+        'aria-valuemax',
+        'aria-valuemin',
+        'aria-valuenow',
+        'aria-valuetext',
+        'class',
+        'content',
+        'contenteditable',
+        'contextmenu',
+        'datatype',
+        'dir',
+        'draggable',
+        'dropzone',
+        'hidden',
+        'hreflang',
+        'id',
+        'inlist',
+        'itemid',
+        'itemref',
+        'itemscope',
+        'itemtype',
+        'lang',
+        'media',
+        'ns1:type',
+        'ns2:alphabet',
+        'ns2:ph',
+        'onabort',
+        'onblur',
+        'oncanplay',
+        'oncanplaythrough',
+        'onchange',
+        'onclick',
+        'oncontextmenu',
+        'ondblclick',
+        'ondrag',
+        'ondragend',
+        'ondragenter',
+        'ondragleave',
+        'ondragover',
+        'ondragstart',
+        'ondrop',
+        'ondurationchange',
+        'onemptied',
+        'onended',
+        'onerror',
+        'onfocus',
+        'oninput',
+        'oninvalid',
+        'onkeydown',
+        'onkeypress',
+        'onkeyup',
+        'onload',
+        'onloadeddata',
+        'onloadedmetadata',
+        'onloadstart',
+        'onmousedown',
+        'onmousemove',
+        'onmouseout',
+        'onmouseover',
+        'onmouseup',
+        'onmousewheel',
+        'onpause',
+        'onplay',
+        'onplaying',
+        'onprogress',
+        'onratechange',
+        'onreadystatechange',
+        'onreset',
+        'onscroll',
+        'onseeked',
+        'onseeking',
+        'onselect',
+        'onshow',
+        'onstalled',
+        'onsubmit',
+        'onsuspend',
+        'ontimeupdate',
+        'onvolumechange',
+        'onwaiting',
+        'prefix',
+        'property',
+        'rel',
+        'resource',
+        'rev',
+        'role',
+        'spellcheck',
+        'style',
+        'tabindex',
+        'target',
+        'title',
+        'type',
+        'typeof',
+        'vocab',
+        'xml:base',
+        'xml:lang',
+        'xml:space',
+        'colspan',
+        'rowspan',
+        'epub:type',
+        'epub:prefix',
+    ];
+    let allowedXhtml11Tags = [
+        'div',
+        'p',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'ul',
+        'ol',
+        'li',
+        'dl',
+        'dt',
+        'dd',
+        'address',
+        'hr',
+        'pre',
+        'blockquote',
+        'center',
+        'ins',
+        'del',
+        'a',
+        'span',
+        'bdo',
+        'br',
+        'em',
+        'strong',
+        'dfn',
+        'code',
+        'samp',
+        'kbd',
+        'bar',
+        'cite',
+        'abbr',
+        'acronym',
+        'q',
+        'sub',
+        'sup',
+        'tt',
+        'i',
+        'b',
+        'big',
+        'small',
+        'u',
+        's',
+        'strike',
+        'basefont',
+        'font',
+        'object',
+        'param',
+        'img',
+        'table',
+        'caption',
+        'colgroup',
+        'col',
+        'thead',
+        'tfoot',
+        'tbody',
+        'tr',
+        'th',
+        'td',
+        'embed',
+        'applet',
+        'iframe',
+        'img',
+        'map',
+        'noscript',
+        'ns:svg',
+        'object',
+        'script',
+        'table',
+        'tt',
+        'var',
+    ];
+    let $ = cheerio.load(chapter.data, {
+        lowerCaseTags: true,
+        recognizeSelfClosing: true,
+    });
+    // only body innerHTML is allowed
+    let body = $('body');
+    if (body.length) {
+        let html = body.html();
+        if (html) {
+            $ = cheerio.load(html, {
+                lowerCaseTags: true,
+                recognizeSelfClosing: true,
+            });
+        }
+    }
+    $($('*').get().reverse()).each(function (elemIndex, elem) {
+        // @ts-ignore
+        let attrs = elem.attribs;
+        // @ts-ignore
+        let that = this;
+        let tags = ['img', 'br', 'hr'];
+        if (tags.includes(that.name)) {
+            if (that.name === 'img' && !$(that).attr('alt')) {
+                $(that).attr('alt', 'image-placeholder');
+            }
+        }
+        Object.entries(attrs).map(([k, v]) => {
+            if (allowedAttributes.includes(k)) {
+                if (k === 'type' && that.name !== 'script') {
+                    $(that).removeAttr(k);
+                }
+            }
+            else {
+                $(that).removeAttr(k);
+            }
+        });
+        if (epubConfigs.version === 2) {
+            if (!allowedXhtml11Tags.includes(that.name)) {
+                if (epubConfigs.verbose) {
+                    console.log('Warning (content[' + index + ']):', that.name, "tag isn't allowed on EPUB 2/XHTML 1.1 DTD.");
+                }
+                let child = $(that).html();
+                $(that).replaceWith($('<div>' + child + '</div>'));
+            }
+        }
+    });
+    $('img').each((index, elem) => {
+        let url = $(elem).attr('src') || '';
+        let image = epubConfigs.images.find((el) => el.url === url);
+        let id;
+        let extension;
+        if (image) {
+            id = image.id;
+            extension = image.extension;
+        }
+        else {
+            id = (0, uuid_1.v4)();
+            let mediaType = mime.getType(url.replace(/\?.*/, '')) || '';
+            extension = mime.getExtension(mediaType) || '';
+            let dir = chapter.dir || '';
+            let img = { id, url, dir, mediaType, extension };
+            epubConfigs.images.push(img);
+        }
+        $(elem).attr('src', `images/${id}.${extension}`);
+    });
+    chapter.data = $.xml();
+    if (Array.isArray(chapter.children)) {
+        chapter.children = chapter.children.map((content, idx) => parseContent(content, `${index}_${idx}`, epubConfigs));
+    }
+    return chapter;
+}
+exports.default = parseContent;
+//# sourceMappingURL=parseContent.js.map

package/dist/render.d.ts

@@ -0,0 +1,7 @@
+/**
+ * render
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+import { IEpubData } from './types';
+export declare function render(data: IEpubData): Promise<void>;

package/dist/render.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * render
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = void 0;
+const archiver = require("archiver");
+const fs = require("fs-extra");
+const path = require("path");
+const downloadImage_1 = require("./downloadImage");
+const generateTempFile_1 = require("./generateTempFile");
+const makeCover_1 = require("./makeCover");
+const utils_1 = require("./utils");
+function render(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { log } = data;
+        log('Generating Template Files...');
+        yield (0, generateTempFile_1.generateTempFile)(data);
+        log('Downloading Images...');
+        yield (0, downloadImage_1.downloadAllImages)(data);
+        log('Making Cover...');
+        yield (0, makeCover_1.default)(data);
+        log('Generating Epub Files...');
+        yield genEpub(data);
+        if (fs.existsSync(data.output)) {
+            log('Output: ' + data.output);
+            log('Done.');
+        }
+        else {
+            log('Output fail!');
+        }
+    });
+}
+exports.render = render;
+function genEpub(epubData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { log, dir, output } = epubData;
+        let archive = archiver('zip', { zlib: { level: 9 } });
+        let outputStream = fs.createWriteStream(epubData.output);
+        log('Zipping temp dir to ' + output);
+        return new Promise((resolve, reject) => {
+            archive.on('end', () => __awaiter(this, void 0, void 0, function* () {
+                log('Done zipping, clearing temp dir...');
+                // log(fs.statSync(epubData.output).size)
+                // setTimeout(() => log(fs.statSync(epubData.output).size), 1)
+                // setTimeout(() => log(fs.statSync(epubData.output).size), 100)
+                // setTimeout(() => log(fs.statSync(epubData.output).size), 1000)
+                let stable = yield (0, utils_1.fileIsStable)(epubData.output);
+                if (!stable) {
+                    log('Output epub file is not stable!');
+                }
+                try {
+                    fs.removeSync(dir);
+                    resolve();
+                }
+                catch (e) {
+                    log('[Error] ' + e.message);
+                    reject(e);
+                }
+            }));
+            archive.on('close', () => {
+                log('Zip close..');
+            });
+            archive.on('finish', () => {
+                log('Zip finish..');
+            });
+            archive.on('error', (err) => {
+                log('[Archive Error] ' + err.message);
+                reject(err);
+            });
+            archive.pipe(outputStream);
+            archive.append('application/epub+zip', { store: true, name: 'mimetype' });
+            archive.directory(path.join(dir, 'META-INF'), 'META-INF');
+            archive.directory(path.join(dir, 'OEBPS'), 'OEBPS');
+            archive.finalize();
+        });
+    });
+}
+//# sourceMappingURL=render.js.map

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * utils
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare const readFile: typeof fs.readFile.__promisify__;
+export declare const writeFile: typeof fs.writeFile.__promisify__;
+export declare const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36";
+export declare const wait: (ms: number) => Promise<unknown>;
+export declare function fileIsStable(filename: string, max_wait?: number): Promise<boolean>;
+export declare function simpleMinifier(xhtml: string): string;

package/dist/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * utils
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleMinifier = exports.fileIsStable = exports.wait = exports.USER_AGENT = exports.writeFile = exports.readFile = void 0;
+const fs = require("fs");
+const util_1 = require("util");
+exports.readFile = (0, util_1.promisify)(fs.readFile);
+exports.writeFile = (0, util_1.promisify)(fs.writeFile);
+exports.USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36';
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.wait = wait;
+function fileIsStable(filename, max_wait = 30000) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let start_time = new Date().getTime();
+        let last_size = fs.statSync(filename).size;
+        while (new Date().getTime() - start_time <= max_wait) {
+            yield (0, exports.wait)(1000);
+            let size = fs.statSync(filename).size;
+            if (size === last_size)
+                return true;
+            last_size = size;
+        }
+        return false;
+    });
+}
+exports.fileIsStable = fileIsStable;
+function simpleMinifier(xhtml) {
+    xhtml = xhtml
+        .replace(/\s+<\/a>/gi, '</a>')
+        .replace(/\n\s+</g, '\n<')
+        .replace(/\n+/g, '\n');
+    return xhtml;
+}
+exports.simpleMinifier = simpleMinifier;
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "wp-epub-gen",
+  "version": "0.1.0",
+  "description": "Epub generator.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "tsc": "tsc",
+    "test": "mocha -r espower-typescript/guess -r tsconfig-paths/register test/*.test.js",
+    "tt": "npm run build && node ./test/tt.js",
+    "build": "tsc",
+    "bt": "npm run build && npm run test",
+    "w": "tsc -w",
+    "p": "npm run build && npm run test && npm publish --access public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oldj/wp-epub-gen.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/oldj/wp-epub-gen/issues"
+  },
+  "homepage": "https://github.com/oldj/wp-epub-gen#readme",
+  "dependencies": {
+    "@types/diacritics": "^1.3.1",
+    "@types/uslug": "^1.0.1",
+    "@types/uuid": "^8.3.4",
+    "archiver": "^5.3.0",
+    "cheerio": "^0.22.0",
+    "diacritics": "^1.3.0",
+    "ejs": "^3.1.6",
+    "entities": "^3.0.1",
+    "fs-extra": "^10.0.1",
+    "mime": "^3.0.0",
+    "superagent": "^7.1.1",
+    "uslug": "^1.0.4",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/archiver": "^5.3.1",
+    "@types/cheerio": "^0.22.31",
+    "@types/ejs": "^3.1.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mime": "^2.0.3",
+    "@types/superagent": "^4.1.15",
+    "@typescript-eslint/eslint-plugin": "^5.16.0",
+    "@typescript-eslint/parser": "^5.16.0",
+    "chai": "^4.3.6",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "espower-typescript": "^10.0.0",
+    "mocha": "^9.2.2",
+    "prettier": "^2.6.1",
+    "terser-webpack-plugin": "^5.3.1",
+    "ts-loader": "^9.2.8",
+    "tsconfig-paths": "^3.14.1",
+    "typescript": "^4.6.3",
+    "webpack": "^5.70.0",
+    "webpack-cli": "^4.9.2",
+    "webpack-notifier": "^1.15.0"
+  }
+}

package/src/downloadImage.ts

@@ -0,0 +1,75 @@
+/**
+ * downloadImage
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+
+import * as fs from 'fs-extra'
+import * as path from 'path'
+import * as request from 'superagent'
+import { IEpubData, IEpubImage } from './types'
+import { USER_AGENT } from './utils'
+
+const downloadImage = async (epubData: IEpubData, options: IEpubImage): Promise<void> => {
+  let { url } = options
+  let { log } = epubData
+  let epub_dir = epubData.dir
+
+  if (!url) {
+    return
+  }
+
+  let image_dir = path.join(epub_dir, 'OEBPS', 'images')
+  fs.ensureDirSync(image_dir)
+
+  let filename = path.join(image_dir, options.id + '.' + options.extension)
+  if (url.startsWith('file://') || url.startsWith('/')) {
+    let auxPath = url.replace(/^file:\/\//i, '')
+    log(`[Copy 1] '${auxPath}' to '${filename}'`)
+    if (fs.existsSync(auxPath)) {
+      try {
+        fs.copySync(auxPath, filename)
+      } catch (e) {
+        log('[Copy 1 Error] ' + e.message)
+      }
+    } else {
+      log(`[Copy 1 Fail] '${url}' not exists!`)
+    }
+    return
+  }
+
+  let requestAction: any
+  if (url.startsWith('http')) {
+    requestAction = request.get(url).set({ 'User-Agent': USER_AGENT })
+    requestAction.pipe(fs.createWriteStream(filename))
+  } else {
+    log(`[Copy 2] '${url}' to '${filename}'`)
+    requestAction = fs.createReadStream(path.join(options.dir || '', url))
+    requestAction.pipe(fs.createWriteStream(filename))
+  }
+
+  return new Promise((resolve, reject) => {
+    requestAction.on('error', (err: any) => {
+      log('[Download Error] Error while downloading: ' + url)
+      log(err)
+      fs.unlinkSync(filename)
+      // reject(err)
+      resolve()
+    })
+
+    requestAction.on('end', () => {
+      log('[Download Success] ' + url)
+      resolve()
+    })
+  })
+}
+
+export const downloadAllImages = async (epubData: IEpubData) => {
+  let { images } = epubData
+  if (images.length === 0) return
+
+  fs.ensureDirSync(path.join(epubData.dir, 'OEBPS', 'images'))
+  for (let image of images) {
+    await downloadImage(epubData, image)
+  }
+}

package/src/errors.ts

@@ -0,0 +1,11 @@
+/**
+ * errors
+ * @author: oldj
+ * @homepage: https://oldj.net
+ */
+
+export const errors = {
+  no_output_path: 'No output path!',
+  no_title: 'Title is required.',
+  no_content: 'Content is required.',
+}