nsp-server-pages 0.1.2 → 0.2.1

package/README.md

@@ -11,7 +11,7 @@ NSP JavaScript Server Pages for Node.js
 - `${ f:h("tag") }` - custom taglib static function call
 - `<ns:tag attr="${ expression }"/>` - custom taglib action tag
 - `<%-- comments --%>` - comments in JSP just ignored
-- See TypeScript declaration [index.d.ts](https://github.com/kawanet/nsp-server-pages/blob/main/index.d.ts) for API detail.
+- See [TypeScript declaration files](https://github.com/kawanet/nsp-server-pages/tree/main/types/) for API detail.
 
 ## SYNOPSIS
 
@@ -156,6 +156,7 @@ app.use("/", async (req, res, next) => {
 - https://github.com/kawanet/nsp-server-pages
 - https://github.com/kawanet/nsp-jstl-taglib
 - https://github.com/kawanet/nsp-struts1-taglib
+- https://github.com/kawanet/nsp-seasar2-taglib
 - https://github.com/apache/tomcat
 
 ## LICENSE

package/cjs/index.js

@@ -1 +1,6 @@
-exports.createNSP = require("./src/app.js").createNSP;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNSP = void 0;
+const app_js_1 = require("./src/app.js");
+const createNSP = (options) => new app_js_1.App(options);
+exports.createNSP = createNSP;

package/cjs/package.json

@@ -1,3 +1,4 @@
 {
+  "main": "./index.js",
   "type": "commonjs"
 }

package/cjs/src/app.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNSP = void 0;
+exports.App = void 0;
 const mount_js_1 = require("./mount.js");
 const loaders_js_1 = require("./loaders.js");
-const parse_jsp_js_1 = require("./parse-jsp.js");
+const jsp_js_1 = require("./parser/jsp.js");
 const catch_js_1 = require("./catch.js");
 const bundle_js_1 = require("./bundle.js");
 const taglib_js_1 = require("./taglib.js");
 const concat_js_1 = require("./concat.js");
-const createNSP = (options) => new App(options);
-exports.createNSP = createNSP;
+const stack_store_js_1 = require("./stack-store.js");
 class App {
     constructor(options) {
         this.loaders = [];
         this.tagMap = new Map();
         this.fnMap = new Map();
-        this.hooks = new Map;
+        this.hooks = new Map();
         this.options = options = Object.create(options || null);
         if (!options.vName)
             options.vName = "v";
@@ -30,7 +29,7 @@ class App {
     process(type, ...args) {
         const fn = this.hooks.get(type);
         if (fn)
-            return fn.apply(null, args);
+            return fn.apply(this, args);
     }
     log(message) {
         const logger = this.options.logger || console;
@@ -46,11 +45,11 @@ class App {
         return fn;
     }
     addTagLib(tagLibDef) {
-        (0, taglib_js_1.addTagLib)(this, tagLibDef);
+        taglib_js_1.addTagLib.call(this, tagLibDef);
     }
     tag(name, attr, ..._) {
         const bodyFn = (0, bundle_js_1.bundle)(arguments, 2);
-        const tagFn = (0, taglib_js_1.prepareTag)(this, name, attr, bodyFn);
+        const tagFn = taglib_js_1.prepareTag.call(this, name, attr, bodyFn);
         return (0, catch_js_1.catchFn)(this, tagFn);
     }
     bundle(..._) {
@@ -58,37 +57,38 @@ class App {
         return (0, catch_js_1.catchFn)(this, fn);
     }
     parse(src) {
-        return (0, parse_jsp_js_1.parseJSP)(this, src);
+        return new jsp_js_1.JSP(this, src);
     }
     mount(path, fn) {
-        return (0, mount_js_1.mount)(this, path, fn);
+        return mount_js_1.mount.call(this, path, fn);
     }
     load(path) {
-        return (0, mount_js_1.load)(this, path);
+        return mount_js_1.load.call(this, path);
     }
     loadJS(file) {
-        const loader = this.jsLoader || (this.jsLoader = new loaders_js_1.JsLoader(this));
+        const loader = (this.jsLoader ??= new loaders_js_1.JsLoader(this));
         return loader.load(file);
     }
     loadJSP(file) {
-        const loader = this.jspLoader || (this.jspLoader = new loaders_js_1.JspLoader(this));
+        const loader = (this.jspLoader ??= new loaders_js_1.JspLoader(this));
         return loader.load(file);
     }
     loadFile(file) {
-        const loader = this.fileLoader || (this.fileLoader = new loaders_js_1.FileLoader(this));
+        const loader = (this.fileLoader ??= new loaders_js_1.FileLoader(this));
         return loader.load(file);
     }
-    store(context, key, initFn) {
+    store(context, key) {
         if ("object" !== typeof context && context == null) {
             throw new Error("Context must be an object");
         }
         const { storeKey } = this.options;
-        const map = context[storeKey] || (context[storeKey] = new Map());
+        const map = (context[storeKey] ??= new Map());
         let value = map.get(key);
         if (value == null) {
-            value = initFn();
+            value = new stack_store_js_1.StackStore();
             map.set(key, value);
         }
         return value;
     }
 }
+exports.App = App;

package/cjs/src/catch.js

@@ -19,10 +19,11 @@ const catchFn = (app, fn) => {
         function errorHandler(e) {
             // just throw the error if it's already handled
             if (context != null) {
-                const data = app.store(context, "error", () => ({}));
-                if (data.error === e)
+                const store = app.store(context, "error");
+                if (store.find(err => (err === e))) {
                     throw e;
-                data.error = e;
+                }
+                store.open(e);
             }
             // call the error hook
             const result = app.process("error", e, context);

package/cjs/src/loaders.js

@@ -65,7 +65,7 @@ class JsLoader extends BaseLoader {
         })(async (file) => {
             const app = this.appRef.deref();
             app.log(`loading: ${file}`);
-            const module = await import(file);
+            const module = await Promise.resolve(`${file}`).then(s => require(s));
             const name = getName(file);
             const fn = module[name];
             if (typeof fn !== "function") {

package/cjs/src/mount.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.load = exports.mount = void 0;
-const mount = (app, match, fn) => {
+function mount(match, fn) {
     const test = ("string" !== typeof match) ? match : {
         test: ((path) => path.startsWith(match))
     };
-    app.loaders.push(!test ? fn : path => {
+    this.loaders.push(!test ? fn : path => {
         if (test.test(path))
             return fn(path);
     });
-};
+}
 exports.mount = mount;
-const load = async (app, path) => {
-    const { loaders } = app;
+async function load(path) {
+    const { loaders } = this;
     const search = path.replace(/^[^?]*\??/, "");
     path = path.replace(/\?.*$/, "");
     path = path.replace(/^\/*/, "/");
@@ -30,5 +30,5 @@ const load = async (app, path) => {
         }
         return fn(context);
     };
-};
+}
 exports.load = load;

package/cjs/src/parser/attr.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attr = void 0;
+const text_js_1 = require("./text.js");
+const isSafeKey = (key) => /^[A-Za-z_]\w+$/.test(key);
+/**
+ * Parser for HTML tag attributes <tagName attr="value"/>
+ */
+class Attr {
+    constructor(app, src) {
+        this.app = app;
+        this.src = app.process("before.parse.attr", src) ?? src;
+    }
+    /**
+     * Transpile HTML tag attributes to JavaScript source code
+     */
+    toJS(option) {
+        const { app, src } = this;
+        const js = app.process("parse.attr", src) ?? this._toJS(option);
+        return app.process("after.parse.attr", js) ?? js;
+    }
+    keys() {
+        return Object.keys(this.getIndex());
+    }
+    get(key) {
+        return this.getIndex()[key];
+    }
+    getIndex() {
+        let { index, src } = this;
+        if (index)
+            return index;
+        index = this.index = {};
+        if (!src)
+            return index;
+        src = src.replace(/^\s*<\S+\s*/s, "");
+        src = src.replace(/\s*\/?>\s*$/s, "");
+        src.replace(/([^\s='"]+)(\s*=(?:\s*"([^"]*)"|\s*'([^']*)'|([^\s='"]*)))?/g, (_, key, eq, v1, v2, v3) => {
+            if (eq) {
+                const value = unescapeXML(v1 || v2 || v3 || "");
+                index[key] = new text_js_1.Text(this.app, value).toJS({});
+            }
+            else {
+                const value = true;
+                index[key] = String(value);
+            }
+            return "";
+        });
+        return index;
+    }
+    /**
+     * Transpile HTML tag attributes to JavaScript source code
+     */
+    _toJS(option) {
+        const { app } = this;
+        const { indent } = app.options;
+        const SP = option?.SP ?? (("string" === typeof indent) ? indent : (+indent ? " ".repeat(+indent) : ""));
+        const LF = option?.LF ?? "\n";
+        const nextLF = LF + SP;
+        const keys = this.keys();
+        const items = keys.map(key => {
+            if (!isSafeKey(key)) {
+                key = JSON.stringify(key);
+            }
+            const value = this.get(key);
+            return `${key}: ${value}`;
+        });
+        // no arguments
+        if (!keys.length)
+            return 'null';
+        const js = items.join(`,${nextLF}`);
+        const trailingComma = (keys.length > 1) ? "," : "";
+        return `{${nextLF}${js}${trailingComma}${LF}}`;
+    }
+}
+exports.Attr = Attr;
+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 → cjs/src/parser/el.js}

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EL = void 0;
 const trim = (str) => str.replace(/^\s+/s, "").replace(/\s+$/s, "");
 const wordMap = {
     and: "&&",
@@ -30,38 +33,23 @@ const itemRegExp = new RegExp(`(${itemRE})`, "s");
 /**
  * Simplified transformer for expression language
  */
-export const parseEL = (app, src) => new ElParser(app, src);
-class ElParser {
+class EL {
     constructor(app, src) {
         this.app = app;
-        this.src = src;
-        //
-    }
-    /**
-     * Compile ${EL} to JavaScript function instance
-     */
-    toFn() {
-        const { app } = this;
-        const { nspName, vName } = app.options;
-        const js = this.toJS();
-        try {
-            const fn = Function(nspName, vName, `return ${js}`);
-            return (context) => fn(app, context);
-        }
-        catch (e) {
-            app.log("ElParser: " + js?.substring(0, 1000));
-            throw e;
-        }
+        src = trim(src);
+        this.src = app.process("before.parse.el", src) ?? src;
     }
     /**
      * Transpile ${EL} to JavaScript source code
      */
-    toJS(_) {
-        const { app } = this;
-        const { nullish, prefilter, postfilter } = app.options;
-        let src = trim(this.src);
-        if (prefilter)
-            src = prefilter(src);
+    toJS(option) {
+        const { app, src } = this;
+        const js = app.process("parse.el", src) ?? this._toJS(option);
+        return app.process("after.parse.el", js) ?? js;
+    }
+    _toJS(_) {
+        const { app, src } = this;
+        const { nullish } = app.options;
         if (src == null)
             return 'null';
         const array = src.split(itemRegExp);
@@ -98,8 +86,7 @@ class ElParser {
             }
             js = `${js} ?? ""`;
         }
-        if (postfilter)
-            js = postfilter(js);
         return js;
     }
 }
+exports.EL = EL;

package/cjs/src/parser/jsp.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jspToJS = exports.JSP = void 0;
+const scriptlet_js_1 = require("./scriptlet.js");
+const stack_store_js_1 = require("../stack-store.js");
+const tag_js_1 = require("./tag.js");
+/**
+ * Parser for JSP document
+ */
+class JSP {
+    constructor(app, src) {
+        this.app = app;
+        this.src = app.process("before.parse.jsp", src) ?? src;
+    }
+    /**
+     * Transpile JSP document to JavaScript source code
+     */
+    toJS(option) {
+        const { app, src } = this;
+        const js = app.process("parse.jsp", src) ?? (0, exports.jspToJS)(app, src, option);
+        return app.process("after.parse.jsp", js) ?? js;
+    }
+    /**
+     * Compile JSP document to JavaScript function
+     */
+    toFn() {
+        const { app } = this;
+        const { nspName } = app.options;
+        const js = this.toJS();
+        try {
+            const fn = Function(nspName, `return ${js}`);
+            return fn(app);
+        }
+        catch (e) {
+            app.log("JspParser: " + js?.substring(0, 1000));
+            throw e;
+        }
+    }
+}
+exports.JSP = JSP;
+const nameRE = `[A-Za-z][A-Za-z0-9]*`;
+const stringRE = `"(?:\\\\[.]|[^\\\\"])*"|'(?:\\\\[.]|[^\\\\'])*'`;
+const insideRE = `[^"']|${stringRE}`;
+const tagRegExp = new RegExp(`(</?${nameRE}:(?:${insideRE})*?>)|(<%(?:${insideRE})*?%>)`, "s");
+const jspToJS = (app, src, option) => {
+    const root = new tag_js_1.Tag(app);
+    const tree = new stack_store_js_1.StackStore(root);
+    const array = src.split(tagRegExp);
+    for (let i = 0; i < array.length; i++) {
+        const i3 = i % 3;
+        let str = array[i];
+        if (i3 === 1 && str) {
+            // taglib
+            const tag = new tag_js_1.Tag(app, str);
+            // close-tag
+            if (tag.isClose()) {
+                const closed = tree.close();
+                if (!closed) {
+                    throw new Error(`invalid closing tag: </${tag.tagName}>`);
+                }
+                if (closed.tagName !== tag.tagName) {
+                    throw new Error(`invalid closing tag: <${closed.tagName}></${tag.tagName}>`);
+                }
+                continue;
+            }
+            tree.get().append(tag);
+            // open-tag
+            if (tag.isOpen()) {
+                tree.open(tag);
+            }
+        }
+        else if (i3 === 2 && str) {
+            // <% scriptlet %>
+            const item = new scriptlet_js_1.Scriptlet(app, str);
+            tree.get().append(item);
+        }
+        else if (i3 === 0) {
+            // text node
+            tree.get().append(str);
+        }
+    }
+    const closed = tree.close();
+    if (closed !== root) {
+        throw new Error(`invalid closing tag: </${closed?.tagName}>`);
+    }
+    return root.toJS(option);
+};
+exports.jspToJS = jspToJS;

package/cjs/src/parser/scriptlet.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scriptlet = void 0;
+const typeMap = {
+    "<%-": "comment",
+    "<%@": "directive",
+    "<%!": "declaration",
+    "<%=": "expression",
+};
+/**
+ * Parser for Directive, Declaration, Scriptlet
+ * <%-- comment --%>
+ * <%@ directive %>
+ * <%! declaration(s) %>
+ * <% scriptlet %>
+ * <%= expression %>
+ */
+class Scriptlet {
+    constructor(app, src) {
+        this.app = app;
+        const type = this.type = typeMap[src.substring(0, 3)] || "scriptlet";
+        this.src = app.process(`before.parse.${type}`, src) ?? src;
+    }
+    /**
+     * Transpile <% scriptlet %> to JavaScript source code
+     */
+    toJS(option) {
+        const { app, src, type } = this;
+        const js = app.process(`parse.${type}`, src) ?? this._toJS(option);
+        return app.process(`after.parse.${type}`, js) ?? js;
+    }
+    _toJS(option) {
+        const { app, type } = this;
+        const { nspName, vName } = app.options;
+        const currentLF = option?.LF ?? "\n";
+        let { src } = this;
+        if (type === "comment") {
+            src = src.replace(/[ \t]*[\r\n]+/sg, `${currentLF}// `);
+            return `// ${src}`;
+        }
+        app.log(`${type} found: ${src?.substring(0, 1000)}`);
+        src = /`|\$\{/.test(src) ? JSON.stringify(src) : "`" + src + "`";
+        src = `${vName} => ${nspName}.process("${type}", ${src}, ${vName})`;
+        return src;
+    }
+}
+exports.Scriptlet = Scriptlet;

package/cjs/src/parser/tag.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tag = void 0;
+const attr_js_1 = require("./attr.js");
+const text_js_1 = require("./text.js");
+const emptyText = {
+    '""': true,
+    "''": true,
+    "``": true,
+    "null": true,
+    "undefined": true,
+    "": true,
+};
+const isTranspiler = (v) => ("function" === typeof v?.toJS);
+/**
+ * Root node or an taglib node
+ */
+class Tag {
+    constructor(app, src) {
+        this.app = app;
+        this.src = src;
+        this.children = [];
+        this.tagName = src?.match(/^<\/?([^\s=/>]+)/)?.[1];
+    }
+    append(node) {
+        this.children.push(node);
+    }
+    isOpen() {
+        return !/\/\s*>$/.test(this.src);
+    }
+    isClose() {
+        return /^<\//.test(this.src);
+    }
+    getBodyJS(option) {
+        const { app } = this;
+        const { indent, trimSpaces, vName } = app.options;
+        const SP = option?.SP ?? (("string" === typeof indent) ? indent : (+indent ? " ".repeat(+indent) : ""));
+        const LF = option?.LF ?? "\n";
+        const nextLF = LF + SP;
+        const nextOption = { SP, LF: nextLF };
+        const { children } = this;
+        const args = children.map(item => {
+            if (isTranspiler(item)) {
+                return item.toJS(nextOption);
+            }
+            else if (!/\S/.test(item)) {
+                // item with only whitespace
+                return (trimSpaces !== false) ? '""' : JSON.stringify(item);
+            }
+            else {
+                if (trimSpaces !== false) {
+                    item = item.replace(/^\s*[\r\n]/s, "\n");
+                    item = item.replace(/\s*[\r\n]\s*$/s, "\n");
+                    item = item.replace(/^[ \t]+/s, " ");
+                    item = item.replace(/[ \t]+$/s, " ");
+                }
+                let js = new text_js_1.Text(app, item).toJS(nextOption);
+                if (/\(.+?\)|\$\{.+?}/s.test(js)) {
+                    js = `${vName} => ${js}`; // array function
+                }
+                return js;
+            }
+        }).filter(v => !emptyText[v]);
+        // empty body
+        if (!children.length) {
+            return "";
+        }
+        // keep a single empty string at least if all arguments are trimmed
+        if (!args.length) {
+            args.push('""');
+        }
+        const last = args.length - 1;
+        args.forEach((v, idx) => {
+            const isComment = /^\/\/[^\n]*$/s.test(v);
+            if (idx !== last && !isComment) {
+                args[idx] += ",";
+            }
+            else if (idx === last && isComment) {
+                args[idx] += LF;
+            }
+        });
+        const bodyL = /^`\n/s.test(args.at(0)) ? "" : nextLF;
+        const bodyR = /(\n`|[)\s])$/s.test(args.at(-1)) ? "" : LF;
+        return bodyL + args.join(nextLF) + bodyR;
+    }
+    /**
+     * Transpile JSP document to JavaScript source code
+     */
+    toJS(option) {
+        const { app, tagName } = this;
+        const { indent, nspName } = app.options;
+        // root element
+        if (!tagName) {
+            const bodyJS = this.getBodyJS(option);
+            return `${nspName}.bundle(${bodyJS})`; // root element
+        }
+        if (this.isClose())
+            return; // invalid
+        const commentJS = this.getCommentJS(option);
+        const attr = new attr_js_1.Attr(app, this.src);
+        const body = this.getBodyJS(option);
+        const SP = option?.SP ?? (("string" === typeof indent) ? indent : (+indent ? " ".repeat(+indent) : ""));
+        const LF = option?.LF ?? "\n";
+        const nextLF = LF + SP;
+        const nextOption = { SP, LF: (body ? nextLF : LF) };
+        const type = `parse.tag.${tagName}`;
+        const def = { app, name: tagName, attr, body, LF: LF, nextLF };
+        const tagJS = app.process(type, def) ?? this.getTagJS(def, nextOption);
+        return commentJS ? commentJS + tagJS : tagJS;
+    }
+    getCommentJS(option) {
+        const { app, src } = this;
+        if (!app.options.comment)
+            return;
+        const currentLF = option?.LF ?? "\n";
+        return `// ${src?.replace(/\s*[\r\n]\s*/g, " ") ?? ""}${currentLF}`;
+    }
+    getTagJS(def, option) {
+        const { app, tagName } = this;
+        const { nspName, vName } = app.options;
+        const attrRaw = def.attr.toJS(option);
+        // transpile attributes to array function if they include variables
+        const hasVars = /\(.+?\)|\$\{.+?}/s.test(attrRaw);
+        const attrArg = hasVars ? `, ${vName} => (${attrRaw})` : `, ${attrRaw}`;
+        const nameJS = JSON.stringify(tagName);
+        const hasAttr = /:/.test(attrRaw);
+        let bodyArg = def.body;
+        if (bodyArg)
+            bodyArg = ((/^\n/.test(bodyArg)) ? "," : ", ") + bodyArg;
+        const restJS = bodyArg ? (attrArg + bodyArg) : (hasAttr ? attrArg : "");
+        return `${nspName}.tag(${nameJS}${restJS})`;
+    }
+}
+exports.Tag = Tag;