@reidelsaltres/pureper 0.1.164 → 0.1.169

package/src/foundation/engine/TemplateEngine.ts

@@ -1,318 +1,68 @@
-import Scope from './Scope.js';
-import Expression from './Expression.js';
-import EscapeHandler from './EscapeHandler.js';
-import TemplateInstance, { TemplateSection, FragmentBinding } from './TemplateInstance.js';
-import Rule, { RuleMatch, RuleResult, SyntaxRule, AttributeRule } from './Rule.js';
-import Observable from '../api/Observer.js';
+import Expression from "./Expression.js";
+import Scope from "./Scope.js";
 
-// Import rules
-import ExpressionRule from './rules/syntax/ExpressionRule.js';
-import IfRule from './rules/syntax/IfRule.js';
-import ForRule from './rules/syntax/ForRule.js';
-import RefRule from './rules/attribute/RefRule.js';
-import EventRule from './rules/attribute/EventRule.js';
-import InjectionRule from './rules/attribute/InjectionRule.js';
-
-/**
- * TemplateEngineOptions - настройки TemplateEngine
- */
-export interface TemplateEngineOptions {
-    /** Оставлять синтаксис атрибутивных Rule в финальном HTML */
-    showAttributeRule?: boolean;
-    /** Включить предупреждения отладки */
-    debugWarnings?: boolean;
-}
-
-/**
- * ProcessResult - результат обработки шаблона
- */
-export interface ProcessResult {
-    output: string;
-    observables: Observable<any>[];
-    sections: TemplateSection[];
-    /** ID созданного фрагмента (если был создан) */
-    fragmentId?: string;
-}
-
-/**
- * TemplateEngine - главный класс шаблонизатора.
- * Обрабатывает HTML-шаблон с Rule и создаёт TemplateInstance.
- */
 export default class TemplateEngine {
-    private readonly scope: Scope;
-    private readonly options: TemplateEngineOptions;
-    private readonly syntaxRules: SyntaxRule[] = [];
-    private readonly attributeRules: AttributeRule[] = [];
-
-    constructor(scope: Scope | object, options?: TemplateEngineOptions) {
-        this.scope = scope instanceof Scope ? scope : Scope.from(scope);
-        this.options = {
-            showAttributeRule: false,
-            debugWarnings: true,
-            ...options
-        };
-
-        // Register default rules (sorted by priority)
-        this.registerDefaultRules();
-    }
-
-    /**
-     * Зарегистрировать стандартные правила
-     */
-    private registerDefaultRules(): void {
-        // Syntax rules
-        this.syntaxRules.push(new ForRule());
-        this.syntaxRules.push(new IfRule());
-        this.syntaxRules.push(new ExpressionRule());
-
-        // Attribute rules
-        this.attributeRules.push(new RefRule());
-        this.attributeRules.push(new EventRule());
-        this.attributeRules.push(new InjectionRule());
-
-        // Sort by priority
-        this.syntaxRules.sort((a, b) => a.priority - b.priority);
-        this.attributeRules.sort((a, b) => a.priority - b.priority);
-    }
-
-    /**
-     * Добавить пользовательское правило
-     */
-    public addRule(rule: Rule): void {
-        if (rule.type === 'syntax') {
-            this.syntaxRules.push(rule as SyntaxRule);
-            this.syntaxRules.sort((a, b) => a.priority - b.priority);
+    public static process(root: Node, onlyRoot: boolean = false): Node[] {
+        let elements: Node[] = [];
+        const walker = document.createTreeWalker(
+            root,
+            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+        );
+        if (onlyRoot) {
+            walker.nextNode();
+            while (walker.nextSibling()) {
+                const node = walker.currentNode;
+                elements.push(node);
+            }
         } else {
-            this.attributeRules.push(rule as AttributeRule);
-            this.attributeRules.sort((a, b) => a.priority - b.priority);
-        }
-    }
-
-    /**
-     * Получить Scope
-     */
-    public getScope(): Scope {
-        return this.scope;
-    }
-
-    /**
-     * Обработать шаблон и вернуть TemplateInstance
-     */
-    public parse(template: string): TemplateInstance {
-        const templateInstance = new TemplateInstance(this.scope);
-        const result = this.processTemplateWithFragments(template, this.scope, templateInstance, null);
-
-        // Устанавливаем корневой фрагмент
-        if (result.fragmentId) {
-            templateInstance.setRootFragment(result.fragmentId);
-        }
-
-        // Add sections and track observables
-        for (const section of result.sections) {
-            templateInstance.addSection(section);
-
-            // Track observables
-            for (const observable of section.result.observables || []) {
-                templateInstance.trackObservable(observable, section, (s) => {
-                    return this.processTemplate(s.sourceTemplate, this.scope);
-                });
+            while (walker.nextNode()) {
+                const node = walker.currentNode;
+                elements.push(node);
             }
         }
-
-        return templateInstance;
+        return elements;
     }
-
-    /**
-     * Обработать шаблон с созданием фрагментов
-     */
-    private processTemplateWithFragments(
-        template: string,
-        scope: Scope,
-        instance: TemplateInstance,
-        parentFragmentId: string | null
-    ): ProcessResult {
-        const result = this.processTemplate(template, scope);
-        
-        // Создаём фрагмент для этого результата
-        const fragmentId = instance.createFragment(
-            result.output,
-            template,
-            result.sections,
-            parentFragmentId
+    public static processFors(root: Node, scope: Scope): Scope {
+        const walker = document.createTreeWalker(
+            root,
+            NodeFilter.SHOW_TEXT,
         );
-        
-        return {
-            ...result,
-            fragmentId
-        };
-    }
-
-    /**
-     * Обработать шаблон (внутренний метод, используется Rule для рекурсии)
-     */
-    public processTemplate(template: string, scope: Scope): ProcessResult {
-        const allObservables: Observable<any>[] = [];
-        const allSections: TemplateSection[] = [];
 
-        // Step 1: Handle @@ escape sequences
-        let processed = EscapeHandler.process(template, (escaped) => {
-            let result = escaped;
 
-            // Step 2: Process syntax rules (in priority order)
-            for (const rule of this.syntaxRules) {
-                result = this.processRule(rule, result, scope, allObservables, allSections);
+        let leftCircleBracketCount = 0;
+        let rightCircleBracketCount = 0;
+        while (walker.nextNode()) {
+            const node = walker.currentNode;
+            if (node.textContent?.includes("@for(")) {
+                leftCircleBracketCount = 1;
+                rightCircleBracketCount = 0;
             }
+            if (node.textContent?.includes("(")) leftCircleBracketCount++;
+            if (node.textContent?.includes(")")) rightCircleBracketCount++;
+            if (leftCircleBracketCount > 0 && leftCircleBracketCount === rightCircleBracketCount) {
 
-            // Step 3: Process attribute rules
-            for (const rule of this.attributeRules) {
-                // Skip injection - processed last
-                if (rule.name === 'injection') continue;
-                result = this.processRule(rule, result, scope, allObservables, allSections);
             }
-
-            return result;
-        });
-
-        // Step 4: Process injection rules last
-        const injectionRule = this.attributeRules.find(r => r.name === 'injection');
-        if (injectionRule) {
-            processed = this.processRule(injectionRule, processed, scope, allObservables, allSections);
-        }
-
-        // Step 5: Handle showAttributeRule option
-        if (!this.options.showAttributeRule) {
-            processed = this.removeAttributeSyntax(processed);
         }
-
-        return {
-            output: processed,
-            observables: allObservables,
-            sections: allSections
-        };
+        return scope;
     }
-
-    /**
-     * Обработать одно правило
-     */
-    private processRule(
-        rule: Rule,
-        template: string,
-        scope: Scope,
-        observables: Observable<any>[],
-        sections: TemplateSection[]
-    ): string {
-        const matches = rule.find(template);
-        
-        // Sort matches by position (reverse to process from end)
-        matches.sort((a, b) => b.start - a.start);
-
-        let result = template;
-
-        for (const match of matches) {
-            try {
-                const ruleResult = rule.execute(match, scope, this) as RuleResult;
-
-                // Track observables
-                if (ruleResult.observables) {
-                    observables.push(...ruleResult.observables);
-                }
-
-                // Create section
-                const section: TemplateSection = {
-                    rule,
-                    match,
-                    result: ruleResult,
-                    sourceTemplate: match.fullMatch,
-                    children: [],
-                    subscriptions: []
-                };
-                sections.push(section);
-
-                // Replace in template
-                result = result.slice(0, match.start) + ruleResult.output + result.slice(match.end);
-
-            } catch (error) {
-                console.error(`[TemplateEngine] Error processing rule "${rule.name}":`, error);
-                // Continue processing other rules
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Удалить синтаксис атрибутивных Rule из финального HTML
-     */
-    private removeAttributeSyntax(template: string): string {
-        // Remove @[ref], @on[...], @injection[...] patterns that weren't processed
-        return template
-            .replace(/@\[ref\]\s*=\s*["'][^"']*["']/gi, '')
-            .replace(/@on\[[a-zA-Z]+\]\s*=\s*["'][^"']*["']/gi, '')
-            .replace(/@injection\[(head|tail)\]\s*=\s*["'][^"']*["']/gi, '');
-    }
-
-    /**
-     * Добавить новый шаблон в существующий TemplateInstance.
-     * Обрабатывает шаблон и добавляет результат как новый фрагмент.
-     * Если instance привязан к контейнерам, DOM обновится автоматически.
-     * 
-     * @param instance - существующий TemplateInstance
-     * @param template - новый шаблон для добавления
-     * @param customScope - опциональный scope для нового шаблона
-     * @returns ID созданного фрагмента
-     */
-    public appendTemplate(instance: TemplateInstance, template: string, customScope?: Scope | object): string {
-        const scope = customScope 
-            ? (customScope instanceof Scope ? customScope : Scope.from(customScope))
-            : instance.getScope();
-        
-        // Обрабатываем шаблон
-        const result = this.processTemplate(template, scope);
-        
-        // Создаём фрагмент
-        const fragmentId = instance.createFragment(
-            result.output,
-            template,
-            result.sections,
-            null // без родителя - это отдельный фрагмент
+    public static processAttributes(root: Node, scope: Scope): Scope {
+        const walker = document.createTreeWalker(
+            root,
+            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
         );
-        
-        // Добавляем секции и отслеживаем Observable
-        for (const section of result.sections) {
-            instance.addSection(section);
-            
-            for (const observable of section.result.observables || []) {
-                instance.trackObservable(observable, section, (s) => {
-                    return this.processTemplate(s.sourceTemplate, scope);
-                });
+
+        while (walker.nextNode()) {
+            const node = walker.currentNode;
+            if (node.nodeType === Node.ELEMENT_NODE) {
+                const element = node as Element;
+                if (element.hasAttribute("ref")) scope.set(element.getAttribute("ref")!, element);
+                [...element.attributes].filter(a => /^on/.test(a.name)).forEach(attr => {
+                    const eventName = attr.name.substring(2);
+                    const expr = new Expression(attr.value);
+                    element.addEventListener(eventName, (e) => {});
+                });5
             }
         }
-        
-        // Вставляем в привязанные контейнеры
-        instance.insertAppendedFragment(fragmentId);
-        
-        return fragmentId;
-    }
-
-    /**
-     * Статический метод для быстрой обработки
-     */
-    public static process(template: string, scope: object, options?: TemplateEngineOptions): string {
-        const engine = new TemplateEngine(scope, options);
-        const TemplateInstance = engine.parse(template);
-        return TemplateInstance.getTemplate();
+        return scope;
     }
-
-    /**
-     * Создать TemplateInstance из шаблона
-     */
-    public static create(template: string, scope: object, options?: TemplateEngineOptions): TemplateInstance {
-        const engine = new TemplateEngine(scope, options);
-        return engine.parse(template);
-    }
-}
-
-// Re-export useful types
-export { Scope, Expression, TemplateInstance, Rule, SyntaxRule, AttributeRule };
-export { ExpressionRule, IfRule, ForRule, RefRule, EventRule, InjectionRule };
-export * from './exceptions/TemplateExceptions.js';
+}

package/src/foundation/engine/TemplateInstance.ts

@@ -335,7 +335,7 @@ export default class TemplateInstance {
      * Привязать к контейнеру.
      * Вставляет DOM, вызывает bindRefs, processInjections и bindEvents.
      */
-    public bind(container: Element, flag: boolean = true): void {
+    public bind(container: Element): void {
         if (this.containerBindings.has(container)) {
             console.warn('[TemplateInstance] Container already bound');
             return;
@@ -353,9 +353,9 @@ export default class TemplateInstance {
         this.insertFragmentsIntoContainer(container, binding);
         
         // Привязываем refs, обрабатываем injections, привязываем events
-        if (flag) this.bindRefsForContainer(container);
+        this.bindRefsForContainer(container);
         this.processInjectionsForContainer(container);
-        if (flag) this.bindEventsForContainer(container, binding);
+        this.bindEventsForContainer(container, binding);
     }
 
     /**

package/src/foundation/worker/Router.ts

@@ -57,7 +57,7 @@ export abstract class Router {
 
       page.load(document.getElementById('page')!);
       if (pushState && typeof window !== "undefined" && window.location) {
-        window.history.pushState(page, '', urlH.href);
+        window.history.pushState({}, '', urlH.href);
       }
     } catch (error) {
       console.error("[Router]: Unable to route to ", urlH.href, error);