@funcstache/stache-stream 0.2.2 → 0.2.3

package/src/global.d.js

@@ -1,8 +0,0 @@
-/******************************************************************************
- * Set up our custom error
- *****************************************************************************/ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-//# sourceMappingURL=global.d.js.map

package/src/global.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../libs/stache-stream/src/global.d.ts"],"sourcesContent":["/******************************************************************************\n * Set up our custom error\n *****************************************************************************/\nexport interface StacheStreamError extends Error {}\n\nexport interface StacheStreamErrorConstructor extends ErrorConstructor {\n  new (message?: string): StacheStreamError;\n  (message?: string): StacheStreamError;\n  readonly prototype: StacheStreamError;\n}\n"],"names":[],"rangeMappings":";;","mappings":"AAAA;;6EAE6E"}

package/src/index.d.ts

@@ -1,7 +0,0 @@
-import type { StacheStreamErrorConstructor } from "./global";
-import type { Context, ContextProvider, ContextTypes, JsonType, PartialTagContext, PartialTagContextLambda, PartialTagContextLambdaResult, SectionTagCallback, SectionTagContext, SectionTagContextRecord, Tag, TemplateName, VariableTagContext, VariableTagContextLambda, VariableTagContextPrimitive, VariableTagContextRecord } from "./lib/types";
-export type { Context, ContextProvider, ContextTypes, JsonType, PartialTagContext, PartialTagContextLambda, PartialTagContextLambdaResult, SectionTagCallback, SectionTagContext, SectionTagContextRecord, Tag, TemplateName, VariableTagContext, VariableTagContextLambda, VariableTagContextPrimitive, VariableTagContextRecord, };
-export * from "./lib/stache-stream/StacheStream";
-declare global {
-    var StacheStreamError: StacheStreamErrorConstructor;
-}

package/src/index.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./lib/stache-stream/StacheStream"), exports);
-/******************************************************************************
- * Set up our custom error
- *****************************************************************************/ function StacheStreamError(message) {
-    if (new.target) {
-        this.message = message || "";
-        this.name = "StacheStreamError";
-        return this;
-    } else {
-        const err = Error(message);
-        err.name = "StacheStreamError";
-        return err;
-    }
-}
-StacheStreamError.prototype = new Error();
-// @ts-expect-error -- function satisfies StacheStreamErrorConstructor at runtime; captureStackTrace and stackTraceLimit are inherited from Error
-global.StacheStreamError = StacheStreamError;
-
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../libs/stache-stream/src/index.ts"],"sourcesContent":["import type { StacheStreamError, StacheStreamErrorConstructor } from \"./global\";\nimport type {\n  Context,\n  ContextProvider,\n  ContextTypes,\n  JsonType,\n  PartialTagContext,\n  PartialTagContextLambda,\n  PartialTagContextLambdaResult,\n  SectionTagCallback,\n  SectionTagContext,\n  SectionTagContextRecord,\n  Tag,\n  TemplateName,\n  VariableTagContext,\n  VariableTagContextLambda,\n  VariableTagContextPrimitive,\n  VariableTagContextRecord,\n} from \"./lib/types\";\nexport type {\n  Context,\n  ContextProvider,\n  ContextTypes,\n  JsonType,\n  PartialTagContext,\n  PartialTagContextLambda,\n  PartialTagContextLambdaResult,\n  SectionTagCallback,\n  SectionTagContext,\n  SectionTagContextRecord,\n  Tag,\n  TemplateName,\n  VariableTagContext,\n  VariableTagContextLambda,\n  VariableTagContextPrimitive,\n  VariableTagContextRecord,\n};\n\nexport * from \"./lib/stache-stream/StacheStream\";\n\n/******************************************************************************\n * Set up our custom error\n *****************************************************************************/\nfunction StacheStreamError(\n  this: InstanceType<StacheStreamErrorConstructor>,\n  message?: string\n): StacheStreamError {\n  if (new.target) {\n    this.message = message || \"\";\n    this.name = \"StacheStreamError\";\n    return this;\n  } else {\n    const err = Error(message);\n    err.name = \"StacheStreamError\";\n    return err;\n  }\n}\n\nStacheStreamError.prototype = new Error();\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var StacheStreamError: StacheStreamErrorConstructor;\n}\n\n// @ts-expect-error -- function satisfies StacheStreamErrorConstructor at runtime; captureStackTrace and stackTraceLimit are inherited from Error\nglobal.StacheStreamError = StacheStreamError;\n"],"names":["StacheStreamError","message","name","err","Error","prototype","global"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;uBAsCc;AAEd;;6EAE6E,GAC7E,SAASA,kBAEPC,OAAgB;IAEhB,IAAI,YAAY;QACd,IAAI,CAACA,OAAO,GAAGA,WAAW;QAC1B,IAAI,CAACC,IAAI,GAAG;QACZ,OAAO,IAAI;IACb,OAAO;QACL,MAAMC,MAAMC,MAAMH;QAClBE,IAAID,IAAI,GAAG;QACX,OAAOC;IACT;AACF;AAEAH,kBAAkBK,SAAS,GAAG,IAAID;AAOlC,iJAAiJ;AACjJE,OAAON,iBAAiB,GAAGA"}

package/src/lib/parse/Parse.d.ts

@@ -1,14 +0,0 @@
-import { ReadableStream } from "node:stream/web";
-import { EventEmitter } from "node:events";
-type ParseEventMap = {
-    inactive: [Parse];
-};
-export interface ParseOptions {
-    onChar: (char: string | null) => Promise<void>;
-}
-export declare class Parse extends EventEmitter<ParseEventMap> {
-    #private;
-    constructor(options: ConstructorParameters<typeof EventEmitter<ParseEventMap>>[0] & ParseOptions);
-    read(readable: ReadableStream<string>): Promise<void>;
-}
-export {};

package/src/lib/parse/Parse.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Parse", {
-    enumerable: true,
-    get: function() {
-        return Parse;
-    }
-});
-const _nodeevents = require("node:events");
-let Parse = class Parse extends _nodeevents.EventEmitter {
-    #onChar;
-    #processPending;
-    #queue;
-    #readState;
-    constructor(options){
-        super(options);
-        this.#processPending = false;
-        this.#queue = [];
-        this.#readState = "pending";
-        this.#onChar = options.onChar;
-    }
-    async read(readable) {
-        this.#readState = "reading";
-        for await (const chunk of readable){
-            if (!chunk) {
-                break;
-            }
-            if (1 < chunk.length) {
-                for (const char of chunk){
-                    this.#push(char);
-                }
-            } else {
-                this.#push(chunk);
-            }
-        }
-        this.#readState = "finished";
-        this.#finalize();
-    }
-    #invokeChar(char) {
-        try {
-            this.#onChar(char);
-        } catch (err) {
-            console.error(err);
-        }
-    }
-    #process() {
-        this.#processPending = false;
-        while(this.#queue.length){
-            const char = this.#queue.shift();
-            if (!char) {
-                continue;
-            }
-            this.#invokeChar(char);
-        }
-        this.#finalize();
-    }
-    #push(char) {
-        this.#queue.push(char);
-        if (this.#processPending) {
-            return;
-        }
-        this.#processPending = true;
-        setTimeout(()=>this.#process(), 0);
-    }
-    #finalize() {
-        if (this.#readState !== "finished") {
-            return;
-        }
-        if (this.#queue.length) {
-            return;
-        }
-        this.#invokeChar(null);
-        this.emit("inactive", this);
-    }
-};
-
-//# sourceMappingURL=Parse.js.map

package/src/lib/parse/Parse.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../libs/stache-stream/src/lib/parse/Parse.ts"],"sourcesContent":["import { ReadableStream } from \"node:stream/web\";\nimport { EventEmitter } from \"node:events\";\n\ntype ParseEventMap = { inactive: [Parse] };\n\nexport interface ParseOptions {\n  onChar: (char: string | null) => Promise<void>;\n}\n\nexport class Parse extends EventEmitter<ParseEventMap> {\n  #onChar: ParseOptions[\"onChar\"];\n  #processPending = false;\n  #queue: string[] = [];\n  #readState: \"finished\" | \"pending\" | \"reading\" = \"pending\";\n\n  constructor(\n    options: ConstructorParameters<typeof EventEmitter<ParseEventMap>>[0] &\n      ParseOptions\n  ) {\n    super(options);\n    this.#onChar = options.onChar;\n  }\n\n  async read(readable: ReadableStream<string>) {\n    this.#readState = \"reading\";\n\n    for await (const chunk of readable) {\n      if (!chunk) {\n        break;\n      }\n\n      if (1 < chunk.length) {\n        for (const char of chunk) {\n          this.#push(char);\n        }\n      } else {\n        this.#push(chunk);\n      }\n    }\n\n    this.#readState = \"finished\";\n    this.#finalize();\n  }\n\n  #invokeChar(char: string | null) {\n    try {\n      this.#onChar(char);\n    } catch (err) {\n      console.error(err);\n    }\n  }\n\n  #process() {\n    this.#processPending = false;\n\n    while (this.#queue.length) {\n      const char = this.#queue.shift();\n      if (!char) {\n        continue;\n      }\n\n      this.#invokeChar(char);\n    }\n\n    this.#finalize();\n  }\n\n  #push(char: string) {\n    this.#queue.push(char);\n\n    if (this.#processPending) {\n      return;\n    }\n\n    this.#processPending = true;\n\n    setTimeout(() => this.#process(), 0);\n  }\n\n  #finalize() {\n    if (this.#readState !== \"finished\") {\n      return;\n    }\n\n    if (this.#queue.length) {\n      return;\n    }\n\n    this.#invokeChar(null);\n    this.emit(\"inactive\", this);\n  }\n}\n"],"names":["Parse","EventEmitter","onChar","processPending","queue","readState","constructor","options","read","readable","chunk","length","char","push","finalize","invokeChar","err","console","error","process","shift","setTimeout","emit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARgB;AAQtB,IAAA,AAAMA,QAAN,MAAMA,cAAcC,wBAAY;IACrC,CAACC,MAAM,CAAyB;IAChC,CAACC,cAAc,CAAS;IACxB,CAACC,KAAK,CAAgB;IACtB,CAACC,SAAS,CAAiD;IAE3DC,YACEC,OACc,CACd;QACA,KAAK,CAACA;aARR,CAACJ,cAAc,GAAG;aAClB,CAACC,KAAK,GAAa,EAAE;aACrB,CAACC,SAAS,GAAuC;QAO/C,IAAI,CAAC,CAACH,MAAM,GAAGK,QAAQL,MAAM;IAC/B;IAEA,MAAMM,KAAKC,QAAgC,EAAE;QAC3C,IAAI,CAAC,CAACJ,SAAS,GAAG;QAElB,WAAW,MAAMK,SAASD,SAAU;YAClC,IAAI,CAACC,OAAO;gBACV;YACF;YAEA,IAAI,IAAIA,MAAMC,MAAM,EAAE;gBACpB,KAAK,MAAMC,QAAQF,MAAO;oBACxB,IAAI,CAAC,CAACG,IAAI,CAACD;gBACb;YACF,OAAO;gBACL,IAAI,CAAC,CAACC,IAAI,CAACH;YACb;QACF;QAEA,IAAI,CAAC,CAACL,SAAS,GAAG;QAClB,IAAI,CAAC,CAACS,QAAQ;IAChB;IAEA,CAACC,UAAU,CAACH,IAAmB;QAC7B,IAAI;YACF,IAAI,CAAC,CAACV,MAAM,CAACU;QACf,EAAE,OAAOI,KAAK;YACZC,QAAQC,KAAK,CAACF;QAChB;IACF;IAEA,CAACG,OAAO;QACN,IAAI,CAAC,CAAChB,cAAc,GAAG;QAEvB,MAAO,IAAI,CAAC,CAACC,KAAK,CAACO,MAAM,CAAE;YACzB,MAAMC,OAAO,IAAI,CAAC,CAACR,KAAK,CAACgB,KAAK;YAC9B,IAAI,CAACR,MAAM;gBACT;YACF;YAEA,IAAI,CAAC,CAACG,UAAU,CAACH;QACnB;QAEA,IAAI,CAAC,CAACE,QAAQ;IAChB;IAEA,CAACD,IAAI,CAACD,IAAY;QAChB,IAAI,CAAC,CAACR,KAAK,CAACS,IAAI,CAACD;QAEjB,IAAI,IAAI,CAAC,CAACT,cAAc,EAAE;YACxB;QACF;QAEA,IAAI,CAAC,CAACA,cAAc,GAAG;QAEvBkB,WAAW,IAAM,IAAI,CAAC,CAACF,OAAO,IAAI;IACpC;IAEA,CAACL,QAAQ;QACP,IAAI,IAAI,CAAC,CAACT,SAAS,KAAK,YAAY;YAClC;QACF;QAEA,IAAI,IAAI,CAAC,CAACD,KAAK,CAACO,MAAM,EAAE;YACtB;QACF;QAEA,IAAI,CAAC,CAACI,UAAU,CAAC;QACjB,IAAI,CAACO,IAAI,CAAC,YAAY,IAAI;IAC5B;AACF"}

package/src/lib/queue/Queue.d.ts

@@ -1,32 +0,0 @@
-import { TokenizeTagEvent, TokenizeTextEvent } from "../tokenize/Tokenize";
-export declare class Queue implements AsyncEventEmitter<QueueEventMap> {
-    #private;
-    get tokenQueue(): TokenizeEvent[];
-    on<E extends keyof QueueEventMap>(eventName: Listeners<QueueEventMap, E>["eventName"], listener: Listeners<QueueEventMap, E>["listener"]): this;
-    push(token: TokenizeEvent): Promise<void>;
-}
-export declare class QueueError<D extends TokenizeAllEvent | TokenizeAllEvent[] = TokenizeAllEvent> extends Error {
-    readonly data: D;
-    constructor(message: string, token: D);
-}
-interface AsyncEventEmitter<T extends object, K extends keyof T = keyof T> {
-    on: (eventName: K, listener: (event: T[K]) => Promise<void>) => AsyncEventEmitter<T>;
-}
-interface Listeners<T extends object, K extends keyof T = keyof T> {
-    eventName: K;
-    listener: (event: T[K]) => Promise<void>;
-}
-export type TokenizeAllEvent = TokenizeTagEvent | TokenizeTextEvent;
-type TokenizeEvent = TokenizeAllEvent | null;
-type QueueEventMap = {
-    comment: TokenizeTagEvent;
-    error: QueueError<TokenizeAllEvent | TokenizeAllEvent[]>;
-    implicit: TokenizeTagEvent;
-    inactive: undefined;
-    inverted: TokenizeAllEvent[];
-    partial: TokenizeTagEvent;
-    section: TokenizeAllEvent[];
-    text: TokenizeTextEvent;
-    variable: TokenizeTagEvent;
-};
-export {};

package/src/lib/queue/Queue.js

@@ -1,181 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    Queue: function() {
-        return Queue;
-    },
-    QueueError: function() {
-        return QueueError;
-    }
-});
-const _logger = require("@funcstache/logger");
-let Queue = class Queue {
-    #logger;
-    #active;
-    #listeners;
-    #accumulator;
-    #tokenQueue;
-    get tokenQueue() {
-        return Array.from(this.#tokenQueue);
-    }
-    on(eventName, listener) {
-        if (!this.#listeners.some(({ eventName: evn, listener: lst })=>eventName === evn && listener === lst)) {
-            const l = listener;
-            this.#listeners.push({
-                eventName,
-                listener: l
-            });
-        }
-        return this;
-    }
-    async push(token) {
-        // this.#logger.debug(() => [`••• push: token=`, token]);
-        this.#tokenQueue.push(token);
-        this.#processToken();
-    }
-    async #emit(eventName, event) {
-        for (const item of this.#listeners){
-            if (item.eventName !== eventName) {
-                continue;
-            }
-            this.#logger.debug(()=>[
-                    `••• #emit: event=`,
-                    event
-                ]);
-            await item.listener(event);
-        }
-    }
-    async #processToken() {
-        if (this.#active) {
-            return;
-        }
-        this.#active = true;
-        const token = this.#tokenQueue.shift();
-        if (token === undefined) {
-            return;
-        }
-        // this.#logger.debug(() => [
-        //   `••• #processToken: token='${JSON.stringify(token)}'`,
-        // ]);
-        if (token === null) {
-            await this.#emit("inactive", undefined);
-            return;
-        }
-        if (token.type === "text") {
-            if (this.#accumulator) {
-                this.#accumulator.push(token);
-            } else {
-                await this.#emit("text", token);
-            }
-        } else if (token.type === "tag") {
-            // this.#logger.debug(() => [
-            //   `    #processToken: token type='${token.data.type}'`,
-            // ]);
-            switch(token.data.type){
-                case "comment":
-                case "implicit":
-                case "partial":
-                case "variable":
-                    {
-                        if (this.#accumulator) {
-                            this.#accumulator.push(token);
-                        } else {
-                            await this.#emit(token.data.type, token);
-                        }
-                        break;
-                    }
-                case "inverted":
-                case "section":
-                    {
-                        if (!this.#accumulator) {
-                            const acc = [
-                                token
-                            ];
-                            acc.level = 0;
-                            this.#accumulator = acc;
-                        } else {
-                            this.#accumulator.level++;
-                            this.#accumulator.push(token);
-                        }
-                        break;
-                    }
-                case "end":
-                    {
-                        if (!this.#accumulator) {
-                            this.#emit("error", new QueueError(`Received end tag '${token.data.value}' without a start tag.`, token));
-                            break;
-                        }
-                        // Received an end tag, but we are not at the lowest level. Add this tag to the
-                        // accumulator and reduce the level by one then exit.
-                        if (0 < this.#accumulator.level) {
-                            this.#accumulator.level--;
-                            this.#accumulator.push(token);
-                            break;
-                        }
-                        // We are at accumulator level 0 so if we've done everything right thing we should emit a
-                        // "section" event with all the accumulated tags...
-                        const start = this.#accumulator[0];
-                        if (!isTagEvent(start)) {
-                            this.#emit("error", new QueueError(`The start tag '${JSON.stringify(start)}' is not a TokenizeTagEvent.`, start));
-                            break;
-                        }
-                        if (start.data.key !== token.data.key) {
-                            this.#emit("error", new QueueError(`The start tag '${JSON.stringify(start)}' does not match the end tag '${JSON.stringify(token)}'`, [
-                                start,
-                                token
-                            ]));
-                            break;
-                        }
-                        if (start.data.type === "inverted" || start.data.type === "section") {
-                            await this.#emit(start.data.type, [
-                                ...Array.from(this.#accumulator),
-                                token
-                            ]);
-                            this.#accumulator = undefined;
-                        } else {
-                            this.#emit("error", new QueueError(`The start tag '${JSON.stringify(start)}' is not a section tag`, start));
-                        }
-                        break;
-                    }
-            }
-        }
-        // this.#logger.debug(() => [
-        //   `    #processToken: this.#accumulator.level=${
-        //     this.#accumulator?.level
-        //   }, this.#accumulator='${JSON.stringify(this.#accumulator)}'`,
-        //   ,
-        // ]);
-        this.#active = false;
-        if (this.#tokenQueue.length) {
-            this.#processToken();
-        }
-    }
-    constructor(){
-        this.#logger = new _logger.Log({
-            category: "QUE",
-            level: process.env.LOG_LEVEL || "warn"
-        });
-        this.#active = false;
-        this.#listeners = [];
-        this.#tokenQueue = [];
-    }
-};
-let QueueError = class QueueError extends Error {
-    constructor(message, token){
-        super(message);
-        this.data = token;
-    }
-};
-function isTagEvent(obj) {
-    return obj && "type" in obj && obj.type === "tag";
-}
-
-//# sourceMappingURL=Queue.js.map

package/src/lib/queue/Queue.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../libs/stache-stream/src/lib/queue/Queue.ts"],"sourcesContent":["import { Log } from \"@funcstache/logger\";\nimport { TokenizeTagEvent, TokenizeTextEvent } from \"../tokenize/Tokenize\";\n\nexport class Queue implements AsyncEventEmitter<QueueEventMap> {\n  #logger = new Log({\n    category: \"QUE\",\n    level: (process.env as any).LOG_LEVEL || \"warn\",\n  });\n\n  #active = false;\n  #listeners: Listeners<QueueEventMap>[] = [];\n  #accumulator: Accumulator | undefined;\n  #tokenQueue: TokenizeEvent[] = [];\n\n  get tokenQueue() {\n    return Array.from(this.#tokenQueue);\n  }\n\n  on<E extends keyof QueueEventMap>(\n    eventName: Listeners<QueueEventMap, E>[\"eventName\"],\n    listener: Listeners<QueueEventMap, E>[\"listener\"]\n  ) {\n    if (\n      !this.#listeners.some(\n        ({ eventName: evn, listener: lst }) =>\n          eventName === evn && listener === lst\n      )\n    ) {\n      const l = listener as any;\n      this.#listeners.push({ eventName, listener: l });\n    }\n\n    return this;\n  }\n\n  async push(token: TokenizeEvent): Promise<void> {\n    // this.#logger.debug(() => [`••• push: token=`, token]);\n\n    this.#tokenQueue.push(token);\n    this.#processToken();\n  }\n\n  async #emit<K extends keyof QueueEventMap>(\n    eventName: K,\n    event: QueueEventMap[K]\n  ): Promise<void> {\n    for (const item of this.#listeners) {\n      if (item.eventName !== eventName) {\n        continue;\n      }\n\n      this.#logger.debug(() => [`••• #emit: event=`, event]);\n      await item.listener(event);\n    }\n  }\n\n  async #processToken(): Promise<void> {\n    if (this.#active) {\n      return;\n    }\n\n    this.#active = true;\n\n    const token = this.#tokenQueue.shift();\n    if (token === undefined) {\n      return;\n    }\n\n    // this.#logger.debug(() => [\n    //   `••• #processToken: token='${JSON.stringify(token)}'`,\n    // ]);\n\n    if (token === null) {\n      await this.#emit(\"inactive\", undefined);\n      return;\n    }\n\n    if (token.type === \"text\") {\n      if (this.#accumulator) {\n        this.#accumulator.push(token);\n      } else {\n        await this.#emit(\"text\", token);\n      }\n    } else if (token.type === \"tag\") {\n      // this.#logger.debug(() => [\n      //   `    #processToken: token type='${token.data.type}'`,\n      // ]);\n\n      switch (token.data.type) {\n        case \"comment\":\n        case \"implicit\":\n        case \"partial\":\n        case \"variable\": {\n          if (this.#accumulator) {\n            this.#accumulator.push(token);\n          } else {\n            await this.#emit(token.data.type, token);\n          }\n\n          break;\n        }\n\n        case \"inverted\":\n        case \"section\": {\n          if (!this.#accumulator) {\n            const acc: Accumulator = [token] as any;\n            acc.level = 0;\n            this.#accumulator = acc;\n          } else {\n            this.#accumulator.level++;\n            this.#accumulator.push(token);\n          }\n\n          break;\n        }\n\n        case \"end\": {\n          if (!this.#accumulator) {\n            this.#emit(\n              \"error\",\n              new QueueError<TokenizeAllEvent>(\n                `Received end tag '${token.data.value}' without a start tag.`,\n                token\n              )\n            );\n            break;\n          }\n\n          // Received an end tag, but we are not at the lowest level. Add this tag to the\n          // accumulator and reduce the level by one then exit.\n          if (0 < this.#accumulator.level) {\n            this.#accumulator.level--;\n            this.#accumulator.push(token);\n            break;\n          }\n\n          // We are at accumulator level 0 so if we've done everything right thing we should emit a\n          // \"section\" event with all the accumulated tags...\n          const start = this.#accumulator[0];\n          if (!isTagEvent(start)) {\n            this.#emit(\n              \"error\",\n              new QueueError<TokenizeAllEvent>(\n                `The start tag '${JSON.stringify(\n                  start\n                )}' is not a TokenizeTagEvent.`,\n                start\n              )\n            );\n            break;\n          }\n\n          if (start.data.key !== token.data.key) {\n            this.#emit(\n              \"error\",\n              new QueueError<TokenizeAllEvent[]>(\n                `The start tag '${JSON.stringify(\n                  start\n                )}' does not match the end tag '${JSON.stringify(token)}'`,\n                [start, token]\n              )\n            );\n            break;\n          }\n\n          if (\n            start.data.type === \"inverted\" ||\n            start.data.type === \"section\"\n          ) {\n            await this.#emit(start.data.type, [\n              ...Array.from(this.#accumulator),\n              token,\n            ]);\n\n            this.#accumulator = undefined;\n          } else {\n            this.#emit(\n              \"error\",\n              new QueueError<TokenizeAllEvent>(\n                `The start tag '${JSON.stringify(start)}' is not a section tag`,\n                start\n              )\n            );\n          }\n\n          break;\n        }\n      }\n    }\n\n    // this.#logger.debug(() => [\n    //   `    #processToken: this.#accumulator.level=${\n    //     this.#accumulator?.level\n    //   }, this.#accumulator='${JSON.stringify(this.#accumulator)}'`,\n    //   ,\n    // ]);\n\n    this.#active = false;\n\n    if (this.#tokenQueue.length) {\n      this.#processToken();\n    }\n  }\n}\n\nexport class QueueError<\n  D extends TokenizeAllEvent | TokenizeAllEvent[] = TokenizeAllEvent\n> extends Error {\n  readonly data: D;\n\n  constructor(message: string, token: D) {\n    super(message);\n\n    this.data = token;\n  }\n}\n\nfunction isTagEvent(obj: any): obj is TokenizeTagEvent {\n  return obj && \"type\" in obj && obj.type === \"tag\";\n}\n\ninterface AsyncEventEmitter<T extends object, K extends keyof T = keyof T> {\n  on: (\n    eventName: K,\n    listener: (event: T[K]) => Promise<void>\n  ) => AsyncEventEmitter<T>;\n}\n\ntype Accumulator = TokenizeAllEvent[] & {\n  level: number;\n};\n\ninterface Listeners<T extends object, K extends keyof T = keyof T> {\n  eventName: K;\n  listener: (event: T[K]) => Promise<void>;\n}\n\nexport type TokenizeAllEvent = TokenizeTagEvent | TokenizeTextEvent;\n\ntype TokenizeEvent = TokenizeAllEvent | null;\n\ntype QueueEventMap = {\n  comment: TokenizeTagEvent;\n  // end: TokenizeTagEvent;\n  error: QueueError<TokenizeAllEvent | TokenizeAllEvent[]>;\n  implicit: TokenizeTagEvent;\n  inactive: undefined;\n  inverted: TokenizeAllEvent[];\n  partial: TokenizeTagEvent;\n  section: TokenizeAllEvent[];\n  text: TokenizeTextEvent;\n  variable: TokenizeTagEvent;\n};\n"],"names":["Queue","QueueError","logger","active","listeners","accumulator","tokenQueue","Array","from","on","eventName","listener","some","evn","lst","l","push","token","processToken","emit","event","item","debug","shift","undefined","type","data","acc","level","value","start","isTagEvent","JSON","stringify","key","length","Log","category","process","env","LOG_LEVEL","Error","constructor","message","obj"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAGaA,KAAK;eAALA;;IA0MAC,UAAU;eAAVA;;;wBA7MO;AAGb,IAAA,AAAMD,QAAN,MAAMA;IACX,CAACE,MAAM,CAGJ;IAEH,CAACC,MAAM,CAAS;IAChB,CAACC,SAAS,CAAkC;IAC5C,CAACC,WAAW,CAA0B;IACtC,CAACC,UAAU,CAAuB;IAElC,IAAIA,aAAa;QACf,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAAC,CAACF,UAAU;IACpC;IAEAG,GACEC,SAAmD,EACnDC,QAAiD,EACjD;QACA,IACE,CAAC,IAAI,CAAC,CAACP,SAAS,CAACQ,IAAI,CACnB,CAAC,EAAEF,WAAWG,GAAG,EAAEF,UAAUG,GAAG,EAAE,GAChCJ,cAAcG,OAAOF,aAAaG,MAEtC;YACA,MAAMC,IAAIJ;YACV,IAAI,CAAC,CAACP,SAAS,CAACY,IAAI,CAAC;gBAAEN;gBAAWC,UAAUI;YAAE;QAChD;QAEA,OAAO,IAAI;IACb;IAEA,MAAMC,KAAKC,KAAoB,EAAiB;QAC9C,yDAAyD;QAEzD,IAAI,CAAC,CAACX,UAAU,CAACU,IAAI,CAACC;QACtB,IAAI,CAAC,CAACC,YAAY;IACpB;IAEA,MAAM,CAACC,IAAI,CACTT,SAAY,EACZU,KAAuB;QAEvB,KAAK,MAAMC,QAAQ,IAAI,CAAC,CAACjB,SAAS,CAAE;YAClC,IAAIiB,KAAKX,SAAS,KAAKA,WAAW;gBAChC;YACF;YAEA,IAAI,CAAC,CAACR,MAAM,CAACoB,KAAK,CAAC,IAAM;oBAAC,CAAC,iBAAiB,CAAC;oBAAEF;iBAAM;YACrD,MAAMC,KAAKV,QAAQ,CAACS;QACtB;IACF;IAEA,MAAM,CAACF,YAAY;QACjB,IAAI,IAAI,CAAC,CAACf,MAAM,EAAE;YAChB;QACF;QAEA,IAAI,CAAC,CAACA,MAAM,GAAG;QAEf,MAAMc,QAAQ,IAAI,CAAC,CAACX,UAAU,CAACiB,KAAK;QACpC,IAAIN,UAAUO,WAAW;YACvB;QACF;QAEA,6BAA6B;QAC7B,2DAA2D;QAC3D,MAAM;QAEN,IAAIP,UAAU,MAAM;YAClB,MAAM,IAAI,CAAC,CAACE,IAAI,CAAC,YAAYK;YAC7B;QACF;QAEA,IAAIP,MAAMQ,IAAI,KAAK,QAAQ;YACzB,IAAI,IAAI,CAAC,CAACpB,WAAW,EAAE;gBACrB,IAAI,CAAC,CAACA,WAAW,CAACW,IAAI,CAACC;YACzB,OAAO;gBACL,MAAM,IAAI,CAAC,CAACE,IAAI,CAAC,QAAQF;YAC3B;QACF,OAAO,IAAIA,MAAMQ,IAAI,KAAK,OAAO;YAC/B,6BAA6B;YAC7B,0DAA0D;YAC1D,MAAM;YAEN,OAAQR,MAAMS,IAAI,CAACD,IAAI;gBACrB,KAAK;gBACL,KAAK;gBACL,KAAK;gBACL,KAAK;oBAAY;wBACf,IAAI,IAAI,CAAC,CAACpB,WAAW,EAAE;4BACrB,IAAI,CAAC,CAACA,WAAW,CAACW,IAAI,CAACC;wBACzB,OAAO;4BACL,MAAM,IAAI,CAAC,CAACE,IAAI,CAACF,MAAMS,IAAI,CAACD,IAAI,EAAER;wBACpC;wBAEA;oBACF;gBAEA,KAAK;gBACL,KAAK;oBAAW;wBACd,IAAI,CAAC,IAAI,CAAC,CAACZ,WAAW,EAAE;4BACtB,MAAMsB,MAAmB;gCAACV;6BAAM;4BAChCU,IAAIC,KAAK,GAAG;4BACZ,IAAI,CAAC,CAACvB,WAAW,GAAGsB;wBACtB,OAAO;4BACL,IAAI,CAAC,CAACtB,WAAW,CAACuB,KAAK;4BACvB,IAAI,CAAC,CAACvB,WAAW,CAACW,IAAI,CAACC;wBACzB;wBAEA;oBACF;gBAEA,KAAK;oBAAO;wBACV,IAAI,CAAC,IAAI,CAAC,CAACZ,WAAW,EAAE;4BACtB,IAAI,CAAC,CAACc,IAAI,CACR,SACA,IAAIlB,WACF,CAAC,kBAAkB,EAAEgB,MAAMS,IAAI,CAACG,KAAK,CAAC,sBAAsB,CAAC,EAC7DZ;4BAGJ;wBACF;wBAEA,+EAA+E;wBAC/E,qDAAqD;wBACrD,IAAI,IAAI,IAAI,CAAC,CAACZ,WAAW,CAACuB,KAAK,EAAE;4BAC/B,IAAI,CAAC,CAACvB,WAAW,CAACuB,KAAK;4BACvB,IAAI,CAAC,CAACvB,WAAW,CAACW,IAAI,CAACC;4BACvB;wBACF;wBAEA,yFAAyF;wBACzF,mDAAmD;wBACnD,MAAMa,QAAQ,IAAI,CAAC,CAACzB,WAAW,CAAC,EAAE;wBAClC,IAAI,CAAC0B,WAAWD,QAAQ;4BACtB,IAAI,CAAC,CAACX,IAAI,CACR,SACA,IAAIlB,WACF,CAAC,eAAe,EAAE+B,KAAKC,SAAS,CAC9BH,OACA,4BAA4B,CAAC,EAC/BA;4BAGJ;wBACF;wBAEA,IAAIA,MAAMJ,IAAI,CAACQ,GAAG,KAAKjB,MAAMS,IAAI,CAACQ,GAAG,EAAE;4BACrC,IAAI,CAAC,CAACf,IAAI,CACR,SACA,IAAIlB,WACF,CAAC,eAAe,EAAE+B,KAAKC,SAAS,CAC9BH,OACA,8BAA8B,EAAEE,KAAKC,SAAS,CAAChB,OAAO,CAAC,CAAC,EAC1D;gCAACa;gCAAOb;6BAAM;4BAGlB;wBACF;wBAEA,IACEa,MAAMJ,IAAI,CAACD,IAAI,KAAK,cACpBK,MAAMJ,IAAI,CAACD,IAAI,KAAK,WACpB;4BACA,MAAM,IAAI,CAAC,CAACN,IAAI,CAACW,MAAMJ,IAAI,CAACD,IAAI,EAAE;mCAC7BlB,MAAMC,IAAI,CAAC,IAAI,CAAC,CAACH,WAAW;gCAC/BY;6BACD;4BAED,IAAI,CAAC,CAACZ,WAAW,GAAGmB;wBACtB,OAAO;4BACL,IAAI,CAAC,CAACL,IAAI,CACR,SACA,IAAIlB,WACF,CAAC,eAAe,EAAE+B,KAAKC,SAAS,CAACH,OAAO,sBAAsB,CAAC,EAC/DA;wBAGN;wBAEA;oBACF;YACF;QACF;QAEA,6BAA6B;QAC7B,mDAAmD;QACnD,+BAA+B;QAC/B,kEAAkE;QAClE,MAAM;QACN,MAAM;QAEN,IAAI,CAAC,CAAC3B,MAAM,GAAG;QAEf,IAAI,IAAI,CAAC,CAACG,UAAU,CAAC6B,MAAM,EAAE;YAC3B,IAAI,CAAC,CAACjB,YAAY;QACpB;IACF;;aAtMA,CAAChB,MAAM,GAAG,IAAIkC,WAAG,CAAC;YAChBC,UAAU;YACVT,OAAO,AAACU,QAAQC,GAAG,CAASC,SAAS,IAAI;QAC3C;aAEA,CAACrC,MAAM,GAAG;aACV,CAACC,SAAS,GAA+B,EAAE;aAE3C,CAACE,UAAU,GAAoB,EAAE;;AA+LnC;AAEO,IAAA,AAAML,aAAN,MAAMA,mBAEHwC;IAGRC,YAAYC,OAAe,EAAE1B,KAAQ,CAAE;QACrC,KAAK,CAAC0B;QAEN,IAAI,CAACjB,IAAI,GAAGT;IACd;AACF;AAEA,SAASc,WAAWa,GAAQ;IAC1B,OAAOA,OAAO,UAAUA,OAAOA,IAAInB,IAAI,KAAK;AAC9C"}

package/src/lib/stache-stream/StacheStream.d.ts

@@ -1,22 +0,0 @@
-import { TransformStream } from "node:stream/web";
-import type { ContextProvider } from "../types";
-/**
- * A {@link https://nodejs.org/api/webstreams.html#class-transformstream TransformStream} that
- * renders a Mustache template.
- *
- * @remarks
- * The incoming {@link https://nodejs.org/api/webstreams.html#class-readablestream ReadableStream}
- * provides the contents of a Mustache template. The stream is processed by StacheStreamTransform
- * which emits the rendered Mustache template. The information needed to render the template is made
- * available through `options` by the `ContextProvider`.
- */
-export declare class StacheTransformStream extends TransformStream<string, string> {
-    /**
-     * @param options Options needed to render a Mustache template stream.
-     * @param options.contextProvider The `ContextProvider` is used during the render process to
-     * access the context for tags.
-     */
-    constructor(options?: {
-        contextProvider?: ContextProvider;
-    });
-}

package/src/lib/stache-stream/StacheStream.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "StacheTransformStream", {
-    enumerable: true,
-    get: function() {
-        return StacheTransformStream;
-    }
-});
-const _web = require("node:stream/web");
-const _Template = require("../template/Template");
-let StacheTransformStream = class StacheTransformStream extends _web.TransformStream {
-    /**
-   * @param options Options needed to render a Mustache template stream.
-   * @param options.contextProvider The `ContextProvider` is used during the render process to
-   * access the context for tags.
-   */ constructor(options){
-        const { readable, push, close } = createReadableProducer();
-        let resolveInactive;
-        let rejectInactive;
-        const waitInactive = new Promise((resolve, reject)=>{
-            resolveInactive = resolve;
-            rejectInactive = reject;
-        });
-        super({
-            start (controller) {
-                new _Template.Template({
-                    contextProvider: options?.contextProvider,
-                    readable,
-                    writeToOutput: async (text)=>{
-                        try {
-                            controller.enqueue(text);
-                        } catch (err) {
-                            rejectInactive(err);
-                            throw err;
-                        }
-                    }
-                }).on("inactive", ()=>resolveInactive()).read();
-            },
-            transform (chunk) {
-                push(chunk);
-            },
-            async flush (controller) {
-                close();
-                try {
-                    await waitInactive;
-                } catch (err) {
-                    controller.error(err);
-                }
-            }
-        });
-    }
-};
-function createReadableProducer() {
-    let pushChunk;
-    let closeStream;
-    const readable = new _web.ReadableStream({
-        start (controller) {
-            pushChunk = controller.enqueue.bind(controller);
-            closeStream = controller.close.bind(controller);
-        }
-    });
-    return {
-        readable,
-        push: pushChunk,
-        close: closeStream
-    };
-}
-
-//# sourceMappingURL=StacheStream.js.map

package/src/lib/stache-stream/StacheStream.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../libs/stache-stream/src/lib/stache-stream/StacheStream.ts"],"sourcesContent":["import { ReadableStream, TransformStream } from \"node:stream/web\";\nimport type { ContextProvider } from \"../types\";\nimport { Template } from \"../template/Template\";\n\n/**\n * A {@link https://nodejs.org/api/webstreams.html#class-transformstream TransformStream} that\n * renders a Mustache template.\n *\n * @remarks\n * The incoming {@link https://nodejs.org/api/webstreams.html#class-readablestream ReadableStream}\n * provides the contents of a Mustache template. The stream is processed by StacheStreamTransform\n * which emits the rendered Mustache template. The information needed to render the template is made\n * available through `options` by the `ContextProvider`.\n */\nexport class StacheTransformStream extends TransformStream<string, string> {\n  /**\n   * @param options Options needed to render a Mustache template stream.\n   * @param options.contextProvider The `ContextProvider` is used during the render process to\n   * access the context for tags.\n   */\n  constructor(options?: { contextProvider?: ContextProvider }) {\n    const { readable, push, close } = createReadableProducer<string>();\n\n    let resolveInactive!: () => void;\n    let rejectInactive!: (err: unknown) => void;\n    const waitInactive = new Promise<void>((resolve, reject) => {\n      resolveInactive = resolve;\n      rejectInactive = reject;\n    });\n\n    super({\n      start(controller) {\n        new Template({\n          contextProvider: options?.contextProvider,\n          readable,\n          writeToOutput: async (text: string) => {\n            try {\n              controller.enqueue(text);\n            } catch (err) {\n              rejectInactive(err);\n              throw err;\n            }\n          },\n        })\n          .on(\"inactive\", () => resolveInactive())\n          .read();\n      },\n      transform(chunk) {\n        push(chunk);\n      },\n      async flush(controller) {\n        close();\n        try {\n          await waitInactive;\n        } catch (err) {\n          controller.error(err);\n        }\n      },\n    });\n  }\n}\n\nfunction createReadableProducer<T>(): {\n  readable: ReadableStream<T>;\n  push: (chunk: T) => void;\n  close: () => void;\n} {\n  let pushChunk!: (chunk: T) => void;\n  let closeStream!: () => void;\n\n  const readable = new ReadableStream<T>({\n    start(controller) {\n      pushChunk = controller.enqueue.bind(controller);\n      closeStream = controller.close.bind(controller);\n    },\n  });\n\n  return { readable, push: pushChunk, close: closeStream };\n}\n"],"names":["StacheTransformStream","TransformStream","constructor","options","readable","push","close","createReadableProducer","resolveInactive","rejectInactive","waitInactive","Promise","resolve","reject","start","controller","Template","contextProvider","writeToOutput","text","enqueue","err","on","read","transform","chunk","flush","error","pushChunk","closeStream","ReadableStream","bind"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAcaA;;;eAAAA;;;qBAdmC;0BAEvB;AAYlB,IAAA,AAAMA,wBAAN,MAAMA,8BAA8BC,oBAAe;IACxD;;;;GAIC,GACDC,YAAYC,OAA+C,CAAE;QAC3D,MAAM,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGC;QAElC,IAAIC;QACJ,IAAIC;QACJ,MAAMC,eAAe,IAAIC,QAAc,CAACC,SAASC;YAC/CL,kBAAkBI;YAClBH,iBAAiBI;QACnB;QAEA,KAAK,CAAC;YACJC,OAAMC,UAAU;gBACd,IAAIC,kBAAQ,CAAC;oBACXC,iBAAiBd,SAASc;oBAC1Bb;oBACAc,eAAe,OAAOC;wBACpB,IAAI;4BACFJ,WAAWK,OAAO,CAACD;wBACrB,EAAE,OAAOE,KAAK;4BACZZ,eAAeY;4BACf,MAAMA;wBACR;oBACF;gBACF,GACGC,EAAE,CAAC,YAAY,IAAMd,mBACrBe,IAAI;YACT;YACAC,WAAUC,KAAK;gBACbpB,KAAKoB;YACP;YACA,MAAMC,OAAMX,UAAU;gBACpBT;gBACA,IAAI;oBACF,MAAMI;gBACR,EAAE,OAAOW,KAAK;oBACZN,WAAWY,KAAK,CAACN;gBACnB;YACF;QACF;IACF;AACF;AAEA,SAASd;IAKP,IAAIqB;IACJ,IAAIC;IAEJ,MAAMzB,WAAW,IAAI0B,mBAAc,CAAI;QACrChB,OAAMC,UAAU;YACda,YAAYb,WAAWK,OAAO,CAACW,IAAI,CAAChB;YACpCc,cAAcd,WAAWT,KAAK,CAACyB,IAAI,CAAChB;QACtC;IACF;IAEA,OAAO;QAAEX;QAAUC,MAAMuB;QAAWtB,OAAOuB;IAAY;AACzD"}

package/src/lib/tag/Tag.d.ts

@@ -1,33 +0,0 @@
-import { ContentTagTagTypes, Tag as TagType, ValueTagTagTypes } from "../types";
-export declare class Tag implements TagType {
-    #private;
-    constructor(options: TagOptions);
-    get content(): string | null;
-    get dynamic(): boolean;
-    /** This should match a key in the Context associated with the template. */
-    get key(): string;
-    get raw(): boolean;
-    get type(): ValueTagTagTypes | ContentTagTagTypes;
-    get value(): string;
-    /** The `value` passed to the constructor via the `option` parameter. Only really useful for
-     * logging; prefer the `Tag.value` property. */
-    get valueOption(): string;
-    static copy(tag: Tag, options?: Partial<Omit<TagOptions, "value"> & {
-        key?: string;
-    }>): Tag;
-    static parse(tag: string, tokens?: [enter: string, exit: string]): Tag | undefined;
-    appendContent(text: string): void;
-    toJSON(): string;
-    toString(): string;
-}
-export interface TagAttributes {
-    dynamic?: boolean;
-    raw: boolean;
-    tagType?: ContentTagTagTypes | ValueTagTagTypes;
-}
-interface TagOptions {
-    rawBraces?: boolean;
-    content?: string;
-    value: string;
-}
-export {};