@reidelsaltres/pureper 0.1.175 → 0.1.176

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

@@ -1,267 +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 { 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 };
-    }
-}

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

@@ -1,261 +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 { InvalidTemplateEngineSyntaxException } from '../../exceptions/TemplateExceptions.js';
-import { isObservable } from '../../../api/Observer.js';
-
-interface IfChainMatch extends RuleMatch {
-    data: {
-        chain: Array<{
-            type: 'if' | 'elseif' | 'else';
-            condition?: string;
-            block: string;
-        }>;
-    };
-}
-
-/**
- * IfRule - обработка @if/@elseif/@else
- */
-export default class IfRule extends SyntaxRule {
-    public readonly name = 'if';
-    public readonly priority = 20; // Выполняется раньше @expression
-
-    public find(template: string): RuleMatch[] {
-        const results: RuleMatch[] = [];
-        const lowerTemplate = template.toLowerCase();
-        let i = 0;
-
-        while (i < template.length) {
-            const idx = lowerTemplate.indexOf('@if', i);
-            if (idx === -1) break;
-
-            // Check for @@ escape
-            if (idx > 0 && template[idx - 1] === '@') {
-                i = idx + 1;
-                continue;
-            }
-
-            // Parse the full if/elseif/else chain
-            const chain = this.parseIfChain(template, idx);
-            if (chain) {
-                results.push({
-                    fullMatch: template.slice(chain.start, chain.end),
-                    start: chain.start,
-                    end: chain.end,
-                    data: { chain: chain.items }
-                });
-                i = chain.end;
-            } else {
-                i = idx + 1;
-            }
-        }
-
-        return results;
-    }
-
-    private parseIfChain(template: string, startIdx: number): { 
-        start: number; 
-        end: number; 
-        items: Array<{ type: 'if' | 'elseif' | 'else'; condition?: string; block: string }> 
-    } | null {
-        const items: Array<{ type: 'if' | 'elseif' | 'else'; condition?: string; block: string }> = [];
-        let pos = startIdx;
-
-        // Parse @if
-        const ifParsed = this.parseConditionBlock(template, pos, '@if');
-        if (!ifParsed) return null;
-
-        items.push({ type: 'if', condition: ifParsed.condition, block: ifParsed.block });
-        pos = ifParsed.end;
-
-        // Parse @elseif/@else chain
-        while (pos < template.length) {
-            // Skip whitespace
-            while (pos < template.length && /\s/.test(template[pos])) {
-                pos++;
-            }
-
-            const remaining = template.slice(pos).toLowerCase();
-
-            if (remaining.startsWith('@elseif')) {
-                const elseifParsed = this.parseConditionBlock(template, pos, '@elseif');
-                if (!elseifParsed) break;
-                items.push({ type: 'elseif', condition: elseifParsed.condition, block: elseifParsed.block });
-                pos = elseifParsed.end;
-            } else if (remaining.startsWith('@else') && !remaining.startsWith('@elseif')) {
-                const elseParsed = this.parseElseBlock(template, pos);
-                if (!elseParsed) break;
-                items.push({ type: 'else', block: elseParsed.block });
-                pos = elseParsed.end;
-                break; // @else is always last
-            } else {
-                break;
-            }
-        }
-
-        return { start: startIdx, end: pos, items };
-    }
-
-    private parseConditionBlock(template: string, start: number, keyword: string): {
-        condition: string;
-        block: string;
-        end: number;
-    } | null {
-        let pos = start + keyword.length;
-
-        // Skip whitespace
-        while (pos < template.length && /\s/.test(template[pos])) {
-            pos++;
-        }
-
-        // Expect (
-        if (template[pos] !== '(') return null;
-
-        // Parse balanced condition
-        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 condition = template.slice(conditionStart, pos - 1);
-
-        // Skip whitespace
-        while (pos < template.length && /\s/.test(template[pos])) {
-            pos++;
-        }
-
-        // Expect {
-        if (template[pos] !== '{') return null;
-
-        // Parse balanced block
-        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 { condition, block, end: pos };
-    }
-
-    private parseElseBlock(template: string, start: number): { block: string; end: number } | null {
-        let pos = start + 5; // '@else'.length
-
-        // Skip whitespace
-        while (pos < template.length && /\s/.test(template[pos])) {
-            pos++;
-        }
-
-        // Expect {
-        if (template[pos] !== '{') return null;
-
-        // Parse balanced block
-        const blockStart = 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 block = template.slice(blockStart, pos - 1);
-
-        return { block, end: pos };
-    }
-
-    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 chain = (match as IfChainMatch).data.chain;
-        const observables: any[] = [];
-
-        for (const item of chain) {
-            if (item.type === 'else') {
-                // Process else block
-                if (engine) {
-                    const result = engine.processTemplate(item.block, scope);
-                    return { output: result.output, observables: [...observables, ...(result.observables || [])] };
-                }
-                return { output: item.block, observables };
-            }
-
-            // Evaluate condition
-            const expr = new Expression(item.condition!);
-            
-            // Находим Observable в условии
-            const conditionObservables = expr.findObservables(scope);
-            observables.push(...conditionObservables);
-            
-            const conditionResult = expr.execute(scope);
-
-            // Check if result is Observable
-            if (isObservable(conditionResult)) {
-                observables.push(conditionResult);
-                const value = conditionResult.getObject?.() ?? conditionResult;
-                if (value) {
-                    if (engine) {
-                        const result = engine.processTemplate(item.block, scope);
-                        return { output: result.output, observables: [...observables, ...(result.observables || [])] };
-                    }
-                    return { output: item.block, observables };
-                }
-            } else if (conditionResult) {
-                // Condition is truthy
-                if (engine) {
-                    const result = engine.processTemplate(item.block, scope);
-                    return { output: result.output, observables: [...observables, ...(result.observables || [])] };
-                }
-                return { output: item.block, observables };
-            }
-        }
-
-        // No condition matched and no else
-        return { output: '', observables };
-    }
-}

package/src/foundation/hmle/Context.ts

@@ -1,90 +0,0 @@
-/**
- * Context — utility for building a safe evaluation context used by parsers
- *
- * Features:
- * - Merges parser variables and local scope objects
- * - Safely copies instance prototype functions bound to the instance
- * - Supports merging multiple contexts or objects
- *
- * This class is intended to replace ad-hoc `buildContext` implementations in
- * parsers such as HMLEParser/HMLEParserReborn and PHTMLParser.
- */
-export default class Context {
-    private values: Record<string, any>;
-
-    constructor(initial?: Record<string, any>) {
-        this.values = Object.assign({}, initial || {});
-    }
-
-    /** Create a Context and merge given scope into it */
-    public static from(scopeVars?: Record<string, any>, scope?: Record<string, any>): Context {
-        const ctx = new Context(scopeVars);
-        if (scope) ctx.merge(scope);
-        return ctx;
-    }
-
-    /** Merge plain object or another Context into this one */
-    public merge(other?: Record<string, any> | Context): this {
-        if (!other) return this;
-        if (other instanceof Context) Object.assign(this.values, other.values);
-        else Object.assign(this.values, other);
-        return this;
-    }
-
-    /**
-     * Copy prototype methods from an instance into the context
-     * Methods are bound to the given instance to preserve `this` semantics.
-     */
-    public bindPrototypeMethods(instance?: Record<string, any>): this {
-        if (!instance) return this;
-
-        const bindTarget: any = (instance as any).__hmle_this ?? instance;
-
-        let proto: any = Object.getPrototypeOf(bindTarget);
-        while (proto && proto !== Object.prototype) {
-            // avoid copying host DOM/window prototype methods
-            const ctorName = proto && proto.constructor ? String((proto as any).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') continue;
-                if (key in this.values) continue; // do not override existing keys
-
-                let desc: PropertyDescriptor | undefined;
-                try {
-                    desc = Object.getOwnPropertyDescriptor(proto, key) as PropertyDescriptor | undefined;
-                } catch (e) {
-                    // Some host objects may throw when attempting to read descriptors — skip
-                    continue;
-                }
-                if (!desc) continue;
-                if (typeof desc.value === 'function') {
-                    try {
-                        this.values[key] = (desc.value as Function).bind(bindTarget);
-                    } catch (_e) {
-                        // binding may fail for native host methods — skip
-                        continue;
-                    }
-                }
-            }
-
-            proto = Object.getPrototypeOf(proto);
-        }
-        return this;
-    }
-
-    /** Return a plain object suitable for `with(this)` evaluation contexts */
-    public toObject(): Record<string, any> {
-        return Object.assign({}, this.values);
-    }
-
-    /** Convenience static builder returning a plain object for use in parsers */
-    public static build(variables?: Record<string, any>, scope?: Record<string, any>): Record<string, any> {
-        const ctx = new Context(variables);
-        if (scope) ctx.merge(scope).bindPrototypeMethods(scope);
-        return ctx.toObject();
-    }
-}