@rs-x/expression-parser 0.4.10 → 0.4.12

package/dist/index.d.ts

@@ -1,6 +1,31 @@
-import { IDisposable, IDisposableOwner, AnyFunction, ConstructorType, IIndexValueAccessor, ISingletonFactory, SingletonFactory, IDeepCloneExcept, ContainerModule } from '@rs-x/core';
 import { Observable } from 'rxjs';
-import { MustProxify as MustProxify$1, IStateManager as IStateManager$1, IStateChange as IStateChange$1, IContextChanged as IContextChanged$1, IMustProxifyItemHandlerFactory, IObjectObserverProxyPairFactory, IObserverProxyPair, IObserver, IProxyTarget } from '@rs-x/state-manager';
+import { IStateManager, IIndexWatchRule as IIndexWatchRule$1, IStateChange, IObserver, IObjectObserverProxyPairFactory, IObserverProxyPair, IProxyTarget } from '@rs-x/state-manager';
+import { IIndexValueAccessor, IGuidFactory, IValueMetadata, IDisposableOwner, IDisposable, AnyFunction, ConstructorType, ISingletonFactory, SingletonFactory, IDeepCloneExcept, ContainerModule } from '@rs-x/core';
+import { IIndexWatchRule } from '@rs-x/state-manager/lib';
+
+interface IExpressionServices {
+    readonly transactionManager: IExpressionChangeTransactionManager;
+    readonly stateManager: IStateManager;
+    readonly indexValueAccessor: IIndexValueAccessor;
+    readonly guidFactory: IGuidFactory;
+    readonly valueMetadata: IValueMetadata;
+}
+
+interface IBindConfigurationBase {
+    readonly services: IExpressionServices;
+    readonly owner?: IDisposableOwner;
+    readonly leafIndexWatchRule?: IIndexWatchRule;
+}
+type IExpressionBindConfigurationExtra = {
+    readonly currentValue?: unknown;
+};
+type IExpressionBindConfiguration = (IBindConfigurationBase & IExpressionBindConfigurationExtra & {
+    rootContext: unknown;
+    context?: never;
+}) | (IBindConfigurationBase & IExpressionBindConfigurationExtra & {
+    rootContext?: never;
+    context: unknown;
+});
 
 interface IExpression<T = unknown, PT = unknown> extends IDisposable {
     readonly changed: Observable<IExpression>;
@@ -11,6 +36,8 @@ interface IExpression<T = unknown, PT = unknown> extends IDisposable {
     readonly value: T | undefined;
     readonly isRoot: boolean;
     toString(): string;
+    clone(): this;
+    bind(settings: IExpressionBindConfiguration): IExpression;
 }
 interface IPropertyPath {
     object: IPropertyPath;
@@ -74,19 +101,9 @@ declare enum ExpressionType {
     UnaryPlus = "unary plus"
 }
 interface IExpressionParser {
-    parse(context: object, expression: string, owner?: IDisposableOwner): AbstractExpression;
+    parse(expression: string): AbstractExpression;
 }
 
-interface IMustProxifyHandler {
-    createMustProxifyHandler: (() => MustProxify$1) | undefined;
-    releaseMustProxifyHandler: (() => void) | undefined;
-}
-interface IExpressionInitializeConfig {
-    context?: unknown;
-    mustProxifyHandler?: IMustProxifyHandler;
-    transactionManager?: IExpressionChangeTransactionManager;
-    owner?: IDisposableOwner;
-}
 declare abstract class AbstractExpression<T = unknown, PT = unknown> implements IExpression<T> {
     readonly type: ExpressionType;
     readonly expressionString: string;
@@ -98,8 +115,11 @@ declare abstract class AbstractExpression<T = unknown, PT = unknown> implements
     private _oldValue;
     private _commitedSubscription;
     private _owner;
+    private _services;
+    private _leafIndexWatchRule?;
     protected constructor(type: ExpressionType, expressionString: string, ...childExpressions: AbstractExpression[]);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    abstract clone(): this;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     get value(): T | undefined;
     get isRoot(): boolean;
     get changed(): Observable<IExpression>;
@@ -107,6 +127,13 @@ declare abstract class AbstractExpression<T = unknown, PT = unknown> implements
     get parent(): AbstractExpression<PT> | undefined;
     dispose(): void;
     toString(): string;
+    protected get services(): IExpressionServices;
+    protected get guidFactory(): IGuidFactory;
+    protected get leafIndexWatchRule(): IIndexWatchRule$1 | undefined;
+    protected get stateManager(): IStateManager;
+    protected get indexValueAccessor(): IIndexValueAccessor;
+    protected get transactionManager(): IExpressionChangeTransactionManager;
+    protected get valueMetadata(): IValueMetadata;
     protected get root(): AbstractExpression;
     protected static setValue(expression: AbstractExpression, evaluate: () => unknown): void;
     protected static setParent(expression: AbstractExpression, parent: AbstractExpression): void;
@@ -121,9 +148,21 @@ declare abstract class AbstractExpression<T = unknown, PT = unknown> implements
     private addChildExpressions;
 }
 
+interface IExpressionChangeCommitHandler {
+    owner: AbstractExpression;
+    commit: (root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>) => boolean;
+}
+interface IExpressionChangeTransactionManager extends IDisposable {
+    readonly commited: Observable<AbstractExpression>;
+    registerChange(rootExpression: AbstractExpression, commitHandler: IExpressionChangeCommitHandler): void;
+    suspend(): void;
+    continue(): void;
+    commit(): void;
+}
+
 declare abstract class ParameterizedExpression<T = unknown, PT = unknown> extends AbstractExpression<T, PT> {
     protected constructor(type: ExpressionType, expressionString: string, ...childExpressions: AbstractExpression[]);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     protected abstract evaluateExpression(...args: unknown[]): T;
     protected prepareReevaluation(): boolean;
     protected evaluate(): T;
@@ -131,6 +170,7 @@ declare abstract class ParameterizedExpression<T = unknown, PT = unknown> extend
 
 declare abstract class BinaryExpression<T = unknown, PT = unknown> extends ParameterizedExpression<T, PT> {
     protected constructor(expressionType: ExpressionType, expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    clone(): this;
 }
 
 declare class AdditionExpression extends BinaryExpression<number, number> {
@@ -144,6 +184,7 @@ declare abstract class CollectionExpression<T = unknown> extends ParameterizedEx
 
 declare class ArrayExpression extends CollectionExpression<unknown[]> {
     constructor(expressions: AbstractExpression[]);
+    clone(): this;
     protected evaluateExpression(...args: unknown[]): unknown[];
 }
 
@@ -159,6 +200,7 @@ declare class BitwiseLeftShiftExpression extends BinaryExpression<number, number
 
 declare class BitwiseNotExpression extends ParameterizedExpression<number, number> {
     constructor(expressionString: string, expression: AbstractExpression<number>);
+    clone(): this;
     protected evaluateExpression(a: number): number;
 }
 
@@ -184,45 +226,43 @@ declare class BitwiseXorExpression extends BinaryExpression<number, number> {
 
 declare class ConditionalExpression extends ParameterizedExpression {
     constructor(expressionString: string, condition: AbstractExpression, ifValueExpression: AbstractExpression, elseValueExpression: AbstractExpression);
+    clone(): this;
     protected evaluateExpression(condition: unknown, consequent: unknown, alternate: unknown): unknown;
 }
 
 declare class ConstantExpression<T> extends AbstractExpression<T> {
-    private readonly _expressionChangeTransactionManager;
     private readonly _commitHandler;
-    constructor(type: ExpressionType, expressionString: string, constValue: T, _expressionChangeTransactionManager: IExpressionChangeTransactionManager);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    constructor(type: ExpressionType, expressionString: string, constValue: T);
+    clone(): this;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     protected evaluate(): T | undefined;
     private commit;
 }
 
 declare class ConstantBigIntExpression extends ConstantExpression<bigint> {
-    constructor(value: bigint, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    constructor(value: bigint);
 }
 
 declare class ConstantBooleanExpression extends ConstantExpression<boolean> {
-    constructor(value: boolean, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    constructor(value: boolean);
 }
 
 declare class ConstantNullExpression extends ConstantExpression<null> {
-    constructor(expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    constructor();
+    clone(): this;
 }
 
 declare class ConstantNumberExpression extends ConstantExpression<number> {
-    constructor(value: number, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    constructor(value: number);
 }
 
 declare class ConstantRegExpExpression extends ConstantExpression<RegExp> {
-    constructor(expressionString: string, value: RegExp, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    constructor(expressionString: string, value: RegExp);
+    clone(): this;
 }
 
 declare class ConstantStringExpression extends ConstantExpression<string> {
-    constructor(value: string, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
-}
-
-declare class UnaryPlusExpression extends ParameterizedExpression<number> {
-    constructor(expressionString: string, expression: AbstractExpression);
-    protected evaluateExpression(a: string | number): number;
+    constructor(value: string);
 }
 
 declare class DivisionExpression extends BinaryExpression<number, number> {
@@ -240,47 +280,18 @@ declare class ExponentiationExpression extends BinaryExpression<number, number>
     protected evaluateExpression(base: number, exponent: number): number;
 }
 
-interface IGuidFactory {
-    create(): string;
-}
-
-type MustProxify = (index: unknown, target?: unknown) => boolean;
-
-interface IContextChanged {
-    oldContext: unknown;
-    context: unknown;
-    key: unknown;
-}
-interface IStateChange extends IContextChanged {
-    oldValue: unknown;
-    newValue?: unknown;
-    watched?: boolean;
-}
-interface IStateManager {
-    readonly changed: Observable<IStateChange>;
-    readonly contextChanged: Observable<IContextChanged>;
-    readonly startChangeCycle: Observable<void>;
-    readonly endChangeCycle: Observable<void>;
-    isWatched(context: unknown, index: unknown, mustProxify?: MustProxify): boolean;
-    watchState(context: unknown, index: unknown, mustProxify?: MustProxify): unknown;
-    releaseState(oontext: unknown, index: unknown, mustProxify?: MustProxify): void;
-    getState<T>(context: unknown, index: unknown): T;
-    setState<T>(context: unknown, index: unknown, value: T): void;
-    clear(): void;
-}
-
 declare class FunctionExpression extends AbstractExpression {
     readonly functionExpression: AbstractExpression<AnyFunction | string | number>;
     readonly objectExpression: AbstractExpression<object>;
     readonly argumentsExpression: ArrayExpression;
     readonly computed: boolean;
     readonly optional: boolean;
-    private readonly _stateManager;
     private _context;
     private _functionContext;
-    private readonly _functionId;
-    constructor(expressionString: string, functionExpression: AbstractExpression<AnyFunction | string | number>, objectExpression: AbstractExpression<object>, argumentsExpression: ArrayExpression, computed: boolean, optional: boolean, expressionChangeTransactionManager: IExpressionChangeTransactionManager, _stateManager: IStateManager, guidFactory: IGuidFactory);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    private _functionId;
+    constructor(expressionString: string, functionExpression: AbstractExpression<AnyFunction | string | number>, objectExpression: AbstractExpression<object>, argumentsExpression: ArrayExpression, computed: boolean, optional: boolean);
+    clone(): this;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     protected internalDispose(): void;
     protected prepareReevaluation(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
     protected evaluate(): unknown;
@@ -301,42 +312,43 @@ declare class GreaterThanOrEqualExpression extends BinaryExpression {
 
 declare class IndexValueObserver {
     private _context;
-    private readonly _key;
-    private readonly _mustProxify;
+    private readonly _index;
+    private readonly _indexWatchRule;
     private readonly _stateManager;
+    private readonly setContext;
     private readonly _changeSubscription;
     private readonly _contextChangeSubscription;
     private readonly _changed;
-    private readonly _contextChanged;
     private _isDisposed;
-    constructor(_context: unknown, _key: unknown, _mustProxify: MustProxify$1 | undefined, _stateManager: IStateManager$1);
-    get changed(): Observable<IStateChange$1>;
-    get contextChanged(): Observable<IContextChanged$1>;
+    constructor(_context: unknown, _index: unknown, _indexWatchRule: IIndexWatchRule$1 | undefined, _stateManager: IStateManager, setContext: (context: unknown) => void);
+    get changed(): Observable<IStateChange>;
     dispose(): void;
     getValue(context: unknown, key: unknown): unknown;
     private onContextCHanged;
     private emitChange;
 }
-interface IIdentifierInitializeConfig extends IExpressionInitializeConfig {
+type IIdentifierBindConfiguration = IExpressionBindConfiguration & {
     currentValue?: unknown;
-}
+};
 declare class IdentifierExpression extends AbstractExpression {
-    private readonly _rootContext;
-    private readonly _stateManager;
-    private readonly _expressionChangeTransactionManager;
     private readonly _indexValue?;
     private _changeSubscription;
-    private _isInitialized;
+    private _isBound;
     private _indexValueObserver;
     private releaseMustProxifyHandler;
     private _commitAfterInitialized;
     private readonly _commitHandler;
-    constructor(_rootContext: unknown, _stateManager: IStateManager$1, expressionString: string, _expressionChangeTransactionManager: IExpressionChangeTransactionManager, _indexValue?: unknown | undefined);
-    initialize(settings: IIdentifierInitializeConfig): AbstractExpression;
+    private _context;
+    private _indexWatchRule;
+    constructor(expressionString: string, _indexValue?: unknown | undefined);
+    clone(): this;
+    bind(settings: IIdentifierBindConfiguration): AbstractExpression;
     protected internalDispose(): void;
     protected evaluate(): unknown;
+    private get isLeaf();
+    private get isMemberExpressionSegment();
+    private shouldWatchIndex;
     private observeChange;
-    private getDefaultMustProxifyHandler;
     private disposeObserver;
     private commit;
     private onValueChanged;
@@ -349,6 +361,7 @@ declare class InExpression extends BinaryExpression<boolean> {
 
 declare class IndexExpression extends ParameterizedExpression {
     constructor(expression: AbstractExpression);
+    clone(): this;
     protected get root(): AbstractExpression;
     protected evaluateExpression(index: unknown): unknown;
 }
@@ -380,6 +393,7 @@ declare class LogicalAndExpression extends BinaryExpression {
 
 declare class LogicalNotExpression extends ParameterizedExpression {
     constructor(expressionString: string, expression: AbstractExpression);
+    clone(): this;
     protected evaluateExpression(value: unknown): boolean;
 }
 
@@ -389,29 +403,25 @@ declare class LogicalOrExpression extends BinaryExpression {
 }
 
 declare class MemberExpression extends AbstractExpression {
-    private readonly _indexValueAccessor;
-    private readonly _stateManager;
-    private readonly _mustProxifyItemHandlerFactory;
-    private readonly _expressionChangeTransactionManager;
     private _slotObservers;
     private _rebindingSlot;
     private readonly _initializeQueue;
-    constructor(expressionString: string, pathSeqments: AbstractExpression[], _indexValueAccessor: IIndexValueAccessor, _stateManager: IStateManager$1, _mustProxifyItemHandlerFactory: IMustProxifyItemHandlerFactory, _expressionChangeTransactionManager: IExpressionChangeTransactionManager);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    constructor(expressionString: string, pathSeqments: AbstractExpression[]);
+    clone(): this;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     protected internalDispose(): void;
     protected prepareReevaluation(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
     protected evaluate(sender: AbstractExpression, root: AbstractExpression): unknown;
     protected isCommitTarget(sender: AbstractExpression): boolean;
-    private isPending;
     private shouldCancelEvaluate;
-    private initializePathSegement;
+    private bindPathSegement;
     private resolvePathSegment;
     private resolveCalculated;
     private disposeSlotObserver;
-    private getMustProxifyHandler;
-    private createMustProxifyHandler;
+    private isPathSegmentPending;
     private observeSlot;
     private onSlotChanged;
+    private isPending;
     private isCalculated;
 }
 
@@ -422,6 +432,7 @@ declare class MultiplicationExpression extends BinaryExpression {
 
 declare class NewExpression extends ParameterizedExpression {
     constructor(expressionString: string, constructorExpression: AbstractExpression<ConstructorType>, argumentExpressions: AbstractExpression[]);
+    clone(): this;
     protected evaluateExpression(constructorFunction: ConstructorType, ...args: unknown[]): unknown;
 }
 
@@ -437,11 +448,13 @@ declare class PropertyExpression extends BinaryExpression<object, number | strin
 
 declare class SpreadExpression extends ParameterizedExpression<unknown[] | object> {
     constructor(expression: ArrayExpression | ObjectExpression | IdentifierExpression);
+    clone(): this;
     protected evaluateExpression(...args: unknown[]): unknown[] | object;
 }
 
 declare class ObjectExpression extends ParameterizedExpression<object> {
     constructor(expressionString: string, propertyExpressions: (PropertyExpression | SpreadExpression)[]);
+    clone(): this;
     protected evaluateExpression(...args: unknown[]): object;
 }
 
@@ -452,7 +465,8 @@ declare class RemainderExpression extends BinaryExpression<number, number> {
 
 declare class SequenceExpression extends AbstractExpression {
     constructor(expressionString: string, expressions: AbstractExpression[]);
-    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    clone(): this;
+    bind(settings: IExpressionBindConfiguration): AbstractExpression;
     protected evaluate(): unknown;
 }
 
@@ -473,29 +487,26 @@ declare class SubtractionExpression extends BinaryExpression<number, number> {
 
 declare class TemplateStringExpression extends CollectionExpression<string> {
     constructor(expressionString: string, expressions: AbstractExpression[]);
+    clone(): this;
     protected evaluateExpression(...segments: unknown[]): string;
 }
 
 declare class TypeofExpression extends ParameterizedExpression<string> {
     constructor(expressionString: string, expression: AbstractExpression);
+    clone(): this;
     protected evaluateExpression(value: unknown): string;
 }
 
 declare class UnaryNegationExpression extends ParameterizedExpression<number> {
     constructor(expressionString: string, expression: AbstractExpression<number>);
+    clone(): this;
     protected evaluateExpression(value: number): number;
 }
 
-interface IExpressionChangeCommitHandler {
-    owner: AbstractExpression;
-    commit: (root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>) => boolean;
-}
-interface IExpressionChangeTransactionManager extends IDisposable {
-    readonly commited: Observable<AbstractExpression>;
-    registerChange(rootExpression: AbstractExpression, commitHandler: IExpressionChangeCommitHandler): void;
-    suspend(): void;
-    continue(): void;
-    commit(): void;
+declare class UnaryPlusExpression extends ParameterizedExpression<number> {
+    constructor(expressionString: string, expression: AbstractExpression);
+    clone(): this;
+    protected evaluateExpression(a: string | number): number;
 }
 
 declare class ExpressionChangeTransactionManager implements IExpressionChangeTransactionManager {
@@ -505,7 +516,7 @@ declare class ExpressionChangeTransactionManager implements IExpressionChangeTra
     private readonly _endChangeCycleSubscription;
     private _emittedChangeCounter;
     private _suspended;
-    constructor(stateManager: IStateManager$1);
+    constructor(stateManager: IStateManager);
     get commited(): Observable<AbstractExpression>;
     dispose(): void;
     suspend(): void;
@@ -517,28 +528,50 @@ declare class ExpressionChangeTransactionManager implements IExpressionChangeTra
     private onEndChangeCycle;
 }
 
+type IExpressionCache = ISingletonFactory<string, string, IExpression>;
+
+declare class ExpressionCache extends SingletonFactory<string, string, IExpression> implements IExpressionCache {
+    private readonly _expressionParser;
+    constructor(_expressionParser: IExpressionParser);
+    getId(expressionString: string): string | undefined;
+    protected createId(expressionString: string): string;
+    create(data: string): {
+        referenceCount: number;
+        instance: IExpression<unknown, unknown>;
+        id: string;
+    };
+    protected createInstance(expressionString: string): IExpression<unknown, unknown>;
+}
+
 interface IExpressionFactory {
-    create<T>(context: object, expression: string): IExpression<T>;
+    create<T>(context: object, expression: string, leafIndexWatchRule?: IIndexWatchRule$1): IExpression<T>;
 }
 
 interface IExpressionInfo {
     context: object;
     expression: string;
 }
-type IExpressionForContextManager = ISingletonFactory<string, string, IExpression>;
+interface IExpressionIdData {
+    expressionString: string;
+}
+interface IExpressionData extends IExpressionIdData {
+    leafIndexWatchRule?: IIndexWatchRule$1;
+}
+type IExpressionForContextManager = ISingletonFactory<string, IExpressionData, IExpression, IExpressionIdData>;
 type IExpressionManager = ISingletonFactory<object, object, IExpressionForContextManager>;
 
 declare class ExpressionFactory implements IExpressionFactory {
     private readonly _expressionManager;
     constructor(_expressionManager: IExpressionManager);
-    create<T>(context: object, expression: string): IExpression<T>;
+    create<T>(context: object, expressionString: string, leafIndexWatchRule?: IIndexWatchRule$1): IExpression<T>;
 }
 
 declare class ExpressionManager extends SingletonFactory<object, object, IExpressionForContextManager> implements IExpressionManager {
-    private readonly _expressionParser;
+    private readonly _expressionCache;
+    private readonly _services;
     getId(context: object): object;
     protected createId(context: object): object;
-    constructor(_expressionParser: IExpressionParser);
+    constructor(_expressionCache: IExpressionCache, _services: IExpressionServices);
     protected createInstance(context: object, id: object): IExpressionForContextManager;
 }
 
@@ -553,6 +586,7 @@ type IExpressionIndexAccessor = IIndexValueAccessor<unknown, string>;
 declare class ExpressionIndexAccessor implements IExpressionIndexAccessor {
     readonly priority: 300;
     isAsync(): boolean;
+    needsProxy(): boolean;
     getResolvedValue(context: unknown, index: string): unknown;
     hasValue(context: unknown, index: string): boolean;
     getValue(context: unknown, index: string): unknown;
@@ -561,16 +595,24 @@ declare class ExpressionIndexAccessor implements IExpressionIndexAccessor {
     applies(context: unknown, index: string): boolean;
 }
 
-type IExpressionObserverProxyPairFactory = IObjectObserverProxyPairFactory<AbstractExpression>;
-
-type IExpressionObserverProxyPair = IObserverProxyPair<AbstractExpression>;
-
 interface IExpressionObserverData {
     owner?: IDisposableOwner;
     expression: AbstractExpression;
 }
 type IExpressionObserverFactory = ISingletonFactory<AbstractExpression, IExpressionObserverData, IObserver>;
 
+declare class ExpressionObserverFactory extends SingletonFactory<AbstractExpression, IExpressionObserverData, IObserver> implements IExpressionObserverFactory {
+    constructor();
+    getId(data: IExpressionObserverData): AbstractExpression;
+    protected createId(data: IExpressionObserverData): AbstractExpression;
+    protected createInstance(data: IExpressionObserverData, id: AbstractExpression): IObserver;
+    protected releaseInstance(observer: IObserver): void;
+}
+
+type IExpressionObserverProxyPairFactory = IObjectObserverProxyPairFactory<AbstractExpression>;
+
+type IExpressionObserverProxyPair = IObserverProxyPair<AbstractExpression>;
+
 declare class ExpressionObserverProxyPairFactory implements IExpressionObserverProxyPairFactory {
     private readonly _expressionObserverFactory;
     readonly priority = 100;
@@ -579,12 +621,13 @@ declare class ExpressionObserverProxyPairFactory implements IExpressionObserverP
     applies(object: unknown): boolean;
 }
 
-declare class ExpressionObserverFactory extends SingletonFactory<AbstractExpression, IExpressionObserverData, IObserver> implements IExpressionObserverFactory {
-    constructor();
-    getId(data: IExpressionObserverData): AbstractExpression;
-    protected createId(data: IExpressionObserverData): AbstractExpression;
-    protected createInstance(data: IExpressionObserverData, id: AbstractExpression): IObserver;
-    protected releaseInstance(observer: IObserver): void;
+declare class ExpressionServices implements IExpressionServices {
+    readonly transactionManager: IExpressionChangeTransactionManager;
+    readonly stateManager: IStateManager;
+    readonly indexValueAccessor: IIndexValueAccessor;
+    readonly guidFactory: IGuidFactory;
+    readonly valueMetadata: IValueMetadata;
+    constructor(transactionManager: IExpressionChangeTransactionManager, stateManager: IStateManager, indexValueAccessor: IIndexValueAccessor, guidFactory: IGuidFactory, valueMetadata: IValueMetadata);
 }
 
 interface IIdentifierOwnerResolver {
@@ -610,19 +653,14 @@ declare class PropertyOwnerResolver implements IIdentifierOwnerResolver {
 }
 
 declare class JsEspreeExpressionParser implements IExpressionParser {
-    private readonly _indexValueAccessor;
-    private readonly _mustProxifyItemHandlerFactory;
-    private readonly _expressionChangeTransactionManager;
-    private readonly _stateManager;
-    private readonly _guidFactory;
     static readonly instance: IExpressionParser;
     private readonly createConstantExpression;
     private readonly expressionFactories;
     private readonly unaryExpressionFactories;
     private readonly binaryExpressionFactories;
     private readonly logicalExpressionFactories;
-    constructor(_indexValueAccessor: IIndexValueAccessor, _mustProxifyItemHandlerFactory: IMustProxifyItemHandlerFactory, _expressionChangeTransactionManager: IExpressionChangeTransactionManager, _stateManager: IStateManager$1, _guidFactory: IGuidFactory);
-    parse(context: unknown, expressionString: string, owner: IDisposableOwner): AbstractExpression;
+    constructor();
+    parse(expressionString: string): AbstractExpression;
     private tryParse;
     private createExpression;
     private createLiteralExpression;
@@ -680,6 +718,9 @@ declare class JsEspreeExpressionParser implements IExpressionParser {
     private flattenMemberExpression;
 }
 
+declare const RsXExpressionParserModule: ContainerModule;
+declare function unloadRsXExpressionParserModule(): Promise<void>;
+
 declare const RsXExpressionParserInjectionTokens: {
     PropertyOwnerResolver: symbol;
     ArrayIndexOwnerResolver: symbol;
@@ -693,9 +734,9 @@ declare const RsXExpressionParserInjectionTokens: {
     IExpressionObserverProxyPairFactory: symbol;
     IExpressionIndexAccessor: symbol;
     IExpressionObserverFactory: symbol;
+    IExpressionCache: symbol;
+    IExpressionServices: symbol;
+    ExpressiomMetadata: symbol;
 };
 
-declare const RsXExpressionParserModule: ContainerModule;
-declare function unloadRsXExpressionParserModule(): Promise<void>;
-
-export { AbstractExpression, AdditionExpression, ArrayExpression, ArrayIndexOwnerResolver, BinaryExpression, BitwiseAndExpression, BitwiseLeftShiftExpression, BitwiseNotExpression, BitwiseOrExpression, BitwiseRightShiftExpression, BitwiseUnsignedRightShiftExpression, BitwiseXorExpression, CollectionExpression, ConditionalExpression, ConstantBigIntExpression, ConstantBooleanExpression, ConstantExpression, ConstantNullExpression, ConstantNumberExpression, ConstantRegExpExpression, ConstantStringExpression, DeepCloneExceptWithExpressionSupport, DefaultIdentifierOwnerResolver, DivisionExpression, EqualityExpression, ExponentiationExpression, ExpressionChangeTransactionManager, ExpressionFactory, ExpressionIndexAccessor, ExpressionManager, ExpressionObserverFactory, ExpressionObserverProxyPairFactory, ExpressionType, FunctionExpression, GreaterThanExpression, GreaterThanOrEqualExpression, type IChangePathValue, type IExpression, type IExpressionChangeCommitHandler, type IExpressionChangeTransactionManager, type IExpressionFactory, type IExpressionForContextManager, type IExpressionIndexAccessor, type IExpressionInfo, type IExpressionInitializeConfig, type IExpressionManager, type IExpressionObserverData, type IExpressionObserverFactory, type IExpressionObserverProxyPair, type IExpressionParser, type IIdentifierInitializeConfig, type IIdentifierOwnerResolver, type IMustProxifyHandler, type IPropertyPath, IdentifierExpression, InExpression, IndexExpression, IndexValueObserver, InequalityExpression, InstanceofExpression, JsEspreeExpressionParser, LessThanExpression, LessThanOrEqualExpression, LogicalAndExpression, LogicalNotExpression, LogicalOrExpression, MapKeyOwnerResolver, MemberExpression, MultiplicationExpression, NewExpression, NullishCoalescingExpression, ObjectExpression, ParameterizedExpression, PropertyExpression, PropertyOwnerResolver, RemainderExpression, RsXExpressionParserInjectionTokens, RsXExpressionParserModule, SequenceExpression, SpreadExpression, StrictEqualityExpression, StrictInequalityExpression, SubtractionExpression, TemplateStringExpression, TypeofExpression, UnaryNegationExpression, UnaryPlusExpression, unloadRsXExpressionParserModule };
+export { AbstractExpression, AdditionExpression, ArrayExpression, ArrayIndexOwnerResolver, BinaryExpression, BitwiseAndExpression, BitwiseLeftShiftExpression, BitwiseNotExpression, BitwiseOrExpression, BitwiseRightShiftExpression, BitwiseUnsignedRightShiftExpression, BitwiseXorExpression, CollectionExpression, ConditionalExpression, ConstantBigIntExpression, ConstantBooleanExpression, ConstantExpression, ConstantNullExpression, ConstantNumberExpression, ConstantRegExpExpression, ConstantStringExpression, DeepCloneExceptWithExpressionSupport, DefaultIdentifierOwnerResolver, DivisionExpression, EqualityExpression, ExponentiationExpression, ExpressionCache, ExpressionChangeTransactionManager, ExpressionFactory, ExpressionIndexAccessor, ExpressionManager, ExpressionObserverFactory, ExpressionObserverProxyPairFactory, ExpressionServices, ExpressionType, FunctionExpression, GreaterThanExpression, GreaterThanOrEqualExpression, type IBindConfigurationBase, type IChangePathValue, type IExpression, type IExpressionBindConfiguration, type IExpressionBindConfigurationExtra, type IExpressionCache, type IExpressionChangeCommitHandler, type IExpressionChangeTransactionManager, type IExpressionData, type IExpressionFactory, type IExpressionForContextManager, type IExpressionIdData, type IExpressionIndexAccessor, type IExpressionInfo, type IExpressionManager, type IExpressionObserverData, type IExpressionObserverFactory, type IExpressionObserverProxyPair, type IExpressionParser, type IExpressionServices, type IIdentifierBindConfiguration, type IIdentifierOwnerResolver, type IPropertyPath, IdentifierExpression, InExpression, IndexExpression, IndexValueObserver, InequalityExpression, InstanceofExpression, JsEspreeExpressionParser, LessThanExpression, LessThanOrEqualExpression, LogicalAndExpression, LogicalNotExpression, LogicalOrExpression, MapKeyOwnerResolver, MemberExpression, MultiplicationExpression, NewExpression, NullishCoalescingExpression, ObjectExpression, ParameterizedExpression, PropertyExpression, PropertyOwnerResolver, RemainderExpression, RsXExpressionParserInjectionTokens, RsXExpressionParserModule, SequenceExpression, SpreadExpression, StrictEqualityExpression, StrictInequalityExpression, SubtractionExpression, TemplateStringExpression, TypeofExpression, UnaryNegationExpression, UnaryPlusExpression, unloadRsXExpressionParserModule };