smart-lifecycle 0.1.1

package/dist/rendering/expression-parser/expression-cache.d.ts

@@ -0,0 +1,65 @@
+import type { IExpressionCache } from './interfaces.js';
+import type { ParsedExpression } from './types.js';
+/**
+ * Implements the responsibility of caching parsed expressions for performance optimization.
+ * Uses an in-memory Map to store parsed expressions, following ISP by focusing solely
+ * on caching operations without mixing with parsing logic.
+ */
+export declare class ExpressionCache implements IExpressionCache {
+    private readonly cache;
+    /**
+     * Retrieves a cached parsed expression by its string representation.
+     *
+     * @param expression - The expression string to look up in the cache
+     * @returns The cached parsed expression or undefined if not found
+     * @throws Error if expression is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const parsed = cache.get('x + 1');
+     * ```
+     */
+    get(expression: string): ParsedExpression | undefined;
+    /**
+     * Stores a parsed expression in the cache.
+     *
+     * @param expression - The expression string to use as the cache key
+     * @param parsed - The parsed expression to store in the cache
+     * @throws Error if expression or parsed is null/undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const parsed = { ast: astNode, dependencies: ['x'], originalExpression: 'x + 1' };
+     * cache.set('x + 1', parsed);
+     * ```
+     */
+    set(expression: string, parsed: ParsedExpression): void;
+    /**
+     * Checks whether a parsed expression exists in the cache.
+     *
+     * @param expression - The expression string to check for in the cache
+     * @returns true if the expression is cached, false otherwise
+     * @throws Error if expression is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const exists = cache.has('x + 1');
+     * ```
+     */
+    has(expression: string): boolean;
+    /**
+     * Clears all cached expressions from memory.
+     * This method completely empties the cache, removing all stored entries.
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * cache.clear();
+     * ```
+     */
+    clear(): void;
+}
+//# sourceMappingURL=expression-cache.d.ts.map

package/dist/rendering/expression-parser/expression-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-cache.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAKrD;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAOvD;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAKhC;;;;;;;;;OASG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/rendering/expression-parser/expression-cache.js

@@ -0,0 +1,79 @@
+/**
+ * Implements the responsibility of caching parsed expressions for performance optimization.
+ * Uses an in-memory Map to store parsed expressions, following ISP by focusing solely
+ * on caching operations without mixing with parsing logic.
+ */
+export class ExpressionCache {
+    cache = new Map();
+    /**
+     * Retrieves a cached parsed expression by its string representation.
+     *
+     * @param expression - The expression string to look up in the cache
+     * @returns The cached parsed expression or undefined if not found
+     * @throws Error if expression is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const parsed = cache.get('x + 1');
+     * ```
+     */
+    get(expression) {
+        if (!expression)
+            throw new Error('Expression key is required');
+        return this.cache.get(expression);
+    }
+    /**
+     * Stores a parsed expression in the cache.
+     *
+     * @param expression - The expression string to use as the cache key
+     * @param parsed - The parsed expression to store in the cache
+     * @throws Error if expression or parsed is null/undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const parsed = { ast: astNode, dependencies: ['x'], originalExpression: 'x + 1' };
+     * cache.set('x + 1', parsed);
+     * ```
+     */
+    set(expression, parsed) {
+        if (!expression)
+            throw new Error('Expression key is required');
+        if (!parsed)
+            throw new Error('Parsed expression is required');
+        this.cache.set(expression, parsed);
+    }
+    /**
+     * Checks whether a parsed expression exists in the cache.
+     *
+     * @param expression - The expression string to check for in the cache
+     * @returns true if the expression is cached, false otherwise
+     * @throws Error if expression is null or undefined
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * const exists = cache.has('x + 1');
+     * ```
+     */
+    has(expression) {
+        if (!expression)
+            throw new Error('Expression key is required');
+        return this.cache.has(expression);
+    }
+    /**
+     * Clears all cached expressions from memory.
+     * This method completely empties the cache, removing all stored entries.
+     *
+     * @example
+     * ```typescript
+     * const cache = new ExpressionCache();
+     * cache.clear();
+     * ```
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+//# sourceMappingURL=expression-cache.js.map

package/dist/rendering/expression-parser/expression-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-cache.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-cache.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,OAAO,eAAe;IACT,KAAK,GAAG,IAAI,GAAG,EAA4B,CAAC;IAE7D;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,UAAkB;QACpB,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,UAAkB,EAAE,MAAwB;QAC9C,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC/D,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QAE9D,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,UAAkB;QACpB,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;CACF"}

package/dist/rendering/expression-parser/expression-parser.factory.d.ts

@@ -0,0 +1,105 @@
+import type { IExpressionCache, IDependencyExtractor, IEvaluator } from './interfaces.js';
+import { ExpressionParserService } from './expression-parser.service.js';
+/**
+ * Defines the configuration options for the ExpressionParserFactory.
+ * Allows customization of the factory's component implementations.
+ */
+export interface ExpressionParserFactoryOptions {
+    /** Custom cache implementation to override the default */
+    cache?: IExpressionCache;
+    /** Custom dependency extractor implementation to override the default */
+    dependencyExtractor?: IDependencyExtractor;
+    /** Custom evaluator implementation to override the default */
+    evaluator?: IEvaluator;
+}
+/**
+ * Implements the responsibility of creating configured expression parser instances.
+ * Follows the Factory Pattern to encapsulate object creation logic and enable
+ * dependency injection. Provides centralized configuration and instantiation
+ * of all expression parsing components.
+ */
+export declare class ExpressionParserFactory {
+    private readonly options;
+    /**
+     * Initializes a new instance of ExpressionParserFactory.
+     *
+     * @param options - Configuration options for customizing component implementations
+     */
+    constructor(options?: ExpressionParserFactoryOptions);
+    /**
+     * Creates a new expression cache instance.
+     * Returns the configured cache implementation or a default ExpressionCache.
+     *
+     * @returns An expression cache implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const cache = factory.createCache();
+     * ```
+     */
+    createCache(): IExpressionCache;
+    /**
+     * Creates a new dependency extractor instance.
+     * Returns the configured dependency extractor or a default DependencyExtractor.
+     *
+     * @returns A dependency extractor implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const extractor = factory.createDependencyExtractor();
+     * ```
+     */
+    createDependencyExtractor(): IDependencyExtractor;
+    /**
+     * Creates a new evaluator instance.
+     * Returns the configured evaluator or a default ASTEvaluator.
+     *
+     * @returns An evaluator implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const evaluator = factory.createEvaluator();
+     * ```
+     */
+    createEvaluator(): IEvaluator;
+    /**
+     * Creates a new parser service with configured dependencies.
+     * Assembles cache and dependency extractor into a complete parser service.
+     *
+     * @returns A fully configured expression parser service
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const service = factory.createParserService();
+     * ```
+     */
+    createParserService(): ExpressionParserService;
+    /**
+     * Creates a complete parser instance with all necessary components.
+     * Convenience method that returns all components needed for expression parsing.
+     *
+     * @returns Object containing all configured parser components
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const { service, evaluator, cache, dependencyExtractor } = factory.createParser();
+     * ```
+     */
+    createParser(): {
+        service: ExpressionParserService;
+        evaluator: IEvaluator;
+        cache: IExpressionCache;
+        dependencyExtractor: IDependencyExtractor;
+    };
+}
+/**
+ * Default factory instance for convenience.
+ * Can be replaced or configured as needed for different use cases.
+ */
+export declare const defaultParserFactory: ExpressionParserFactory;
+//# sourceMappingURL=expression-parser.factory.d.ts.map

package/dist/rendering/expression-parser/expression-parser.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.factory.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-parser.factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI1F,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,8BAA8B;IAC7C,0DAA0D;IAC1D,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,8DAA8D;IAC9D,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IAEzD;;;;OAIG;gBACS,OAAO,GAAE,8BAAmC;IAIxD;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,gBAAgB;IAI/B;;;;;;;;;;;OAWG;IACH,yBAAyB,IAAI,oBAAoB;IAIjD;;;;;;;;;;;OAWG;IACH,eAAe,IAAI,UAAU;IAI7B;;;;;;;;;;;OAWG;IACH,mBAAmB,IAAI,uBAAuB;IAM9C;;;;;;;;;;;OAWG;IACH,YAAY,IAAI;QACd,OAAO,EAAE,uBAAuB,CAAC;QACjC,SAAS,EAAE,UAAU,CAAC;QACtB,KAAK,EAAE,gBAAgB,CAAC;QACxB,mBAAmB,EAAE,oBAAoB,CAAC;KAC3C;CAaF;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,yBAAgC,CAAC"}

package/dist/rendering/expression-parser/expression-parser.factory.js

@@ -0,0 +1,113 @@
+import { ExpressionCache } from './expression-cache.js';
+import { DependencyExtractor } from './dependency-extractor.js';
+import { ASTEvaluator } from './evaluators/ast.evaluator.js';
+import { ExpressionParserService } from './expression-parser.service.js';
+/**
+ * Implements the responsibility of creating configured expression parser instances.
+ * Follows the Factory Pattern to encapsulate object creation logic and enable
+ * dependency injection. Provides centralized configuration and instantiation
+ * of all expression parsing components.
+ */
+export class ExpressionParserFactory {
+    options;
+    /**
+     * Initializes a new instance of ExpressionParserFactory.
+     *
+     * @param options - Configuration options for customizing component implementations
+     */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Creates a new expression cache instance.
+     * Returns the configured cache implementation or a default ExpressionCache.
+     *
+     * @returns An expression cache implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const cache = factory.createCache();
+     * ```
+     */
+    createCache() {
+        return this.options.cache || new ExpressionCache();
+    }
+    /**
+     * Creates a new dependency extractor instance.
+     * Returns the configured dependency extractor or a default DependencyExtractor.
+     *
+     * @returns A dependency extractor implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const extractor = factory.createDependencyExtractor();
+     * ```
+     */
+    createDependencyExtractor() {
+        return this.options.dependencyExtractor || new DependencyExtractor();
+    }
+    /**
+     * Creates a new evaluator instance.
+     * Returns the configured evaluator or a default ASTEvaluator.
+     *
+     * @returns An evaluator implementation
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const evaluator = factory.createEvaluator();
+     * ```
+     */
+    createEvaluator() {
+        return this.options.evaluator || new ASTEvaluator();
+    }
+    /**
+     * Creates a new parser service with configured dependencies.
+     * Assembles cache and dependency extractor into a complete parser service.
+     *
+     * @returns A fully configured expression parser service
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const service = factory.createParserService();
+     * ```
+     */
+    createParserService() {
+        const cache = this.createCache();
+        const dependencyExtractor = this.createDependencyExtractor();
+        return new ExpressionParserService(cache, dependencyExtractor);
+    }
+    /**
+     * Creates a complete parser instance with all necessary components.
+     * Convenience method that returns all components needed for expression parsing.
+     *
+     * @returns Object containing all configured parser components
+     *
+     * @example
+     * ```typescript
+     * const factory = new ExpressionParserFactory();
+     * const { service, evaluator, cache, dependencyExtractor } = factory.createParser();
+     * ```
+     */
+    createParser() {
+        const cache = this.createCache();
+        const dependencyExtractor = this.createDependencyExtractor();
+        const service = new ExpressionParserService(cache, dependencyExtractor);
+        const evaluator = this.createEvaluator();
+        return {
+            service,
+            evaluator,
+            cache,
+            dependencyExtractor
+        };
+    }
+}
+/**
+ * Default factory instance for convenience.
+ * Can be replaced or configured as needed for different use cases.
+ */
+export const defaultParserFactory = new ExpressionParserFactory();
+//# sourceMappingURL=expression-parser.factory.js.map

package/dist/rendering/expression-parser/expression-parser.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.factory.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-parser.factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAezE;;;;;GAKG;AACH,MAAM,OAAO,uBAAuB;IACjB,OAAO,CAAiC;IAEzD;;;;OAIG;IACH,YAAY,UAA0C,EAAE;QACtD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,IAAI,eAAe,EAAE,CAAC;IACrD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,yBAAyB;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,mBAAmB,IAAI,IAAI,mBAAmB,EAAE,CAAC;IACvE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,IAAI,YAAY,EAAE,CAAC;IACtD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,mBAAmB;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,MAAM,mBAAmB,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAC7D,OAAO,IAAI,uBAAuB,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;IACjE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,YAAY;QAMV,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,MAAM,mBAAmB,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAC7D,MAAM,OAAO,GAAG,IAAI,uBAAuB,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;QACxE,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAEzC,OAAO;YACL,OAAO;YACP,SAAS;YACT,KAAK;YACL,mBAAmB;SACpB,CAAC;IACJ,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,uBAAuB,EAAE,CAAC"}

package/dist/rendering/expression-parser/expression-parser.service.d.ts

@@ -0,0 +1,30 @@
+import type { IExpressionParser } from "./interfaces.js";
+import type { ParsedExpression } from "./types.js";
+/**
+ * Implements the responsibility of parsing expression strings into structured representations.
+ * Coordinates tokenization, AST construction, dependency analysis, and result caching.
+ * Cache and dependency extraction are implementation details private to this class.
+ */
+export declare class ExpressionParserService implements IExpressionParser {
+    private readonly cache;
+    /**
+     * Parses an expression string, utilizing caching for performance.
+     * If the expression has been parsed before, returns the cached result.
+     * Otherwise, parses the expression and stores it in the cache.
+     *
+     * @param expression - The expression string to parse
+     * @returns The parsed expression containing AST, dependencies, and original expression
+     * @throws Error if expression is null/undefined or contains syntax errors
+     *
+     * @example
+     * ```typescript
+     * const service = new ExpressionParserService();
+     * const parsed = service.parse('x + y * 2');
+     * // Returns { ast: ASTNode, dependencies: ['x', 'y'], originalExpression: 'x + y * 2' }
+     * ```
+     */
+    parse(expression: string): ParsedExpression;
+    private extractDependencies;
+    private traverseForDependencies;
+}
+//# sourceMappingURL=expression-parser.service.d.ts.map

package/dist/rendering/expression-parser/expression-parser.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.service.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-parser.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAQV,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAIpB;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;IAC/D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAwB3C,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,uBAAuB;CAmDhC"}

package/dist/rendering/expression-parser/expression-parser.service.js

@@ -0,0 +1,96 @@
+import { Tokenizer } from "./tokenizer.js";
+import { Parser } from "./parser.js";
+/**
+ * Implements the responsibility of parsing expression strings into structured representations.
+ * Coordinates tokenization, AST construction, dependency analysis, and result caching.
+ * Cache and dependency extraction are implementation details private to this class.
+ */
+export class ExpressionParserService {
+    cache = new Map();
+    /**
+     * Parses an expression string, utilizing caching for performance.
+     * If the expression has been parsed before, returns the cached result.
+     * Otherwise, parses the expression and stores it in the cache.
+     *
+     * @param expression - The expression string to parse
+     * @returns The parsed expression containing AST, dependencies, and original expression
+     * @throws Error if expression is null/undefined or contains syntax errors
+     *
+     * @example
+     * ```typescript
+     * const service = new ExpressionParserService();
+     * const parsed = service.parse('x + y * 2');
+     * // Returns { ast: ASTNode, dependencies: ['x', 'y'], originalExpression: 'x + y * 2' }
+     * ```
+     */
+    parse(expression) {
+        if (!expression)
+            throw new Error("Expression string is required");
+        const cached = this.cache.get(expression);
+        if (cached) {
+            return cached;
+        }
+        const tokenizer = new Tokenizer(expression);
+        const tokens = tokenizer.tokenize();
+        const parser = new Parser(tokens);
+        const ast = parser.parse();
+        const dependencies = this.extractDependencies(ast);
+        const parsed = {
+            ast,
+            dependencies,
+            originalExpression: expression,
+        };
+        this.cache.set(expression, parsed);
+        return parsed;
+    }
+    extractDependencies(node) {
+        const deps = new Set();
+        this.traverseForDependencies(node, deps);
+        return Array.from(deps);
+    }
+    traverseForDependencies(node, deps) {
+        switch (node.type) {
+            case "Identifier":
+                deps.add(node.name);
+                break;
+            case "MemberExpression": {
+                const memberExpr = node;
+                if (memberExpr.object.type === "Identifier") {
+                    deps.add(memberExpr.object.name);
+                }
+                else {
+                    this.traverseForDependencies(memberExpr.object, deps);
+                }
+                break;
+            }
+            case "CallExpression": {
+                const callExpr = node;
+                this.traverseForDependencies(callExpr.callee, deps);
+                callExpr.arguments.forEach((arg) => this.traverseForDependencies(arg, deps));
+                break;
+            }
+            case "BinaryExpression": {
+                const binaryExpr = node;
+                this.traverseForDependencies(binaryExpr.left, deps);
+                this.traverseForDependencies(binaryExpr.right, deps);
+                break;
+            }
+            case "UnaryExpression": {
+                const unaryExpr = node;
+                this.traverseForDependencies(unaryExpr.argument, deps);
+                break;
+            }
+            case "ConditionalExpression": {
+                const conditionalExpr = node;
+                this.traverseForDependencies(conditionalExpr.test, deps);
+                this.traverseForDependencies(conditionalExpr.consequent, deps);
+                this.traverseForDependencies(conditionalExpr.alternate, deps);
+                break;
+            }
+            case "Literal":
+                // No dependencies for literal values
+                break;
+        }
+    }
+}
+//# sourceMappingURL=expression-parser.service.js.map

package/dist/rendering/expression-parser/expression-parser.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.service.js","sourceRoot":"","sources":["../../../src/rendering/expression-parser/expression-parser.service.ts"],"names":[],"mappings":"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"}

package/dist/rendering/expression-parser/host-projector.d.ts

@@ -0,0 +1,80 @@
+import { SmartComponent } from '../../core/smart-component.js';
+import { IDomAdapter } from '../dom/dom-adapter.interface.js';
+import type { IHostProjectionRegistry } from '../host-projection/host-projection-registry.interface.js';
+/**
+ * Implements the responsibility of handling host content projection.
+ *
+ * @description
+ * Implements host content projection mechanism, replacing <smart-host> elements
+ * with projected content from the component's Light DOM. Supports both named
+ * and default hosts with fallback content.
+ *
+ * @architecture
+ * Host Projection Rules:
+ * - **Default host**: <smart-host> receives all content without host attribute
+ * - **Named hosts**: <smart-host name="x"> receives content with host="x" attribute
+ * - **Fallback content**: Host innerHTML used if no matching content
+ */
+/**
+ * Defines the responsibility of projecting content into <smart-host> elements.
+ *
+ * @description
+ * Defines the contract for projecting content into <smart-host> elements,
+ * handling both named and default hosts according to SmartComponents standards.
+ */
+export interface IHostProjector {
+    /**
+     * Projects captured host content into template hosts.
+     *
+     * @param element - Template root element containing <smart-host> elements
+     * @param component - Component instance with captured host content
+     * @throws Error if element or component are null/undefined
+     */
+    project(element: HTMLElement, component: SmartComponent): void;
+}
+export declare class HostProjector implements IHostProjector {
+    private readonly domAdapter;
+    private readonly hostProjectionRegistry;
+    /**
+     * Initializes a new instance of HostProjector.
+     *
+     * @param domAdapter - Adapter for DOM element creation
+     * @param hostProjectionRegistry - Registry for host projection content
+     * @throws Error if domAdapter is null or undefined
+     * @throws Error if hostProjectionRegistry is null or undefined
+     */
+    constructor(domAdapter: IDomAdapter, hostProjectionRegistry: IHostProjectionRegistry);
+    /**
+     * Projects captured content into template hosts
+     *
+     * @description
+     * Processes all <smart-host> elements in the template, replacing them with
+     * appropriate projected content based on host names and fallback rules.
+     *
+     * @param element - Template root element containing <smart-host> elements
+     * @param component - Component instance with captured host content
+     *
+     * @example
+     * ```typescript
+     * // Template:
+     * `<div>
+     *   <header><smart-host name="header">Default Header</smart-host></header>
+     *   <main><smart-host>Default Content</smart-host></main>
+     * </div>`
+     *
+     * // Usage:
+     * `<my-component>
+     *   <h1 host="header">Custom Header</h1>
+     *   <p>Custom Content</p>
+     * </my-component>`
+     *
+     * // Result after projection:
+     * `<div>
+     *   <header><h1>Custom Header</h1></header>
+     *   <main><p>Custom Content</p></main>
+     * </div>`
+     * ```
+     */
+    project(element: HTMLElement, component: SmartComponent): void;
+}
+//# sourceMappingURL=host-projector.d.ts.map

package/dist/rendering/expression-parser/host-projector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-projector.d.ts","sourceRoot":"","sources":["../../../src/rendering/expression-parser/host-projector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0DAA0D,CAAC;AAGxG;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,GAAG,IAAI,CAAC;CAChE;AAED,qBAAa,aAAc,YAAW,cAAc;IAUhD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IAVzC;;;;;;;OAOG;gBAEgB,UAAU,EAAE,WAAW,EACvB,sBAAsB,EAAE,uBAAuB;IAUlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,GAAG,IAAI;CAqD/D"}