nsp-server-pages 0.1.2 → 0.2.0

package/esm/src/stack-store.js

@@ -0,0 +1,27 @@
+export 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;
+            }
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
 import { toXML } from "to-xml";
-export const addTagLib = (app, tagLibDef) => {
-    const { fnMap, tagMap } = app;
+export function addTagLib(tagLibDef) {
+    const { fnMap, tagMap } = this;
     const { ns, fn, tag } = tagLibDef;
     if (fn) {
         for (const name in fn) {
@@ -12,14 +12,14 @@ export const addTagLib = (app, tagLibDef) => {
             tagMap.set(`${ns}:${name}`, tag[name]);
         }
     }
-};
-export const prepareTag = (app, name, attr, body) => {
-    const { tagMap } = app;
+}
+export 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);
-};
+}
 const defaultTagFn = (tagDef) => {
     const { name } = tagDef;
     // tagDef.app.log(`Unknown tag: ${name}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nsp-server-pages",
   "description": "NSP JavaScript Server Pages for Node.js",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "author": "@kawanet",
   "bugs": {
     "url": "https://github.com/kawanet/nsp-server-pages/issues"
@@ -13,25 +13,26 @@
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^15.2.1",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^20.5.4",
+    "@types/node": "^20.5.6",
     "mocha": "^10.2.0",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   },
   "exports": {
     "import": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./types/index.d.ts",
+      "default": "./esm/index.js"
     },
     "require": "./cjs/index.js"
   },
   "files": [
-    "cjs/index.js",
+    "cjs/*.js",
     "cjs/package.json",
-    "cjs/src/*.js",
-    "index.d.ts",
-    "index.js",
-    "package.json",
-    "src/*.js"
+    "cjs/src/**/*.js",
+    "esm/*.js",
+    "esm/package.json",
+    "esm/src/**/*.js",
+    "types/*.d.ts",
+    "package.json"
   ],
   "homepage": "https://github.com/kawanet/nsp-server-pages#readme",
   "keywords": [
@@ -41,7 +42,7 @@
     "taglib"
   ],
   "license": "Apache-2.0",
-  "main": "index.js",
+  "main": "./esm/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kawanet/nsp-server-pages.git"
@@ -54,5 +55,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "types": "./index.d.ts"
+  "types": "./types/index.d.ts"
 }

package/types/hooks.d.ts

@@ -0,0 +1,103 @@
+import type {NSP} from "./index";
+
+type RuntimeErrorHookType = "error";
+
+type RuntimeScriptletHookTypes =
+    "directive"
+    | "declaration"
+    | "expression"
+    | "scriptlet";
+
+type BeforeParseHookTypes =
+    "before.parse.attr"
+    | "before.parse.comment"
+    | "before.parse.declaration"
+    | "before.parse.directive"
+    | "before.parse.el"
+    | "before.parse.expression"
+    | "before.parse.jsp"
+    | "before.parse.text";
+
+type ParseHookTypes =
+    "parse.attr"
+    | "parse.comment"
+    | "parse.declaration"
+    | "parse.directive"
+    | "parse.el"
+    | "parse.expression"
+    | "parse.jsp"
+    | "parse.text";
+
+type AfterParseHookTypes =
+    "after.parse.attr"
+    | "after.parse.comment"
+    | "after.parse.declaration"
+    | "after.parse.directive"
+    | "after.parse.el"
+    | "after.parse.expression"
+    | "after.parse.jsp"
+    | "after.parse.text";
+
+type ParseTagHookTypes = `parse.tag.${string}`;
+
+type KnownHookTypes =
+    RuntimeErrorHookType
+    | RuntimeScriptletHookTypes
+    | BeforeParseHookTypes
+    | ParseHookTypes
+    | AfterParseHookTypes
+    | ParseTagHookTypes;
+
+export interface Hooks {
+    /**
+     * ==== RUNTIME HOOKS ====
+     *
+     * hook called when an Error thrown.
+     * return a string to output the error message and cancel the exception.
+     * return undefined to stop the page with the exception.
+     */
+    hook(type: RuntimeErrorHookType, fn: (e: Error, context: any) => string | void): void;
+
+    /**
+     * hooks called with JSP directive, declaration, scriptlet on runtime.
+     */
+    hook(type: RuntimeScriptletHookTypes, fn: (src: string, context: any) => string | void): void;
+
+    /**
+     * ==== TRANSPILER HOOKS ====
+     *
+     * hooks called with input JSP document before transpiling started.
+     * return a string to modify the input.
+     * return undefined not to modify the input.
+     */
+    hook(type: BeforeParseHookTypes, fn: (src: string) => string | void): void;
+
+    /**
+     * hooks called with JSP document to replace our default transpiler.
+     * return a string if you have own transpiler for the type.
+     * return undefined for our default transpiler to work.
+     */
+    hook(type: ParseHookTypes, fn: (src: string) => string | void): void;
+
+    /**
+     * hooks called with output JavaScript code after transpiling done.
+     * return a string to modify the output.
+     * return undefined not to modify the output.
+     */
+    hook(type: AfterParseHookTypes, fn: (src: string) => string | void): void;
+
+    /**
+     * hooks called with TagParserDef to transpile tag implementation inline.
+     *
+     * @example
+     * nsp.hook("parse.tag.c:set", tag => {
+     *     return `v => { v[${tag.attr.get("var")}] = ${tag.attr.get("value")} }`;
+     * });
+     */
+    hook<A>(type: ParseTagHookTypes, fn: (tag: NSP.TagParserDef<A>) => string | void): void;
+
+    /**
+     * ==== OTHER HOOKS ====
+     */
+    hook(type: Exclude<string, KnownHookTypes>, fn: (...args: any[]) => any): void;
+}

package/{index.d.ts → types/index.d.ts}

@@ -4,9 +4,11 @@
  * @see https://github.com/kawanet/nsp-server-pages
  */
 
+import type {Hooks} from "./hooks.js";
+
 export const createNSP: (options?: NSP.Options) => NSP.App;
 
-declare namespace NSP {
+export declare namespace NSP {
     type NodeFn<T> = (context: T) => string | Promise<string>;
 
     type Node<T> = string | NodeFn<T>;
@@ -52,10 +54,10 @@ declare namespace NSP {
         storeKey?: string;
 
         /**
-         * indent size for JavaScript source generated
-         * @default 0
+         * indent spaces for JavaScript source generated
+         * @default 0 (no indent)
          */
-        indent?: number;
+        indent?: number | string;
 
         /**
          * add comments at toJS() result
@@ -74,23 +76,10 @@ declare namespace NSP {
          * @default false
          */
         nullish?: 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[];
+    interface App extends Hooks {
         options: Options;
-        tagMap: Map<string, TagFn<any>>;
 
         /**
          * register a tag library
@@ -142,27 +131,20 @@ declare namespace NSP {
         mount(path: RegExp | string, fn: LoaderFn): void;
 
         /**
-         * register a hook function
+         * register a hook function. see hooks.d.ts for detail
          */
-        hook(type: "error", fn: (e: Error, context?: any) => string | void): void;
-
-        hook(type: "directive", fn: (src: string, context?: any) => string | void): void;
-
-        hook(type: "declaration", fn: (src: string, context?: any) => string | void): void;
-
-        hook(type: "scriptlet", fn: (src: string, context?: any) => string | void): void;
 
-        hook(type: string, fn: (...args: any[]) => any): void;
+        // hook(type: string, fn: (...args: any[]) => any): void;
 
         /**
          * parse a JSP document
          */
-        parse(src: string): Parser;
+        parse(src: string): JspParser;
 
         /**
          * get a private data store in context
          */
-        store<S>(context: any, key: string, initFn?: () => S): S;
+        store<P>(context: any, key: string): StackStore<P>;
 
         /**
          * generates a NodeFn for the tag
@@ -187,22 +169,66 @@ declare namespace NSP {
         tag?: { [name: string]: TagFn<any> };
     }
 
+    interface StackStore<P> {
+        /**
+         * set value to the store
+         */
+        set(value: P): void;
+
+        /**
+         * get value from the store
+         */
+        get(): P;
+
+        /**
+         * open a new layer
+         */
+        open(value?: P): void;
+
+        /**
+         * close the current layer
+         */
+        close(): P;
+
+        /**
+         * find a value from layers with the test function
+         */
+        find(test: (data: P) => boolean): P;
+    }
+
     interface ToJSOption {
-        indent?: number;
+        LF?: string;
     }
 
-    /**
-     * Parser for JSP document
-     */
-    interface Parser {
+    interface Transpiler {
         /**
-         * transpile the JSP document to JavaScript source code
+         * transpile to JavaScript source code
          */
         toJS(option?: ToJSOption): string;
+    }
 
+    /**
+     * Parser for JSP document
+     */
+    interface JspParser extends Transpiler {
         /**
          * compile the JSP document as a NodeFn
          */
         toFn<T>(): NodeFn<T>;
     }
+
+    interface TagParserDef<A> {
+        app: App;
+        name: string;
+        attr: AttrParser<A>;
+        body: string;
+        LF: string;
+        nextLF: string;
+    }
+
+    interface AttrParser<A> extends Transpiler {
+        keys(): (keyof A)[];
+
+        get(key: keyof A): string; // JavaScript
+    }
 }

package/cjs/src/parse-attr.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAttr = void 0;
-const parse_text_js_1 = require("./parse-text.js");
-/**
- * Parser for HTML tag attributes <tagName attr="value"/>
- */
-const parseAttr = (app, src) => new AttrParser(app, src);
-exports.parseAttr = parseAttr;
-class AttrParser {
-    constructor(app, src) {
-        this.app = app;
-        this.src = src;
-        //
-    }
-    /**
-     * Transpile HTML tag attributes to JavaScript source code
-     */
-    toJS(option) {
-        return attrToJS(this.app, this.src, option);
-    }
-    /**
-     * Compile HTML tag attributes 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("AttrParser: " + js.substring(0, 1000));
-            throw e;
-        }
-    }
-}
-/**
- * Transpile HTML tag attributes to JavaScript source code
- */
-const attrToJS = (app, tag, option) => {
-    tag = tag?.replace(/^\s*<\S+\s*/s, "");
-    tag = tag?.replace(/\s*\/?>\s*$/s, "");
-    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 keys = [];
-    const index = {};
-    tag?.replace(/([^\s='"]+)(\s*=(?:\s*"([^"]*)"|\s*'([^']*)'|([^\s='"]*)))?/g, (_, key, eq, v1, v2, v3) => {
-        if (!index[key])
-            keys.push(key);
-        index[key] = (eq ? unescapeXML(v1 || v2 || v3 || "") : true);
-        return "";
-    });
-    const items = keys.map(key => {
-        let value = index[key];
-        if (!/^[A-Za-z_]\w+$/.test(key)) {
-            key = JSON.stringify(key);
-        }
-        if ("string" === typeof value) {
-            value = (0, parse_text_js_1.parseText)(app, value).toJS({ indent: nextIndent });
-        }
-        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-jsp.js

@@ -1,206 +0,0 @@
-"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, nspName, trimSpaces, vName } = 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 (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 = (0, parse_text_js_1.parseText)(app, item).toJS({ indent: nextIndent });
-                if (/\(.+?\)|\$\{.+?}/s.test(js)) {
-                    js = `${vName} => ${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 `${nspName}.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 = `${vName} => (${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}${nspName}.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 { 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");
-const jspToJS = (app, src, option) => {
-    const root = new Element(app);
-    const tree = new Tree(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 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
-            tree.append(str);
-        }
-    }
-    if (!tree.isRoot()) {
-        throw new Error("missing closing tag: " + tree.getTagName());
-    }
-    return root.toJS(option);
-};
-exports.jspToJS = jspToJS;