@reidelsaltres/pureper 0.1.174 → 0.1.176

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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,171 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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 };
-    }
-}