@hyperfixi/core 2.2.1 → 2.3.0

package/dist/index.mjs

@@ -454,7 +454,9 @@ function tokenize$1(input) {
                 prevToken.value === ',' ||
                 prevToken.value === ';';
             const isAdjacentToPrev = prevToken && prevToken.end === tokenizer.position;
-            if (isCSSSelectorContext && !isAdjacentToPrev && isAlpha(peek(tokenizer))) {
+            if (isCSSSelectorContext &&
+                !isAdjacentToPrev &&
+                (isAlpha(peek(tokenizer)) || peek(tokenizer) === '{')) {
                 tokenizeCSSSelector(tokenizer);
                 continue;
             }
@@ -687,6 +689,17 @@ function tokenizeCSSSelector(tokenizer) {
     const start = tokenizer.position;
     const prefix = advance(tokenizer);
     let value = prefix;
+    if (tokenizer.position < tokenizer.input.length && tokenizer.input[tokenizer.position] === '{') {
+        value += advance(tokenizer);
+        while (tokenizer.position < tokenizer.input.length) {
+            const ch = tokenizer.input[tokenizer.position];
+            value += advance(tokenizer);
+            if (ch === '}')
+                break;
+        }
+        addToken(tokenizer, TokenKind.SELECTOR, value, start);
+        return;
+    }
     while (tokenizer.position < tokenizer.input.length) {
         const char = tokenizer.input[tokenizer.position];
         if (isAlphaNumeric(char) || char === '-' || char === '_' || char === ':') {
@@ -2377,33 +2390,14 @@ function parseTriggerCommand(ctx, identifierNode) {
             });
         }
     }
-    while (!isCommandBoundary(ctx)) {
-        allArgs.push(ctx.parsePrimary());
-    }
-    let operationIndex = -1;
-    let operationKeyword = 'on';
-    for (let i = 0; i < allArgs.length; i++) {
-        const arg = allArgs[i];
-        const argRecord = arg;
-        const argValue = argRecord.name || argRecord.value;
-        if ((arg.type === 'identifier' || arg.type === 'literal' || arg.type === 'keyword') &&
-            (argValue === 'on' || argValue === 'to')) {
-            operationIndex = i;
-            operationKeyword = argValue;
-            break;
+    const finalArgs = [...allArgs];
+    if (ctx.check('on') || ctx.check('to')) {
+        const keyword = ctx.advance().value;
+        finalArgs.push(ctx.createIdentifier(keyword));
+        while (!isCommandBoundary(ctx)) {
+            finalArgs.push(ctx.parsePrimary());
         }
     }
-    const finalArgs = [];
-    if (operationIndex === -1) {
-        finalArgs.push(...allArgs);
-    }
-    else {
-        const eventArgs = allArgs.slice(0, operationIndex);
-        const targetArgs = allArgs.slice(operationIndex + 1);
-        finalArgs.push(...eventArgs);
-        finalArgs.push(ctx.createIdentifier(operationKeyword));
-        finalArgs.push(...targetArgs);
-    }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...finalArgs)
         .endingAt(ctx.getPosition())
@@ -3123,8 +3117,13 @@ function parseSwapCommand(ctx, identifierNode) {
 
 function parseWaitCommand(ctx, commandToken) {
     const args = [];
-    if (ctx.checkTimeExpression() || ctx.checkLiteral()) {
-        const timeExpr = ctx.parsePrimary();
+    const isExpressionStart = ctx.checkTimeExpression() ||
+        ctx.checkLiteral() ||
+        ctx.checkContextVar() ||
+        ctx.check('(') ||
+        (ctx.checkIdentifierLike() && !ctx.check('for') && !isCommandBoundary(ctx));
+    if (isExpressionStart) {
+        const timeExpr = ctx.parseExpression();
         args.push(timeExpr);
         return CommandNodeBuilder.from(commandToken)
             .withArgs(...args)
@@ -3310,43 +3309,24 @@ function parsePropertyOfTarget(ctx, startPosition) {
         return null;
     const thePosition = ctx.savePosition();
     ctx.advance();
-    const nextToken = ctx.peek();
-    const tokenAfterNext = ctx.peekAt(1);
-    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.OF) {
-        const propertyToken = ctx.advance();
-        if (ctx.check(KEYWORDS$1.OF)) {
-            ctx.advance();
-            const targetToken = ctx.advance();
-            const isIdSelector = targetToken.value.startsWith('#');
-            return {
-                type: 'propertyOfExpression',
-                property: {
-                    type: 'identifier',
-                    name: propertyToken.value,
-                    start: propertyToken.start,
-                    end: propertyToken.end,
-                },
-                target: {
-                    type: isIdSelector ? 'idSelector' : 'cssSelector',
-                    value: targetToken.value,
-                    start: targetToken.start,
-                    end: targetToken.end,
-                },
-                start: startPosition,
-                end: ctx.savePosition(),
-            };
-        }
-        ctx.restorePosition(startPosition);
+    const propertyExpr = ctx.parseExpression();
+    if (!propertyExpr) {
+        ctx.restorePosition(thePosition);
         return null;
     }
-    if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.TO) {
-        const variableToken = ctx.advance();
-        return {
-            type: 'identifier',
-            name: variableToken.value,
-            start: variableToken.start,
-            end: variableToken.end,
-        };
+    const exprAny = propertyExpr;
+    if (exprAny.type === 'binaryExpression' && exprAny.operator === KEYWORDS$1.OF) {
+        const property = exprAny.left;
+        const target = exprAny.right;
+        return createPropertyOfExpression(property, target, {
+            start: property.start ?? 0,
+            end: target.end ?? 0,
+            line: property.line ?? 1,
+            column: property.column ?? 1,
+        });
+    }
+    if (ctx.check(KEYWORDS$1.TO)) {
+        return propertyExpr;
     }
     ctx.restorePosition(thePosition);
     return null;
@@ -3705,6 +3685,71 @@ function parseFetchNakedNamedArgs(ctx) {
         column: startPos.column,
     };
 }
+function findJsEndBoundary(ctx, startPos) {
+    const input = ctx.getInputSlice(startPos);
+    if (!input) {
+        return startPos;
+    }
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === "'" || ch === '\u2019' || ch === '\u2018') {
+            i++;
+            while (i < input.length && input[i] !== ch) {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            i++;
+            while (i < input.length && input[i] !== '"') {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '`') {
+            i++;
+            while (i < input.length && input[i] !== '`') {
+                if (input[i] === '\\')
+                    i++;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '/' && i + 1 < input.length && input[i + 1] === '/') {
+            i += 2;
+            while (i < input.length && input[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && i + 1 < input.length && input[i + 1] === '*') {
+            i += 2;
+            while (i < input.length &&
+                !(input[i] === '*' && i + 1 < input.length && input[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        if ((ch === 'e' || ch === 'E') &&
+            i + 3 <= input.length &&
+            input.slice(i, i + 3).toLowerCase() === 'end') {
+            const before = i === 0 || !/[a-zA-Z0-9_]/.test(input[i - 1]);
+            const after = i + 3 >= input.length || !/[a-zA-Z0-9_]/.test(input[i + 3]);
+            if (before && after) {
+                return startPos + i;
+            }
+        }
+        i++;
+    }
+    return startPos + input.length;
+}
 function parseJsCommand(ctx, identifierNode) {
     const parameters = [];
     if (ctx.match('(')) {
@@ -3717,11 +3762,12 @@ function parseJsCommand(ctx, identifierNode) {
         ctx.consume(')', 'Expected ) after js parameters');
     }
     const jsCodeStart = ctx.peek().start;
-    while (!ctx.check(KEYWORDS$1.END) && !ctx.isAtEnd()) {
+    const jsCodeEnd = findJsEndBoundary(ctx, jsCodeStart);
+    while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
+        if (ctx.peek().start >= jsCodeEnd)
+            break;
         ctx.advance();
     }
-    const endToken = ctx.peek();
-    const jsCodeEnd = endToken.start;
     ctx.consume(KEYWORDS$1.END, 'Expected end after js code body');
     const rawSlice = ctx.getInputSlice(jsCodeStart, jsCodeEnd);
     const code = rawSlice.trim();
@@ -4624,7 +4670,12 @@ class Parser {
                     }
                     else {
                         const commandName = expr.name.toLowerCase();
-                        if (commandName === 'wait' && this.checkTimeExpression()) {
+                        if (commandName === 'wait' &&
+                            (this.checkTimeExpression() ||
+                                this.checkNumber() ||
+                                this.checkIdentifier() ||
+                                this.checkContextVar() ||
+                                this.check('('))) {
                             const command = this.createCommandFromIdentifier(expr);
                             if (command) {
                                 expr = command;
@@ -5843,9 +5894,7 @@ class Parser {
         while (!this.isAtEnd() && !this.check('end')) {
             if (this.match('on')) {
                 const handlerPos = this.getPosition();
-                const eventToken = this.peek();
-                const eventName = eventToken.value;
-                this.advance();
+                const eventName = this.parseEventNameWithNamespace("Expected event name after 'on'");
                 const eventArgs = [];
                 if (this.check('(')) {
                     this.advance();
@@ -8664,6 +8713,8 @@ class BaseExpressionEvaluator {
                 return this.evaluateIdSelector(node, context);
             case 'attributeAccess':
                 return this.evaluateAttributeAccess(node, context);
+            case 'asExpression':
+                return this.evaluateAsExpression(node, context);
             default:
                 throw new Error(`Unsupported AST node type for evaluation: ${node.type}`);
         }
@@ -8949,6 +9000,14 @@ class BaseExpressionEvaluator {
         }
         return `@${node.attributeName}`;
     }
+    async evaluateAsExpression(node, context) {
+        const value = await this.evaluate(node.expression, context);
+        const asExpr = this.expressionRegistry.get('as');
+        if (asExpr) {
+            return asExpr.evaluate(context, value, node.targetType);
+        }
+        throw new Error(`Conversion type 'as' not registered`);
+    }
     getAvailableExpressions() {
         return Array.from(this.expressionRegistry.keys());
     }
@@ -14529,6 +14588,8 @@ class RuntimeBase {
         this.behaviorAPI = {
             has: (name) => this.behaviorRegistry.has(name),
             get: (name) => this.behaviorRegistry.get(name),
+            set: (name, definition) => this.behaviorRegistry.set(name, definition),
+            resolve: null,
             install: async (behaviorName, element, parameters) => {
                 return await this.installBehaviorOnElement(behaviorName, element, parameters);
             },
@@ -15010,9 +15071,14 @@ class RuntimeBase {
     }
     async installBehaviorOnElement(behaviorName, element, parameters) {
         debug.runtime(`BEHAVIOR: installBehaviorOnElement called: ${behaviorName}`);
-        const behavior = this.behaviorRegistry.get(behaviorName);
-        if (!behavior)
-            throw new Error(`Behavior "${behaviorName}" not found`);
+        let behavior = this.behaviorRegistry.get(behaviorName);
+        if (!behavior) {
+            if (this.behaviorAPI.resolve && this.behaviorAPI.resolve(behaviorName)) {
+                behavior = this.behaviorRegistry.get(behaviorName);
+            }
+            if (!behavior)
+                throw new Error(`Behavior "${behaviorName}" not found`);
+        }
         if (behavior.type === 'imperative' && typeof behavior.install === 'function') {
             debug.runtime(`BEHAVIOR: Installing imperative behavior '${behaviorName}'`);
             behavior.install(element, parameters);
@@ -20323,7 +20389,11 @@ let SetCommand = (() => {
                 return { type: 'property', element: firstValue[0], property: 'textContent', value };
             }
             if (typeof firstValue !== 'string') {
-                throw new Error('set command target must be a string or object literal');
+                const isMember = firstArg?.type === 'memberExpression' || firstArg?.type === 'propertyAccess';
+                const hint = isMember
+                    ? ` (a property chain evaluated to ${firstValue === null ? 'null' : typeof firstValue} — check that all intermediate objects exist)`
+                    : '';
+                throw new Error(`set command target must be a string or object literal${hint}`);
             }
             const value = await this.extractValue(raw, evaluator, context);
             return { type: 'variable', name: firstValue, value };
@@ -23532,12 +23602,19 @@ class InstallCommand {
         const behaviorRegistry = context.locals.get('_behaviors');
         if (behaviorRegistry && typeof behaviorRegistry === 'object') {
             const registry = behaviorRegistry;
-            return registry.has(behaviorName);
+            if (registry.has(behaviorName))
+                return true;
+            if (registry.resolve && registry.resolve(behaviorName))
+                return true;
         }
         if (typeof globalThis !== 'undefined') {
             const hyperscriptGlobal = globalThis._hyperscript;
             if (hyperscriptGlobal?.behaviors) {
-                return hyperscriptGlobal.behaviors.has(behaviorName);
+                if (hyperscriptGlobal.behaviors.has(behaviorName))
+                    return true;
+                if (hyperscriptGlobal.behaviors.resolve &&
+                    hyperscriptGlobal.behaviors.resolve(behaviorName))
+                    return true;
             }
         }
         return false;