@hyperfixi/core 2.9.1 → 2.9.3

package/dist/index.mjs

@@ -514,13 +514,13 @@ function tokenize$1(input) {
             continue;
         }
         if (char === '{') {
-            addToken(tokenizer, TokenKind.OPERATOR, '{');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '{');
             continue;
         }
         if (char === '}') {
-            addToken(tokenizer, TokenKind.OPERATOR, '}');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '}');
             continue;
         }
         if (char === '[') {
@@ -536,24 +536,24 @@ function tokenize$1(input) {
                     prevToken.value === ']') &&
                 !isEventCondition;
             if (isMemberAccess) {
-                addToken(tokenizer, TokenKind.OPERATOR, '[');
                 advance(tokenizer);
+                addToken(tokenizer, TokenKind.OPERATOR, '[');
             }
             else {
                 if (isEventCondition) {
-                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                 }
                 else {
-                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                 }
             }
             continue;
         }
         if (char === ']') {
-            addToken(tokenizer, TokenKind.OPERATOR, ']');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, ']');
             continue;
         }
         if (char === '$') {
@@ -2980,7 +2980,6 @@ const MULTI_WORD_PATTERNS = [
         keywords: ['a', 'an', 'from', 'called'],
         syntax: 'make (a|an) <type> [from <args>] [called <name>]',
     },
-    { command: 'send', keywords: ['to'], syntax: 'send <event> to <target>' },
     { command: 'throw', keywords: [], syntax: 'throw <error>' },
 ];
 function getMultiWordPattern(commandName) {
@@ -3281,7 +3280,13 @@ function parseTriggerCommand(ctx, identifierNode) {
             finalArgs.push(ctx.createIdentifier(keyword));
             continue;
         }
-        finalArgs.push(ctx.parsePrimary());
+        const before = ctx.savePosition();
+        const expr = ctx.parsePrimary();
+        if (expr)
+            finalArgs.push(expr);
+        if (ctx.savePosition() === before) {
+            ctx.advance();
+        }
     }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...finalArgs)
@@ -3500,11 +3505,64 @@ function parseRepeatCommand(ctx, commandToken) {
     }
     return builder.endingAt(ctx.getPosition()).build();
 }
+function parseIfBranchCommands(ctx, stopAtElse) {
+    const commands = [];
+    const atTerminator = () => ctx.check(KEYWORDS$1.END) || (stopAtElse && ctx.check(KEYWORDS$1.ELSE));
+    while (!ctx.isAtEnd() && !atTerminator()) {
+        if (isComment(ctx.peek())) {
+            ctx.advance();
+            continue;
+        }
+        if (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))
+            break;
+        ctx.advance();
+        const cmd = ctx.parseCommand();
+        if (cmd) {
+            commands.push(cmd);
+        }
+        if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.AND) || ctx.check(',')) {
+            ctx.advance();
+        }
+    }
+    return commands;
+}
+const OPERAND_INTRODUCERS = new Set([
+    'is',
+    'am',
+    'are',
+    'not',
+    'no',
+    'and',
+    'or',
+    '==',
+    '===',
+    '!=',
+    '!==',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    'mod',
+]);
+function isBodyCommandStart(ctx, prevToken, token) {
+    if (prevToken === null) {
+        return false;
+    }
+    if (OPERAND_INTRODUCERS.has(prevToken.value?.toLowerCase?.() ?? '')) {
+        return false;
+    }
+    return ctx.checkIsCommand() || ctx.isCommand(token.value?.toLowerCase());
+}
 function parseIfCommand(ctx, commandToken) {
     const args = [];
     let hasThen = false;
     const savedPosForThen = ctx.savePosition();
     const maxThenLookahead = 500;
+    let prevForThen = null;
     for (let i = 0; i < maxThenLookahead && !ctx.isAtEnd(); i++) {
         const token = ctx.peek();
         if (token.value === KEYWORDS$1.THEN) {
@@ -3517,6 +3575,14 @@ function parseIfCommand(ctx, commandToken) {
             token.value === KEYWORDS$1.ON) {
             break;
         }
+        if (token.line !== undefined &&
+            token.line !== commandToken.line &&
+            isBodyCommandStart(ctx, prevForThen, token)) {
+            break;
+        }
+        if (!isComment(token)) {
+            prevForThen = token;
+        }
         ctx.advance();
     }
     ctx.restorePosition(savedPosForThen);
@@ -3525,9 +3591,14 @@ function parseIfCommand(ctx, commandToken) {
         const savedPosition = ctx.savePosition();
         const ifStatementLine = commandToken.line;
         const maxLookahead = 100;
+        let firstCommandOnIfLine = false;
+        let prevToken = null;
         while (!ctx.isAtEnd() && ctx.current - savedPosition < maxLookahead) {
             const token = ctx.peek();
             const tokenValue = token.value?.toLowerCase();
+            if (firstCommandOnIfLine && token.line !== undefined && token.line !== ifStatementLine) {
+                break;
+            }
             if (tokenValue === KEYWORDS$1.BEHAVIOR ||
                 tokenValue === KEYWORDS$1.DEF ||
                 tokenValue === KEYWORDS$1.ON) {
@@ -3539,11 +3610,15 @@ function parseIfCommand(ctx, commandToken) {
                 }
                 break;
             }
-            if (ctx.checkIsCommand() || ctx.isCommand(tokenValue)) {
+            if (isBodyCommandStart(ctx, prevToken, token)) {
                 if (token.line !== undefined && token.line !== ifStatementLine) {
                     hasImplicitMultiLineEnd = true;
                     break;
                 }
+                firstCommandOnIfLine = true;
+            }
+            if (!isComment(token)) {
+                prevToken = token;
             }
             ctx.advance();
         }
@@ -3558,11 +3633,12 @@ function parseIfCommand(ctx, commandToken) {
         const conditionTokens = [];
         const maxIterations = 20;
         let iterations = 0;
+        let firstConditionParse = true;
         while (!ctx.isAtEnd() &&
-            !ctx.checkIsCommand() &&
-            !ctx.isCommand(ctx.peek().value) &&
             !ctx.check(KEYWORDS$1.THEN) &&
+            (firstConditionParse || (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))) &&
             iterations < maxIterations) {
+            firstConditionParse = false;
             const beforePos = ctx.savePosition();
             conditionTokens.push(ctx.parseLogicalAnd());
             if (ctx.savePosition() === beforePos) {
@@ -3589,22 +3665,8 @@ function parseIfCommand(ctx, commandToken) {
     }
     args.push(condition);
     if (isMultiLine) {
-        if (hasThen) {
-            ctx.advance();
-        }
-        const thenCommands = [];
-        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.ELSE) && !ctx.check(KEYWORDS$1.END)) {
-            if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                ctx.advance();
-                const cmd = ctx.parseCommand();
-                if (cmd) {
-                    thenCommands.push(cmd);
-                }
-            }
-            else {
-                break;
-            }
-        }
+        consumeOptionalKeyword(ctx, KEYWORDS$1.THEN);
+        const thenCommands = parseIfBranchCommands(ctx, true);
         if (thenCommands.length === 0 && ctx.isAtEnd()) {
             throw new Error("Expected command after 'then' in if statement - incomplete conditional");
         }
@@ -3630,19 +3692,7 @@ function parseIfCommand(ctx, commandToken) {
                 consumedElseIf = true;
             }
             else {
-                const elseCommands = [];
-                while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
-                    if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                        ctx.advance();
-                        const cmd = ctx.parseCommand();
-                        if (cmd) {
-                            elseCommands.push(cmd);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
+                const elseCommands = parseIfBranchCommands(ctx, false);
                 args.push(createBlock(elseCommands, {
                     start: commandToken.start,
                     end: ctx.getPosition().end,
@@ -4464,21 +4514,6 @@ const GO_KEYWORDS = new Set([
     'back',
     'forward',
 ]);
-const GO_URL_STOP = new Set([
-    'in',
-    'then',
-    'and',
-    'else',
-    'end',
-    'otherwise',
-    'when',
-    'where',
-    'catch',
-    'finally',
-]);
-function isGoURLTerminator(ctx) {
-    return ctx.isAtEnd() || GO_URL_STOP.has(ctx.peek().value);
-}
 function stringNode(value, tok) {
     return {
         type: 'string',
@@ -4500,7 +4535,7 @@ function parseGoCommand(ctx, identifierNode) {
             continue;
         }
         if (isNakedURLStart(ctx)) {
-            const url = parseBareURLPath(ctx, isGoURLTerminator);
+            const url = parseBareURLPath(ctx);
             if (url) {
                 args.push(url);
                 continue;
@@ -4640,13 +4675,6 @@ function parseMultiWordCommand(ctx, commandToken, commandName) {
     }
     return builder.build();
 }
-function isFetchURLTerminator(ctx) {
-    if (ctx.isAtEnd())
-        return true;
-    const val = ctx.peek().value;
-    return (['as', 'with', '{', 'then', 'end', 'else', 'otherwise', ')'].includes(val) ||
-        isCommandBoundary(ctx));
-}
 function isNakedURLStart(ctx) {
     const tok = ctx.peek();
     if (tok.value === '/')
@@ -4657,23 +4685,50 @@ function isNakedURLStart(ctx) {
     }
     return false;
 }
-function parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
+const URL_HARD_STOPS = new Set(['{', ')']);
+function parseBareURLPath(ctx) {
     const startPos = ctx.savePosition();
+    const firstTok = ctx.peek();
     let path = '';
-    while (!ctx.isAtEnd() && !isTerminator(ctx)) {
-        path += ctx.advance().value;
+    let prev = null;
+    while (!ctx.isAtEnd()) {
+        const tok = ctx.peek();
+        if (prev && tok.start !== prev.end)
+            break;
+        if (tok.value === '$' && ctx.peekAt(1)?.value === '{') {
+            ctx.advance();
+            let last = ctx.advance();
+            let depth = 1;
+            while (!ctx.isAtEnd() && depth > 0) {
+                last = ctx.advance();
+                if (last.value === '{')
+                    depth++;
+                else if (last.value === '}')
+                    depth--;
+            }
+            path += ctx.getInputSlice(tok.start, last.end);
+            prev = last;
+            continue;
+        }
+        if (URL_HARD_STOPS.has(tok.value))
+            break;
+        prev = ctx.advance();
+        path += prev.value;
     }
     if (!path || path === '/') {
         ctx.restorePosition(startPos);
         return null;
     }
-    return {
-        type: 'literal',
-        value: path,
-        raw: path,
-        start: startPos,
-        end: ctx.savePosition(),
+    const span = {
+        start: firstTok.start,
+        end: prev ? prev.end : firstTok.end,
+        line: firstTok.line,
+        column: firstTok.column,
     };
+    if (path.includes('${')) {
+        return { type: 'templateLiteral', value: path, ...span };
+    }
+    return { type: 'literal', value: path, raw: path, ...span };
 }
 function parseFetchCommand(ctx, commandToken) {
     const modifiers = {};
@@ -4904,10 +4959,10 @@ function parseTellCommand(ctx, identifierNode) {
             catch {
                 break;
             }
-            if (ctx.match(KEYWORDS$1.AND)) {
+            if (ctx.match(KEYWORDS$1.AND) || ctx.match(KEYWORDS$1.THEN)) {
                 continue;
             }
-            if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
+            if (ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
                 break;
             }
             if (ctx.checkIsCommand()) {
@@ -5110,6 +5165,7 @@ class Parser {
         const result = this.parseInternal();
         if (this.errors.length > 0) {
             result.errors = [...this.errors];
+            result.recovered = true;
         }
         return result;
     }
@@ -7141,6 +7197,9 @@ class Parser {
                 this.advance();
                 const cmd = this.parseCommand();
                 commands.push(cmd);
+                if (this.match('then', 'and', ',')) {
+                    continue;
+                }
             }
             else {
                 break;
@@ -13047,6 +13106,25 @@ function isImplicitCommand(val) {
     return val !== null && typeof val === 'object' && 'command' in val && 'selector' in val;
 }
 const eventRecursionDepth = new WeakMap();
+function collectIdentifierNames(node, out = new Set()) {
+    if (node === null || typeof node !== 'object')
+        return out;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectIdentifierNames(item, out);
+        return out;
+    }
+    const obj = node;
+    if (obj.type === 'identifier' && typeof obj.name === 'string') {
+        out.add(obj.name);
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === 'start' || key === 'end' || key === 'line' || key === 'column')
+            continue;
+        collectIdentifierNames(obj[key], out);
+    }
+    return out;
+}
 class RuntimeBase {
     constructor(options) {
         this.autoCleanupObserver = null;
@@ -13238,6 +13316,9 @@ class RuntimeBase {
                 case 'behavior': {
                     return await this.executeBehaviorDefinition(node, context);
                 }
+                case 'def': {
+                    return this.installFunction(node, context);
+                }
                 case 'Program': {
                     return await this.executeProgram(node, context);
                 }
@@ -13453,17 +13534,64 @@ class RuntimeBase {
         };
         return this.processCommand(commandNode, context);
     }
+    installFunction(node, context) {
+        const runtime = this;
+        const params = node.params ?? [];
+        const body = (node.body ?? []);
+        const errorHandler = node.errorHandler;
+        const finallyHandler = node.finallyHandler;
+        const errorSymbol = node.errorSymbol;
+        const fn = async (...args) => {
+            const fnContext = {
+                ...context,
+                locals: new Map(context.locals),
+            };
+            params.forEach((name, i) => {
+                if (name)
+                    fnContext.locals.set(name, args[i]);
+            });
+            const run = async (commands) => {
+                const result = await runtime.executeCommandSequenceWithResult(commands, fnContext);
+                if (!isOk(result))
+                    throw asControlFlowError(result.error);
+                return result.value;
+            };
+            if (!errorHandler && !finallyHandler) {
+                return await run(body);
+            }
+            try {
+                return await run(body);
+            }
+            catch (e) {
+                if (!errorHandler || isControlFlowError(e))
+                    throw e;
+                if (errorSymbol)
+                    fnContext.locals.set(errorSymbol, e);
+                return await run(errorHandler);
+            }
+            finally {
+                if (finallyHandler) {
+                    await run(finallyHandler);
+                }
+            }
+        };
+        context.globals.set(node.name, fn);
+    }
     async executeProgram(node, context) {
         if (!node.statements || !Array.isArray(node.statements))
             return;
         let lastResult = undefined;
         const eventHandlers = [];
+        const defs = [];
         const initBlocks = [];
         const otherStatements = [];
         for (const statement of node.statements) {
             if (statement.type === 'eventHandler') {
                 eventHandlers.push(statement);
             }
+            else if (statement.type === 'def') {
+                defs.push(statement);
+            }
             else if (statement.type === 'initBlock') {
                 initBlocks.push(statement);
             }
@@ -13471,6 +13599,9 @@ class RuntimeBase {
                 otherStatements.push(statement);
             }
         }
+        for (const def of defs) {
+            this.execute(def, context);
+        }
         for (const handler of eventHandlers) {
             try {
                 await this.execute(handler, context);
@@ -13666,7 +13797,7 @@ class RuntimeBase {
         debug.runtime(`BEHAVIOR: Finished installing ${behaviorName}`);
     }
     async executeEventHandler(node, context) {
-        const { event, events, commands, target, args, selector, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler, } = node;
+        const { event, events, commands, target, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler, } = node;
         const eventNames = events && events.length > 0 ? events : [event];
         debug.runtime(`BEHAVIOR: executeEventHandler: event='${event}', target='${target}'`);
         let targets = [];
@@ -13749,7 +13880,8 @@ class RuntimeBase {
             }
             return;
         }
-        const baseEventHandler = RuntimeBase.createEventHandler(this, commands, context, selector, args, { errorSymbol, errorHandler, finallyHandler });
+        const applicableCondition = eventNames.length === 1 ? condition : undefined;
+        const baseEventHandler = RuntimeBase.createEventHandler(this, commands, context, selector, args, { errorSymbol, errorHandler, finallyHandler }, applicableCondition);
         let eventHandler;
         let debounceCleanup = null;
         if (modifiers) {
@@ -13853,7 +13985,7 @@ class RuntimeBase {
             }
         }
     }
-    static createEventHandler(runtime, commands, context, selector, args, errorBlocks) {
+    static createEventHandler(runtime, commands, context, selector, args, errorBlocks, condition) {
         return async (domEvent) => {
             const currentDepth = eventRecursionDepth.get(domEvent) ?? 0;
             if (currentDepth >= 100) {
@@ -13889,6 +14021,25 @@ class RuntimeBase {
                     eventContext.locals.set(argName, value);
                 }
             }
+            if (condition) {
+                const eventProps = domEvent;
+                for (const name of collectIdentifierNames(condition)) {
+                    if (!eventContext.locals.has(name) && name in eventProps) {
+                        eventContext.locals.set(name, eventProps[name]);
+                    }
+                }
+                let filterResult;
+                try {
+                    filterResult = await runtime.evaluateExpression(condition, eventContext);
+                }
+                catch (e) {
+                    debug.runtime(`Event filter threw; skipping handler body:`, e);
+                    return;
+                }
+                if (!filterResult) {
+                    return;
+                }
+            }
             const runCommands = async (toRun) => {
                 for (const command of toRun) {
                     try {
@@ -80807,9 +80958,11 @@ function compileSync(code, options) {
         const parseResult = parse$1(code, parserOptions);
         const timeMs = performance.now() - startTime;
         if (parseResult.success && parseResult.node) {
+            const recovered = parseResult.errors ?? [];
             const result = {
                 ok: true,
                 ast: parseResult.node,
+                ...(recovered.length > 0 ? { errors: recovered.map(toCompileError) } : {}),
                 meta: {
                     parser: usesSemanticParser ? 'semantic' : 'traditional',
                     language: lang,
@@ -80935,9 +81088,10 @@ async function evalCode(code, context, options) {
 }
 async function validate(code, options) {
     const result = await compileAsync(code, options);
+    const errors = result.errors ?? [];
     return {
-        valid: result.ok,
-        errors: result.errors,
+        valid: result.ok && errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined,
     };
 }
 function createContextWithParent(element, parent) {