@reidelsaltres/pureper 0.1.157 → 0.1.160

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

@@ -0,0 +1,119 @@
+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: '' };
+        }
+
+        // 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: []
+        };
+    }
+
+    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 };
+    }
+}

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

@@ -0,0 +1,267 @@
+import { SyntaxRule } from '../../Rule.js';
+import type { RuleMatch, RuleResult } from '../../Rule.js';
+import Scope from '../../Scope.js';
+import Expression from '../../Expression.js';
+import { InvalidTemplateEngineSyntaxException } from '../../exceptions/TemplateExceptions.js';
+import { isObservable } from '../../../api/Observer.js';
+
+interface ForMatch extends RuleMatch {
+    data: {
+        /** Вариант: 'single' (item in expr), 'indexed' (idx, item in expr), 'numeric' (i in number) */
+        variant: 'single' | 'indexed' | 'numeric';
+        /** Имена локальных переменных */
+        variables: string[];
+        /** Выражение коллекции/числа */
+        expression: string;
+        /** Тело цикла */
+        block: string;
+    };
+}
+
+/**
+ * ForRule - обработка @for
+ * Варианты:
+ * 1. @for(item in collection) { ... }
+ * 2. @for(idx, item in collection) { ... }
+ * 3. @for(i in 5) { ... } - числовая итерация 0..4
+ */
+export default class ForRule extends SyntaxRule {
+    public readonly name = 'for';
+    public readonly priority = 10; // Выполняется раньше всех
+
+    public find(template: string): RuleMatch[] {
+        const results: RuleMatch[] = [];
+        const lowerTemplate = template.toLowerCase();
+        let i = 0;
+
+        while (i < template.length) {
+            const idx = lowerTemplate.indexOf('@for', i);
+            if (idx === -1) break;
+
+            // Check for @@ escape
+            if (idx > 0 && template[idx - 1] === '@') {
+                i = idx + 1;
+                continue;
+            }
+
+            const parsed = this.parseForStatement(template, idx);
+            if (parsed) {
+                results.push({
+                    fullMatch: template.slice(parsed.start, parsed.end),
+                    start: parsed.start,
+                    end: parsed.end,
+                    data: {
+                        variant: parsed.variant,
+                        variables: parsed.variables,
+                        expression: parsed.expression,
+                        block: parsed.block
+                    }
+                });
+                i = parsed.end;
+            } else {
+                i = idx + 1;
+            }
+        }
+
+        return results;
+    }
+
+    private parseForStatement(template: string, start: number): {
+        start: number;
+        end: number;
+        variant: 'single' | 'indexed' | 'numeric';
+        variables: string[];
+        expression: string;
+        block: string;
+    } | null {
+        let pos = start + 4; // '@for'.length
+
+        // Skip whitespace
+        while (pos < template.length && /\s/.test(template[pos])) {
+            pos++;
+        }
+
+        // Expect (
+        if (template[pos] !== '(') return null;
+
+        // Parse balanced parentheses
+        const conditionStart = pos + 1;
+        pos++;
+        let depth = 1;
+
+        while (pos < template.length && depth > 0) {
+            const ch = template[pos];
+            if (ch === '"' || ch === "'" || ch === '`') {
+                pos = this.skipString(template, pos, ch);
+                continue;
+            }
+            if (ch === '(') depth++;
+            else if (ch === ')') depth--;
+            pos++;
+        }
+
+        if (depth !== 0) return null;
+        const conditionContent = template.slice(conditionStart, pos - 1).trim();
+
+        // Parse condition: "var in expr" or "idx, var in expr"
+        const inMatch = conditionContent.match(/^(.+?)\s+in\s+(.+)$/);
+        if (!inMatch) return null;
+
+        const varPart = inMatch[1].trim();
+        const expression = inMatch[2].trim();
+
+        // Parse variables
+        let variables: string[];
+        let variant: 'single' | 'indexed' | 'numeric';
+
+        if (varPart.includes(',')) {
+            // Indexed variant: "idx, item"
+            variables = varPart.split(',').map(v => v.trim());
+            if (variables.length !== 2) return null;
+            variant = 'indexed';
+        } else {
+            variables = [varPart];
+            variant = 'single'; // Will be determined at execution time if numeric
+        }
+
+        // Skip whitespace
+        while (pos < template.length && /\s/.test(template[pos])) {
+            pos++;
+        }
+
+        // Expect {
+        if (template[pos] !== '{') return null;
+
+        // Parse balanced braces
+        const blockStart = pos + 1;
+        pos++;
+        depth = 1;
+
+        while (pos < template.length && depth > 0) {
+            const ch = template[pos];
+            if (ch === '"' || ch === "'" || ch === '`') {
+                pos = this.skipString(template, pos, ch);
+                continue;
+            }
+            if (ch === '{') depth++;
+            else if (ch === '}') depth--;
+            pos++;
+        }
+
+        if (depth !== 0) return null;
+        const block = template.slice(blockStart, pos - 1);
+
+        return { start, end: pos, variant, variables, expression, block };
+    }
+
+    private skipString(input: string, pos: number, quote: string): number {
+        pos++;
+        while (pos < input.length) {
+            if (input[pos] === '\\') {
+                pos += 2;
+                continue;
+            }
+            if (input[pos] === quote) {
+                return pos + 1;
+            }
+            pos++;
+        }
+        return pos;
+    }
+
+    public execute(match: RuleMatch, scope: Scope, engine?: any): RuleResult {
+        const data = (match as ForMatch).data;
+        const observables: any[] = [];
+        const outputs: string[] = [];
+
+        // Evaluate expression
+        const expr = new Expression(data.expression);
+        
+        // Находим Observable в выражении
+        const exprObservables = expr.findObservables(scope);
+        observables.push(...exprObservables);
+        
+        let collection = expr.execute(scope);
+
+        // Check if Observable
+        if (isObservable(collection)) {
+            observables.push(collection);
+            collection = collection.getObject?.() ?? collection;
+        }
+
+        // Determine iteration type
+        if (typeof collection === 'number') {
+            // Numeric iteration: 0 to collection-1
+            if (data.variant === 'indexed') {
+                throw new InvalidTemplateEngineSyntaxException(
+                    '@for with numeric value does not support indexed variant (idx, var). Use single variable.'
+                );
+            }
+
+            const count = Math.floor(collection);
+            if (count < 0) {
+                throw new InvalidTemplateEngineSyntaxException(
+                    `@for numeric value must be non-negative, got: ${count}`
+                );
+            }
+
+            for (let i = 0; i < count; i++) {
+                const localScope = scope.createChild({ [data.variables[0]]: i });
+                
+                if (engine) {
+                    const result = engine.processTemplate(data.block, localScope);
+                    outputs.push(result.output);
+                    if (result.observables) observables.push(...result.observables);
+                } else {
+                    outputs.push(data.block);
+                }
+            }
+        } else if (Array.isArray(collection) || (collection && typeof collection[Symbol.iterator] === 'function')) {
+            // Array or iterable
+            const items = Array.isArray(collection) ? collection : Array.from(collection);
+
+            if (data.variant === 'indexed') {
+                // (idx, item in collection)
+                items.forEach((item, idx) => {
+                    const localScope = scope.createChild({
+                        [data.variables[0]]: idx,
+                        [data.variables[1]]: item
+                    });
+
+                    if (engine) {
+                        const result = engine.processTemplate(data.block, localScope);
+                        outputs.push(result.output);
+                        if (result.observables) observables.push(...result.observables);
+                    } else {
+                        outputs.push(data.block);
+                    }
+                });
+            } else {
+                // (item in collection)
+                items.forEach((item) => {
+                    const localScope = scope.createChild({ [data.variables[0]]: item });
+
+                    if (engine) {
+                        const result = engine.processTemplate(data.block, localScope);
+                        outputs.push(result.output);
+                        if (result.observables) observables.push(...result.observables);
+                    } else {
+                        outputs.push(data.block);
+                    }
+                });
+            }
+        } else if (typeof collection === 'string') {
+            throw new InvalidTemplateEngineSyntaxException(
+                `@for does not support string iteration. Got: "${collection}"`
+            );
+        } else if (collection === null || collection === undefined) {
+            // Empty result
+        } else {
+            throw new InvalidTemplateEngineSyntaxException(
+                `@for expression must return a number, array, or iterable. Got: ${typeof collection}`
+            );
+        }
+
+        return { output: outputs.join(''), observables };
+    }
+}