@funcstache/stache-stream 0.2.2 → 0.2.3

package/src/lib/template/Template-section.spec.ts

@@ -0,0 +1,142 @@
+import { TextDecoderStream } from "node:stream/web";
+import { Template } from "./Template";
+import { createReadableStream } from "../test/streams";
+import type { ContextTypes } from "../../types";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(process.env as any).LOG_LEVEL = "debug";
+
+describe("Template sections", () => {
+  async function render(
+    template: string,
+    context: ContextTypes
+  ): Promise<string[]> {
+    return new Promise<string[]>((resolve) => {
+      const calls: string[] = [];
+      new Template({
+        contextProvider: { context },
+        readable: createReadableStream(template).pipeThrough(
+          new TextDecoderStream()
+        ),
+        writeToOutput: async (text) => {
+          calls.push(text);
+        },
+      })
+        .on("inactive", () => resolve(calls))
+        .read();
+    });
+  }
+
+  it("renders when context is true", async () => {
+    expect(await render("{{#s}}text{{/s}}", { s: true })).toEqual(["text"]);
+  });
+
+  it("renders nothing when context is false", async () => {
+    expect(await render("{{#s}}text{{/s}}", { s: false })).toEqual([]);
+  });
+
+  it("renders nothing when context is empty list", async () => {
+    expect(await render("{{#s}}text{{/s}}", { s: [] })).toEqual([]);
+  });
+
+  it("renders with object context", async () => {
+    expect(
+      await render("{{#s}}{{name}}{{/s}}", { s: { name: "Alice" } })
+    ).toEqual(["Alice"]);
+  });
+
+  it("renders once per item in a list", async () => {
+    expect(
+      await render("{{#s}}{{name}}{{/s}}", {
+        s: [{ name: "Alice" }, { name: "Bob" }],
+      })
+    ).toEqual(["Alice", "Bob"]);
+  });
+
+  it("renders implicit iterator per item in a list", async () => {
+    expect(await render("{{#s}}{{.}}{{/s}}", { s: ["a", "b"] })).toEqual([
+      "a",
+      "b",
+    ]);
+  });
+
+  it("renders using a lambda", async () => {
+    expect(
+      await render("{{#s}}text{{/s}}", {
+        s: (content: string) => `<em>${content}</em>`,
+      })
+    ).toEqual(["<em>text</em>"]);
+  });
+
+  it("renders nested sections", async () => {
+    expect(
+      await render("{{#outer}}{{#inner}}text{{/inner}}{{/outer}}", {
+        outer: { inner: true },
+      })
+    ).toEqual(["text"]);
+  });
+
+  it("falls back to parent context for missing keys", async () => {
+    expect(
+      await render("{{#s}}{{name}}{{/s}}", { s: true, name: "Alice" })
+    ).toEqual(["Alice"]);
+  });
+
+  it("flushes pending whitespace before section tag", async () => {
+    expect(await render("  {{#s}}text{{/s}}", { s: true })).toEqual([
+      "  ",
+      "text",
+    ]);
+  });
+
+  it("renders surrounding text with nested sections", async () => {
+    expect(
+      await render(
+        "a {{#outer}} L {{#inner}}text{{/inner}} N {{/outer}} z",
+        { outer: { inner: true } }
+      )
+    ).toEqual(["a ", " L ", "text", " N ", " z"]);
+  });
+
+  describe("standalone suppression", () => {
+    it("suppresses standalone section tag lines", async () => {
+      expect((await render("{{#s}}\nbody\n{{/s}}\n", { s: true })).join("")).toBe("body\n");
+    });
+
+    it("suppresses standalone section tag lines when context is false", async () => {
+      expect((await render("{{#s}}\nbody\n{{/s}}\n", { s: false })).join("")).toBe("");
+    });
+
+    it("suppresses standalone section in middle of content", async () => {
+      expect((await render("before\n{{#s}}\nbody\n{{/s}}\nafter", { s: true })).join("")).toBe("before\nbody\nafter");
+    });
+
+    it("suppresses standalone section in middle of content when context is false", async () => {
+      expect((await render("before\n{{#s}}\nbody\n{{/s}}\nafter", { s: false })).join("")).toBe("before\nafter");
+    });
+
+    it("suppresses leading whitespace on a standalone section tag line", async () => {
+      expect((await render("  {{#s}}\nbody\n{{/s}}\nafter", { s: true })).join("")).toBe("body\nafter");
+    });
+
+    it("suppresses standalone section tag lines with leading whitespace when context is false", async () => {
+      expect((await render("  {{#s}}\nbody\n{{/s}}\nafter", { s: false })).join("")).toBe("after");
+    });
+
+    it("flushes pending whitespace for a non-standalone section tag", async () => {
+      expect((await render("  {{#s}}text{{/s}}\n", { s: true })).join("")).toBe("  text\n");
+    });
+
+    it("does not suppress when content precedes the opening tag", async () => {
+      expect((await render("a {{#s}}body{{/s}}\nz", { s: true })).join("")).toBe("a body\nz");
+    });
+
+    it("suppresses standalone nested section tag lines", async () => {
+      expect((await render("{{#a}}\n{{#b}}\nbody\n{{/b}}\n{{/a}}\n", { a: true, b: true })).join("")).toBe("body\n");
+    });
+
+    it("suppresses standalone section containing a standalone comment", async () => {
+      expect((await render("{{#s}}\n{{! comment }}\n{{/s}}", { s: true })).join("")).toBe("");
+    });
+  });
+});

package/src/lib/template/Template.spec.ts

@@ -0,0 +1,178 @@
+import { TextDecoderStream } from "node:stream/web";
+import { Template } from "./Template";
+import { createReadableStream } from "../test/streams";
+import type { ContextTypes } from "../../types";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(process.env as any).LOG_LEVEL = "debug";
+
+describe("Template", () => {
+  it("writes text", async () => {
+    let resolve: () => void;
+    const mockWriteToOutput = vitest.fn();
+    new Template({
+      readable: createReadableStream("hello").pipeThrough(
+        new TextDecoderStream()
+      ),
+      writeToOutput: mockWriteToOutput,
+    })
+      .on("inactive", () => resolve())
+      .read();
+
+    await new Promise<void>((res) => {
+      resolve = res;
+    });
+
+    expect(mockWriteToOutput).toHaveBeenCalledTimes(1);
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(1, "hello");
+  });
+
+  it("processes a simple template", async () => {
+    let resolve: () => void;
+    const mockWriteToOutput = vitest.fn();
+    new Template({
+      contextProvider: { context: { m: "HELLO WORLD" } },
+      readable: createReadableStream("ab{{m}}yz").pipeThrough(
+        new TextDecoderStream()
+      ),
+      writeToOutput: mockWriteToOutput,
+    })
+      .on("inactive", () => resolve())
+      .read();
+
+    await new Promise<void>((res) => {
+      resolve = res;
+    });
+
+    expect(mockWriteToOutput).toHaveBeenCalledTimes(3);
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(1, "ab");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(2, "HELLO WORLD");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(3, "yz");
+  });
+
+  it("flushes pending whitespace before variable tag", async () => {
+    let resolve: () => void;
+    const mockWriteToOutput = vitest.fn();
+    new Template({
+      contextProvider: { context: { name: "Alice" } },
+      readable: createReadableStream("  {{name}}").pipeThrough(
+        new TextDecoderStream()
+      ),
+      writeToOutput: mockWriteToOutput,
+    })
+      .on("inactive", () => resolve())
+      .read();
+
+    await new Promise<void>((res) => {
+      resolve = res;
+    });
+
+    expect(mockWriteToOutput).toHaveBeenCalledTimes(2);
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(1, "  ");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(2, "Alice");
+  });
+
+  describe("implicit iterator", () => {
+    async function render(
+      template: string,
+      context: ContextTypes
+    ): Promise<string[]> {
+      return new Promise<string[]>((resolve) => {
+        const calls: string[] = [];
+        new Template({
+          contextProvider: { context },
+          readable: createReadableStream(template).pipeThrough(
+            new TextDecoderStream()
+          ),
+          writeToOutput: async (text) => {
+            calls.push(text);
+          },
+        })
+          .on("inactive", () => resolve(calls))
+          .read();
+      });
+    }
+
+    it("renders a string context", async () => {
+      expect(await render("{{.}}", "hello")).toEqual(["hello"]);
+    });
+
+    it("renders a number context", async () => {
+      expect(await render("{{.}}", 42)).toEqual(["42"]);
+    });
+
+    it("HTML-escapes the context value", async () => {
+      expect(await render("{{.}}", '& " < >')).toEqual([
+        "&amp; &quot; &lt; &gt;",
+      ]);
+    });
+
+    it("renders surrounding text alongside the implicit value", async () => {
+      expect(await render("Hello, {{.}}!", "world")).toEqual([
+        "Hello, ",
+        "world",
+        "!",
+      ]);
+    });
+
+    it("produces no output when context is an object", async () => {
+      expect(await render("{{.}}", { name: "rich" })).toEqual([]);
+    });
+
+    it("flushes pending whitespace before implicit tag", async () => {
+      expect(await render("  {{.}}", "hello")).toEqual(["  ", "hello"]);
+    });
+
+    it("triple-brace {{{.}}} outputs without HTML escaping", async () => {
+      expect(await render("{{{.}}}", '& " < >')).toEqual(['& " < >']);
+    });
+
+    it("ampersand {{&.}} outputs without HTML escaping", async () => {
+      expect(await render("{{&.}}", '& " < >')).toEqual(['& " < >']);
+    });
+  });
+
+  it("flushes trailing whitespace at end of template", async () => {
+    let resolve: () => void;
+    const mockWriteToOutput = vitest.fn();
+    new Template({
+      readable: createReadableStream("hello\n  ").pipeThrough(
+        new TextDecoderStream()
+      ),
+      writeToOutput: mockWriteToOutput,
+    })
+      .on("inactive", () => resolve())
+      .read();
+
+    await new Promise<void>((res) => {
+      resolve = res;
+    });
+
+    expect(mockWriteToOutput).toHaveBeenCalledTimes(2);
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(1, "hello\n");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(2, "  ");
+  });
+
+  it.skip("processes a nested, implicit, template", async () => {
+    let resolve: () => void;
+    const mockWriteToOutput = vitest.fn();
+    new Template({
+      contextProvider: { context: { m: "HELLO WORLD" } },
+      readable: createReadableStream(
+        "aa{{#ee}}{{#.}}{{.}}{{/.}}{{/ee}}zz"
+      ).pipeThrough(new TextDecoderStream()),
+      writeToOutput: mockWriteToOutput,
+    })
+      .on("inactive", () => resolve())
+      .read();
+
+    await new Promise<void>((res) => {
+      resolve = res;
+    });
+
+    expect(mockWriteToOutput).toHaveBeenCalledTimes(3);
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(1, "ab");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(2, "HELLO WORLD");
+    expect(mockWriteToOutput).toHaveBeenNthCalledWith(3, "yz");
+  });
+});