@hyperfixi/core 2.6.0 → 2.7.0

package/dist/commands/index.mjs

@@ -3746,6 +3746,36 @@ function setGlobal(context, name, value) {
     }
 }
 
+const elementScopes = new WeakMap();
+function getElementScopeMap(element) {
+    let map = elementScopes.get(element);
+    if (!map) {
+        map = new Map();
+        elementScopes.set(element, map);
+    }
+    return map;
+}
+function resolveScopeOwner(context) {
+    const owner = context.owner;
+    if (owner)
+        return owner;
+    return context.me instanceof Element ? context.me : null;
+}
+function getElementVar(context, name) {
+    const owner = resolveScopeOwner(context);
+    if (!owner)
+        return undefined;
+    notifyLocalRead(name, context);
+    return getElementScopeMap(owner).get(name);
+}
+function setElementVar(context, name, value) {
+    const owner = resolveScopeOwner(context);
+    if (!owner)
+        return;
+    getElementScopeMap(owner).set(name, value);
+    notifyLocalWrite(name, value, context);
+}
+
 function convertToNumber(value) {
     if (value === null || value === undefined) {
         return 0;
@@ -3778,6 +3808,9 @@ function convertToNumber(value) {
     return 0;
 }
 function getVariableValue(name, context, preferredScope) {
+    if (preferredScope === 'element') {
+        return getElementVar(context, name);
+    }
     if (preferredScope === 'global' && context.globals && context.globals.has(name)) {
         return context.globals.get(name);
     }
@@ -3804,6 +3837,10 @@ function getVariableValue(name, context, preferredScope) {
     return undefined;
 }
 function setVariableValue(name, value, context, preferredScope) {
+    if (preferredScope === 'element') {
+        setElementVar(context, name, value);
+        return;
+    }
     if (preferredScope === 'global') {
         setGlobal(context, name, value);
         if (typeof window !== 'undefined') {
@@ -3897,6 +3934,9 @@ function getCurrentNumericValue(target, property, scope, context) {
         }
     }
     if (typeof target === 'string') {
+        if (scope === 'element') {
+            return convertToNumber(getVariableValue(target, context, 'element'));
+        }
         if (scope === 'global') {
             const value = getVariableValue(target, context, 'global');
             return convertToNumber(value);
@@ -3941,6 +3981,10 @@ function setTargetValue(target, property, scope, newValue, context) {
         return;
     }
     if (typeof target === 'string') {
+        if (scope === 'element') {
+            setVariableValue(target, newValue, context, 'element');
+            return;
+        }
         if (scope === 'global') {
             setVariableValue(target, newValue, context, 'global');
             return;
@@ -9179,7 +9223,7 @@ function parseColonVariable(ctx) {
     return {
         type: 'identifier',
         name: varToken.value,
-        scope: 'local',
+        scope: 'element',
         start: varToken.start - 1,
         end: varToken.end,
     };
@@ -9231,7 +9275,7 @@ function parseTargetFallback(ctx) {
             expression: {
                 type: 'identifier',
                 name: varToken.value,
-                scope: 'local',
+                scope: 'element',
                 start: varToken.start,
                 end: varToken.end,
             },
@@ -9312,6 +9356,11 @@ function parseSetCommand(ctx, identifierNode) {
     }
     ctx.advance();
     const value = ctx.parseExpression() ?? ctx.parsePrimary();
+    let scopeTarget;
+    if (ctx.check(KEYWORDS$1.ON) && tokenLooksLikeElementTarget(ctx.peekAt(1))) {
+        ctx.advance();
+        scopeTarget = parseOneArgument(ctx);
+    }
     const finalArgs = [];
     if (targetExpression) {
         finalArgs.push(targetExpression);
@@ -9323,11 +9372,22 @@ function parseSetCommand(ctx, identifierNode) {
     if (value) {
         finalArgs.push(value);
     }
-    return CommandNodeBuilder.fromIdentifier(identifierNode)
-        .withArgs(...finalArgs)
-        .endingAt(ctx.getPosition())
-        .build();
+    const builder = CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...finalArgs);
+    if (scopeTarget) {
+        builder.withModifier('on', scopeTarget);
+    }
+    return builder.endingAt(ctx.getPosition()).build();
 }
+function tokenLooksLikeElementTarget(token) {
+    if (!token)
+        return false;
+    if (token.kind === 'selector')
+        return true;
+    if (token.value.startsWith('<'))
+        return true;
+    return ELEMENT_PRONOUNS.has(token.value);
+}
+const ELEMENT_PRONOUNS = new Set(['me', 'my', 'it', 'its', 'you', 'your', 'yourself']);
 function parseIncrementDecrementCommand(ctx, commandToken) {
     const commandName = commandToken.value;
     const isIncrement = commandName === 'increment';
@@ -9373,6 +9433,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         column: commandToken.column,
     };
     const binaryExpr = createBinaryExpression(operator, target, amount, pos);
+    binaryExpr.coerceNumeric = true;
     const toIdentifier = createIdentifier(KEYWORDS$1.TO, pos);
     const args = [targetWithScope, toIdentifier, binaryExpr];
     return CommandNodeBuilder.from(commandToken)
@@ -9991,6 +10052,18 @@ class Parser {
                         this.advance();
                         continue;
                     }
+                    if (this.check('then')) {
+                        const next = this.peekAt(1);
+                        const startsFeature = next !== null &&
+                            (next.value === 'init' ||
+                                next.value === 'on' ||
+                                next.value === 'def' ||
+                                getRegisteredFeature(next.value) !== undefined);
+                        if (startsFeature) {
+                            this.advance();
+                            continue;
+                        }
+                    }
                     if (this.check('init')) {
                         this.advance();
                         const initBlock = this.parseTopLevelInitBlock();
@@ -10791,7 +10864,7 @@ class Parser {
                 return {
                     type: 'identifier',
                     name: varToken.value,
-                    scope: 'local',
+                    scope: 'element',
                     start: varToken.start - 1,
                     end: varToken.end,
                     line: varToken.line,
@@ -11418,6 +11491,33 @@ class Parser {
             return null;
         }
     }
+    parseTemporalKeywordModifiers(modifiers) {
+        if (!this.check('debounced') && !this.check('throttled')) {
+            return;
+        }
+        const modToken = this.advance();
+        const modName = modToken.value.toLowerCase();
+        const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
+        if (this.match('at')) {
+            if (this.checkTimeExpression()) {
+                const timeToken = this.advance();
+                const delayMs = parseTimeToMs(timeToken.value);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
+            }
+            else if (this.matchNumber()) {
+                const delayMs = parseInt(this.previous().value, 10);
+                modifiers[modifierKey] = delayMs;
+                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
+            }
+            else {
+                this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
+            }
+        }
+        else {
+            this.addError(`Expected 'at' after '${modName}'`);
+        }
+    }
     parseEventHandler() {
         debug.parse(`🔧 parseEventHandler: ENTRY - parsing event handler`);
         const eventNames = [];
@@ -11505,30 +11605,7 @@ class Parser {
                 debug.parse(`🔧 parseEventHandler: Warning - unknown modifier '.${modName}'`);
             }
         }
-        if (this.check('debounced') || this.check('throttled')) {
-            const modToken = this.advance();
-            const modName = modToken.value.toLowerCase();
-            const modifierKey = modName === 'debounced' ? 'debounce' : 'throttle';
-            if (this.match('at')) {
-                if (this.checkTimeExpression()) {
-                    const timeToken = this.advance();
-                    const delayMs = parseTimeToMs(timeToken.value);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
-                }
-                else if (this.matchNumber()) {
-                    const delayMs = parseInt(this.previous().value, 10);
-                    modifiers[modifierKey] = delayMs;
-                    debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
-                }
-                else {
-                    this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
-                }
-            }
-            else {
-                this.addError(`Expected 'at' after '${modName}'`);
-            }
-        }
+        this.parseTemporalKeywordModifiers(modifiers);
         if (firstOnceAlias) {
             modifiers.once = true;
         }
@@ -11545,6 +11622,7 @@ class Parser {
             const targetToken = this.advance();
             target = targetToken.value;
             debug.parse(`🔧 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+            this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
         if (this.match('of')) {
@@ -12515,6 +12593,10 @@ class Parser {
         }
         return this.tokens[this.current];
     }
+    peekAt(offset) {
+        const index = this.current + offset;
+        return index >= 0 && index < this.tokens.length ? this.tokens[index] : null;
+    }
     previous() {
         return this.tokens[this.current - 1];
     }
@@ -12719,10 +12801,7 @@ class Parser {
             restorePosition: (pos) => {
                 parser.current = pos;
             },
-            peekAt: (offset) => {
-                const index = parser.current + offset;
-                return index >= 0 && index < parser.tokens.length ? parser.tokens[index] : null;
-            },
+            peekAt: (offset) => parser.peekAt(offset),
             getInputSlice: (start, end) => {
                 if (!this.originalInput)
                     return '';
@@ -12866,7 +12945,7 @@ function evaluateExpressionSync(node, context) {
         case 'selector':
             return evaluateSelectorSync(n, context);
         case 'identifier':
-            return resolveIdentifierSync(n.name, context);
+            return resolveIdentifierSync(n.name, context, n.scope);
         case 'contextReference':
             return resolveContextReferenceSync(n.contextType, context);
         case 'arrayLiteral':
@@ -12902,7 +12981,7 @@ function evaluateExpressionSync(node, context) {
             throw new NotSyncEvaluable(n?.type ?? 'unknown');
     }
 }
-function resolveIdentifierSync(name, context) {
+function resolveIdentifierSync(name, context, scope) {
     if (name === 'me' || name === 'my' || name === 'I')
         return context.me;
     if (name === 'you' || name === 'your' || name === 'yourself')
@@ -12913,6 +12992,8 @@ function resolveIdentifierSync(name, context) {
         return typeof window !== 'undefined' ? window : globalThis;
     if (name === 'document')
         return typeof document !== 'undefined' ? document : undefined;
+    if (scope === 'element')
+        return getElementVar(context, name);
     if (context.locals?.has(name))
         return context.locals.get(name);
     if (context.globals?.has(name))
@@ -13042,6 +13123,9 @@ async function evaluateIdentifier(node, context) {
         notifyGlobalRead(name, context);
         return context.globals.get(name);
     }
+    if (node.scope === 'element') {
+        return getElementVar(context, name);
+    }
     if (context.locals && context.locals.has(name)) {
         notifyLocalRead(name, context);
         return context.locals.get(name);
@@ -13077,6 +13161,9 @@ async function evaluateBinaryExpression(node, context) {
             else if (leftNode.scope === 'global') {
                 setGlobal(context, name, value);
             }
+            else if (leftNode.scope === 'element') {
+                setElementVar(context, name, value);
+            }
             else {
                 if (!context.locals)
                     context.locals = new Map();
@@ -13158,14 +13245,26 @@ async function evaluateBinaryExpression(node, context) {
     const L = node.ignoringCase ? applyCI(left) : left;
     const R = node.ignoringCase ? applyCI(right) : right;
     switch (operator) {
-        case '+':
-            if (typeof left === 'string' || typeof right === 'string') {
-                return String(left ?? '') + String(right ?? '');
-            }
-            if (Array.isArray(left)) {
-                return Array.isArray(right) ? [...left, ...right] : [...left, right];
-            }
-            return unwrapTypedResult(await getExpr(context, 'addition').evaluate(context, { left, right }));
+        case '+': {
+            let addLeft = left;
+            let addRight = right;
+            if (node.coerceNumeric) {
+                if (typeof addLeft === 'string')
+                    addLeft = convertToNumber(addLeft);
+                if (typeof addRight === 'string')
+                    addRight = convertToNumber(addRight);
+            }
+            if (typeof addLeft === 'string' || typeof addRight === 'string') {
+                return String(addLeft ?? '') + String(addRight ?? '');
+            }
+            if (Array.isArray(addLeft)) {
+                return Array.isArray(addRight) ? [...addLeft, ...addRight] : [...addLeft, addRight];
+            }
+            return unwrapTypedResult(await getExpr(context, 'addition').evaluate(context, {
+                left: addLeft,
+                right: addRight,
+            }));
+        }
         case '-':
             return unwrapTypedResult(await getExpr(context, 'subtraction').evaluate(context, { left, right }));
         case '*':
@@ -16676,6 +16775,7 @@ let SetCommand = (() => {
             }
             const firstArg = raw.args[0];
             const argName = (firstArg?.name || firstArg?.value);
+            const argScope = firstArg?.scope;
             const firstArgType = firstArg?.type;
             if (firstArgType) {
                 const writer = getRegisteredNodeWriter(firstArgType);
@@ -16769,12 +16869,21 @@ let SetCommand = (() => {
                 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 };
+            const scope = argScope === 'element' || argScope === 'global' ? argScope : undefined;
+            return { type: 'variable', name: firstValue, value, scope };
         }
         async execute(input, context) {
             switch (input.type) {
                 case 'variable':
-                    setVariableValue(input.name, input.value, context);
+                    if (input.scope === 'element') {
+                        setElementVar(context, input.name, input.value);
+                    }
+                    else if (input.scope === 'global') {
+                        setVariableValue(input.name, input.value, context, 'global');
+                    }
+                    else {
+                        setVariableValue(input.name, input.value, context);
+                    }
                     if (input.name === 'result' || input.name === 'it') {
                         Object.assign(context, { [input.name]: input.value });
                     }

package/dist/core/context.d.ts

@@ -1,4 +1,8 @@
 import type { ExecutionContext } from '../types/core';
+export declare function getElementScopeMap(element: Element): Map<string, unknown>;
+export declare function resolveScopeOwner(context: ExecutionContext): Element | null;
+export declare function getElementVar(context: ExecutionContext, name: string): unknown;
+export declare function setElementVar(context: ExecutionContext, name: string, value: unknown): void;
 export declare function createContext(element?: Element | null, globals?: Map<string, any>): ExecutionContext;
 export declare function getSharedGlobals(): Map<string, any>;
 export declare function createChildContext(parent: ExecutionContext, element?: Element | null): ExecutionContext;

package/dist/dom/attribute-processor.d.ts

@@ -22,6 +22,7 @@ export declare class AttributeProcessor {
     constructor(options?: AttributeProcessorOptions);
     init(): Promise<void>;
     scanAndProcessAll(): Promise<void>;
+    private reportCompileError;
     private processHyperscriptTag;
     private processHyperscriptTagForElements;
     private processHyperscriptTagGlobal;