@reidelsaltres/pureper 0.1.157 → 0.1.162

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);
+    }
+}

package/src/foundation/engine/Rule.ts

@@ -0,0 +1,138 @@
+import Scope from './Scope.js';
+import Expression from './Expression.js';
+
+/**
+ * RuleMatch - результат поиска Rule в шаблоне
+ */
+export interface RuleMatch {
+    /** Полное совпадение включая синтаксис Rule */
+    fullMatch: string;
+    /** Начальная позиция в исходной строке */
+    start: number;
+    /** Конечная позиция в исходной строке */
+    end: number;
+    /** Дополнительные данные специфичные для Rule */
+    data?: Record<string, any>;
+}
+
+/**
+ * RuleResult - результат выполнения Rule
+ */
+export interface RuleResult {
+    /** HTML-результат для замены */
+    output: string;
+    /** Использованные Observable для отслеживания */
+    observables?: any[];
+    /** Дочерние Rule (для вложенных структур) */
+    children?: Rule[];
+    /** Дополнительные данные (например, refName для RefRule) */
+    data?: Record<string, any>;
+}
+
+/**
+ * RuleType - тип Rule
+ */
+export type RuleType = 'syntax' | 'attribute';
+
+/**
+ * Rule - базовый абстрактный класс для всех правил шаблонизатора.
+ */
+export default abstract class Rule {
+    /** Уникальное имя правила */
+    public abstract readonly name: string;
+    
+    /** Тип правила: syntax или attribute */
+    public abstract readonly type: RuleType;
+    
+    /** Приоритет выполнения (меньше = раньше) */
+    public readonly priority: number = 100;
+
+    /**
+     * Найти все вхождения этого Rule в шаблоне.
+     * @param template - исходный шаблон
+     * @returns массив найденных совпадений
+     */
+    public abstract find(template: string): RuleMatch[];
+
+    /**
+     * Выполнить Rule и вернуть результат.
+     * @param match - найденное совпадение
+     * @param scope - текущий Scope
+     * @param engine - ссылка на TemplateEngine (для рекурсивной обработки)
+     */
+    public abstract execute(
+        match: RuleMatch, 
+        scope: Scope,
+        engine?: any // TemplateEngine, circular dependency workaround
+    ): RuleResult | Promise<RuleResult>;
+
+    /**
+     * Проверить, поддерживает ли Rule Observable значения
+     */
+    public supportsObservable(): boolean {
+        return true;
+    }
+}
+
+/**
+ * SyntaxRule - базовый класс для синтаксических правил.
+ * Синтаксические правила могут быть в любом месте шаблона (кроме атрибутов).
+ */
+export abstract class SyntaxRule extends Rule {
+    public readonly type: RuleType = 'syntax';
+}
+
+/**
+ * AttributeRule - базовый класс для атрибутивных правил.
+ * Атрибутивные правила работают только внутри HTML-тегов.
+ */
+export abstract class AttributeRule extends Rule {
+    public readonly type: RuleType = 'attribute';
+    
+    /**
+     * Получить элемент, к которому применяется атрибут.
+     * @param template - шаблон
+     * @param attributePosition - позиция атрибута
+     * @returns информация об элементе
+     */
+    protected findParentElement(
+        template: string, 
+        attributePosition: number
+    ): { tagName: string; tagStart: number; tagEnd: number } | null {
+        // Find opening < before attribute
+        let tagStart = attributePosition;
+        while (tagStart > 0 && template[tagStart] !== '<') {
+            tagStart--;
+        }
+
+        if (template[tagStart] !== '<') {
+            return null;
+        }
+
+        // Extract tag name
+        let nameEnd = tagStart + 1;
+        while (nameEnd < template.length && /[a-zA-Z0-9_-]/.test(template[nameEnd])) {
+            nameEnd++;
+        }
+        const tagName = template.slice(tagStart + 1, nameEnd);
+
+        // Find closing >
+        let tagEnd = attributePosition;
+        let inString = false;
+        let stringChar = '';
+        while (tagEnd < template.length) {
+            const ch = template[tagEnd];
+            if (!inString && (ch === '"' || ch === "'")) {
+                inString = true;
+                stringChar = ch;
+            } else if (inString && ch === stringChar) {
+                inString = false;
+            } else if (!inString && ch === '>') {
+                break;
+            }
+            tagEnd++;
+        }
+
+        return { tagName, tagStart, tagEnd: tagEnd + 1 };
+    }
+}

package/src/foundation/engine/Scope.ts

@@ -0,0 +1,176 @@
+/**
+ * Scope - класс для работы с контекстом переменных и функций.
+ * Поддерживает объединение нескольких Scope, извлечение полей из объектов и классов.
+ */
+export default class Scope {
+    private variables: Record<string, any> = {};
+    private readonly debugWarnings: boolean;
+    /** Оригинальный объект для синхронизации refs */
+    private originalSource: object | null = null;
+
+    constructor(options?: { debugWarnings?: boolean }) {
+        this.debugWarnings = options?.debugWarnings ?? true;
+    }
+
+    /**
+     * Получить все переменные Scope как Record
+     */
+    public getVariables(): Record<string, any> {
+        return { ...this.variables };
+    }
+
+    /**
+     * Установить переменную в Scope
+     * @param syncToOriginal - синхронизировать с оригинальным объектом (по умолчанию true)
+     */
+    public set(key: string, value: any, syncToOriginal: boolean = true): void {
+        if (this.debugWarnings && key in this.variables && this.variables[key] !== undefined) {
+            // Не предупреждаем при установке ref (значение было undefined)
+        }
+        this.variables[key] = value;
+        
+        // Синхронизируем с оригинальным объектом если он есть
+        if (syncToOriginal && this.originalSource) {
+            (this.originalSource as any)[key] = value;
+        }
+    }
+
+    /**
+     * Получить переменную из Scope
+     */
+    public get(key: string): any {
+        return this.variables[key];
+    }
+
+    /**
+     * Проверить наличие переменной
+     */
+    public has(key: string): boolean {
+        return key in this.variables;
+    }
+
+    /**
+     * Удалить переменную из Scope
+     */
+    public delete(key: string): boolean {
+        if (key in this.variables) {
+            delete this.variables[key];
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Объединить другой Scope или объект в текущий Scope.
+     * При конфликте имён выводится предупреждение, последнее значение имеет приоритет.
+     */
+    public merge(source: Scope | Record<string, any> | object): Scope {
+        const sourceVars = source instanceof Scope 
+            ? source.getVariables() 
+            : this.extractFromObject(source);
+
+        for (const [key, value] of Object.entries(sourceVars)) {
+            if (this.debugWarnings && key in this.variables) {
+                console.warn(`[Scope] Warning: Variable "${key}" conflict during merge, using new value`);
+            }
+            this.variables[key] = value;
+        }
+
+        return this;
+    }
+
+    /**
+     * Создать дочерний (локальный) Scope на основе текущего.
+     * Изменения в дочернем Scope не влияют на родительский.
+     */
+    public createChild(localVariables?: Record<string, any>): Scope {
+        const child = new Scope({ debugWarnings: this.debugWarnings });
+        child.variables = { ...this.variables };
+        
+        if (localVariables) {
+            for (const [key, value] of Object.entries(localVariables)) {
+                child.variables[key] = value;
+            }
+        }
+
+        return child;
+    }
+
+    /**
+     * Извлечь поля и методы из объекта или экземпляра класса.
+     * Пропускает нативные DOM/браузерные прототипы.
+     */
+    public extractFromObject(obj: object): Record<string, any> {
+        const ctx: Record<string, any> = {};
+
+        if (!obj || typeof obj !== 'object') {
+            return ctx;
+        }
+
+        // Copy own properties
+        for (const key of Object.keys(obj)) {
+            ctx[key] = (obj as any)[key];
+        }
+
+        // Copy prototype methods (for class instances)
+        let proto = Object.getPrototypeOf(obj);
+        while (proto && proto !== Object.prototype) {
+            // Avoid copying host (DOM/native) prototype methods which may throw
+            const ctorName = proto?.constructor 
+                ? String(proto.constructor.name ?? '') 
+                : '';
+            
+            if (/HTMLElement|Element|Node|EventTarget|Window|GlobalThis/i.test(ctorName)) {
+                proto = Object.getPrototypeOf(proto);
+                continue;
+            }
+
+            for (const key of Object.getOwnPropertyNames(proto)) {
+                if (key === 'constructor' || key in ctx) continue;
+
+                let desc: PropertyDescriptor | undefined;
+                try {
+                    desc = Object.getOwnPropertyDescriptor(proto, key);
+                } catch {
+                    continue;
+                }
+                if (!desc) continue;
+
+                // Only bind plain function values — don't copy getters/setters
+                if (typeof desc.value === 'function') {
+                    try {
+                        ctx[key] = (desc.value as Function).bind(obj);
+                    } catch {
+                        continue;
+                    }
+                }
+            }
+
+            proto = Object.getPrototypeOf(proto);
+        }
+
+        return ctx;
+    }
+
+    /**
+     * Статический метод для создания Scope из объекта
+     * Сохраняет ссылку на оригинальный объект для синхронизации refs
+     */
+    public static from(source: object | Record<string, any>, options?: { debugWarnings?: boolean }): Scope {
+        const scope = new Scope(options);
+        scope.originalSource = source;
+        scope.merge(source);
+        return scope;
+    }
+
+    /**
+     * Статический метод для объединения нескольких Scope/объектов
+     */
+    public static combine(...sources: (Scope | Record<string, any> | object)[]): Scope {
+        const scope = new Scope();
+        for (const source of sources) {
+            scope.merge(source);
+        }
+        return scope;
+    }
+}