fulmine.js 5.0.0-rc.1

package/src/view.js

@@ -0,0 +1,172 @@
+/*
+Copyright 2024 dimden.dev
+Copyright 2026 Nigro Simone
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const path = require("path");
+const fs = require("fs");
+const { NullObject } = require("./utils.js");
+
+module.exports = class View {
+    /**
+     * Resolves a template name to a file, so that render() has something to hand the engine. An
+     * absolute name is taken as it stands; anything else is looked for under each configured root.
+     *
+     * @param {string} name template name, with or without its extension
+     * @param {any} options defaultEngine, root and engines. Loosely typed on purpose: the
+     *   constructor throws when what it needs is missing rather than checking each use
+     */
+    constructor(name, options) {
+        this.name = name;
+        this.options = options ? Object.assign({}, options) : new NullObject();
+        this.defaultEngine = options.defaultEngine;
+        this.ext = path.extname(name);
+        this.root = options.root;
+
+        if (!this.ext && !this.defaultEngine) {
+            throw new Error("No default engine was specified and no extension was provided.");
+        }
+
+        let fileName = name;
+        if (!this.ext) {
+            this.ext = this.defaultEngine[0] !== "." ? "." + this.defaultEngine : this.defaultEngine;
+
+            fileName += this.ext;
+        }
+
+        if (!this.options.engines[this.ext]) {
+            const mod = this.ext.slice(1);
+
+            // default engine export
+            const fn = require(mod).__express;
+
+            if (typeof fn !== "function") {
+                throw new Error('Module "' + mod + '" does not provide a view engine.');
+            }
+
+            this.options.engines[this.ext] = fn;
+        }
+
+        this.engine = this.options.engines[this.ext];
+        if (path.isAbsolute(name)) {
+            this.path = name;
+            if (path.extname(name) === "") {
+                this.path += this.ext;
+            }
+        } else {
+            this.path = this.lookup(fileName);
+        }
+    }
+
+    /**
+     * The first of the configured roots that actually holds this template, or undefined when none
+     * of them does. `views` may be a single directory or a list, and the list is searched in order,
+     * so an application can put its own templates in front of a package's.
+     *
+     * @param {string} name template file name, relative to a root
+     * @returns {string|undefined} absolute path to the file that exists
+     */
+    lookup(name) {
+        let _path;
+        const roots = [].concat(this.root);
+        for (let i = 0; i < roots.length && !_path; i++) {
+            const root = roots[i];
+
+            // resolve the path
+            const loc = path.resolve(root, name);
+            const dir = path.dirname(loc);
+            const file = path.basename(loc);
+
+            // resolve the file
+            _path = this.resolve(dir, file);
+        }
+        return _path;
+    }
+
+    /**
+     * Renders the template through its engine.
+     *
+     * The callback is always delivered asynchronously, even when the engine answers on the spot.
+     * `sync` is still true only if the engine called back before this function returned, and in
+     * that case the callback is pushed to the next tick, so a caller never has to handle both
+     * orders. Express normalises it the same way.
+     *
+     * @param {Record<string, any>} options locals and engine options, passed through untouched
+     * @param {Function} callback called with whatever the engine passed, which is normally
+     *   (err, html) but is forwarded as it came rather than reshaped
+     */
+    render(options, callback) {
+        let sync = true;
+        // `this` is whatever the engine called onRender with, and it is forwarded untouched
+        this.engine(
+            this.path,
+            options,
+            /** @this {any} */ function onRender() {
+                if (!sync) {
+                    return callback.apply(this, arguments);
+                }
+
+                return process.nextTick(() => {
+                    return callback.apply(this, arguments);
+                });
+            }
+        );
+
+        sync = false;
+    }
+
+    /**
+     * The file a template name resolves to inside one directory, trying `<name>.<ext>` first and
+     * then `<name>/index.<ext>`, which is how a template can be a directory with an index in it.
+     *
+     * @param {string} dir directory to look in
+     * @param {string} file file name, with or without the extension
+     * @returns {string|undefined} the path that exists, or undefined when neither does
+     */
+    resolve(dir, file) {
+        const ext = this.ext;
+
+        // <path>.<ext>
+        let _path = path.join(dir, file);
+        let stat = tryStat(_path);
+
+        if (stat && stat.isFile()) {
+            return _path;
+        }
+
+        // <path>/index.<ext>
+        _path = path.join(dir, path.basename(file, ext), "index" + ext);
+        stat = tryStat(_path);
+
+        if (stat && stat.isFile()) {
+            return _path;
+        }
+    }
+};
+
+/**
+ * fs.statSync that answers undefined instead of throwing, since a template that is not there is
+ * the ordinary case while looking through several roots.
+ *
+ * @param {string} path
+ * @returns {import("fs").Stats|undefined}
+ */
+function tryStat(path) {
+    try {
+        return fs.statSync(path);
+    } catch (e) {
+        return undefined;
+    }
+}

package/src/worker.js

@@ -0,0 +1,38 @@
+/*
+Copyright 2024 dimden.dev
+Copyright 2026 Nigro Simone
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const fs = require("fs");
+const { parentPort } = require("worker_threads");
+
+// this file is only ever loaded as a worker, where parentPort is always present. Reading it in the
+// main thread would give null, so say so once here rather than at each use
+if (!parentPort) {
+    throw new Error("worker.js must be loaded as a worker thread");
+}
+const port = parentPort;
+
+port.on("message", (message) => {
+    if (message.type === "readFile") {
+        try {
+            const data = fs.readFileSync(message.path);
+            const ab = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            port.postMessage({ key: message.key, data: ab }, [ab]);
+        } catch (err) {
+            port.postMessage({ key: message.key, err: String(err) });
+        }
+    }
+});