nsp-server-pages 0.0.1

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "nsp-server-pages",
+  "description": "NSP JavaScript Server Pages for Node.js",
+  "version": "0.0.1",
+  "author": "@kawanet",
+  "bugs": {
+    "url": "https://github.com/kawanet/nsp-server-pages/issues"
+  },
+  "dependencies": {
+    "async-cache-queue": "^0.2.7",
+    "to-xml": "^0.1.10"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.5.1",
+    "mocha": "^10.2.0",
+    "typescript": "^5.1.6"
+  },
+  "exports": {
+    "import": {
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "require": "./cjs/index.js"
+  },
+  "files": [
+    "cjs/index.js",
+    "cjs/package.json",
+    "cjs/src/*.js",
+    "index.d.ts",
+    "index.js",
+    "package.json",
+    "src/*.js"
+  ],
+  "homepage": "https://github.com/kawanet/nsp-server-pages#readme",
+  "keywords": [
+    "JSP",
+    "Struts",
+    "Tomcat",
+    "taglib"
+  ],
+  "license": "Apache-2.0",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kawanet/nsp-server-pages.git"
+  },
+  "scripts": {
+    "build": "make all",
+    "fixpack": "fixpack",
+    "prepack": "make clean test-title all test",
+    "test": "make test"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./index.d.ts"
+}

package/src/app.js

@@ -0,0 +1,77 @@
+import { load, mount } from "./mount.js";
+import { FileLoader, JsLoader, JspLoader } from "./loaders.js";
+import { parseJSP } from "./parse-jsp.js";
+import { catchFn } from "./catch.js";
+import { bundle } from "./bundle.js";
+import { addTagLib, prepareTag } from "./taglib.js";
+import { concat } from "./concat.js";
+export const createNSP = (options) => new App(options);
+class App {
+    constructor(options) {
+        this.loaders = [];
+        this.tagMap = new Map();
+        this.fnMap = new Map();
+        this.listeners = new Map;
+        this.options = options = Object.create(options || null);
+        if (!options.conf)
+            options.conf = {};
+        if (!options.vKey)
+            options.vKey = "v";
+        if (!options.nspKey)
+            options.nspKey = "nsp";
+    }
+    on(type, fn) {
+        this.listeners.set(type, fn);
+    }
+    emit(type, arg) {
+        const fn = this.listeners.get(type);
+        if (fn)
+            return fn(arg);
+    }
+    log(message) {
+        const logger = this.options.logger || console;
+        logger.log(message);
+    }
+    concat(..._) {
+        return concat(arguments);
+    }
+    fn(name) {
+        const fn = this.fnMap.get(name);
+        if (!fn)
+            throw new Error(`Unknown function: ${name}`);
+        return fn;
+    }
+    addTagLib(tagLibDef) {
+        addTagLib(this, tagLibDef);
+    }
+    tag(name, attr, ..._) {
+        const bodyFn = bundle(arguments, 2);
+        const tagFn = prepareTag(this, name, attr, bodyFn);
+        return catchFn(this, tagFn);
+    }
+    bundle(..._) {
+        const fn = bundle(arguments);
+        return catchFn(this, fn);
+    }
+    parse(src) {
+        return parseJSP(this, src);
+    }
+    mount(match, fn) {
+        return mount(this, match, fn);
+    }
+    load(path) {
+        return load(this, path);
+    }
+    loadJS(file) {
+        const loader = this.jsLoader || (this.jsLoader = new JsLoader(this));
+        return loader.load(file);
+    }
+    loadJSP(file) {
+        const loader = this.jspLoader || (this.jspLoader = new JspLoader(this));
+        return loader.load(file);
+    }
+    loadFile(file) {
+        const loader = this.fileLoader || (this.fileLoader = new FileLoader(this));
+        return loader.load(file);
+    }
+}

package/src/bundle.js

@@ -0,0 +1,47 @@
+const isPromise = (v) => v && (typeof v.then === "function");
+const join = (a, b) => (a == null ? b : (b == null ? a : a + b));
+export const bundle = (array, start, end) => {
+    start = +start || 0;
+    end = +end || array?.length || 0;
+    if (end <= start) {
+        return () => null;
+    }
+    if (end - 1 === start) {
+        const node = array[start];
+        return (typeof node === "function") ? node : () => node;
+    }
+    return context => {
+        let result;
+        let promise;
+        for (let i = start; i < end; i++) {
+            let v = array[i];
+            if (promise) {
+                promise = promise.then(result => {
+                    if (typeof v === "function") {
+                        v = v(context);
+                    }
+                    if (isPromise(v)) {
+                        return v.then(v => join(result, v));
+                    }
+                    else {
+                        return join(result, v);
+                    }
+                });
+            }
+            else {
+                if (typeof v === "function") {
+                    v = v(context);
+                }
+                if (isPromise(v)) {
+                    // upgrade to async mode
+                    promise = v.then(v => join(result, v));
+                }
+                else {
+                    // sync mode per default
+                    result = join(result, v);
+                }
+            }
+        }
+        return promise || result;
+    };
+};

package/src/catch.js

@@ -0,0 +1,26 @@
+import { toXML } from "to-xml";
+const isPromise = (v) => v && (typeof v.catch === "function");
+const escapeError = (e) => toXML({ "#": (e?.message || String(e)) });
+export const catchFn = (app, fn) => {
+    return context => {
+        try {
+            const result = fn(context);
+            if (isPromise(result)) {
+                return result.catch(errorHandler);
+            }
+            else {
+                return result;
+            }
+        }
+        catch (e) {
+            return errorHandler(e);
+        }
+        function errorHandler(e) {
+            const result = app.emit("error", e, context);
+            if (result == null) {
+                return `<!--\n[ERR] ${escapeError(e)}\n-->`;
+            }
+            return result;
+        }
+    };
+};

package/src/concat.js

@@ -0,0 +1,31 @@
+const isPromise = (v) => v && (typeof v.then === "function");
+const join = (a, b) => (a == null ? b : (b == null ? a : a + b));
+const single = (v) => (Array.isArray(v) ? concat(v) : v);
+export const concat = (array) => {
+    let result;
+    let promise;
+    for (let i = 0; i < array.length; i++) {
+        let text = single(array[i]);
+        if (promise) {
+            promise = promise.then(result => {
+                if (isPromise(text)) {
+                    return text.then(text => join(result, text));
+                }
+                else {
+                    return join(result, text);
+                }
+            });
+        }
+        else {
+            if (isPromise(text)) {
+                // upgrade to async mode
+                promise = text.then(text => join(result, text));
+            }
+            else {
+                // sync mode per default
+                result = join(result, text);
+            }
+        }
+    }
+    return promise || result;
+};

package/src/loaders.js

@@ -0,0 +1,117 @@
+import { queueFactory } from "async-cache-queue";
+import { promises as fs } from "fs";
+const getName = (path) => path.split("/").at(-1)?.split(".").at(0) || "";
+class BaseLoader {
+    constructor(app) {
+        /**
+         * This tests the file exists.
+         * The test cache is separated from the loader cache to avoid cache flushed by dirty requests.
+         */
+        this.isFile = queueFactory({
+            cache: 60 * 1000,
+            maxItems: 10 * 1000,
+            negativeCache: 1000,
+            timeout: 1000,
+        })(async (file) => {
+            return await fs.stat(file).then(stat => stat?.isFile()).catch(() => false);
+        });
+        this.appRef = new WeakRef(app);
+    }
+}
+export class JspLoader extends BaseLoader {
+    constructor() {
+        super(...arguments);
+        /**
+         * Parse JSP file, cache the result function and return it.
+         */
+        this._load = queueFactory({
+            cache: 60 * 1000,
+            maxItems: 10 * 1000,
+            negativeCache: 1000,
+            timeout: 1000,
+        })(async (path) => {
+            const app = this.appRef.deref();
+            app.log(`loading: ${path}`);
+            const text = await fs.readFile(path, "utf8");
+            return app.parse(text).toFn();
+        });
+    }
+    async load(file) {
+        // valid only for .jsp files
+        if (!/\.jsp$/.test(file))
+            return;
+        // skip when file does not exist
+        if (!await this.isFile(file))
+            return;
+        // load .jsp file then
+        return this._load(file);
+    }
+}
+export class JsLoader extends BaseLoader {
+    constructor() {
+        super(...arguments);
+        /**
+         * Parse JS file, cache the result function and return it.
+         */
+        this._load = queueFactory({
+            cache: 60 * 1000,
+            maxItems: 1000,
+            negativeCache: 1000,
+            timeout: 1000,
+        })(async (file) => {
+            const app = this.appRef.deref();
+            app.log(`loading: ${file}`);
+            const module = await import(file);
+            const name = getName(file);
+            const fn = module[name];
+            if (typeof fn !== "function") {
+                throw new Error(`Named export "${name}" not found in module: ${file}`);
+            }
+            const nodeFn = fn(app);
+            if (typeof nodeFn !== "function") {
+                throw new Error(`Exported "${name}" function does not returns a valid function: ${file}`);
+            }
+            return nodeFn;
+        });
+    }
+    async load(file) {
+        file = file?.replace(/\.jsp$/, ".js");
+        // valid only for .js files
+        if (!/\.[cm]?js$/.test(file))
+            return;
+        // skip when file does not exist
+        if (!await this.isFile(file))
+            return;
+        // import .js file then
+        return this._load(file);
+    }
+}
+export class FileLoader extends BaseLoader {
+    constructor() {
+        super(...arguments);
+        /**
+         * Parse HTML or other text files, cache the result function and return it.
+         */
+        this._load = queueFactory({
+            cache: 60 * 1000,
+            maxItems: 1000,
+            negativeCache: 1000,
+            timeout: 1000,
+        })(async (file) => {
+            const app = this.appRef.deref();
+            app.log(`loading: ${file}`);
+            const text = await fs.readFile(file, "utf8");
+            return () => text;
+        });
+    }
+    async load(file) {
+        // disabled for JSP, JS and image files
+        if (/\.(jsp|[cm]?js|png|gif|jpe?g)$/i.test(file))
+            return;
+        // skip when file does not exist
+        if (!await this.isFile(file))
+            return;
+        // load HTML and other text files then
+        return this._load(file);
+    }
+}

package/src/mount.js

@@ -0,0 +1,29 @@
+export const mount = (app, match, fn) => {
+    const test = ("string" !== typeof match) ? match : {
+        test: ((path) => path.startsWith(match))
+    };
+    app.loaders.push(!test ? fn : path => {
+        if (test.test(path))
+            return fn(path);
+    });
+};
+export const load = async (app, path) => {
+    const { loaders } = app;
+    const search = path.replace(/^[^?]*\??/, "");
+    path = path.replace(/\?.*$/, "");
+    path = path.replace(/^\/*/, "/");
+    let fn;
+    for (const loaderFn of loaders) {
+        fn = await loaderFn(path);
+        if (fn)
+            break;
+    }
+    if (!fn)
+        throw new Error(`file not found: ${path}`);
+    return context => {
+        for (const [key, value] of new URLSearchParams(search)) {
+            context[key] = value;
+        }
+        return fn(context);
+    };
+};

package/src/parse-attr.js

@@ -0,0 +1,87 @@
+import { parseText } from "./parse-text.js";
+/**
+ * Parser for HTML tag attributes <tagName attr="value"/>
+ */
+export const parseAttr = (app, src) => new AttrParser(app, src);
+class AttrParser {
+    constructor(app, src) {
+        this.app = app;
+        this.src = src;
+        //
+    }
+    /**
+     * Transpile HTML tag attributes to JavaScript source code
+     */
+    toJS(option) {
+        return attrToJS(this.app, this.src, option);
+    }
+    /**
+     * Compile HTML tag attributes to JavaScript function instance
+     */
+    toFn() {
+        const { app } = this;
+        const { nspKey, vKey } = app.options;
+        const js = this.toJS();
+        try {
+            const fn = Function(nspKey, vKey, `return ${js}`);
+            return (context) => fn(app, context);
+        }
+        catch (e) {
+            app.log("AttrParser: " + js.substring(0, 1000));
+            throw e;
+        }
+    }
+}
+/**
+ * Transpile HTML tag attributes to JavaScript source code
+ */
+const attrToJS = (app, tag, option) => {
+    tag = tag?.replace(/^\s*<\S+\s*/s, "");
+    tag = tag?.replace(/\s*\/?>\s*$/s, "");
+    const indent = +app.options.indent || 0;
+    const currentIndent = +option?.indent || 0;
+    const nextIndent = currentIndent + indent;
+    const currentLF = currentIndent ? "\n" + " ".repeat(currentIndent) : "\n";
+    const nextLF = nextIndent ? "\n" + " ".repeat(nextIndent) : "\n";
+    const keys = [];
+    const index = {};
+    tag?.replace(/([^\s='"]+)(\s*=(?:\s*"([^"]*)"|\s*'([^']*)'|([^\s='"]*)))?/g, (_, key, eq, v1, v2, v3) => {
+        if (!index[key])
+            keys.push(key);
+        index[key] = (eq ? unescapeXML(v1 || v2 || v3 || "") : true);
+        return "";
+    });
+    const items = keys.map(key => {
+        let value = index[key];
+        if (!/^[A-Za-z_]\w+$/.test(key)) {
+            key = JSON.stringify(key);
+        }
+        if ("string" === typeof value) {
+            value = parseText(app, value).toJS({ indent: nextIndent });
+        }
+        return `${key}: ${value}`;
+    });
+    // no arguments
+    if (!keys.length)
+        return 'null';
+    const js = items.join(`,${nextLF}`);
+    const trailingComma = (keys.length > 1) ? "," : "";
+    return `{${nextLF}${js}${trailingComma}${currentLF}}`;
+};
+const UNESCAPE = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&apos;": "'",
+    "&quot;": '"'
+};
+const unescapeXML = (str) => {
+    return str?.replace(/(&(?:lt|gt|amp|apos|quot|#(?:\d{1,6}|x[0-9a-fA-F]{1,5}));)/g, (str) => {
+        if (str[1] === "#") {
+            const code = (str[2] === "x") ? parseInt(str.substring(3), 16) : parseInt(str.substr(2), 10);
+            if (code > -1)
+                return String.fromCharCode(code);
+        }
+        return UNESCAPE[str] || str;
+    });
+};

package/src/parse-el.js

@@ -0,0 +1,100 @@
+const trim = (str) => str.replace(/^\s+/s, "").replace(/\s+$/s, "");
+const wordMap = {
+    and: "&&",
+    div: "/",
+    empty: "!",
+    eq: "==",
+    false: "false",
+    ge: ">=",
+    gt: ">",
+    instanceof: "instanceof",
+    le: "<=",
+    lt: "<",
+    mod: "%",
+    ne: "!=",
+    not: "!",
+    null: "null",
+    or: "||",
+    true: "true",
+};
+const numericRE = `[0-9]+(?![0-9])`;
+const floatRE = `${numericRE}(?:\\.${numericRE})?(?!\\.)`;
+const stringRE = `"(?:\\\\\\.|[^\\\\"])*"|'(?:\\\\\\.|[^\\\\'])*'`;
+const nameRE = `[A-Za-z_][A-Za-z_0-9]*(?![A-Za-z_0-9])`;
+const tagFnRE = `${nameRE}:${nameRE}\\(`;
+const variableRE = `${nameRE}(?:\\.${nameRE}|\\[(?:${numericRE}|${stringRE})\\])*`;
+const opRE = `[+\\-\\*/%=<>()!|&:?,]+(?![+\\-\\*/%=<>()!|&:?,])`;
+const itemRE = [tagFnRE, variableRE, floatRE, stringRE, opRE].join("|");
+const tagFnRegExp = new RegExp(`^${tagFnRE}$`, "s");
+const variableRegExp = new RegExp(`^${variableRE}$`, "s");
+const itemRegExp = new RegExp(`(${itemRE})`, "s");
+/**
+ * Simplified transformer for expression language
+ */
+export const parseEL = (app, src) => new ElParser(app, src);
+class ElParser {
+    constructor(app, src) {
+        this.app = app;
+        this.src = src;
+        //
+    }
+    /**
+     * Compile ${EL} to JavaScript function instance
+     */
+    toFn() {
+        const { app } = this;
+        const { nspKey, vKey } = app.options;
+        const js = this.toJS();
+        try {
+            const fn = Function(nspKey, vKey, `return ${js}`);
+            return (context) => fn(app, context);
+        }
+        catch (e) {
+            app.log("ElParser: " + js?.substring(0, 1000));
+            throw e;
+        }
+    }
+    /**
+     * Transpile ${EL} to JavaScript source code
+     */
+    toJS(_) {
+        const { app } = this;
+        const { prefilter, postfilter } = app.options;
+        let src = trim(this.src);
+        if (prefilter)
+            src = prefilter(src);
+        if (src == null)
+            return 'null';
+        const array = src.split(itemRegExp);
+        const { nspKey, vKey } = app.options;
+        for (let i = 0; i < array.length; i++) {
+            let exp = array[i];
+            if (i & 1) {
+                if (wordMap[exp]) {
+                    // eq, and, or
+                    array[i] = wordMap[exp];
+                }
+                else if (tagFnRegExp.test(exp)) {
+                    // taglib function
+                    exp = exp.replace(/\($/, "");
+                    array[i] = `${nspKey}.fn(${JSON.stringify(exp)})(`;
+                }
+                else if (variableRegExp.test(exp)) {
+                    // variable
+                    exp = exp.replace(/\./g, "?.");
+                    exp = exp.replace(/\[/g, "?.[");
+                    exp = exp.replace(/\s+$/, "");
+                    array[i] = `${vKey}.${exp}`;
+                }
+            }
+            else {
+                // less spaces
+                array[i] = exp.replace(/\s+/sg, " ");
+            }
+        }
+        let js = array.join("");
+        if (postfilter)
+            js = postfilter(js);
+        return js;
+    }
+}