@reidelsaltres/pureper 0.1.157 → 0.1.160

package/src/foundation/engine/BalancedParser.ts

@@ -0,0 +1,353 @@
+/**
+ * BalancedParser - утилита для парсинга сбалансированных скобок (), {}.
+ * Корректно обрабатывает строки и комментарии.
+ */
+export default class BalancedParser {
+    
+    /**
+     * Найти все сбалансированные выражения с заданным opener.
+     * @param input - входная строка
+     * @param opener - открывающая последовательность, например '@(' или '@for('
+     * @returns массив объектов с content и позициями
+     */
+    public static parseBalanced(
+        input: string, 
+        opener: string,
+        closerChar: ')' | '}' = ')'
+    ): Array<{ content: string; start: number; end: number }> {
+        const results: Array<{ content: string; start: number; end: number }> = [];
+        const openerChar = closerChar === ')' ? '(' : '{';
+        let i = 0;
+
+        while (i < input.length) {
+            const idx = input.indexOf(opener, i);
+            if (idx === -1) break;
+
+            const contentStart = idx + opener.length;
+            let pos = contentStart;
+            let depth = 1;
+
+            while (pos < input.length && depth > 0) {
+                const ch = input[pos];
+
+                // Skip string literals
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    pos = this.skipString(input, pos, ch);
+                    continue;
+                }
+
+                // Skip single-line comments
+                if (ch === '/' && input[pos + 1] === '/') {
+                    pos = this.skipLineComment(input, pos);
+                    continue;
+                }
+
+                // Skip multi-line comments
+                if (ch === '/' && input[pos + 1] === '*') {
+                    pos = this.skipBlockComment(input, pos);
+                    continue;
+                }
+
+                if (ch === openerChar) depth++;
+                else if (ch === closerChar) depth--;
+
+                pos++;
+            }
+
+            if (depth === 0) {
+                results.push({
+                    content: input.slice(contentStart, pos - 1),
+                    start: idx,
+                    end: pos
+                });
+                i = pos;
+            } else {
+                // Unbalanced, skip this opener and continue
+                i = idx + 1;
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Парсить блочные Rule типа @for(...) { ... }
+     * @returns объект с condition (содержимое скобок) и block (содержимое фигурных скобок)
+     */
+    public static parseBlockRule(
+        input: string,
+        opener: string // например '@for', '@if'
+    ): Array<{ condition: string; block: string; start: number; end: number }> {
+        const results: Array<{ condition: string; block: string; start: number; end: number }> = [];
+        const openerLower = opener.toLowerCase();
+        let i = 0;
+
+        while (i < input.length) {
+            // Case-insensitive search
+            const lowerInput = input.toLowerCase();
+            let idx = lowerInput.indexOf(openerLower, i);
+            if (idx === -1) break;
+
+            // Check for @@ escape
+            if (idx > 0 && input[idx - 1] === '@') {
+                i = idx + 1;
+                continue;
+            }
+
+            // Find opening parenthesis
+            let parenStart = idx + opener.length;
+            while (parenStart < input.length && /\s/.test(input[parenStart])) {
+                parenStart++;
+            }
+
+            if (input[parenStart] !== '(') {
+                i = idx + 1;
+                continue;
+            }
+
+            // Parse balanced parentheses for condition
+            let pos = parenStart + 1;
+            let depth = 1;
+
+            while (pos < input.length && depth > 0) {
+                const ch = input[pos];
+
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    pos = this.skipString(input, pos, ch);
+                    continue;
+                }
+                if (ch === '/' && input[pos + 1] === '/') {
+                    pos = this.skipLineComment(input, pos);
+                    continue;
+                }
+                if (ch === '/' && input[pos + 1] === '*') {
+                    pos = this.skipBlockComment(input, pos);
+                    continue;
+                }
+
+                if (ch === '(') depth++;
+                else if (ch === ')') depth--;
+                pos++;
+            }
+
+            if (depth !== 0) {
+                i = idx + 1;
+                continue;
+            }
+
+            const condition = input.slice(parenStart + 1, pos - 1);
+            const conditionEnd = pos;
+
+            // Find opening brace for block
+            let braceStart = conditionEnd;
+            while (braceStart < input.length && /\s/.test(input[braceStart])) {
+                braceStart++;
+            }
+
+            if (input[braceStart] !== '{') {
+                i = idx + 1;
+                continue;
+            }
+
+            // Parse balanced braces for block
+            pos = braceStart + 1;
+            depth = 1;
+
+            while (pos < input.length && depth > 0) {
+                const ch = input[pos];
+
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    pos = this.skipString(input, pos, ch);
+                    continue;
+                }
+                if (ch === '/' && input[pos + 1] === '/') {
+                    pos = this.skipLineComment(input, pos);
+                    continue;
+                }
+                if (ch === '/' && input[pos + 1] === '*') {
+                    pos = this.skipBlockComment(input, pos);
+                    continue;
+                }
+
+                if (ch === '{') depth++;
+                else if (ch === '}') depth--;
+                pos++;
+            }
+
+            if (depth !== 0) {
+                i = idx + 1;
+                continue;
+            }
+
+            const block = input.slice(braceStart + 1, pos - 1);
+
+            results.push({
+                condition,
+                block,
+                start: idx,
+                end: pos
+            });
+
+            i = pos;
+        }
+
+        return results;
+    }
+
+    /**
+     * Парсить @if/@elseif/@else цепочки
+     */
+    public static parseIfChain(input: string): Array<{
+        type: 'if' | 'elseif' | 'else';
+        condition?: string;
+        block: string;
+        start: number;
+        end: number;
+    }> {
+        const results: Array<{
+            type: 'if' | 'elseif' | 'else';
+            condition?: string;
+            block: string;
+            start: number;
+            end: number;
+        }> = [];
+
+        // Find @if first
+        const ifMatches = this.parseBlockRule(input, '@if');
+        
+        for (const ifMatch of ifMatches) {
+            results.push({
+                type: 'if',
+                condition: ifMatch.condition,
+                block: ifMatch.block,
+                start: ifMatch.start,
+                end: ifMatch.end
+            });
+
+            // Look for @elseif/@else after this @if
+            let searchPos = ifMatch.end;
+            
+            while (searchPos < input.length) {
+                // Skip whitespace
+                while (searchPos < input.length && /\s/.test(input[searchPos])) {
+                    searchPos++;
+                }
+
+                const remaining = input.slice(searchPos).toLowerCase();
+
+                if (remaining.startsWith('@elseif')) {
+                    const elseifMatches = this.parseBlockRule(input.slice(searchPos), '@elseif');
+                    if (elseifMatches.length > 0) {
+                        const m = elseifMatches[0];
+                        results.push({
+                            type: 'elseif',
+                            condition: m.condition,
+                            block: m.block,
+                            start: searchPos + m.start,
+                            end: searchPos + m.end
+                        });
+                        searchPos = searchPos + m.end;
+                        continue;
+                    }
+                } else if (remaining.startsWith('@else')) {
+                    // @else without condition
+                    let pos = searchPos + 5; // length of '@else'
+                    while (pos < input.length && /\s/.test(input[pos])) {
+                        pos++;
+                    }
+
+                    if (input[pos] === '{') {
+                        let bracePos = pos + 1;
+                        let depth = 1;
+
+                        while (bracePos < input.length && depth > 0) {
+                            const ch = input[bracePos];
+                            if (ch === '"' || ch === "'" || ch === '`') {
+                                bracePos = this.skipString(input, bracePos, ch);
+                                continue;
+                            }
+                            if (ch === '{') depth++;
+                            else if (ch === '}') depth--;
+                            bracePos++;
+                        }
+
+                        if (depth === 0) {
+                            results.push({
+                                type: 'else',
+                                block: input.slice(pos + 1, bracePos - 1),
+                                start: searchPos,
+                                end: bracePos
+                            });
+                            searchPos = bracePos;
+                            continue;
+                        }
+                    }
+                }
+
+                break; // No more @elseif/@else found
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Skip over a string literal (handles escape sequences)
+     */
+    private static skipString(input: string, pos: number, quote: string): number {
+        pos++; // skip opening quote
+        while (pos < input.length) {
+            if (input[pos] === '\\') {
+                pos += 2; // skip escape sequence
+                continue;
+            }
+            if (input[pos] === quote) {
+                return pos + 1;
+            }
+            // Handle template literal ${...}
+            if (quote === '`' && input[pos] === '$' && input[pos + 1] === '{') {
+                pos += 2;
+                let depth = 1;
+                while (pos < input.length && depth > 0) {
+                    if (input[pos] === '{') depth++;
+                    else if (input[pos] === '}') depth--;
+                    pos++;
+                }
+                continue;
+            }
+            pos++;
+        }
+        return pos;
+    }
+
+    /**
+     * Skip single-line comment
+     */
+    private static skipLineComment(input: string, pos: number): number {
+        while (pos < input.length && input[pos] !== '\n') {
+            pos++;
+        }
+        return pos + 1;
+    }
+
+    /**
+     * Skip block comment
+     */
+    private static skipBlockComment(input: string, pos: number): number {
+        pos += 2; // skip /*
+        while (pos < input.length - 1) {
+            if (input[pos] === '*' && input[pos + 1] === '/') {
+                return pos + 2;
+            }
+            pos++;
+        }
+        return pos;
+    }
+
+    /**
+     * Извлечь простые @(expression) без блоков
+     */
+    public static parseExpressions(input: string): Array<{ content: string; start: number; end: number }> {
+        return this.parseBalanced(input, '@(', ')');
+    }
+}

package/src/foundation/engine/EscapeHandler.ts

@@ -0,0 +1,54 @@
+/**
+ * EscapeHandler - обработка escape-последовательностей.
+ * @@ -> @
+ * @@@@ -> @@
+ */
+export default class EscapeHandler {
+    
+    /**
+     * Заменить @@ на специальный placeholder перед парсингом
+     */
+    public static escapeDoubleAt(input: string): { result: string; placeholder: string } {
+        // Use a unique placeholder that won't appear in normal code
+        const placeholder = '\x00AT_ESCAPE\x00';
+        const result = input.replace(/@@/g, placeholder);
+        return { result, placeholder };
+    }
+
+    /**
+     * Восстановить @ из placeholder после парсинга
+     */
+    public static restoreEscapes(input: string, placeholder: string): string {
+        return input.replace(new RegExp(placeholder.replace(/\x00/g, '\\x00'), 'g'), '@');
+    }
+
+    /**
+     * Полный цикл: escape -> process -> restore
+     */
+    public static process(
+        input: string, 
+        processor: (escaped: string) => string
+    ): string {
+        const { result: escaped, placeholder } = this.escapeDoubleAt(input);
+        const processed = processor(escaped);
+        return this.restoreEscapes(processed, placeholder);
+    }
+
+    /**
+     * Проверить, является ли позиция escaped (предшествует @@)
+     */
+    public static isEscaped(input: string, position: number): boolean {
+        if (position === 0) return false;
+        
+        // Count consecutive @ before this position
+        let count = 0;
+        let i = position - 1;
+        while (i >= 0 && input[i] === '@') {
+            count++;
+            i--;
+        }
+        
+        // If odd number of @ before, this @ is escaped
+        return count % 2 === 1;
+    }
+}

package/src/foundation/engine/Expression.ts

@@ -0,0 +1,285 @@
+import Scope from './Scope.js';
+import Observable, { isObservable } from '../api/Observer.js';
+
+/**
+ * Expression - класс для выполнения JS-кода в контексте Scope.
+ * Поддерживает:
+ * - Простые выражения: value, user.name
+ * - Вызовы функций: doSomething()
+ * - Сложный JS-код: encodeURIComponent(JSON.stringify(subject))
+ * - Код с return: const f = ""; return f;
+ * - Async/await: await fetchData()
+ * 
+ * Для Observable автоматически разворачивает значения:
+ *   user.name -> user.getObject().name (если user - Observable)
+ */
+export default class Expression {
+    private readonly code: string;
+    private readonly isAsync: boolean;
+    private readonly hasReturn: boolean;
+
+    constructor(code: string) {
+        this.code = code.trim();
+        this.isAsync = this.detectAsync(this.code);
+        this.hasReturn = this.detectReturn(this.code);
+    }
+
+    /**
+     * Определить, содержит ли код await
+     */
+    private detectAsync(code: string): boolean {
+        // Simple check for await keyword (not in string)
+        return /\bawait\s+/.test(code);
+    }
+
+    /**
+     * Определить, содержит ли код return
+     */
+    private detectReturn(code: string): boolean {
+        // Check for return keyword followed by space, semicolon, or end
+        return /\breturn\s+/.test(code) || /\breturn;/.test(code) || /\breturn$/.test(code);
+    }
+
+    /**
+     * Получить исходный код выражения
+     */
+    public getCode(): string {
+        return this.code;
+    }
+
+    /**
+     * Найти все Observable, используемые в выражении.
+     * Например, для "user.name + user.age" вернёт [Observable(user)]
+     */
+    public findObservables(scope: Scope): Observable<any>[] {
+        const context = scope.getVariables();
+        const observables: Observable<any>[] = [];
+        const seen = new Set<Observable<any>>();
+
+        // Извлекаем идентификаторы из выражения
+        const identifiers = this.extractIdentifiers(this.code);
+
+        for (const id of identifiers) {
+            const value = context[id];
+            if (isObservable(value) && !seen.has(value)) {
+                seen.add(value);
+                observables.push(value);
+            }
+        }
+
+        return observables;
+    }
+
+    /**
+     * Извлечь идентификаторы верхнего уровня из выражения.
+     * "user.name + count" -> ["user", "count"]
+     */
+    private extractIdentifiers(code: string): string[] {
+        const identifiers: string[] = [];
+        // Regex для идентификаторов (не после точки)
+        const regex = /(?<![.\w])([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+        
+        // Список встроенных глобальных объектов, которые нужно игнорировать
+        const builtins = new Set([
+            'true', 'false', 'null', 'undefined', 'NaN', 'Infinity',
+            'Math', 'Date', 'JSON', 'Array', 'Object', 'String', 'Number', 'Boolean',
+            'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+            'encodeURIComponent', 'decodeURIComponent', 'encodeURI', 'decodeURI',
+            'console', 'window', 'document', 'this',
+            'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+            'return', 'function', 'const', 'let', 'var', 'new', 'typeof', 'instanceof',
+            'in', 'of', 'async', 'await', 'try', 'catch', 'finally', 'throw'
+        ]);
+
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            const id = match[1];
+            if (!builtins.has(id) && !identifiers.includes(id)) {
+                identifiers.push(id);
+            }
+        }
+
+        return identifiers;
+    }
+
+    /**
+     * Трансформировать код, разворачивая Observable.
+     * "user.name" -> "user.getObject().name" (если user - Observable)
+     */
+    public transformCode(scope: Scope): string {
+        const context = scope.getVariables();
+        let transformedCode = this.code;
+        
+        // Находим Observable переменные
+        const observableVars = new Set<string>();
+        for (const [key, value] of Object.entries(context)) {
+            if (isObservable(value)) {
+                observableVars.add(key);
+            }
+        }
+
+        if (observableVars.size === 0) {
+            return transformedCode;
+        }
+
+        // Трансформируем: user.name -> user.getObject().name
+        // и user (само по себе) -> user.getObject()
+        for (const varName of observableVars) {
+            // user.property -> user.getObject().property
+            const propRegex = new RegExp(`\\b${varName}\\.(?!getObject|setObject|subscribe|unsubscribe|getObserver|getMutationObserver|subscribeMutation|unsubscribeMutation)`, 'g');
+            transformedCode = transformedCode.replace(propRegex, `${varName}.getObject().`);
+            
+            // Если просто user без вызова метода, не трансформируем (может быть намеренно)
+        }
+
+        return transformedCode;
+    }
+
+    /**
+     * Выполнить выражение в контексте Scope.
+     * @param scope - Scope с переменными и функциями
+     * @param extraVars - дополнительные переменные (например, event для @on)
+     * @returns результат выполнения
+     */
+    public execute(scope: Scope, extraVars?: Record<string, any>): any {
+        const context = scope.getVariables();
+        
+        if (extraVars) {
+            Object.assign(context, extraVars);
+        }
+
+        try {
+            // Трансформируем код для автоматического разворачивания Observable
+            const transformedCode = this.transformCode(scope);
+            return this.executeInContext(context, transformedCode);
+        } catch (error) {
+            console.error(`[Expression] Error executing: ${this.code}`);
+            console.error(error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Выполнить выражение асинхронно
+     */
+    public async executeAsync(scope: Scope, extraVars?: Record<string, any>): Promise<any> {
+        const context = scope.getVariables();
+        
+        if (extraVars) {
+            Object.assign(context, extraVars);
+        }
+
+        try {
+            const transformedCode = this.transformCode(scope);
+            return await this.executeInContextAsync(context, transformedCode);
+        } catch (error) {
+            console.error(`[Expression] Error executing async: ${this.code}`);
+            console.error(error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Выполнить в контексте (синхронно)
+     */
+    private executeInContext(context: Record<string, any>, codeOverride?: string): any {
+        const keys = Object.keys(context);
+        const values = Object.values(context);
+        const codeToExecute = codeOverride ?? this.code;
+
+        let functionBody: string;
+
+        if (this.hasReturn) {
+            // Code contains return, wrap in function directly
+            functionBody = codeToExecute;
+        } else {
+            // No return, add implicit return
+            functionBody = `return (${codeToExecute})`;
+        }
+
+        try {
+            // Create function with context variables as parameters
+            const fn = new Function(...keys, functionBody);
+            return fn.apply(null, values);
+        } catch (syntaxError) {
+            // If implicit return fails, try without it (for statements)
+            if (!this.hasReturn) {
+                try {
+                    const fn = new Function(...keys, codeToExecute);
+                    return fn.apply(null, values);
+                } catch {
+                    throw syntaxError;
+                }
+            }
+            throw syntaxError;
+        }
+    }
+
+    /**
+     * Выполнить в контексте (асинхронно)
+     */
+    private async executeInContextAsync(context: Record<string, any>, codeOverride?: string): Promise<any> {
+        const keys = Object.keys(context);
+        const values = Object.values(context);
+        const codeToExecute = codeOverride ?? this.code;
+
+        let functionBody: string;
+
+        if (this.hasReturn) {
+            functionBody = codeToExecute;
+        } else {
+            functionBody = `return (${codeToExecute})`;
+        }
+
+        try {
+            // Create async function
+            const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+            const fn = new AsyncFunction(...keys, functionBody);
+            return await fn.apply(null, values);
+        } catch (syntaxError) {
+            if (!this.hasReturn) {
+                try {
+                    const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+                    const fn = new AsyncFunction(...keys, codeToExecute);
+                    return await fn.apply(null, values);
+                } catch {
+                    throw syntaxError;
+                }
+            }
+            throw syntaxError;
+        }
+    }
+
+    /**
+     * Проверить, является ли выражение асинхронным
+     */
+    public isAsyncExpression(): boolean {
+        return this.isAsync;
+    }
+
+    /**
+     * Выполнить выражение (авто-выбор sync/async)
+     */
+    public eval(scope: Scope, extraVars?: Record<string, any>): any | Promise<any> {
+        if (this.isAsync) {
+            return this.executeAsync(scope, extraVars);
+        }
+        return this.execute(scope, extraVars);
+    }
+
+    /**
+     * Статический метод для быстрого выполнения
+     */
+    public static evaluate(code: string, scope: Scope, extraVars?: Record<string, any>): any {
+        const expr = new Expression(code);
+        return expr.eval(scope, extraVars);
+    }
+
+    /**
+     * Статический метод для асинхронного выполнения
+     */
+    public static async evaluateAsync(code: string, scope: Scope, extraVars?: Record<string, any>): Promise<any> {
+        const expr = new Expression(code);
+        return await expr.executeAsync(scope, extraVars);
+    }
+}