honkit 3.6.21

package/lib/models/hash.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashString = exports.hash = void 0;
+// v8 has an optimization for storing 31-bit signed numbers.
+// Values which have either 00 or 11 as the high order bits qualify.
+// This function drops the highest order bit in a signed number, maintaining
+// the sign bit.
+function smi(i32) {
+    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
+}
+const defaultValueOf = Object.prototype.valueOf;
+// If possible, use a WeakMap.
+const usingWeakMap = typeof WeakMap === "function";
+let weakMap;
+if (usingWeakMap) {
+    weakMap = new WeakMap();
+}
+let objHashUID = 0;
+let UID_HASH_KEY = "__immutablehash__";
+if (typeof Symbol === "function") {
+    // @ts-expect-error ts-migrate(2322) FIXME: Type 'symbol' is not assignable to type 'string'.
+    UID_HASH_KEY = Symbol(UID_HASH_KEY);
+}
+const STRING_HASH_CACHE_MIN_STRLEN = 16;
+const STRING_HASH_CACHE_MAX_SIZE = 255;
+let STRING_HASH_CACHE_SIZE = 0;
+let stringHashCache = {};
+const hash = function hash(o) {
+    switch (typeof o) {
+        case "boolean":
+            // The hash values for built-in constants are a 1 value for each 5-byte
+            // shift region expect for the first, which encodes the value. This
+            // reduces the odds of a hash collision for these common values.
+            return o ? 0x42108421 : 0x42108420;
+        case "number":
+            return hashNumber(o);
+        case "string":
+            return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);
+        case "object":
+        case "function":
+            if (o === null) {
+                return 0x42108422;
+            }
+            if (typeof o.hashCode === "function") {
+                // Drop any high bits from accidentally long hash codes.
+                return smi(o.hashCode(o));
+            }
+            if (o.valueOf !== defaultValueOf && typeof o.valueOf === "function") {
+                o = o.valueOf(o);
+            }
+            return hashJSObj(o);
+        case "undefined":
+            return 0x42108423;
+        default:
+            if (typeof o.toString === "function") {
+                return hashString(o.toString());
+            }
+            throw new Error(`Value type ${typeof o} cannot be hashed.`);
+    }
+};
+exports.hash = hash;
+// Compress arbitrarily large numbers into smi hashes.
+function hashNumber(n) {
+    if (n !== n || n === Infinity) {
+        return 0;
+    }
+    let hash = n | 0;
+    if (hash !== n) {
+        hash ^= n * 0xffffffff;
+    }
+    while (n > 0xffffffff) {
+        n /= 0xffffffff;
+        hash ^= n;
+    }
+    return smi(hash);
+}
+function cachedHashString(string) {
+    let hashed = stringHashCache[string];
+    if (hashed === undefined) {
+        hashed = hashString(string);
+        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
+            STRING_HASH_CACHE_SIZE = 0;
+            stringHashCache = {};
+        }
+        STRING_HASH_CACHE_SIZE++;
+        stringHashCache[string] = hashed;
+    }
+    return hashed;
+}
+// http://jsperf.com/hashing-strings
+function hashString(string) {
+    // This is the hash from JVM
+    // The hash code for a string is computed as
+    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
+    // where s[i] is the ith character of the string and n is the length of
+    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
+    // (exclusive) by dropping high bits.
+    let hashed = 0;
+    for (let ii = 0; ii < string.length; ii++) {
+        hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
+    }
+    return smi(hashed);
+}
+exports.hashString = hashString;
+function hashJSObj(obj) {
+    let hashed;
+    if (usingWeakMap) {
+        hashed = weakMap.get(obj);
+        if (hashed !== undefined) {
+            return hashed;
+        }
+    }
+    hashed = obj[UID_HASH_KEY];
+    if (hashed !== undefined) {
+        return hashed;
+    }
+    if (!canDefineProperty) {
+        hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
+        if (hashed !== undefined) {
+            return hashed;
+        }
+        hashed = getIENodeHash(obj);
+        if (hashed !== undefined) {
+            return hashed;
+        }
+    }
+    hashed = ++objHashUID;
+    if (objHashUID & 0x40000000) {
+        objHashUID = 0;
+    }
+    if (usingWeakMap) {
+        weakMap.set(obj, hashed);
+    }
+    else if (isExtensible !== undefined && isExtensible(obj) === false) {
+        throw new Error("Non-extensible objects are not allowed as keys.");
+    }
+    else if (canDefineProperty) {
+        Object.defineProperty(obj, UID_HASH_KEY, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: hashed,
+        });
+    }
+    else if (obj.propertyIsEnumerable !== undefined &&
+        obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
+        // Since we can't define a non-enumerable property on the object
+        // we'll hijack one of the less-used non-enumerable properties to
+        // save our hash on it. Since this is a function it will not show up in
+        // `JSON.stringify` which is what we want.
+        obj.propertyIsEnumerable = function () {
+            return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);
+        };
+        obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
+    }
+    else if (obj.nodeType !== undefined) {
+        // At this point we couldn't get the IE `uniqueID` to use as a hash
+        // and we couldn't use a non-enumerable property to exploit the
+        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
+        // itself.
+        obj[UID_HASH_KEY] = hashed;
+    }
+    else {
+        throw new Error("Unable to set a non-enumerable property on object.");
+    }
+    return hashed;
+}
+// Get references to ES5 object methods.
+const isExtensible = Object.isExtensible;
+// True if Object.defineProperty works as expected. IE8 fails this test.
+const canDefineProperty = (function () {
+    try {
+        Object.defineProperty({}, "@", {});
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+})();
+// IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
+// and avoid memory leaks from the IE cloneNode bug.
+function getIENodeHash(node) {
+    if (node && node.nodeType > 0) {
+        switch (node.nodeType) {
+            case 1: // Element
+                return node.uniqueID;
+            case 9: // Document
+                return node.documentElement && node.documentElement.uniqueID;
+        }
+    }
+}

package/lib/models/ignore.js

@@ -0,0 +1,40 @@
+"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 ignore_1 = __importDefault(require("ignore"));
+/*
+    Immutable version of node-ignore
+*/
+class Ignore extends immutable_1.default.Record({
+    ignore: ignore_1.default(),
+}, "Ignore") {
+    getIgnore() {
+        return this.get("ignore");
+    }
+    /**
+     Test if a file is ignored by these rules
+
+     @return {boolean}
+     * @param filename
+     */
+    isFileIgnored(filename) {
+        const ignore = this.getIgnore();
+        return ignore.filter([filename]).length == 0;
+    }
+    /**
+     Add rules
+     @param {string}
+     @return {Ignore}
+     */
+    add(rule) {
+        const ignore = this.getIgnore();
+        const newIgnore = ignore_1.default();
+        newIgnore.add(ignore);
+        newIgnore.add(rule);
+        return this.set("ignore", newIgnore);
+    }
+}
+exports.default = Ignore;

package/lib/models/language.js

@@ -0,0 +1,22 @@
+"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 immutable_1 = __importDefault(require("immutable"));
+class Language extends immutable_1.default.Record({
+    title: String(),
+    path: String(),
+}) {
+    getTitle() {
+        return this.get("title");
+    }
+    getPath() {
+        return this.get("path");
+    }
+    getID() {
+        return path_1.default.basename(this.getPath());
+    }
+}
+exports.default = Language;

package/lib/models/languages.js

@@ -0,0 +1,64 @@
+"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 file_1 = __importDefault(require("./file"));
+const language_1 = __importDefault(require("./language"));
+class Languages extends immutable_1.default.Record({
+    file: new file_1.default(),
+    list: immutable_1.default.OrderedMap(),
+}) {
+    getFile() {
+        return this.get("file");
+    }
+    getList() {
+        return this.get("list");
+    }
+    /**
+     Get default languages
+
+     @return {Language}
+     */
+    getDefaultLanguage() {
+        return this.getList().first();
+    }
+    /**
+     Get a language by its ID
+
+     @param {string} lang
+     @return {Language}
+     */
+    getLanguage(lang) {
+        return this.getList().get(lang);
+    }
+    /**
+     Return count of langs
+
+     @return {number}
+     */
+    getCount() {
+        return this.getList().size;
+    }
+    /**
+     Create a languages list from a JS object
+
+     @return {Language}
+     */
+    static createFromList(file, langs) {
+        let list = immutable_1.default.OrderedMap();
+        langs.forEach((lang) => {
+            lang = new language_1.default({
+                title: lang.title,
+                path: lang.ref,
+            });
+            list = list.set(lang.getID(), lang);
+        });
+        return new Languages({
+            file: file,
+            list: list,
+        });
+    }
+}
+exports.default = Languages;

package/lib/models/output.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const immutable_1 = __importDefault(require("immutable"));
+const parsePageFromString_1 = __importDefault(require("../parse/parsePageFromString"));
+const book_1 = __importDefault(require("./book"));
+const location_1 = __importDefault(require("../utils/location"));
+class Output extends immutable_1.default.Record({
+    book: new book_1.default(),
+    // Name of the generator being used
+    generator: String(),
+    // Map of plugins to use (String -> Plugin)
+    plugins: immutable_1.default.OrderedMap(),
+    // Map pages to generation (String -> Page)
+    pages: immutable_1.default.OrderedMap(),
+    // List assets (String)
+    assets: immutable_1.default.List(),
+    // Option for the generation
+    options: immutable_1.default.Map(),
+    // Internal state for the generation
+    state: immutable_1.default.Map(),
+    // incrementalChangeFileSet for incremental building
+    // If it is empty, should build all
+    incrementalChangeFileSet: immutable_1.default.Set(),
+}) {
+    getBook() {
+        return this.get("book");
+    }
+    getGenerator() {
+        return this.get("generator");
+    }
+    getPlugins() {
+        return this.get("plugins");
+    }
+    getPages() {
+        return this.get("pages");
+    }
+    getOptions() {
+        return this.get("options");
+    }
+    getAssets() {
+        return this.get("assets");
+    }
+    getState() {
+        return this.get("state");
+    }
+    /**
+     Return a page byt its file path
+
+     @param {string} filePath
+     @return {Page|undefined}
+     */
+    getPage(filePath) {
+        filePath = location_1.default.normalize(filePath);
+        const pages = this.getPages();
+        return pages.get(filePath);
+    }
+    reloadPage(contentRootDir, filePath) {
+        const relativePath = location_1.default.normalize(path_1.default.normalize(path_1.default.relative(contentRootDir, filePath)));
+        const pages = this.getPages();
+        const page = pages.get(relativePath);
+        if (!page) {
+            return this;
+        }
+        const newPage = parsePageFromString_1.default(page, fs_1.default.readFileSync(filePath, "utf-8"));
+        return this.merge({
+            pages: pages.set(relativePath, newPage),
+        });
+    }
+    /**
+     Get root folder for output
+
+     @return {string}
+     */
+    getRoot() {
+        return this.getOptions().get("root");
+    }
+    /**
+     Update state of output
+
+     @param {Map} newState
+     @return {Output}
+     */
+    setState(newState) {
+        return this.set("state", newState);
+    }
+    /**
+     Update options
+
+     @param {Map} newOptions
+     @return {Output}
+     */
+    setOptions(newOptions) {
+        return this.set("options", newOptions);
+    }
+    /**
+     Return logegr for this output (same as book)
+
+     @return {Logger}
+     */
+    getLogger() {
+        return this.getBook().getLogger();
+    }
+}
+exports.default = Output;

package/lib/models/page.js

@@ -0,0 +1,91 @@
+"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 js_yaml_1 = __importDefault(require("js-yaml"));
+const file_1 = __importDefault(require("./file"));
+const hash_1 = require("./hash");
+class Page extends immutable_1.default.Record({
+    file: new file_1.default(),
+    // Attributes extracted from the YAML header
+    attributes: immutable_1.default.Map(),
+    // Content of the page
+    content: String(),
+    // Direction of the text
+    dir: String("ltr"),
+}) {
+    getFile() {
+        return this.get("file");
+    }
+    getAttributes() {
+        return this.get("attributes");
+    }
+    getContent() {
+        return this.get("content");
+    }
+    getDir() {
+        return this.get("dir");
+    }
+    /**
+     * Return page as text
+     * @return {string}
+     */
+    toText() {
+        const attrs = this.getAttributes();
+        const content = this.getContent();
+        if (attrs.size === 0) {
+            return content;
+        }
+        const frontMatter = `---\n${js_yaml_1.default.safeDump(attrs.toJS(), { skipInvalid: true })}---\n\n`;
+        return frontMatter + (content || "");
+    }
+    /**
+     * Return path of the page
+     * @return {string}
+     */
+    getPath() {
+        return this.getFile().getPath();
+    }
+    /**
+     * Create a page for a file
+     * @param {File} file
+     * @return {Page}
+     */
+    static createForFile(file) {
+        return new Page({
+            file: file,
+        });
+    }
+    /**
+     * Load a page for a file
+     * @param {File} file
+     * @param {string} content
+     * @return {Page}
+     */
+    static loadFile(file, content) {
+        return new Page({
+            file: file,
+            content: content,
+        });
+    }
+    static fromJSON(json) {
+        return new Page({
+            file: new file_1.default(json.file),
+            // Attributes extracted from the YAML header
+            attributes: immutable_1.default.Map(json.atributes),
+            // Content of the page
+            content: json.content,
+            // Direction of the text
+            dir: json.dir,
+        });
+    }
+    static toJSON(page) {
+        return page.toJS();
+    }
+    hash() {
+        return hash_1.hashString(JSON.stringify(this.toJS()));
+    }
+}
+exports.default = Page;