nsp-server-pages 0.1.1 → 0.2.0

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 {

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.1",
+  "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
@@ -110,13 +99,7 @@ declare namespace NSP {
         /**
          * retrieve a result from hook function
          */
-        process<T>(type: "error", e: Error, context: T): string;
-
-        process<T>(type: "directive", src: string, context: T): string;
-
-        process<T>(type: "declaration", src: string, context: T): string;
-
-        process<T>(type: "scriptlet", src: string, context: T): string;
+        process<R>(type: string, ...args: any[]): R;
 
         /**
          * pickup the taglib function
@@ -148,25 +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: <T>(e: Error, context?: T) => string | void): void;
-
-        hook(type: "directive", fn: <T>(src: string, context?: T) => string | void): void;
 
-        hook(type: "declaration", fn: <T>(src: string, context?: T) => string | void): void;
-
-        hook(type: "scriptlet", fn: <T>(src: string, context?: T) => string | void): 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
@@ -191,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;
-    });
-};