nsp-server-pages 0.0.1

package/cjs/src/parse-el.js

@@ -0,0 +1,104 @@
+"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: "&&",
+    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
+ */
+const parseEL = (app, src) => new ElParser(app, src);
+exports.parseEL = parseEL;
+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;
+    }
+}

package/cjs/src/parse-jsp.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jspToJS = exports.parseJSP = void 0;
+const parse_text_js_1 = require("./parse-text.js");
+const parse_attr_js_1 = require("./parse-attr.js");
+const parse_scriptlet_js_1 = require("./parse-scriptlet.js");
+const emptyText = {
+    '""': true,
+    "''": true,
+    "``": true,
+    "null": true,
+    "undefined": true,
+    "": true,
+};
+const isElement = (node) => ("function" === typeof node?.toJS);
+/**
+ * Parser for JSP document
+ */
+const parseJSP = (app, src) => new JspParser(app, src);
+exports.parseJSP = parseJSP;
+/**
+ * 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 = (0, parse_text_js_1.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 = (0, parse_attr_js_1.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 (0, exports.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");
+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 = (0, parse_scriptlet_js_1.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);
+};
+exports.jspToJS = jspToJS;

package/cjs/src/parse-scriptlet.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScriptlet = void 0;
+const parse_el_js_1 = require("./parse-el.js");
+/**
+ * Parser for Directive, Declaration, Scriptlet
+ * <%-- comment --%>
+ * <%@ directive %>
+ * <%! declaration(s) %>
+ * <% scriptlet %>
+ * <%= expression %>
+ */
+const parseScriptlet = (app, src) => new ScriptletParser(app, src);
+exports.parseScriptlet = parseScriptlet;
+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 = (0, parse_el_js_1.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/cjs/src/parse-text.js

@@ -0,0 +1,118 @@
+"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");
+/**
+ * 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
+ */
+const parseText = (app, src) => new TextParser(app, src);
+exports.parseText = parseText;
+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 = (0, parse_el_js_1.parseEL)(app, value);
+            if (isAsync) {
+                items.push({ toJS: (option) => `await ${item.toJS(option)}` });
+            }
+            else {
+                items.push(item);
+            }
+        }
+        else if (i3 === 2) {
+            // <% scriptlet %>
+            const item = (0, parse_scriptlet_js_1.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/cjs/src/taglib.js

@@ -0,0 +1,44 @@
+"use strict";
+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;
+    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]);
+        }
+    }
+};
+exports.addTagLib = addTagLib;
+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);
+};
+exports.prepareTag = prepareTag;
+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 = (0, to_xml_1.toXML)(xml);
+        if (body === null) {
+            return tag;
+        }
+        tag = tag.replace(/\/>$/, `>`);
+        return tagDef.app.concat(tag, body, `</${name}>`);
+    };
+};

package/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * nsp-server-pages
+ *
+ * @see https://github.com/kawanet/nsp-server-pages
+ */
+
+export const createNSP: (options?: NSP.Options) => NSP.App;
+
+declare namespace NSP {
+    type NodeFn<T> = (context?: T) => string | Promise<string>;
+
+    type Node<T> = string | NodeFn<T>;
+
+    type AttrFn<A, T = any> = (context?: T) => A;
+
+    type TagFn<A, T = any> = (tag: TagDef<A, T>) => NodeFn<T>;
+
+    type LoaderFn = (path: string) => Promise<NSP.NodeFn<any>>;
+
+    type TextFlex = string | Promise<string> | (string | Promise<string>)[];
+
+    interface TagDef<A, T = any> {
+        app: NSP.App;
+        conf: any;
+        name: string;
+        attr: AttrFn<A, T>;
+        body: NodeFn<T>;
+    }
+
+    interface Options {
+        logger?: { log: (message: string) => void };
+
+        /**
+         * tag configuration
+         */
+        conf?: { [tagName: string]: any };
+
+        /**
+         * variable name for context
+         */
+        vKey?: string;
+
+        /**
+         * variable name for NSP.App instance
+         */
+        nspKey?: string;
+
+        /**
+         * indent size for JavaScript source generated
+         */
+        indent?: number;
+
+        /**
+         * add comments at toJS() result
+         */
+        comment?: boolean;
+
+        /**
+         * remove edge spaces in HTML in some cases
+         */
+        trimSpaces?: boolean;
+
+        /**
+         * expression filter before transpile starts
+         */
+        prefilter?: (src: string) => string;
+
+        /**
+         * expression filter after transpile done
+         */
+        postfilter?: (src: string) => string;
+    }
+
+    interface App {
+        fnMap: Map<string, (...args: any[]) => any>;
+        loaders: LoaderFn[];
+        options: Options;
+        tagMap: Map<string, TagFn<any>>;
+
+        addTagLib(tagLibDef: TagLibDef): void;
+
+        bundle<T>(...node: Node<T>[]): NodeFn<T>;
+
+        concat(...text: TextFlex[]): string | Promise<string>;
+
+        emit<T>(type: "error", e: Error, context?: T): string;
+
+        emit<T>(type: "directive", src: string, context?: T): string;
+
+        emit<T>(type: "declaration", src: string, context?: T): string;
+
+        emit<T>(type: "scriptlet", src: string, context?: T): string;
+
+        fn(name: string): (...args: any[]) => any;
+
+        load<T>(path: string): Promise<NSP.NodeFn<T>>;
+
+        loadFile<T>(file: string): Promise<NSP.NodeFn<T>>;
+
+        loadJS<T>(file: string): Promise<NSP.NodeFn<T>>;
+
+        loadJSP<T>(file: string): Promise<NSP.NodeFn<T>>;
+
+        log(message: string): void;
+
+        mount(match: RegExp | string, fn: LoaderFn): void;
+
+        on(type: "error", fn: <T>(e: Error, context?: T) => string | void): void;
+
+        on(type: "directive", fn: <T>(src: string, context?: T) => string | void): void;
+
+        on(type: "declaration", fn: <T>(src: string, context?: T) => string | void): void;
+
+        on(type: "scriptlet", fn: <T>(src: string, context?: T) => string | void): void;
+
+        parse(src: string): Parser;
+
+        tag<A, T = any>(name: string, attr?: A | AttrFn<A, T>, ...body: Node<T>[]): NodeFn<T>;
+    }
+
+    interface TagLibDef {
+        ns: string;
+
+        fn?: { [name: string]: (...args: any[]) => any };
+
+        tag?: { [name: string]: TagFn<any> };
+    }
+
+    interface ToJSOption {
+        indent?: number;
+    }
+
+    /**
+     * Parser for JSP document
+     */
+    interface Parser {
+        toJS(option?: ToJSOption): string;
+
+        toFn<T>(): NodeFn<T>;
+    }
+}

package/index.js

@@ -0,0 +1 @@
+export {createNSP} from "./src/app.js";