@ender672/minja-js 0.1.1 → 0.1.2

package/README.md

@@ -9,19 +9,13 @@ This is an independent port — not affiliated with or endorsed by the original
 ### Low-level: parse and render a template
 
 ```js
-import { Parser, Context, parseTemplate } from '@ender672/minja-js/minja';
+import { Parser, Context } from '@ender672/minja-js/minja';
 
-// parseTemplate() caches the AST so repeated calls with the same
-// template string skip parsing. The AST is stateless — safe to
-// render concurrently with different contexts.
-const root = parseTemplate('Hello {{ name }}!');
+const root = Parser.parse('Hello {{ name }}!');
 const ctx = Context.make({ name: 'world' });
 console.log(root.render(ctx)); // "Hello world!"
 ```
 
-If you are generating template strings dynamically and don't want to
-fill the cache, call `Parser.parse()` directly instead.
-
 ### High-level: ChatTemplate
 
 ```js
@@ -34,10 +28,6 @@ const output = tmpl.apply({
 });
 ```
 
-`ChatTemplate` automatically caches its parsed AST via `parseTemplate()`,
-so constructing multiple `ChatTemplate` instances with the same source
-string only parses the template once.
-
 ## Running tests
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ender672/minja-js",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "JavaScript port of the Minja Jinja2 template engine for LLM chat templates",
   "license": "MIT",

package/src/chat-template.js

@@ -7,14 +7,14 @@
 */
 // SPDX-License-Identifier: MIT
 
-import { Parser, Context, Value, parseTemplate } from './minja.js';
+import { Parser, Context, Value } from './minja.js';
 
 export class ChatTemplate {
   constructor(source, bosToken = '', eosToken = '') {
     this._source = source;
     this._bosToken = bosToken;
     this._eosToken = eosToken;
-    this._templateRoot = parseTemplate(source, {
+    this._templateRoot = Parser.parse(source, {
       trimBlocks: true,
       lstripBlocks: true,
       keepTrailingNewline: false,

package/src/minja.js

@@ -2438,49 +2438,4 @@ function _createBuiltins() {
 
   return new Context(globals);
 }
-
-// ── Template Cache ──────────────────────────────────────────────────────
-//
-// Parser.parse() builds an AST from a template string. The AST is stateless —
-// all runtime state lives in the Context passed to render(). That means a
-// parsed template can be rendered any number of times with different contexts,
-// and concurrent renders of the same cached AST are safe.
-//
-// This cache is keyed on (templateStr + options) so that the same template
-// parsed with different whitespace-control options gets separate entries.
-// It uses a plain Map (unbounded) which is fine for the expected use case of
-// tens-to-hundreds of distinct chat templates in a server process. If you are
-// dynamically generating template strings, bypass the cache and call
-// Parser.parse() directly.
-//
-const _templateCache = new Map();
-
-function _cacheKey(templateStr, options) {
-  return `${templateStr}\0${options.trimBlocks ? 1 : 0}${options.lstripBlocks ? 1 : 0}${options.keepTrailingNewline ? 1 : 0}`;
-}
-
-/**
- * Parse a template string into a reusable AST, returning a cached copy if
- * the same template and options have been parsed before.
- *
- * The returned AST is stateless and safe for concurrent use across renders.
- */
-function parseTemplate(templateStr, options = {}) {
-  const key = _cacheKey(templateStr, options);
-  let root = _templateCache.get(key);
-  if (!root) {
-    root = Parser.parse(templateStr, options);
-    _templateCache.set(key, root);
-  }
-  return root;
-}
-
-/**
- * Clear the parsed-template cache. Useful in tests or if you want to
- * reclaim memory after loading a batch of templates you no longer need.
- */
-function clearTemplateCache() {
-  _templateCache.clear();
-}
-
-export { Parser, Context, Value, parseTemplate, clearTemplateCache };
+export { Parser, Context, Value };