@bpmnkit/feel 0.0.20 → 0.0.21

package/README.md

@@ -9,7 +9,7 @@
   [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
   [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
 
-  [Website](https://bpmnkit.com) · [Documentation](https://docs.bpmnkit.com) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/feel/CHANGELOG.md)
+  [Website](https://bpmnkit.com) · [Documentation](https://bpmnkit.com/docs) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/feel/CHANGELOG.md)
 </div>
 
 ---
@@ -117,6 +117,7 @@ interface ParseResult {
 | [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
 | [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |
 | [`@bpmnkit/worker-client`](https://www.npmjs.com/package/@bpmnkit/worker-client) | Thin Zeebe REST client for standalone workers |
+| [`@bpmnkit/user-tasks`](https://www.npmjs.com/package/@bpmnkit/user-tasks) | Embeddable user task widget for Camunda 8 |
 | [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
 | [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
 | [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |

package/dist/builtins.js

@@ -319,18 +319,39 @@ reg("ends with", (str, match) => {
         return null;
     return s.endsWith(m);
 });
+// Patterns in FEEL come from static expression text, so the same few regexes
+// are compiled over and over inside loops and decision tables; keep them.
+const REGEX_CACHE_LIMIT = 256;
+const regexCache = new Map();
+/** Compiled regex for `pattern`/`flags`, or null when the pattern is invalid. */
+function cachedRegExp(pattern, flags) {
+    const key = `${flags}/${pattern}`;
+    const hit = regexCache.get(key);
+    if (hit !== undefined)
+        return hit;
+    let re;
+    try {
+        re = new RegExp(pattern, flags);
+    }
+    catch {
+        re = null;
+    }
+    if (regexCache.size >= REGEX_CACHE_LIMIT)
+        regexCache.clear();
+    regexCache.set(key, re);
+    return re;
+}
 reg("matches", (str, pattern, flags) => {
     const s = toStr(str);
     const p = toStr(pattern);
     if (s === null || p === null)
         return null;
     const f = flags !== undefined && flags !== null ? (toStr(flags) ?? "") : "";
-    try {
-        return new RegExp(p, f).test(s);
-    }
-    catch {
+    const re = cachedRegExp(p, f);
+    if (re === null)
         return null;
-    }
+    re.lastIndex = 0;
+    return re.test(s);
 });
 reg("replace", (str, pattern, replacement, flags) => {
     const s = toStr(str);
@@ -339,24 +360,19 @@ reg("replace", (str, pattern, replacement, flags) => {
     if (s === null || p === null || r === null)
         return null;
     const f = flags !== undefined && flags !== null ? (toStr(flags) ?? "g") : "g";
-    try {
-        return s.replace(new RegExp(p, f.includes("g") ? f : `${f}g`), r);
-    }
-    catch {
+    const re = cachedRegExp(p, f.includes("g") ? f : `${f}g`);
+    if (re === null)
         return null;
-    }
+    re.lastIndex = 0;
+    return s.replace(re, r);
 });
 reg("split", (str, delimiter) => {
     const s = toStr(str);
     const d = toStr(delimiter);
     if (s === null || d === null)
         return null;
-    try {
-        return s.split(new RegExp(d));
-    }
-    catch {
-        return s.split(d);
-    }
+    const re = cachedRegExp(d, "");
+    return re === null ? s.split(d) : s.split(re);
 });
 reg("string join", (...args) => {
     const flat = flattenToList(args);
@@ -713,45 +729,40 @@ reg("index of", (list, match) => {
     }
     return result;
 });
+// Set membership is SameValueZero, exactly what Array#includes used here, so
+// de-duplication keeps its semantics while dropping from O(n²) to O(n).
 reg("union", (...args) => {
-    const result = [];
+    const seen = new Set();
     for (const v of args) {
         if (isFeelList(v)) {
-            for (const item of v) {
-                if (!result.includes(item))
-                    result.push(item);
-            }
+            for (const item of v)
+                seen.add(item);
         }
-        else if (!result.includes(v)) {
-            result.push(v);
+        else {
+            seen.add(v);
         }
     }
-    return result;
+    return [...seen];
 });
 reg("distinct values", (list) => {
     if (!isFeelList(list))
         return null;
-    const result = [];
-    for (const v of list) {
-        if (!result.includes(v))
-            result.push(v);
-    }
-    return result;
+    return [...new Set(list)];
 });
 reg("flatten", (list) => {
     if (!isFeelList(list))
         return null;
+    const result = [];
     const flat = (arr) => {
-        const result = [];
         for (const v of arr) {
             if (isFeelList(v))
-                result.push(...flat(v));
+                flat(v);
             else
                 result.push(v);
         }
-        return result;
     };
-    return flat(list);
+    flat(list);
+    return result;
 });
 reg("sort", (list, fn) => {
     if (!isFeelList(list))
@@ -1178,12 +1189,21 @@ reg("coincides", (a, b) => {
 // -------------------------------------------------------------------------
 // Exports
 // -------------------------------------------------------------------------
+// One FeelFunction wrapper per built-in, created on first use and shared: name
+// resolution runs for every identifier the evaluator meets, so allocating a
+// wrapper and closure per lookup showed up on every loop iteration.
+const builtinWrappers = new Map();
 /** Look up a built-in function by name. Returns undefined if not found. */
 export function getBuiltin(name) {
+    const cached = builtinWrappers.get(name);
+    if (cached)
+        return cached;
     const fn = builtinMap.get(name);
     if (!fn)
         return undefined;
-    return { type: "function", call: (args) => fn(...args) };
+    const wrapper = { type: "function", call: (args) => fn(...args) };
+    builtinWrappers.set(name, wrapper);
+    return wrapper;
 }
 /** All built-in names. */
 export function builtinNames() {

package/dist/highlighter.js

@@ -120,6 +120,16 @@ export function annotate(input) {
                 i = end;
                 continue;
             }
+            // The greedy match above already decided whether this word is a
+            // built-in; re-running the lookahead in classifyToken would repeat it.
+            result.push({
+                kind: BUILTINS.has(name) ? "builtin" : "variable",
+                value: tok.value,
+                start: tok.start,
+                end: tok.end,
+            });
+            i++;
+            continue;
         }
         const { kind } = classifyToken(tok, tokens, i);
         result.push({ kind, value: tok.value, start: tok.start, end: tok.end });
@@ -127,22 +137,25 @@ export function annotate(input) {
     }
     return result;
 }
+const HTML_ESCAPE_RE = /[&<>]/;
+const HTML_ESCAPE_ALL_RE = /[&<>]/g;
+const HTML_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;" };
 function escapeHtml(s) {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    // Most tokens contain nothing to escape; one test beats three replace passes.
+    if (!HTML_ESCAPE_RE.test(s))
+        return s;
+    return s.replace(HTML_ESCAPE_ALL_RE, (ch) => HTML_ESCAPES[ch] ?? ch);
 }
 /** Render annotated tokens to HTML with span wrappers. */
 export function highlightToHtml(input) {
     if (!input.trim())
         return escapeHtml(input) || '<span class="feel-empty">-</span>';
-    const tokens = annotate(input);
-    return tokens
-        .map((t) => {
+    let html = "";
+    for (const t of annotate(input)) {
         const escaped = escapeHtml(t.value);
-        if (t.kind === "plain")
-            return escaped;
-        return `<span class="feel-${t.kind}">${escaped}</span>`;
-    })
-        .join("");
+        html += t.kind === "plain" ? escaped : `<span class="feel-${t.kind}">${escaped}</span>`;
+    }
+    return html;
 }
 /** Backward-compatible alias. */
 export const highlightFeel = highlightToHtml;

package/dist/lexer.js

@@ -20,140 +20,171 @@ const KEYWORDS = new Set([
     "instance",
     "of",
 ]);
+// Character codes; comparing codes avoids allocating a one-character string
+// for every position the scanner visits.
+const SLASH = 0x2f;
+const STAR = 0x2a;
+const AT = 0x40;
+const DQUOTE = 0x22;
+const BACKSLASH = 0x5c;
+const BACKTICK = 0x60;
+const SPACE = 0x20;
+const TAB = 0x09;
+const LF = 0x0a;
+const CR = 0x0d;
+const DOT = 0x2e;
+const GT = 0x3e;
+const LT = 0x3c;
+const BANG = 0x21;
+const MINUS = 0x2d;
+const EQ = 0x3d;
+const UNDERSCORE = 0x5f;
+function isDigit(c) {
+    return c >= 0x30 && c <= 0x39;
+}
+function isLetter(c) {
+    return (c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a);
+}
+function isWhitespace(c) {
+    return c === SPACE || c === TAB || c === LF || c === CR;
+}
+const SINGLE_OPS = new Set("+-*/=<>?".split("").map((c) => c.charCodeAt(0)));
+const PUNCT = new Set("()[]{},:".split("").map((c) => c.charCodeAt(0)));
 export function tokenize(input) {
     const tokens = [];
     let i = 0;
     const len = input.length;
-    const ch = (offset = 0) => input.charAt(i + offset);
-    const slice = (start, end) => input.slice(start, end);
     while (i < len) {
         const start = i;
+        const c = input.charCodeAt(i);
+        // NaN past the end never equals any code, so lookahead needs no bounds check.
+        const next = input.charCodeAt(i + 1);
         // Line comment
-        if (ch() === "/" && ch(1) === "/") {
+        if (c === SLASH && next === SLASH) {
             i += 2;
-            while (i < len && ch() !== "\n")
+            while (i < len && input.charCodeAt(i) !== LF)
                 i++;
-            tokens.push({ kind: "comment", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "comment", value: input.slice(start, i), start, end: i });
             continue;
         }
         // Block comment
-        if (ch() === "/" && ch(1) === "*") {
+        if (c === SLASH && next === STAR) {
             i += 2;
-            while (i < len && !(ch() === "*" && ch(1) === "/"))
+            while (i < len && !(input.charCodeAt(i) === STAR && input.charCodeAt(i + 1) === SLASH))
                 i++;
             i += 2;
-            tokens.push({ kind: "comment", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "comment", value: input.slice(start, i), start, end: i });
             continue;
         }
         // Temporal literal @"..."
-        if (ch() === "@" && ch(1) === '"') {
+        if (c === AT && next === DQUOTE) {
             i += 2;
-            while (i < len && ch() !== '"') {
-                if (ch() === "\\")
+            while (i < len && input.charCodeAt(i) !== DQUOTE) {
+                if (input.charCodeAt(i) === BACKSLASH)
                     i++;
                 i++;
             }
             i++; // closing "
-            tokens.push({ kind: "temporal", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "temporal", value: input.slice(start, i), start, end: i });
             continue;
         }
         // String literal
-        if (ch() === '"') {
+        if (c === DQUOTE) {
             i++;
-            while (i < len && ch() !== '"') {
-                if (ch() === "\\")
+            while (i < len && input.charCodeAt(i) !== DQUOTE) {
+                if (input.charCodeAt(i) === BACKSLASH)
                     i++;
                 i++;
             }
             i++; // closing "
-            tokens.push({ kind: "string", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "string", value: input.slice(start, i), start, end: i });
             continue;
         }
         // Backtick name
-        if (ch() === "`") {
+        if (c === BACKTICK) {
             i++;
-            while (i < len && ch() !== "`")
+            while (i < len && input.charCodeAt(i) !== BACKTICK)
                 i++;
             i++; // closing `
             tokens.push({
                 kind: "backtick",
-                value: slice(start + 1, i - 1),
+                value: input.slice(start + 1, i - 1),
                 start,
                 end: i,
             });
             continue;
         }
         // Whitespace
-        if (ch() === " " || ch() === "\t" || ch() === "\n" || ch() === "\r") {
-            while (i < len && (ch() === " " || ch() === "\t" || ch() === "\n" || ch() === "\r"))
+        if (isWhitespace(c)) {
+            while (i < len && isWhitespace(input.charCodeAt(i)))
                 i++;
-            tokens.push({ kind: "whitespace", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "whitespace", value: input.slice(start, i), start, end: i });
             continue;
         }
         // Two-char operators (check before single-char)
-        const two = slice(i, i + 2);
-        if (two === "**" ||
-            two === ">=" ||
-            two === "<=" ||
-            two === "!=" ||
-            two === "->" ||
-            two === "..") {
-            tokens.push({ kind: "op", value: two, start, end: i + 2 });
+        if ((c === STAR && next === STAR) ||
+            (c === GT && next === EQ) ||
+            (c === LT && next === EQ) ||
+            (c === BANG && next === EQ) ||
+            (c === MINUS && next === GT) ||
+            (c === DOT && next === DOT)) {
+            tokens.push({ kind: "op", value: input.slice(i, i + 2), start, end: i + 2 });
             i += 2;
             continue;
         }
         // "==" is not standard FEEL but users familiar with JS/Java write it; treat as "=".
-        if (two === "==") {
+        if (c === EQ && next === EQ) {
             tokens.push({ kind: "op", value: "=", start, end: i + 2 });
             i += 2;
             continue;
         }
         // Single-char operators
-        if ("+-*/=<>?".includes(ch())) {
-            tokens.push({ kind: "op", value: ch(), start, end: i + 1 });
+        if (SINGLE_OPS.has(c)) {
+            tokens.push({ kind: "op", value: input[i], start, end: i + 1 });
             i++;
             continue;
         }
         // Punctuation
-        if ("()[]{},:".includes(ch())) {
-            tokens.push({ kind: "punct", value: ch(), start, end: i + 1 });
+        if (PUNCT.has(c)) {
+            tokens.push({ kind: "punct", value: input[i], start, end: i + 1 });
             i++;
             continue;
         }
         // Dot (not ..)
-        if (ch() === ".") {
+        if (c === DOT) {
             tokens.push({ kind: "punct", value: ".", start, end: i + 1 });
             i++;
             continue;
         }
         // Number (only consume one decimal point, and only if followed by a digit)
-        if (ch() >= "0" && ch() <= "9") {
-            while (i < len && ch() >= "0" && ch() <= "9")
+        if (isDigit(c)) {
+            while (i < len && isDigit(input.charCodeAt(i)))
                 i++;
             // Consume decimal fraction only if next char is '.' followed by a digit (not '..')
-            if (i < len && ch() === "." && i + 1 < len && ch(1) >= "0" && ch(1) <= "9") {
+            if (i + 1 < len && input.charCodeAt(i) === DOT && isDigit(input.charCodeAt(i + 1))) {
                 i++; // consume the '.'
-                while (i < len && ch() >= "0" && ch() <= "9")
+                while (i < len && isDigit(input.charCodeAt(i)))
                     i++;
             }
-            tokens.push({ kind: "number", value: slice(start, i), start, end: i });
+            tokens.push({ kind: "number", value: input.slice(start, i), start, end: i });
             continue;
         }
         // Identifier / keyword
-        if ((ch() >= "a" && ch() <= "z") || (ch() >= "A" && ch() <= "Z") || ch() === "_") {
-            while (i < len &&
-                ((ch() >= "a" && ch() <= "z") ||
-                    (ch() >= "A" && ch() <= "Z") ||
-                    (ch() >= "0" && ch() <= "9") ||
-                    ch() === "_"))
+        if (isLetter(c) || c === UNDERSCORE) {
+            i++;
+            while (i < len) {
+                const w = input.charCodeAt(i);
+                if (!isLetter(w) && !isDigit(w) && w !== UNDERSCORE)
+                    break;
                 i++;
-            const word = slice(start, i);
+            }
+            const word = input.slice(start, i);
             const kind = KEYWORDS.has(word) ? "keyword" : "name";
             tokens.push({ kind, value: word, start, end: i });
             continue;
         }
         // Unknown character
-        tokens.push({ kind: "unknown", value: ch(), start, end: i + 1 });
+        tokens.push({ kind: "unknown", value: input[i], start, end: i + 1 });
         i++;
     }
     return tokens;

package/dist/parser.js

@@ -854,18 +854,40 @@ class Parser {
         }
     }
 }
+// Expression text is static model content that engines and decision tables
+// evaluate over and over, so parse results are memoized. Results are treated
+// as immutable by every consumer; the caches are bounded and simply reset when
+// full.
+const PARSE_CACHE_LIMIT = 2048;
+const expressionCache = new Map();
+const unaryTestsCache = new Map();
+function remember(cache, input, result) {
+    if (cache.size >= PARSE_CACHE_LIMIT)
+        cache.clear();
+    cache.set(input, result);
+    return result;
+}
 export function parseExpression(input) {
+    const cached = expressionCache.get(input);
+    if (cached !== undefined)
+        return cached;
     const p = new Parser(input);
     const ast = p.parseExpression(0);
     p.checkDone();
-    return { ast, errors: p.errors };
+    return remember(expressionCache, input, { ast, errors: p.errors });
 }
 export function parseUnaryTests(input) {
+    const cached = unaryTestsCache.get(input);
+    if (cached !== undefined)
+        return cached;
     if (input.trim() === "-") {
-        return { ast: { kind: "any-input", start: 0, end: input.length }, errors: [] };
+        return remember(unaryTestsCache, input, {
+            ast: { kind: "any-input", start: 0, end: input.length },
+            errors: [],
+        });
     }
     const p = new Parser(input);
     const ast = p.parseUnaryTests();
-    return { ast, errors: p.errors };
+    return remember(unaryTestsCache, input, { ast, errors: p.errors });
 }
 //# sourceMappingURL=parser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/feel",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "private": false,
   "type": "module",
   "exports": {