nsp-server-pages 0.0.1

package/src/parse-jsp.js

@@ -0,0 +1,202 @@
+import { parseText } from "./parse-text.js";
+import { parseAttr } from "./parse-attr.js";
+import { parseScriptlet } from "./parse-scriptlet.js";
+const emptyText = {
+    '""': true,
+    "''": true,
+    "``": true,
+    "null": true,
+    "undefined": true,
+    "": true,
+};
+const isElement = (node) => ("function" === typeof node?.toJS);
+/**
+ * Parser for JSP document
+ */
+export const parseJSP = (app, src) => new JspParser(app, src);
+/**
+ * Root element or an taglib element
+ */
+class Element {
+    constructor(app, tagName, tagLine) {
+        this.app = app;
+        this.tagName = tagName;
+        this.tagLine = tagLine;
+        this.children = [];
+        //
+    }
+    append(node) {
+        this.children.push(node);
+    }
+    /**
+     * Transpile JSP document to JavaScript source code
+     */
+    toJS(option) {
+        const { app, tagLine } = this;
+        const { comment, nspKey, vKey } = app.options;
+        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 { children } = this;
+        const args = children.map(item => {
+            if (isElement(item)) {
+                return item.toJS({ indent: nextIndent });
+            }
+            else if (!/\S/.test(item)) {
+                // item with only whitespace
+                return '""';
+            }
+            else {
+                let js = parseText(app, item).toJS({ indent: nextIndent });
+                if (/\(.+?\)|\$\{.+?}/s.test(js)) {
+                    js = `${vKey} => ${js}`; // array function
+                }
+                return js;
+            }
+        }).filter(v => !emptyText[v]);
+        const hasBody = !!children.length;
+        // keep at least single empty string if all arguments are empty strings
+        if (hasBody && !args.length) {
+            args.push('""');
+        }
+        const { tagName } = this;
+        const isRoot = !tagName;
+        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;
+            }
+        });
+        let body = args.join(nextLF);
+        const bodyL = /^`\n/s.test(body) ? (isRoot ? "" : " ") : nextLF;
+        const bodyR = /(\n`|[)\s])$/s.test(body) ? "" : currentLF;
+        if (isRoot) {
+            return `${nspKey}.bundle(${bodyL}${body}${bodyR})`; // root element
+        }
+        // attributes as the second argument
+        let attr = parseAttr(app, tagLine).toJS({ indent: args.length ? nextIndent : currentIndent });
+        if (/\(.+?\)|\$\{.+?}/s.test(attr)) {
+            attr = `${vKey} => (${attr})`; // array function
+        }
+        const commentV = comment ? `// ${tagLine?.replace(/\s*[\r\n]\s*/g, " ") ?? ""}${currentLF}` : "";
+        const nameV = JSON.stringify(tagName);
+        const hasAttr = /:/.test(attr);
+        const attrV = (hasBody || hasAttr) ? `, ${attr}` : "";
+        const bodyV = hasBody ? `,${bodyL}${body}${bodyR}` : "";
+        return `${commentV}${nspKey}.tag(${nameV}${attrV}${bodyV})`;
+    }
+}
+/**
+ * Tree of elements
+ */
+class Tree {
+    constructor(root) {
+        this.root = root;
+        this.tree = [];
+        this.tree.push(root);
+    }
+    append(node) {
+        this.tree.at(0).append(node);
+    }
+    open(node) {
+        this.append(node);
+        this.tree.unshift(node);
+    }
+    close(tagName) {
+        const openTag = this.getTagName();
+        if (openTag !== tagName) {
+            throw new Error(`mismatch closing tag: ${openTag} !== ${tagName}`);
+        }
+        this.tree.shift();
+    }
+    getTagName() {
+        return this.tree.at(0).tagName;
+    }
+    isRoot() {
+        return this.tree.length === 1;
+    }
+}
+class JspParser {
+    constructor(app, src) {
+        this.app = app;
+        this.src = src;
+        //
+    }
+    /**
+     * Transpile JSP document to JavaScript source code
+     */
+    toJS(option) {
+        const { app, src } = this;
+        return jspToJS(app, src, option);
+    }
+    /**
+     * Compile JSP document to JavaScript function
+     */
+    toFn() {
+        const { app } = this;
+        const { nspKey } = app.options;
+        const js = this.toJS();
+        try {
+            const fn = Function(nspKey, `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 Element(app);
+    const tree = new Tree(root);
+    const { trimSpaces } = app.options;
+    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 tagName = str.match(/^<\/?([^\s=/>]+)/)?.[1];
+            if (/^<\//.test(str)) {
+                tree.close(tagName);
+                continue;
+            }
+            const element = new Element(app, tagName, str);
+            if (/\/\s*>$/.test(str)) {
+                tree.append(element);
+            }
+            else {
+                tree.open(element);
+            }
+        }
+        else if (i3 === 2 && str) {
+            // <% scriptlet %>
+            const item = parseScriptlet(app, str);
+            tree.append(item);
+        }
+        else if (i3 === 0) {
+            // text node
+            if (trimSpaces !== false) {
+                str = str.replace(/^\s*[\r\n]/s, "\n");
+                str = str.replace(/\s*[\r\n]\s*$/s, "\n");
+                str = str.replace(/^[ \t]+/s, " ");
+                str = str.replace(/[ \t]+$/s, " ");
+            }
+            tree.append(str);
+        }
+    }
+    if (!tree.isRoot()) {
+        throw new Error("missing closing tag: " + tree.getTagName());
+    }
+    return root.toJS(option);
+};

package/src/parse-scriptlet.js

@@ -0,0 +1,65 @@
+import { parseEL } from "./parse-el.js";
+/**
+ * Parser for Directive, Declaration, Scriptlet
+ * <%-- comment --%>
+ * <%@ directive %>
+ * <%! declaration(s) %>
+ * <% scriptlet %>
+ * <%= expression %>
+ */
+export const parseScriptlet = (app, src) => new ScriptletParser(app, src);
+const typeMap = {
+    "<%-": "comment",
+    "<%@": "directive",
+    "<%!": "declaration",
+    "<%=": "expression",
+};
+class ScriptletParser {
+    constructor(app, src) {
+        this.app = app;
+        this.src = src;
+        //
+    }
+    /**
+     * Compile <% scriptlet %> to JavaScript function instance
+     */
+    toFn() {
+        const { app } = this;
+        const { nspKey } = app.options;
+        const js = this.toJS();
+        const isComment = /^\/\/[^\n]*$/s.test(js);
+        if (isComment)
+            return () => null;
+        try {
+            const fn = Function(nspKey, `return ${js}`);
+            return fn(app);
+        }
+        catch (e) {
+            app.log("ScriptletParser: " + js?.substring(0, 1000));
+            throw e;
+        }
+    }
+    /**
+     * Transpile <% scriptlet %> to JavaScript source code
+     */
+    toJS(option) {
+        const { app } = this;
+        const { nspKey, vKey } = app.options;
+        let { src } = this;
+        const type = typeMap[src.substring(0, 3)] || "scriptlet";
+        if (type === "comment") {
+            src = src.replace(/\s\s+/sg, " ");
+            return `// ${src}`;
+        }
+        if (type === "expression") {
+            src = src.replace(/^<%=\s*/s, "");
+            src = src.replace(/\s*%>$/s, "");
+            src = parseEL(app, src).toJS(option);
+            return `${vKey} => (${src})`;
+        }
+        app.log(`${type} found: ${src?.substring(0, 1000)}`);
+        src = /`|\$\{/.test(src) ? JSON.stringify(src) : "`" + src + "`";
+        src = `${vKey} => ${nspKey}.emit("${type}", ${src}, ${vKey})`;
+        return src;
+    }
+}

package/src/parse-text.js

@@ -0,0 +1,114 @@
+import { parseEL } from "./parse-el.js";
+import { parseScriptlet } from "./parse-scriptlet.js";
+/**
+ * escape special characters in Template Literal
+ */
+const escapeTL = (str) => str.replace(/([\\`$])/g, "\\$1");
+const TLStringify = (str) => ("`" + escapeTL(str) + "`");
+const stringify = (str) => (/[\r\n"<>]/.test(str) ? TLStringify(str) : JSON.stringify(str));
+/**
+ * Regular expression to match ${expression} in text
+ */
+const stringRE = `"(?:\\\\[.]|[^\\\\"])*"|'(?:\\\\[.]|[^\\\\'])*'`;
+const insideRE = `[^"']|${stringRE}`;
+const bodyRE = `([$#][{](?:${insideRE})*?})|(<%=(?:${insideRE})*?%>)`;
+const bodyRegExp = new RegExp(bodyRE, "s");
+/**
+ * Parser for: text content
+ */
+export const parseText = (app, src) => new TextParser(app, src);
+class TextParser {
+    constructor(app, src) {
+        this.app = app;
+        this.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 { 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("TextParser: " + js?.substring(0, 1000));
+            throw e;
+        }
+    }
+}
+/**
+ * Transpile ${expression}, #{async expression} and <% scriptlet %> to JavaScript source code
+ */
+const textToJS = (app, src, option) => {
+    const array = src.split(bodyRegExp);
+    const items = [];
+    for (let i = 0; i < array.length; i++) {
+        const i3 = i % 3;
+        let value = array[i];
+        if (!value)
+            continue;
+        if (i3 === 1) {
+            // ${expression}, #{async expression}
+            const isAsync = /^#/s.test(value);
+            value = value.replace(/^[$#]\{\s*/s, "");
+            value = value.replace(/\s*}$/s, "");
+            const item = parseEL(app, value);
+            if (isAsync) {
+                items.push({ toJS: (option) => `await ${item.toJS(option)}` });
+            }
+            else {
+                items.push(item);
+            }
+        }
+        else if (i3 === 2) {
+            // <% scriptlet %>
+            const item = parseScriptlet(app, value);
+            items.push(item);
+        }
+        else {
+            // text literal
+            items.push(value);
+        }
+    }
+    // empty string
+    if (!items.length)
+        return '""';
+    // single element
+    if (items.length === 1) {
+        const item = items[0];
+        if (typeof item === "string") {
+            return stringify(item);
+        }
+        else {
+            return "(" + item.toJS(option) + ")";
+        }
+    }
+    let hasAwait = false;
+    items.forEach((item, i) => {
+        if (typeof item === "string") {
+            items[i] = escapeTL(item);
+        }
+        else {
+            const js = item.toJS(option);
+            if (/^\(?await\s/.test(js))
+                hasAwait = true;
+            items[i] = "${" + js + "}";
+        }
+    });
+    let out = "`" + items.join("") + "`";
+    // wrap in async function if it has an await
+    if (hasAwait) {
+        out = `(async () => (${out}))()`;
+    }
+    return out;
+};

package/src/taglib.js

@@ -0,0 +1,39 @@
+import { toXML } from "to-xml";
+export const addTagLib = (app, tagLibDef) => {
+    const { fnMap, tagMap } = app;
+    const { ns, fn, tag } = tagLibDef;
+    if (fn) {
+        for (const name in fn) {
+            fnMap.set(`${ns}:${name}`, fn[name]);
+        }
+    }
+    if (tag) {
+        for (const name in tag) {
+            tagMap.set(`${ns}:${name}`, tag[name]);
+        }
+    }
+};
+export const prepareTag = (app, name, attr, body) => {
+    const { tagMap, options } = app;
+    const tagFn = tagMap.get(name) || defaultTagFn;
+    const conf = options.conf[name];
+    const attrFn = !attr ? () => ({}) : (typeof attr !== "function") ? () => attr : attr;
+    const tagDef = { name, app, conf, attr: attrFn, body };
+    return tagFn(tagDef);
+};
+const defaultTagFn = (tagDef) => {
+    const { name } = tagDef;
+    // tagDef.app.log(`Unknown tag: ${name}`);
+    return (context) => {
+        const attr = tagDef.attr(context);
+        const body = tagDef.body(context);
+        const xml = {};
+        xml[name] = { "@": attr };
+        let tag = toXML(xml);
+        if (body === null) {
+            return tag;
+        }
+        tag = tag.replace(/\/>$/, `>`);
+        return tagDef.app.concat(tag, body, `</${name}>`);
+    };
+};