@hyperfixi/core 2.6.0 → 2.7.1

package/dist/registry/index.js

@@ -1222,6 +1222,7 @@ const FEATURE_REGISTRY = new Map();
 const NODE_EVALUATORS = new Map();
 const GLOBAL_WRITE_HOOKS = new Set();
 const GLOBAL_READ_HOOKS = new Set();
+const LOCAL_WRITE_HOOKS = new Set();
 const LOCAL_READ_HOOKS = new Set();
 function getRegisteredFeature(name) {
     return FEATURE_REGISTRY.get(name.toLowerCase());
@@ -1243,6 +1244,20 @@ function notifyGlobalRead(name, context) {
         }
     }
 }
+function notifyLocalWrite(name, value, context) {
+    if (LOCAL_WRITE_HOOKS.size === 0)
+        return;
+    for (const hook of LOCAL_WRITE_HOOKS) {
+        try {
+            hook(name, value, context);
+        }
+        catch (err) {
+            if (typeof console !== 'undefined') {
+                console.error('[hyperfixi] localWriteHook threw:', err);
+            }
+        }
+    }
+}
 function notifyLocalRead(name, context) {
     if (LOCAL_READ_HOOKS.size === 0)
         return;
@@ -1273,6 +1288,68 @@ 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;
+    }
+    if (typeof value === 'number') {
+        return isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = parseFloat(value);
+        return parsed;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length;
+    }
+    if (typeof value === 'object') {
+        if ('length' in value && typeof value.length === 'number') {
+            return value.length;
+        }
+        if (typeof value.valueOf === 'function') {
+            const result = value.valueOf();
+            if (typeof result === 'number') {
+                return result;
+            }
+        }
+        return NaN;
+    }
+    return 0;
+}
+
 class ExpressionTypeRegistry {
     constructor(config = {}) {
         this.types = new Map();
@@ -6976,7 +7053,7 @@ function parseColonVariable(ctx) {
     return {
         type: 'identifier',
         name: varToken.value,
-        scope: 'local',
+        scope: 'element',
         start: varToken.start - 1,
         end: varToken.end,
     };
@@ -7028,7 +7105,7 @@ function parseTargetFallback(ctx) {
             expression: {
                 type: 'identifier',
                 name: varToken.value,
-                scope: 'local',
+                scope: 'element',
                 start: varToken.start,
                 end: varToken.end,
             },
@@ -7109,6 +7186,11 @@ function parseSetCommand(ctx, identifierNode) {
     }
     ctx.advance();
     const value = ctx.parseExpression() ?? ctx.parsePrimary();
+    let scopeTarget;
+    if (ctx.check(KEYWORDS.ON) && tokenLooksLikeElementTarget(ctx.peekAt(1))) {
+        ctx.advance();
+        scopeTarget = parseOneArgument(ctx);
+    }
     const finalArgs = [];
     if (targetExpression) {
         finalArgs.push(targetExpression);
@@ -7120,11 +7202,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';
@@ -7170,6 +7263,7 @@ function parseIncrementDecrementCommand(ctx, commandToken) {
         column: commandToken.column,
     };
     const binaryExpr = createBinaryExpression(operator, target, amount, pos);
+    binaryExpr.coerceNumeric = true;
     const toIdentifier = createIdentifier(KEYWORDS.TO, pos);
     const args = [targetWithScope, toIdentifier, binaryExpr];
     return CommandNodeBuilder.from(commandToken)
@@ -7788,6 +7882,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();
@@ -8588,7 +8694,7 @@ class Parser {
                 return {
                     type: 'identifier',
                     name: varToken.value,
-                    scope: 'local',
+                    scope: 'element',
                     start: varToken.start - 1,
                     end: varToken.end,
                     line: varToken.line,
@@ -9215,6 +9321,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 = [];
@@ -9302,30 +9435,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;
         }
@@ -9342,6 +9452,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')) {
@@ -10312,6 +10423,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];
     }
@@ -10516,10 +10631,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 '';
@@ -10663,7 +10775,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':
@@ -10699,7 +10811,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')
@@ -10710,6 +10822,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))
@@ -10839,6 +10953,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);
@@ -10874,6 +10991,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();
@@ -10955,14 +11075,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 '*':
@@ -11744,6 +11876,7 @@ class ContextBridge {
     static toTyped(context) {
         return {
             me: context.me,
+            ...(context.owner !== undefined && { owner: context.owner }),
             it: context.it,
             you: context.you,
             result: context.result,