nsp-server-pages 0.1.1 → 0.2.0

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

@@ -1,5 +1,8 @@
-import { parseEL } from "./parse-el.js";
-import { parseScriptlet } from "./parse-scriptlet.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = void 0;
+const el_js_1 = require("./el.js");
+const scriptlet_js_1 = require("./scriptlet.js");
 /**
  * escape special characters in Template Literal
  */
@@ -16,36 +19,21 @@ const bodyRegExp = new RegExp(bodyRE, "s");
 /**
  * Parser for: text content
  */
-export const parseText = (app, src) => new TextParser(app, src);
-class TextParser {
+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;
     }
 }
+exports.Text = Text;
 /**
  * Transpile ${expression}, #{async expression} and <% scriptlet %> to JavaScript source code
  */
@@ -62,7 +50,7 @@ const textToJS = (app, src, option) => {
             const isAsync = /^#/s.test(value);
             value = value.replace(/^[$#]\{\s*/s, "");
             value = value.replace(/\s*}$/s, "");
-            const item = parseEL(app, value);
+            const item = new el_js_1.EL(app, value);
             if (isAsync) {
                 items.push({ toJS: (option) => `await ${item.toJS(option)}` });
             }
@@ -72,7 +60,7 @@ const textToJS = (app, src, option) => {
         }
         else if (i3 === 2) {
             // <% scriptlet %>
-            const item = parseScriptlet(app, value);
+            const item = new scriptlet_js_1.Scriptlet(app, value);
             items.push(item);
         }
         else {

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.listeners = new Map;
+        this.hooks = new Map();
         this.options = options = Object.create(options || null);
         if (!options.vName)
             options.vName = "v";
@@ -21,12 +21,12 @@ class App {
             options.storeKey = "#nsp";
     }
     hook(type, fn) {
-        this.listeners.set(type, fn);
+        this.hooks.set(type, fn);
     }
-    process(type, arg) {
-        const fn = this.listeners.get(type);
+    process(type, ...args) {
+        const fn = this.hooks.get(type);
         if (fn)
-            return fn(arg);
+            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

@@ -1,6 +1,4 @@
-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 {
@@ -18,16 +16,19 @@ 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 handler
+            // call the error hook
             const result = app.process("error", e, context);
-            if (result != null)
-                return result;
-            return `<!--\n[ERR] ${escapeError(e)}\n-->`;
+            // if the hook returns nothing, throw the error
+            if (result == null)
+                throw e;
+            // if the hook returns a string, show it
+            return result;
         }
     };
 };

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;
+    }
+}