nsp-server-pages 0.1.2 → 0.2.0

package/cjs/src/stack-store.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackStore = void 0;
+class StackStore {
+    constructor(value) {
+        this.stack = [];
+        if (arguments.length) {
+            this.set(value);
+        }
+    }
+    open(value) {
+        this.stack.unshift(value);
+    }
+    close() {
+        return this.stack.shift();
+    }
+    get() {
+        return this.stack[0];
+    }
+    set(value) {
+        this.stack[0] = value;
+    }
+    find(test) {
+        for (const data of this.stack) {
+            if (test(data)) {
+                return data;
+            }
+        }
+    }
+}
+exports.StackStore = StackStore;

package/cjs/src/taglib.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareTag = exports.addTagLib = void 0;
 const to_xml_1 = require("to-xml");
-const addTagLib = (app, tagLibDef) => {
-    const { fnMap, tagMap } = app;
+function addTagLib(tagLibDef) {
+    const { fnMap, tagMap } = this;
     const { ns, fn, tag } = tagLibDef;
     if (fn) {
         for (const name in fn) {
@@ -15,15 +15,15 @@ const addTagLib = (app, tagLibDef) => {
             tagMap.set(`${ns}:${name}`, tag[name]);
         }
     }
-};
+}
 exports.addTagLib = addTagLib;
-const prepareTag = (app, name, attr, body) => {
-    const { tagMap } = app;
+function prepareTag(name, attr, body) {
+    const { tagMap } = this;
     const tagFn = tagMap.get(name) || defaultTagFn;
     const attrFn = !attr ? () => ({}) : (typeof attr !== "function") ? () => attr : attr;
-    const tagDef = { name, app, attr: attrFn, body };
+    const tagDef = { name, app: this, attr: attrFn, body };
     return tagFn(tagDef);
-};
+}
 exports.prepareTag = prepareTag;
 const defaultTagFn = (tagDef) => {
     const { name } = tagDef;

package/esm/index.js

@@ -0,0 +1,2 @@
+import { App } from "./src/app.js";
+export const createNSP = (options) => new App(options);

package/esm/package.json

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

package/{src → esm/src}/app.js

@@ -1,17 +1,17 @@
 import { load, mount } from "./mount.js";
 import { FileLoader, JsLoader, JspLoader } from "./loaders.js";
-import { parseJSP } from "./parse-jsp.js";
+import { JSP } from "./parser/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 {
+import { StackStore } from "./stack-store.js";
+export 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";
@@ -26,7 +26,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;
@@ -42,11 +42,11 @@ class App {
         return fn;
     }
     addTagLib(tagLibDef) {
-        addTagLib(this, tagLibDef);
+        addTagLib.call(this, tagLibDef);
     }
     tag(name, attr, ..._) {
         const bodyFn = bundle(arguments, 2);
-        const tagFn = prepareTag(this, name, attr, bodyFn);
+        const tagFn = prepareTag.call(this, name, attr, bodyFn);
         return catchFn(this, tagFn);
     }
     bundle(..._) {
@@ -54,35 +54,35 @@ class App {
         return catchFn(this, fn);
     }
     parse(src) {
-        return parseJSP(this, src);
+        return new JSP(this, src);
     }
     mount(path, fn) {
-        return mount(this, path, fn);
+        return mount.call(this, path, fn);
     }
     load(path) {
-        return load(this, path);
+        return load.call(this, path);
     }
     loadJS(file) {
-        const loader = this.jsLoader || (this.jsLoader = new JsLoader(this));
+        const loader = (this.jsLoader ??= new JsLoader(this));
         return loader.load(file);
     }
     loadJSP(file) {
-        const loader = this.jspLoader || (this.jspLoader = new JspLoader(this));
+        const loader = (this.jspLoader ??= new JspLoader(this));
         return loader.load(file);
     }
     loadFile(file) {
-        const loader = this.fileLoader || (this.fileLoader = new FileLoader(this));
+        const loader = (this.fileLoader ??= new 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 StackStore();
             map.set(key, value);
         }
         return value;

package/{src → esm/src}/catch.js

@@ -16,10 +16,11 @@ export 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/{src → esm/src}/mount.js

@@ -1,14 +1,14 @@
-export const mount = (app, match, fn) => {
+export 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);
     });
-};
-export const load = async (app, path) => {
-    const { loaders } = app;
+}
+export async function load(path) {
+    const { loaders } = this;
     const search = path.replace(/^[^?]*\??/, "");
     path = path.replace(/\?.*$/, "");
     path = path.replace(/^\/*/, "/");
@@ -26,4 +26,4 @@ export const load = async (app, path) => {
         }
         return fn(context);
     };
-};
+}

package/esm/src/parser/attr.js

@@ -0,0 +1,88 @@
+import { Text } from "./text.js";
+const isSafeKey = (key) => /^[A-Za-z_]\w+$/.test(key);
+/**
+ * Parser for HTML tag attributes <tagName attr="value"/>
+ */
+export 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(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 spaces = +indent ? " ".repeat(+indent) : (indent ?? "");
+        const currentLF = option?.LF ?? "\n";
+        const nextLF = currentLF + spaces;
+        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}${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/{cjs/src/parse-el.js → esm/src/parser/el.js}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEL = void 0;
 const trim = (str) => str.replace(/^\s+/s, "").replace(/\s+$/s, "");
 const wordMap = {
     and: "&&",
@@ -33,39 +30,23 @@ const itemRegExp = new RegExp(`(${itemRE})`, "s");
 /**
  * Simplified transformer for expression language
  */
-const parseEL = (app, src) => new ElParser(app, src);
-exports.parseEL = parseEL;
-class ElParser {
+export 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);
@@ -102,8 +83,6 @@ class ElParser {
             }
             js = `${js} ?? ""`;
         }
-        if (postfilter)
-            js = postfilter(js);
         return js;
     }
 }

package/esm/src/parser/jsp.js

@@ -0,0 +1,83 @@
+import { Scriptlet } from "./scriptlet.js";
+import { StackStore } from "../stack-store.js";
+import { Tag } from "./tag.js";
+/**
+ * Parser for JSP document
+ */
+export 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) ?? 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;
+        }
+    }
+}
+const nameRE = `[A-Za-z][A-Za-z0-9]*`;
+const stringRE = `"(?:\\\\[.]|[^\\\\"])*"|'(?:\\\\[.]|[^\\\\'])*'`;
+const insideRE = `[^"']|${stringRE}`;
+const tagRegExp = new RegExp(`(</?${nameRE}:(?:${insideRE})*?>)|(<%(?:${insideRE})*?%>)`, "s");
+export const jspToJS = (app, src, option) => {
+    const root = new Tag(app);
+    const tree = new 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(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(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);
+};

package/esm/src/parser/scriptlet.js

@@ -0,0 +1,43 @@
+const typeMap = {
+    "<%-": "comment",
+    "<%@": "directive",
+    "<%!": "declaration",
+    "<%=": "expression",
+};
+/**
+ * Parser for Directive, Declaration, Scriptlet
+ * <%-- comment --%>
+ * <%@ directive %>
+ * <%! declaration(s) %>
+ * <% scriptlet %>
+ * <%= expression %>
+ */
+export 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;
+    }
+}

package/esm/src/parser/tag.js

@@ -0,0 +1,126 @@
+import { Text } from "./text.js";
+import { Attr } from "./attr.js";
+const emptyText = {
+    '""': true,
+    "''": true,
+    "``": true,
+    "null": true,
+    "undefined": true,
+    "": true,
+};
+const isTranspiler = (v) => ("function" === typeof v?.toJS);
+/**
+ * Root node or an taglib node
+ */
+export 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 spaces = +indent ? " ".repeat(+indent) : (indent ?? "");
+        const currentLF = option?.LF ?? "\n";
+        const nextLF = currentLF + spaces;
+        const { children } = this;
+        const args = children.map(item => {
+            if (isTranspiler(item)) {
+                return item.toJS({ LF: nextLF });
+            }
+            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(app, item).toJS({ LF: nextLF });
+                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] += currentLF;
+            }
+        });
+        const bodyL = /^`\n/s.test(args.at(0)) ? "" : nextLF;
+        const bodyR = /(\n`|[)\s])$/s.test(args.at(-1)) ? "" : currentLF;
+        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(app, this.src);
+        const body = this.getBodyJS(option);
+        const spaces = +indent ? " ".repeat(+indent) : (indent ?? "");
+        const currentLF = option?.LF ?? "\n";
+        const nextLF = currentLF + spaces;
+        const tagOption = { LF: (body ? nextLF : currentLF) };
+        const type = `parse.tag.${tagName}`;
+        const def = { app, name: tagName, attr, body, LF: currentLF, nextLF };
+        const tagJS = app.process(type, def) ?? this.getTagJS(def, tagOption);
+        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 attrJS = hasVars ? `${vName} => (${attrRaw})` : attrRaw;
+        const nameJS = JSON.stringify(tagName);
+        const hasAttr = /:/.test(attrRaw);
+        const restJS = def.body ? (`, ${attrJS}, ${def.body}`) : (hasAttr ? `, ${attrJS}` : "");
+        return `${nspName}.tag(${nameJS}${restJS})`;
+    }
+}

package/{cjs/src/parse-text.js → esm/src/parser/text.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseText = void 0;
-const parse_el_js_1 = require("./parse-el.js");
-const parse_scriptlet_js_1 = require("./parse-scriptlet.js");
+import { EL } from "./el.js";
+import { Scriptlet } from "./scriptlet.js";
 /**
  * escape special characters in Template Literal
  */
@@ -19,35 +16,18 @@ const bodyRegExp = new RegExp(bodyRE, "s");
 /**
  * Parser for: text content
  */
-const parseText = (app, src) => new TextParser(app, src);
-exports.parseText = parseText;
-class TextParser {
+export class Text {
     constructor(app, src) {
         this.app = app;
-        this.src = src;
-        //
+        this.src = app.process("before.parse.text", src) ?? src;
     }
     /**
      * Transpile ${expression} and <% scriptlet %> to JavaScript source code
      */
     toJS(option) {
-        return textToJS(this.app, this.src, option);
-    }
-    /**
-     * Compile ${expression} and <% scriptlet %> 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("TextParser: " + js?.substring(0, 1000));
-            throw e;
-        }
+        const { app, src } = this;
+        const js = app.process("parse.text", src) ?? textToJS(app, src, option);
+        return app.process("after.parse.text", js) ?? js;
     }
 }
 /**
@@ -66,7 +46,7 @@ const textToJS = (app, src, option) => {
             const isAsync = /^#/s.test(value);
             value = value.replace(/^[$#]\{\s*/s, "");
             value = value.replace(/\s*}$/s, "");
-            const item = (0, parse_el_js_1.parseEL)(app, value);
+            const item = new EL(app, value);
             if (isAsync) {
                 items.push({ toJS: (option) => `await ${item.toJS(option)}` });
             }
@@ -76,7 +56,7 @@ const textToJS = (app, src, option) => {
         }
         else if (i3 === 2) {
             // <% scriptlet %>
-            const item = (0, parse_scriptlet_js_1.parseScriptlet)(app, value);
+            const item = new Scriptlet(app, value);
             items.push(item);
         }
         else {