honkit 3.6.21

package/lib/cli/server.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const http_1 = __importDefault(require("http"));
+const send_1 = __importDefault(require("send"));
+const url_1 = __importDefault(require("url"));
+const promise_1 = __importDefault(require("../utils/promise"));
+class Server extends events_1.default.EventEmitter {
+    constructor() {
+        super();
+        this.running = null;
+        this.dir = null;
+        this.port = 0;
+        this.sockets = [];
+    }
+    /**
+     Return true if the server is running
+
+     @return {boolean}
+     */
+    isRunning() {
+        return !!this.running;
+    }
+    /**
+     Stop the server
+
+     @return {Promise}
+     */
+    stop() {
+        const that = this;
+        if (!this.isRunning())
+            return promise_1.default();
+        const d = promise_1.default.defer();
+        this.running.close((err) => {
+            that.running = null;
+            that.emit("state", false);
+            if (err)
+                d.reject(err);
+            else
+                d.resolve();
+        });
+        for (let i = 0; i < this.sockets.length; i++) {
+            this.sockets[i].destroy();
+        }
+        return d.promise;
+    }
+    /**
+     Start the server
+
+     @return {Promise}
+     */
+    start(dir, port) {
+        const that = this;
+        let pre = promise_1.default();
+        port = port || 8004;
+        if (that.isRunning())
+            pre = this.stop();
+        return pre.then(() => {
+            const d = promise_1.default.defer();
+            that.running = http_1.default.createServer((req, res) => {
+                // Render error
+                function error(err) {
+                    res.statusCode = err.status || 500;
+                    res.end(err.message);
+                }
+                // Redirect to directory's index.html
+                function redirect() {
+                    const resultURL = urlTransform(req.url, (parsed) => {
+                        parsed.pathname += "/";
+                        return parsed;
+                    });
+                    res.statusCode = 301;
+                    res.setHeader("Location", resultURL);
+                    res.end(`Redirecting to ${resultURL}`);
+                }
+                res.setHeader("X-Current-Location", req.url);
+                // Send file
+                send_1.default(req, url_1.default.parse(req.url).pathname, {
+                    root: dir,
+                })
+                    .on("error", error)
+                    .on("directory", redirect)
+                    .pipe(res);
+            });
+            that.running.on("connection", (socket) => {
+                that.sockets.push(socket);
+                socket.setTimeout(4000);
+                socket.on("close", () => {
+                    that.sockets.splice(that.sockets.indexOf(socket), 1);
+                });
+            });
+            that.running.listen(port, () => {
+                that.port = port;
+                that.dir = dir;
+                that.emit("state", true);
+                d.resolve();
+            });
+            return d.promise;
+        });
+    }
+}
+/**
+ urlTransform is a helper function that allows a function to transform
+ a url string in it's parsed form and returns the new url as a string
+
+ @param {string} uri
+ @param {Function} fn
+ @return {string}
+ */
+function urlTransform(uri, fn) {
+    return url_1.default.format(fn(url_1.default.parse(uri)));
+}
+exports.default = Server;

package/lib/cli/watch.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const parsers_1 = __importDefault(require("../parsers"));
+/**
+ Watch a folder and resolve promise once a file is modified
+
+ @param {string} dir
+ @param callback
+ @return {Promise}
+ */
+function watch(dir, callback) {
+    dir = path_1.default.resolve(dir);
+    const toWatch = ["book.json", "book.js", "_layouts/**"];
+    // Watch all parsable files
+    parsers_1.default.extensions.forEach((ext) => {
+        toWatch.push(`**/*${ext}`);
+    });
+    const watcher = chokidar_1.default.watch(toWatch, {
+        cwd: dir,
+        ignored: "_book/**",
+        ignoreInitial: true,
+    });
+    watcher.on("all", (e, filepath) => {
+        callback(null, path_1.default.resolve(dir, filepath));
+    });
+    watcher.on("error", (err) => {
+        callback(err);
+    });
+}
+exports.default = watch;

package/lib/constants/__tests__/configSchema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonschema_1 = __importDefault(require("jsonschema"));
+const configSchema_1 = __importDefault(require("../configSchema"));
+describe("configSchema", () => {
+    function validate(cfg) {
+        const v = new jsonschema_1.default.Validator();
+        return v.validate(cfg, configSchema_1.default, {
+            propertyName: "config",
+        });
+    }
+    describe("structure", () => {
+        test("should accept dot in filename", () => {
+            const result = validate({
+                structure: {
+                    readme: "book-intro.adoc",
+                },
+            });
+            expect(result.errors.length).toBe(0);
+        });
+        test("should accept uppercase in filename", () => {
+            const result = validate({
+                structure: {
+                    readme: "BOOK.adoc",
+                },
+            });
+            expect(result.errors.length).toBe(0);
+        });
+        test("should not accept filepath", () => {
+            const result = validate({
+                structure: {
+                    readme: "folder/myFile.md",
+                },
+            });
+            expect(result.errors.length).toBe(1);
+        });
+    });
+});

package/lib/constants/configDefault.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const configSchema_1 = __importDefault(require("./configSchema"));
+const immutable_1 = __importDefault(require("immutable"));
+const json_schema_defaults_1 = __importDefault(require("json-schema-defaults"));
+exports.default = immutable_1.default.fromJS(json_schema_defaults_1.default(configSchema_1.default));

package/lib/constants/configFiles.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ["book.js", "book.json"];

package/lib/constants/configSchema.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FILENAME_REGEX = "^[a-zA-Z-._d,s]+$";
+exports.default = {
+    $schema: "http://json-schema.org/schema#",
+    id: "https://gitbook.com/schemas/book.json",
+    title: "HonKit Configuration",
+    type: "object",
+    properties: {
+        root: {
+            type: "string",
+            title: "Path fro the root folder containing the book's content",
+        },
+        title: {
+            type: "string",
+            title: "Title of the book, default is extracted from README",
+        },
+        author: {
+            type: "string",
+            title: "Name of the author",
+        },
+        authorSort: {
+            type: "string",
+            title: "String to be used to sort the author(s)",
+        },
+        producer: {
+            type: "string",
+            title: "Name of the producer",
+        },
+        publisher: {
+            type: "string",
+            title: "Name of the publisher",
+        },
+        pubdate: {
+            type: "string",
+            title: "Publication date of the book",
+        },
+        series: {
+            type: "string",
+            title: "Series this book belongs to",
+        },
+        seriesIndex: {
+            type: "string",
+            title: "Index of the book in this series",
+        },
+        isbn: {
+            type: "string",
+            title: "ISBN for published book",
+        },
+        language: {
+            type: "string",
+            title: "Language of the book",
+        },
+        gitbook: {
+            type: "string",
+            default: "*",
+            title: "GitBook/HonKit version to match",
+        },
+        direction: {
+            type: "string",
+            enum: ["ltr", "rtl"],
+            title: "Direction of texts, default is detected in the pages",
+        },
+        theme: {
+            type: "string",
+            default: "default",
+            title: "Name of the theme plugin to use",
+        },
+        variables: {
+            type: "object",
+            title: "Templating context variables",
+        },
+        plugins: {
+            oneOf: [{ $ref: "#/definitions/pluginsArray" }, { $ref: "#/definitions/pluginsString" }],
+            default: [],
+        },
+        pluginsConfig: {
+            type: "object",
+            title: "Configuration for plugins",
+        },
+        structure: {
+            type: "object",
+            properties: {
+                langs: {
+                    default: "LANGS.md",
+                    type: "string",
+                    title: "File to use as languages index",
+                    pattern: FILENAME_REGEX,
+                },
+                readme: {
+                    default: "README.md",
+                    type: "string",
+                    title: "File to use as preface",
+                    pattern: FILENAME_REGEX,
+                },
+                glossary: {
+                    default: "GLOSSARY.md",
+                    type: "string",
+                    title: "File to use as glossary index",
+                    pattern: FILENAME_REGEX,
+                },
+                summary: {
+                    default: "SUMMARY.md",
+                    type: "string",
+                    title: "File to use as table of contents",
+                    pattern: FILENAME_REGEX,
+                },
+            },
+            additionalProperties: false,
+        },
+        pdf: {
+            type: "object",
+            title: "PDF specific configurations",
+            properties: {
+                pageNumbers: {
+                    type: "boolean",
+                    default: true,
+                    title: "Add page numbers to the bottom of every page",
+                },
+                fontSize: {
+                    type: "integer",
+                    minimum: 8,
+                    maximum: 30,
+                    default: 12,
+                    title: "Font size for the PDF output",
+                },
+                fontFamily: {
+                    type: "string",
+                    default: "Arial",
+                    title: "Font family for the PDF output",
+                },
+                paperSize: {
+                    type: "string",
+                    enum: [
+                        "a0",
+                        "a1",
+                        "a2",
+                        "a3",
+                        "a4",
+                        "a5",
+                        "a6",
+                        "b0",
+                        "b1",
+                        "b2",
+                        "b3",
+                        "b4",
+                        "b5",
+                        "b6",
+                        "legal",
+                        "letter",
+                    ],
+                    default: "a4",
+                    title: "Paper size for the PDF",
+                },
+                chapterMark: {
+                    type: "string",
+                    enum: ["pagebreak", "rule", "both", "none"],
+                    default: "pagebreak",
+                    title: "How to mark detected chapters",
+                },
+                pageBreaksBefore: {
+                    type: "string",
+                    default: "/",
+                    title: 'An XPath expression. Page breaks are inserted before the specified elements. To disable use the expression: "/"',
+                },
+                margin: {
+                    type: "object",
+                    properties: {
+                        right: {
+                            type: "integer",
+                            title: "Right Margin",
+                            minimum: 0,
+                            maximum: 100,
+                            default: 62,
+                        },
+                        left: {
+                            type: "integer",
+                            title: "Left Margin",
+                            minimum: 0,
+                            maximum: 100,
+                            default: 62,
+                        },
+                        top: {
+                            type: "integer",
+                            title: "Top Margin",
+                            minimum: 0,
+                            maximum: 100,
+                            default: 56,
+                        },
+                        bottom: {
+                            type: "integer",
+                            title: "Bottom Margin",
+                            minimum: 0,
+                            maximum: 100,
+                            default: 56,
+                        },
+                    },
+                },
+                embedFonts: {
+                    type: "boolean",
+                    default: false,
+                    title: "Embed all fonts into the PDF",
+                },
+            },
+        },
+    },
+    required: [],
+    definitions: {
+        pluginsArray: {
+            type: "array",
+            items: {
+                oneOf: [{ $ref: "#/definitions/pluginObject" }, { $ref: "#/definitions/pluginString" }],
+            },
+        },
+        pluginsString: {
+            type: "string",
+        },
+        pluginString: {
+            type: "string",
+        },
+        pluginObject: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                },
+                version: {
+                    type: "string",
+                },
+            },
+            additionalProperties: false,
+            required: ["name"],
+        },
+    },
+};

package/lib/constants/defaultBlocks.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const templateBlock_1 = __importDefault(require("../models/templateBlock"));
+exports.default = immutable_1.default.Map({
+    html: new templateBlock_1.default({
+        name: "html",
+        process: function (blk) {
+            return blk;
+        },
+    }),
+    code: new templateBlock_1.default({
+        name: "code",
+        process: function (blk) {
+            return {
+                html: false,
+                body: blk.body,
+            };
+        },
+    }),
+    markdown: new templateBlock_1.default({
+        name: "markdown",
+        process: function (blk) {
+            return this.book.renderInline("markdown", blk.body).then((out) => {
+                return { body: out };
+            });
+        },
+    }),
+    asciidoc: new templateBlock_1.default({
+        name: "asciidoc",
+        process: function (blk) {
+            return this.book.renderInline("asciidoc", blk.body).then((out) => {
+                return { body: out };
+            });
+        },
+    }),
+    markup: new templateBlock_1.default({
+        name: "markup",
+        process: function (blk) {
+            return this.book.renderInline(this.ctx.file.type, blk.body).then((out) => {
+                return { body: out };
+            });
+        },
+    }),
+});