@reidelsaltres/pureper 0.1.157 → 0.1.162

package/src/foundation/engine/exceptions/TemplateExceptions.ts

@@ -0,0 +1,27 @@
+/**
+ * InvalidDynamicRuleUsage - исключение при использовании Observable
+ * в правилах, которые не поддерживают динамическое обновление.
+ * Например: @[ref], @injection
+ */
+export class InvalidDynamicRuleUsage extends Error {
+    constructor(ruleName: string, message?: string) {
+        super(message ?? `Rule "${ruleName}" does not support Observable values. Use a static value instead.`);
+        this.name = 'InvalidDynamicRuleUsage';
+    }
+}
+
+/**
+ * InvalidTemplateEngineSyntaxException - исключение при синтаксических ошибках
+ * в шаблоне. Например: @if без boolean, @for с неверным типом.
+ */
+export class InvalidTemplateEngineSyntaxException extends Error {
+    public readonly line?: number;
+    public readonly column?: number;
+
+    constructor(message: string, options?: { line?: number; column?: number }) {
+        super(message);
+        this.name = 'InvalidTemplateEngineSyntaxException';
+        this.line = options?.line;
+        this.column = options?.column;
+    }
+}

package/src/foundation/engine/rules/attribute/EventRule.ts

@@ -0,0 +1,171 @@
+import { AttributeRule } from '../../Rule.js';
+import type { RuleMatch, RuleResult } from '../../Rule.js';
+import Scope from '../../Scope.js';
+import Expression from '../../Expression.js';
+
+interface EventMatch extends RuleMatch {
+    data: {
+        eventName: string;
+        expression: string;
+        attributeMatch: string;
+    };
+}
+
+/**
+ * EventRule - обработка @on[eventName]="expression"
+ * Подписывает элемент на событие.
+ */
+export default class EventRule extends AttributeRule {
+    public readonly name = 'event';
+    public readonly priority = 30;
+
+    public find(template: string): RuleMatch[] {
+        const results: RuleMatch[] = [];
+        // Match @on[eventName]="
+        const pattern = /@on\[([a-zA-Z]+)\]\s*=/gi;
+        let match: RegExpExecArray | null;
+
+        while ((match = pattern.exec(template)) !== null) {
+            const idx = match.index;
+
+            // Check for @@ escape
+            if (idx > 0 && template[idx - 1] === '@') {
+                continue;
+            }
+
+            const eventName = match[1].toLowerCase();
+
+            // Find quote char after =
+            let pos = idx + match[0].length;
+            while (pos < template.length && /\s/.test(template[pos])) {
+                pos++;
+            }
+
+            const quoteChar = template[pos];
+            if (quoteChar !== '"' && quoteChar !== "'") {
+                continue;
+            }
+
+            // Find matching closing quote
+            const contentStart = pos + 1;
+            pos++;
+            while (pos < template.length && template[pos] !== quoteChar) {
+                pos++;
+            }
+
+            if (pos >= template.length) continue;
+
+            const content = template.slice(contentStart, pos);
+            const fullMatch = template.slice(idx, pos + 1);
+
+            results.push({
+                fullMatch,
+                start: idx,
+                end: pos + 1,
+                data: {
+                    eventName,
+                    expression: content,
+                    attributeMatch: fullMatch
+                }
+            });
+        }
+
+        return results;
+    }
+
+    public execute(match: RuleMatch, scope: Scope): RuleResult {
+        const data = (match as EventMatch).data;
+        
+        // Generate data attribute for later DOM binding
+        // Actual event binding happens in postprocessing
+        const encodedExpr = encodeURIComponent(data.expression);
+        
+        return {
+            output: `data-event-${data.eventName}="${encodedExpr}"`,
+            observables: []
+        };
+    }
+
+    /**
+     * Постобработка: привязать события к элементам
+     */
+    public static bindEvents(element: Element, scope: Scope): (() => void)[] {
+        const unbinders: (() => void)[] = [];
+
+        // Find all data-event-* attributes
+        const attributes = Array.from(element.attributes);
+        
+        for (const attr of attributes) {
+            if (attr.name.startsWith('data-event-')) {
+                const eventName = attr.name.slice('data-event-'.length);
+                const exprCode = decodeURIComponent(attr.value);
+
+                const handler = (event: Event) => {
+                    // Create local scope with event
+                    const localScope = scope.createChild({ event });
+                    const expr = new Expression(exprCode);
+                    
+                    try {
+                        expr.execute(localScope);
+                    } catch (error) {
+                        console.error(`[EventRule] Error executing handler for ${eventName}:`, error);
+                    }
+                };
+
+                element.addEventListener(eventName, handler);
+                unbinders.push(() => element.removeEventListener(eventName, handler));
+
+                // Optionally remove the data attribute
+                // element.removeAttribute(attr.name);
+            }
+        }
+
+        return unbinders;
+    }
+
+    /**
+     * Привязать событие с поддержкой Observable
+     */
+    public static bindEventWithObservable(
+        element: Element,
+        eventName: string,
+        exprCode: string,
+        scope: Scope
+    ): () => void {
+        let currentHandler: ((event: Event) => void) | null = null;
+
+        const setupHandler = () => {
+            // Remove old handler if exists
+            if (currentHandler) {
+                element.removeEventListener(eventName, currentHandler);
+            }
+
+            currentHandler = (event: Event) => {
+                const localScope = scope.createChild({ event });
+                const expr = new Expression(exprCode);
+                
+                try {
+                    const result = expr.execute(localScope);
+                    
+                    // If result is Observable, handle it
+                    if (result && typeof result === 'object' && typeof result.subscribe === 'function') {
+                        // Re-setup handler when Observable changes
+                        result.subscribe(() => setupHandler());
+                    }
+                } catch (error) {
+                    console.error(`[EventRule] Error executing handler for ${eventName}:`, error);
+                }
+            };
+
+            element.addEventListener(eventName, currentHandler);
+        };
+
+        setupHandler();
+
+        return () => {
+            if (currentHandler) {
+                element.removeEventListener(eventName, currentHandler);
+            }
+        };
+    }
+}

package/src/foundation/engine/rules/attribute/InjectionRule.ts

@@ -0,0 +1,140 @@
+import { AttributeRule } from '../../Rule.js';
+import type { RuleMatch, RuleResult } from '../../Rule.js';
+import Scope from '../../Scope.js';
+import Expression from '../../Expression.js';
+import { InvalidDynamicRuleUsage } from '../../exceptions/TemplateExceptions.js';
+
+interface InjectionMatch extends RuleMatch {
+    data: {
+        type: 'head' | 'tail';
+        expression: string;
+        attributeMatch: string;
+    };
+}
+
+/**
+ * InjectionRule - обработка @injection[type]="expression"
+ * Инжектирует элемент в целевой элемент (найденный по @[ref]).
+ * type: 'head' = prepend, 'tail' = append
+ */
+export default class InjectionRule extends AttributeRule {
+    public readonly name = 'injection';
+    public readonly priority = 200; // Выполняется в самом конце
+
+    public find(template: string): RuleMatch[] {
+        const results: RuleMatch[] = [];
+        // Match @injection[head] or @injection[tail]
+        const pattern = /@injection\[(head|tail)\]\s*=/gi;
+        let match: RegExpExecArray | null;
+
+        while ((match = pattern.exec(template)) !== null) {
+            const idx = match.index;
+
+            // Check for @@ escape
+            if (idx > 0 && template[idx - 1] === '@') {
+                continue;
+            }
+
+            const injectionType = match[1].toLowerCase() as 'head' | 'tail';
+
+            // Find quote char after =
+            let pos = idx + match[0].length;
+            while (pos < template.length && /\s/.test(template[pos])) {
+                pos++;
+            }
+
+            const quoteChar = template[pos];
+            if (quoteChar !== '"' && quoteChar !== "'") {
+                continue;
+            }
+
+            // Find matching closing quote
+            const contentStart = pos + 1;
+            pos++;
+            while (pos < template.length && template[pos] !== quoteChar) {
+                pos++;
+            }
+
+            if (pos >= template.length) continue;
+
+            const content = template.slice(contentStart, pos);
+            const fullMatch = template.slice(idx, pos + 1);
+
+            results.push({
+                fullMatch,
+                start: idx,
+                end: pos + 1,
+                data: {
+                    type: injectionType,
+                    expression: content,
+                    attributeMatch: fullMatch
+                }
+            });
+        }
+
+        return results;
+    }
+
+    public execute(match: RuleMatch, scope: Scope): RuleResult {
+        const data = (match as InjectionMatch).data;
+        const expr = new Expression(data.expression);
+        const targetRefName = expr.execute(scope);
+
+        // Check if Observable - not allowed for @injection
+        if (targetRefName && typeof targetRefName === 'object' && typeof targetRefName.subscribe === 'function') {
+            throw new InvalidDynamicRuleUsage('@injection',
+                '@injection does not support Observable values. The target reference must be static.');
+        }
+
+        if (typeof targetRefName !== 'string') {
+            console.error(`[InjectionRule] Expression must return a string (reference name), got: ${typeof targetRefName}`);
+            return { output: '' };
+        }
+
+        // Store injection info for postprocessing
+        const encodedTarget = encodeURIComponent(targetRefName);
+
+        return {
+            output: `data-injection-type="${data.type}" data-injection-target="${encodedTarget}"`,
+            observables: []
+        };
+    }
+
+    public supportsObservable(): boolean {
+        return false;
+    }
+
+    /**
+     * Постобработка: выполнить инжекцию элементов
+     */
+    public static processInjections(root: Element | DocumentFragment, scope: Scope): void {
+        // Find all elements with injection attributes
+        const injectElements = root.querySelectorAll('[data-injection-type][data-injection-target]');
+
+        for (const element of Array.from(injectElements)) {
+            const type = element.getAttribute('data-injection-type') as 'head' | 'tail';
+            const targetRefName = decodeURIComponent(element.getAttribute('data-injection-target') || '');
+
+            if (!targetRefName) continue;
+
+            // Get target element from scope
+            const targetElement = scope.get(targetRefName);
+
+            if (!targetElement || !(targetElement instanceof Element)) {
+                console.warn(`[InjectionRule] Target element "${targetRefName}" not found in scope or is not an Element`);
+                continue;
+            }
+
+            // Remove injection attributes
+            element.removeAttribute('data-injection-type');
+            element.removeAttribute('data-injection-target');
+
+            // Perform injection
+            if (type === 'head') {
+                targetElement.prepend(element);
+            } else {
+                targetElement.append(element);
+            }
+        }
+    }
+}

package/src/foundation/engine/rules/attribute/RefRule.ts

@@ -0,0 +1,126 @@
+import { AttributeRule } from '../../Rule.js';
+import type { RuleMatch, RuleResult } from '../../Rule.js';
+import Scope from '../../Scope.js';
+import Expression from '../../Expression.js';
+import { InvalidDynamicRuleUsage } from '../../exceptions/TemplateExceptions.js';
+
+/**
+ * RefRule - обработка @[ref]="expression"
+ * Добавляет HTML элемент в Scope под указанным именем.
+ */
+export default class RefRule extends AttributeRule {
+    public readonly name = 'ref';
+    public readonly priority = 5; // Выполняется очень рано
+
+    public find(template: string): RuleMatch[] {
+        const results: RuleMatch[] = [];
+        // Match @[ref]=" or @[ref]='
+        const opener = '@[ref]=';
+        let i = 0;
+
+        while (i < template.length) {
+            const idx = template.toLowerCase().indexOf(opener.toLowerCase(), i);
+            if (idx === -1) break;
+
+            // Check for @@ escape
+            if (idx > 0 && template[idx - 1] === '@') {
+                i = idx + 1;
+                continue;
+            }
+
+            // Find quote char after =
+            let pos = idx + opener.length;
+            while (pos < template.length && /\s/.test(template[pos])) {
+                pos++;
+            }
+
+            const quoteChar = template[pos];
+            if (quoteChar !== '"' && quoteChar !== "'") {
+                i = idx + 1;
+                continue;
+            }
+
+            // Find matching closing quote (handle nested quotes)
+            const contentStart = pos + 1;
+            pos++;
+            
+            // Simple: find the closing quote that matches
+            while (pos < template.length && template[pos] !== quoteChar) {
+                pos++;
+            }
+
+            if (pos >= template.length) {
+                i = idx + 1;
+                continue;
+            }
+
+            const content = template.slice(contentStart, pos);
+            const fullMatch = template.slice(idx, pos + 1);
+
+            results.push({
+                fullMatch,
+                start: idx,
+                end: pos + 1,
+                data: { 
+                    expression: content,
+                    attributeMatch: fullMatch
+                }
+            });
+
+            i = pos + 1;
+        }
+
+        return results;
+    }
+
+    public execute(match: RuleMatch, scope: Scope): RuleResult {
+        const exprCode = match.data?.expression as string;
+        const expr = new Expression(exprCode);
+        const refName = expr.execute(scope);
+
+        // Check if Observable - not allowed for @[ref]
+        if (refName && typeof refName === 'object' && typeof refName.subscribe === 'function') {
+            throw new InvalidDynamicRuleUsage('@[ref]', 
+                '@[ref] does not support Observable values. The reference name must be static.');
+        }
+
+        if (typeof refName !== 'string') {
+            console.error(`[RefRule] Expression must return a string (variable name), got: ${typeof refName}`);
+            return { output: '' };
+        }
+
+        // Сразу регистрируем ref в scope с null значением
+        // Будет заполнен реальным элементом при bindRefs()
+        if (!scope.has(refName)) {
+            scope.set(refName, null);
+        }
+
+        // Store placeholder - actual element will be set during DOM processing
+        // For now, return the attribute without the @[ref] syntax
+        return { 
+            output: `data-ref="${refName}"`,
+            observables: [],
+            data: { refName } // Сохраняем имя ref для быстрого доступа
+        };
+    }
+
+    public supportsObservable(): boolean {
+        return false;
+    }
+
+    /**
+     * Постобработка: привязать реальный элемент к Scope
+     */
+    public static bindElement(element: Element, refName: string, scope: Scope): void {
+        scope.set(refName, element);
+    }
+
+    /**
+     * Очистка: установить ref в null если элемент удалён
+     */
+    public static unbindElement(refName: string, scope: Scope): void {
+        if (scope.has(refName)) {
+            scope.set(refName, null);
+        }
+    }
+}

package/src/foundation/engine/rules/syntax/ExpressionRule.ts

@@ -0,0 +1,102 @@
+import { SyntaxRule } from '../../Rule.js';
+import type { RuleMatch, RuleResult } from '../../Rule.js';
+import Scope from '../../Scope.js';
+import Expression from '../../Expression.js';
+import BalancedParser from '../../BalancedParser.js';
+import { isObservable } from '../../../api/Observer.js';
+
+/**
+ * ExpressionRule - обработка @(Expression)
+ * Выводит результат выражения как строку.
+ * Автоматически отслеживает Observable и разворачивает их значения.
+ */
+export default class ExpressionRule extends SyntaxRule {
+    public readonly name = 'expression';
+    public readonly priority = 50; // Выполняется после блочных правил
+
+    public find(template: string): RuleMatch[] {
+        const matches = BalancedParser.parseExpressions(template);
+        
+        return matches.map(m => ({
+            fullMatch: template.slice(m.start, m.end),
+            start: m.start,
+            end: m.end,
+            data: { expression: m.content }
+        }));
+    }
+
+    public execute(match: RuleMatch, scope: Scope): RuleResult {
+        const code = match.data?.expression as string;
+        
+        if (!code || code.trim() === '') {
+            return { output: '' };
+        }
+
+        const expr = new Expression(code);
+        
+        // Находим Observable, используемые в выражении
+        const observables = expr.findObservables(scope);
+        
+        // Check for async
+        if (expr.isAsyncExpression()) {
+            // Return promise wrapper - engine should handle this
+            const promise = expr.executeAsync(scope).then(result => {
+                if (result === undefined || result === null) {
+                    return '';
+                }
+                return String(result);
+            });
+            
+            // For now, return placeholder - proper async handling in engine
+            return { 
+                output: '', 
+                observables,
+                children: []
+            };
+        }
+
+        const result = expr.execute(scope);
+        
+        // Если результат сам Observable (например @(counter)), отслеживаем его
+        if (isObservable(result)) {
+            return {
+                output: String(result.getObject?.() ?? result),
+                observables: [...observables, result]
+            };
+        }
+
+        if (result === undefined || result === null) {
+            return { output: '', observables };
+        }
+
+        return { output: String(result), observables };
+    }
+
+    /**
+     * Асинхронная версия execute
+     */
+    public async executeAsync(match: RuleMatch, scope: Scope): Promise<RuleResult> {
+        const code = match.data?.expression as string;
+        
+        if (!code || code.trim() === '') {
+            return { output: '' };
+        }
+
+        const expr = new Expression(code);
+        const observables = expr.findObservables(scope);
+        const result = await expr.executeAsync(scope);
+        
+        if (isObservable(result)) {
+            return {
+                output: String(result.getObject?.() ?? result),
+                observables: [...observables, result]
+            };
+        }
+
+        if (result === undefined || result === null) {
+            return { output: '', observables };
+        }
+
+        return { output: String(result), observables };
+    }
+}