@bpmnkit/feel 0.0.8

package/dist/formatter.js

@@ -0,0 +1,120 @@
+const DEFAULTS = {
+    indent: "  ",
+    maxLineLength: 80,
+};
+export function formatFeel(node, opts) {
+    const o = { ...DEFAULTS, ...opts };
+    return fmt(node, o, 0);
+}
+function fmt(node, o, depth) {
+    const ind = o.indent.repeat(depth);
+    const ind1 = o.indent.repeat(depth + 1);
+    switch (node.kind) {
+        case "null":
+            return "null";
+        case "boolean":
+            return String(node.value);
+        case "number":
+            return String(node.value);
+        case "string":
+            return `"${node.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+        case "temporal":
+            return node.raw;
+        case "name":
+            return node.name;
+        case "unary-minus":
+            return `-${fmt(node.operand, o, depth)}`;
+        case "binary": {
+            const l = fmt(node.left, o, depth);
+            const r = fmt(node.right, o, depth);
+            return `${l} ${node.op} ${r}`;
+        }
+        case "path":
+            return `${fmt(node.base, o, depth)}.${node.key}`;
+        case "filter":
+            return `${fmt(node.base, o, depth)}[${fmt(node.condition, o, depth)}]`;
+        case "range": {
+            const s = fmt(node.low, o, depth);
+            const e = fmt(node.high, o, depth);
+            const open = node.startIncluded ? "[" : "(";
+            const close = node.endIncluded ? "]" : ")";
+            return `${open}${s}..${e}${close}`;
+        }
+        case "list": {
+            if (node.items.length === 0)
+                return "[]";
+            const inline = `[${node.items.map((i) => fmt(i, o, depth)).join(", ")}]`;
+            if (inline.length <= o.maxLineLength - depth * o.indent.length)
+                return inline;
+            const items = node.items.map((i) => `${ind1}${fmt(i, o, depth + 1)}`).join(",\n");
+            return `[\n${items}\n${ind}]`;
+        }
+        case "context": {
+            if (node.entries.length === 0)
+                return "{}";
+            const inline = `{${node.entries.map((e) => `${e.key}: ${fmt(e.value, o, depth)}`).join(", ")}}`;
+            if (inline.length <= o.maxLineLength - depth * o.indent.length)
+                return inline;
+            const entries = node.entries
+                .map((e) => `${ind1}${e.key}: ${fmt(e.value, o, depth + 1)}`)
+                .join(",\n");
+            return `{\n${entries}\n${ind}}`;
+        }
+        case "call": {
+            const args = node.args.map((a) => fmt(a, o, depth)).join(", ");
+            return `${node.callee}(${args})`;
+        }
+        case "call-named": {
+            const args = node.args.map((a) => `${a.name}: ${fmt(a.value, o, depth)}`).join(", ");
+            return `${node.callee}(${args})`;
+        }
+        case "if": {
+            const cond = fmt(node.condition, o, depth);
+            const thn = fmt(node.then, o, depth);
+            const els = fmt(node.else, o, depth);
+            const inline = `if ${cond} then ${thn} else ${els}`;
+            if (inline.length <= o.maxLineLength - depth * o.indent.length)
+                return inline;
+            return `if ${cond}\n${ind1}then ${thn}\n${ind1}else ${els}`;
+        }
+        case "for": {
+            const bindings = node.bindings
+                .map((b) => `${b.name} in ${fmt(b.domain, o, depth)}`)
+                .join(", ");
+            const body = fmt(node.body, o, depth);
+            const inline = `for ${bindings} return ${body}`;
+            if (inline.length <= o.maxLineLength - depth * o.indent.length)
+                return inline;
+            return `for ${bindings}\n${ind1}return ${body}`;
+        }
+        case "some":
+        case "every": {
+            const bindings = node.bindings
+                .map((b) => `${b.name} in ${fmt(b.domain, o, depth)}`)
+                .join(", ");
+            const sat = fmt(node.satisfies, o, depth);
+            const inline = `${node.kind} ${bindings} satisfies ${sat}`;
+            if (inline.length <= o.maxLineLength - depth * o.indent.length)
+                return inline;
+            return `${node.kind} ${bindings}\n${ind1}satisfies ${sat}`;
+        }
+        case "between":
+            return `${fmt(node.value, o, depth)} between ${fmt(node.low, o, depth)} and ${fmt(node.high, o, depth)}`;
+        case "in-test":
+            return `${fmt(node.value, o, depth)} in ${fmt(node.test, o, depth)}`;
+        case "instance-of":
+            return `${fmt(node.value, o, depth)} instance of ${node.typeName}`;
+        case "function-def": {
+            const params = node.params.join(", ");
+            const body = fmt(node.body, o, depth);
+            return `function(${params}) ${body}`;
+        }
+        case "unary-test-list":
+            return node.tests.map((t) => fmt(t, o, depth)).join(", ");
+        case "unary-not":
+            return `not(${node.tests.map((t) => fmt(t, o, depth)).join(", ")})`;
+        case "any-input":
+            return "-";
+    }
+}
+//# sourceMappingURL=formatter.js.map

package/dist/highlighter.d.ts

@@ -0,0 +1,14 @@
+export type HighlightKind = "keyword" | "operator" | "literal-number" | "literal-string" | "literal-temporal" | "literal-bool" | "literal-null" | "literal-range" | "builtin" | "variable" | "comment" | "punctuation" | "plain";
+export interface AnnotatedToken {
+    kind: HighlightKind;
+    value: string;
+    start: number;
+    end: number;
+}
+/** Annotate token stream with semantic highlight kinds. */
+export declare function annotate(input: string): AnnotatedToken[];
+/** Render annotated tokens to HTML with span wrappers. */
+export declare function highlightToHtml(input: string): string;
+/** Backward-compatible alias. */
+export declare const highlightFeel: typeof highlightToHtml;
+//# sourceMappingURL=highlighter.d.ts.map

package/dist/highlighter.js

@@ -0,0 +1,149 @@
+import { builtinNames } from "./builtins.js";
+import { tokenize } from "./lexer.js";
+const BUILTINS = new Set(builtinNames());
+// Multi-word built-in names for lookahead annotation
+const BUILTIN_PREFIXES = (() => {
+    const s = new Set();
+    for (const name of BUILTINS) {
+        const parts = name.split(" ");
+        for (let i = 1; i < parts.length; i++) {
+            s.add(parts.slice(0, i).join(" "));
+        }
+    }
+    return s;
+})();
+function classifyToken(tok, allTokens, idx) {
+    switch (tok.kind) {
+        case "number":
+            return { kind: "literal-number" };
+        case "string":
+            return { kind: "literal-string" };
+        case "temporal":
+            return { kind: "literal-temporal" };
+        case "comment":
+            return { kind: "comment" };
+        case "whitespace":
+            return { kind: "plain" };
+        case "unknown":
+            return { kind: "plain" };
+        case "backtick":
+            return { kind: "variable" };
+        case "op":
+        case "punct":
+            return { kind: tok.kind === "punct" ? "punctuation" : "operator" };
+        case "keyword": {
+            if (tok.value === "true" || tok.value === "false")
+                return { kind: "literal-bool" };
+            if (tok.value === "null")
+                return { kind: "literal-null" };
+            return { kind: "keyword" };
+        }
+        case "name": {
+            // Try to match multi-word builtin
+            let name = tok.value;
+            let lookahead = idx + 1;
+            while (BUILTIN_PREFIXES.has(name)) {
+                // Skip whitespace
+                while (lookahead < allTokens.length && allTokens[lookahead]?.kind === "whitespace") {
+                    lookahead++;
+                }
+                const next = allTokens[lookahead];
+                if (!next || (next.kind !== "name" && next.kind !== "keyword"))
+                    break;
+                const extended = `${name} ${next.value}`;
+                if (BUILTINS.has(extended) || BUILTIN_PREFIXES.has(extended)) {
+                    name = extended;
+                    lookahead++;
+                }
+                else {
+                    break;
+                }
+            }
+            if (BUILTINS.has(name))
+                return { kind: "builtin", name };
+            return { kind: "variable" };
+        }
+    }
+}
+/** Annotate token stream with semantic highlight kinds. */
+export function annotate(input) {
+    const tokens = tokenize(input);
+    const result = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        if (!tok) {
+            i++;
+            continue;
+        }
+        // Try multi-word built-in name
+        if (tok.kind === "name") {
+            let name = tok.value;
+            let end = i + 1;
+            let endPos = tok.end;
+            // Greedy multi-word match
+            let lookahead = end;
+            while (BUILTIN_PREFIXES.has(name)) {
+                const wsStart = lookahead;
+                while (lookahead < tokens.length && tokens[lookahead]?.kind === "whitespace")
+                    lookahead++;
+                const next = tokens[lookahead];
+                if (!next || (next.kind !== "name" && next.kind !== "keyword")) {
+                    lookahead = wsStart;
+                    break;
+                }
+                const extended = `${name} ${next.value}`;
+                if (BUILTINS.has(extended) || BUILTIN_PREFIXES.has(extended)) {
+                    name = extended;
+                    lookahead++;
+                    end = lookahead;
+                    endPos = next.end;
+                }
+                else {
+                    lookahead = wsStart;
+                    break;
+                }
+            }
+            if (BUILTINS.has(name) && end > i + 1) {
+                // Multi-word builtin: emit all tokens as builtin
+                for (let j = i; j < end; j++) {
+                    const t = tokens[j];
+                    if (!t)
+                        continue;
+                    result.push({
+                        kind: t.kind === "whitespace" ? "plain" : "builtin",
+                        value: t.value,
+                        start: t.start,
+                        end: t.end,
+                    });
+                }
+                i = end;
+                continue;
+            }
+        }
+        const { kind } = classifyToken(tok, tokens, i);
+        result.push({ kind, value: tok.value, start: tok.start, end: tok.end });
+        i++;
+    }
+    return result;
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** 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) => {
+        const escaped = escapeHtml(t.value);
+        if (t.kind === "plain")
+            return escaped;
+        return `<span class="feel-${t.kind}">${escaped}</span>`;
+    })
+        .join("");
+}
+/** Backward-compatible alias. */
+export const highlightFeel = highlightToHtml;
+//# sourceMappingURL=highlighter.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { FeelValue, FeelDate, FeelTime, FeelDateTime, FeelDayTimeDuration, FeelYearsMonthsDuration, FeelRange, FeelContext, FeelFunction, } from "./types.js";
+export { isFeelDate, isFeelTime, isFeelDateTime, isFeelDayTimeDuration, isFeelYearsMonthsDuration, isFeelDuration, isFeelList, isFeelContext, isFeelRange, isFeelFunction, getProperty, } from "./types.js";
+export { tokenize } from "./lexer.js";
+export type { FeelToken, FeelTokenKind } from "./lexer.js";
+export type { FeelNode, BinaryOp } from "./ast.js";
+export { parseExpression, parseUnaryTests } from "./parser.js";
+export type { ParseResult, ParseError } from "./parser.js";
+export { evaluate, evaluateUnaryTests, evaluateUnaryTest } from "./evaluator.js";
+export type { EvalContext } from "./evaluator.js";
+export { formatFeel } from "./formatter.js";
+export type { FormatOptions } from "./formatter.js";
+export { annotate, highlightToHtml, highlightFeel } from "./highlighter.js";
+export type { AnnotatedToken, HighlightKind } from "./highlighter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+export { isFeelDate, isFeelTime, isFeelDateTime, isFeelDayTimeDuration, isFeelYearsMonthsDuration, isFeelDuration, isFeelList, isFeelContext, isFeelRange, isFeelFunction, getProperty, } from "./types.js";
+// Lexer
+export { tokenize } from "./lexer.js";
+// Parser
+export { parseExpression, parseUnaryTests } from "./parser.js";
+// Evaluator
+export { evaluate, evaluateUnaryTests, evaluateUnaryTest } from "./evaluator.js";
+// Formatter
+export { formatFeel } from "./formatter.js";
+// Highlighter
+export { annotate, highlightToHtml, highlightFeel } from "./highlighter.js";
+//# sourceMappingURL=index.js.map

package/dist/lexer.d.ts

@@ -0,0 +1,9 @@
+export type FeelTokenKind = "number" | "string" | "temporal" | "name" | "keyword" | "op" | "punct" | "comment" | "whitespace" | "backtick" | "unknown";
+export interface FeelToken {
+    kind: FeelTokenKind;
+    value: string;
+    start: number;
+    end: number;
+}
+export declare function tokenize(input: string): FeelToken[];
+//# sourceMappingURL=lexer.d.ts.map

package/dist/lexer.js

@@ -0,0 +1,161 @@
+const KEYWORDS = new Set([
+    "true",
+    "false",
+    "null",
+    "if",
+    "then",
+    "else",
+    "for",
+    "in",
+    "return",
+    "some",
+    "every",
+    "satisfies",
+    "function",
+    "external",
+    "not",
+    "and",
+    "or",
+    "between",
+    "instance",
+    "of",
+]);
+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;
+        // Line comment
+        if (ch() === "/" && ch(1) === "/") {
+            i += 2;
+            while (i < len && ch() !== "\n")
+                i++;
+            tokens.push({ kind: "comment", value: slice(start, i), start, end: i });
+            continue;
+        }
+        // Block comment
+        if (ch() === "/" && ch(1) === "*") {
+            i += 2;
+            while (i < len && !(ch() === "*" && ch(1) === "/"))
+                i++;
+            i += 2;
+            tokens.push({ kind: "comment", value: slice(start, i), start, end: i });
+            continue;
+        }
+        // Temporal literal @"..."
+        if (ch() === "@" && ch(1) === '"') {
+            i += 2;
+            while (i < len && ch() !== '"') {
+                if (ch() === "\\")
+                    i++;
+                i++;
+            }
+            i++; // closing "
+            tokens.push({ kind: "temporal", value: slice(start, i), start, end: i });
+            continue;
+        }
+        // String literal
+        if (ch() === '"') {
+            i++;
+            while (i < len && ch() !== '"') {
+                if (ch() === "\\")
+                    i++;
+                i++;
+            }
+            i++; // closing "
+            tokens.push({ kind: "string", value: slice(start, i), start, end: i });
+            continue;
+        }
+        // Backtick name
+        if (ch() === "`") {
+            i++;
+            while (i < len && ch() !== "`")
+                i++;
+            i++; // closing `
+            tokens.push({
+                kind: "backtick",
+                value: 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"))
+                i++;
+            tokens.push({ kind: "whitespace", value: 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 });
+            i += 2;
+            continue;
+        }
+        // "==" is not standard FEEL but users familiar with JS/Java write it; treat as "=".
+        if (two === "==") {
+            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 });
+            i++;
+            continue;
+        }
+        // Punctuation
+        if ("()[]{},:".includes(ch())) {
+            tokens.push({ kind: "punct", value: ch(), start, end: i + 1 });
+            i++;
+            continue;
+        }
+        // Dot (not ..)
+        if (ch() === ".") {
+            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")
+                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") {
+                i++; // consume the '.'
+                while (i < len && ch() >= "0" && ch() <= "9")
+                    i++;
+            }
+            tokens.push({ kind: "number", value: 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() === "_"))
+                i++;
+            const word = 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 });
+        i++;
+    }
+    return tokens;
+}
+//# sourceMappingURL=lexer.js.map

package/dist/parser.d.ts

@@ -0,0 +1,13 @@
+import type { FeelNode } from "./ast.js";
+export interface ParseError {
+    message: string;
+    start: number;
+    end: number;
+}
+export interface ParseResult {
+    ast: FeelNode | null;
+    errors: ParseError[];
+}
+export declare function parseExpression(input: string): ParseResult;
+export declare function parseUnaryTests(input: string): ParseResult;
+//# sourceMappingURL=parser.d.ts.map