Merge pull request #8 from kawanet/0.2.2

0.2.2

package.json

@@ -1,7 +1,7 @@
 {
   "name": "nsp-server-pages",
   "description": "NSP JavaScript Server Pages for Node.js",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "author": "@kawanet",
   "bugs": {
     "url": "https://github.com/kawanet/nsp-server-pages/issues"

src/app.ts

@@ -1,13 +1,12 @@
 import type {NSP} from "../index.js";
-
-import {load, mount} from "./mount.js";
+import {bundle} from "./bundle.js";
+import {catchFn} from "./catch.js";
+import {concat} from "./concat.js";
 import {FileLoader, JsLoader, JspLoader} from "./loaders.js";
+import {load, mount} from "./mount.js";
 import {JSP} from "./parser/jsp.js";
-import {catchFn} from "./catch.js";
-import {bundle} from "./bundle.js";
+import {Store} from "./store.js";
 import {addTagLib, prepareTag} from "./taglib.js";
-import {concat} from "./concat.js";
-import {StackStore} from "./stack-store.js";
 
 export class App implements NSP.App {
     protected loaders: NSP.LoaderFn[] = [];
@@ -93,17 +92,17 @@ export class App implements NSP.App {
         return loader.load<T>(file);
     }
 
-    store<P>(context: any, key: string): StackStore<P> {
+    store<P>(context: any, key: string): NSP.StackStore<P> {
         if ("object" !== typeof context && context == null) {
             throw new Error("Context must be an object");
         }
 
         const {storeKey} = this.options;
-        const map = (context[storeKey] ??= new Map()) as Map<string, StackStore<any>>;
+        const map = (context[storeKey] ??= new Map()) as Map<string, Store<any>>;
 
-        let value: StackStore<P> = map.get(key);
+        let value: Store<P> = map.get(key);
         if (value == null) {
-            value = new StackStore<P>();
+            value = new Store<P>();
             map.set(key, value);
         }
         return value;

src/parser/jsp.ts

@@ -1,6 +1,6 @@
 import type {NSP} from "../../index.js";
+import {Store} from "../store.js";
 import {Scriptlet} from "./scriptlet.js";
-import {StackStore} from "../stack-store.js";
 import {Tag} from "./tag.js";
 
 /**
@@ -48,7 +48,7 @@ const tagRegExp = new RegExp(`(</?${nameRE}:(?:${insideRE})*?>)|(<%(?:${insideRE
 
 export const jspToJS = (app: NSP.App, src: string, option: NSP.ToJSOption): string => {
     const root = new Tag(app);
-    const tree = new StackStore<Tag>(root);
+    const tree = new Store<Tag>(root);
     const array = src.split(tagRegExp);
 
     for (let i = 0; i < array.length; i++) {

src/store.ts

@@ -0,0 +1,47 @@
+import type {NSP} from "../types/index.js";
+
+/**
+ * The Store class was implemented using a stack {stack: P[]} at first.
+ * Now it was changed to a linked list to allow access to the parent.
+ */
+export class Store<P> implements NSP.StackStore<P> {
+    item: Item<P>;
+
+    constructor(value?: P) {
+        this.item = {value} as Item<P>;
+    }
+
+    open(value?: P): void {
+        this.item = {parent: this.item, value};
+    }
+
+    close(): P {
+        const item = this.item;
+        this.item = item.parent;
+        return item.value;
+    }
+
+    get(): P {
+        return this.item.value;
+    }
+
+    set(value: P): void {
+        this.item.value = value;
+    }
+
+    find(test: (data: P) => boolean): P {
+        let item = this.item;
+
+        while (item) {
+            if (test(item.value)) {
+                return item.value;
+            }
+            item = item.parent;
+        }
+    }
+}
+
+interface Item<P> {
+    parent: Item<P>;
+    value: P;
+}

src/taglib.ts

@@ -3,19 +3,45 @@ import {toXML} from "to-xml";
 import type {NSP} from "../index.js";
 import type {App} from "./app.js";
 
+const isTagCon = (v: any): v is NSP.TagCon<any> => ("function" === typeof (v as NSP.TagCon<any>)?.prototype?.render);
+
+const tagConToTagFn = <A, T>(Tag: NSP.TagCon<A, T>): NSP.TagFn<A, T> => {
+    return (tag) => {
+        return (context) => {
+            const result = new Tag(tag, context).render();
+            if (result) return result as (string | Promise<string>);
+        };
+    };
+};
+
 export function addTagLib(this: App, tagLibDef: NSP.TagLibDef): void {
     const {fnMap, tagMap} = this;
     const {ns, fn, tag} = tagLibDef;
 
     if (fn) {
         for (const name in fn) {
-            fnMap.set(`${ns}:${name}`, fn[name]);
+            const impl = fn[name];
+            if (typeof impl === "function") {
+                // FnFn is called with App instance as this
+                fnMap.set(`${ns}:${name}`, impl.bind(this));
+            } else if (impl != null) {
+                throw new Error(`Invalid taglib implementation: \${${ns}:${name}()}`);
+            }
         }
     }
 
     if (tag) {
         for (const name in tag) {
-            tagMap.set(`${ns}:${name}`, tag[name]);
+            const impl = tag[name];
+            if (isTagCon(impl)) {
+                // NSP.TagCon
+                tagMap.set(`${ns}:${name}`, tagConToTagFn(impl));
+            } else if (typeof impl === "function") {
+                // NSP.TagFn
+                tagMap.set(`${ns}:${name}`, impl);
+            } else if (impl != null) {
+                throw new Error(`Invalid taglib implementation: <${ns}:${name}>`);
+            }
         }
     }
 }

test/300.function.ts

@@ -63,4 +63,8 @@ describe(TITLE, () => {
 
         assert.equal(nsp.parse('[${test:upper(bar)}]').toFn()(context), "[BAR]");
     });
+
+    it("throws", () => {
+        assert.throws(() => nsp.addTagLib({ns: "test", fn: {invalid: [] as any}}));
+    });
 });

test/310.tag.ts

@@ -70,4 +70,35 @@ describe(TITLE, () => {
         assert.equal(await nsp.parse(`<test:na>FOO</test:na>`).toFn()(ctx), `<test:na>FOO</test:na>`);
         assert.equal(await nsp.parse(`<test:na><test:na/></test:na>`).toFn()(ctx), `<test:na><test:na/></test:na>`);
     });
+
+    it("throws", () => {
+        assert.throws(() => nsp.addTagLib({ns: "test", tag: {invalid: [] as any}}));
+    });
+
+    it("VoidFn", async () => {
+        nsp.addTagLib({
+            ns: "void",
+            tag: {
+                syncFn: (_) => (_): void => {
+                    // void
+                },
+                asyncFn: (_) => async (_) => {
+                    // Promise<void>
+                },
+                syncClass: class {
+                    render() {
+                        // void
+                    }
+                },
+                asyncClass: class {
+                    async render() {
+                        // Promise<void>
+                    }
+                },
+            },
+        });
+
+        const src: string = `[<void:syncFn/>][<void:asyncFn/>][<void:syncClass/>][<void:asyncClass/>]`;
+        assert.equal(await nsp.parse(src).toFn()(ctx), `[][][][]`);
+    });
 });

test/350.tag-class.ts

@@ -0,0 +1,51 @@
+import {strict as assert} from "assert";
+import {createNSP, NSP} from "../index.js";
+
+const TITLE = "350.tag-class.ts";
+
+interface TagAttr {
+    //
+}
+
+describe(TITLE, () => {
+    const nsp = createNSP();
+    const ctx = {};
+
+    class BodyTag implements NSP.TagClass {
+        constructor(private tag: NSP.TagDef<TagAttr>, private context: any) {
+            //
+        }
+
+        async render() {
+            const body = await this.tag.body(this.context);
+            return (body == null) ? "null" : (body === "") ? "empty" : ("string" === typeof body) ? body : typeof body;
+        }
+    }
+
+    nsp.addTagLib({ns: "test", tag: {body: BodyTag}});
+
+    it("empty tag", async () => {
+        assert.equal(await nsp.parse(`[<test:body/>]`).toFn()(ctx), "[null]");
+    });
+
+    it("empty body", async () => {
+        assert.equal(await nsp.parse(`[<test:body></test:body>]`).toFn()(ctx), "[empty]");
+    });
+
+    it("string body", async () => {
+        assert.equal(await nsp.parse(`[<test:body>FOO</test:body>]`).toFn()(ctx), "[FOO]");
+    });
+
+    it("nested", async () => {
+        assert.equal(await nsp.parse(`[<test:body><test:body/></test:body>]`).toFn()(ctx), "[null]");
+        assert.equal(await nsp.parse(`[<test:body><test:body></test:body></test:body>]`).toFn()(ctx), "[empty]");
+        assert.equal(await nsp.parse(`[<test:body><test:body>FOO</test:body></test:body>]`).toFn()(ctx), "[FOO]");
+    });
+
+    it("unregistered tag", async () => {
+        assert.equal(await nsp.parse(`<test:na/>`).toFn()(ctx), `<test:na/>`);
+        assert.equal(await nsp.parse(`<test:na></test:na>`).toFn()(ctx), `<test:na></test:na>`);
+        assert.equal(await nsp.parse(`<test:na>FOO</test:na>`).toFn()(ctx), `<test:na>FOO</test:na>`);
+        assert.equal(await nsp.parse(`<test:na><test:na/></test:na>`).toFn()(ctx), `<test:na><test:na/></test:na>`);
+    });
+});

test/360.function-this.ts

@@ -0,0 +1,30 @@
+import {strict as assert} from "assert";
+import {createNSP, NSP} from "../index.js";
+
+const TITLE = "360.function-this.ts";
+
+describe(TITLE, () => {
+    const nsp = createNSP();
+    const ctx = {};
+
+    nsp.addTagLib({
+        ns: "test",
+        fn: {thisIsApp, thisIsNull}
+    });
+
+    function thisIsApp(this: NSP.App) {
+        return this instanceof nsp.constructor;
+    }
+
+    function thisIsNull(this: NSP.App) {
+        return this == null;
+    }
+
+    it("test:thisIsApp()", async () => {
+        assert.equal(nsp.parse('[${test:thisIsApp()}]').toFn()(ctx), "[true]");
+    });
+
+    it("test:thisIsNull()", async () => {
+        assert.equal(nsp.parse('[${test:thisIsNull()}]').toFn()(ctx), "[false]");
+    });
+});

types/index.d.ts

@@ -19,6 +19,8 @@ export declare namespace NSP {
 
     type TagFn<A, T = any> = (tag: TagDef<A, T>) => (NodeFn<T> | VoidFn<T>);
 
+    type TagCon<A, T = any> = { new(tag: NSP.TagDef<A>, context: T): TagClass };
+
     type LoaderFn = (path: string) => Promise<NodeFn<any> | undefined>;
 
     type Strings = string | Promise<string> | Strings[];
@@ -166,7 +168,11 @@ export declare namespace NSP {
         /**
          * tags
          */
-        tag?: { [name: string]: TagFn<any> };
+        tag?: { [name: string]: TagFn<any> | TagCon<any> };
+    }
+
+    interface TagClass {
+        render(): string | Promise<string> | void | Promise<void>;
     }
 
     interface StackStore<P> {