@ibyar/expressions 0.5.62 → 0.6.0

package/scope/pool.js

@@ -0,0 +1,29 @@
+import { ReactiveScope, ReactiveScopeControl, ReadOnlyScope, Scope } from './scope.js';
+const pool = new WeakMap();
+export function getScopeFor(ctx, type, propertyKeys) {
+    if (pool.has(ctx)) {
+        return pool.get(ctx);
+    }
+    if (!type) {
+        return;
+    }
+    let scope;
+    switch (type) {
+        case 'read-only':
+            scope = ReadOnlyScope.for(ctx, propertyKeys);
+            break;
+        case 'reactive':
+            scope = ReactiveScope.for(ctx, propertyKeys);
+            break;
+        case 'reactive-control':
+            scope = ReactiveScopeControl.for(ctx, propertyKeys);
+            break;
+        default:
+        case 'scope':
+            scope = Scope.for(ctx, propertyKeys);
+            break;
+    }
+    pool.set(ctx, scope);
+    return scope;
+}
+//# sourceMappingURL=pool.js.map

package/scope/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../../src/expressions/scope/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEvF,MAAM,IAAI,GAAG,IAAI,OAAO,EAAsB,CAAC;AAS/C,MAAM,UAAU,WAAW,CAAuC,GAAM,EAAE,IAAgB,EAAE,YAA0B;IACrH,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QAClB,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAQ,CAAC;KAC5B;IACD,IAAI,CAAC,IAAI,EAAE;QACV,OAAO;KACP;IACD,IAAI,KAAe,CAAC;IACpB,QAAQ,IAAI,EAAE;QACb,KAAK,WAAW;YACf,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;YAC7C,MAAM;QACP,KAAK,UAAU;YACd,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;YAC7C,MAAM;QACP,KAAK,kBAAkB;YACtB,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;YACpD,MAAM;QACP,QAAQ;QACR,KAAK,OAAO;YACX,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;YACrC,MAAM;KACP;IACD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACrB,OAAO,KAAiB,CAAC;AAC1B,CAAC","sourcesContent":["import { ReactiveScope, ReactiveScopeControl, ReadOnlyScope, Scope } from './scope.js';\n\nconst pool = new WeakMap<object, Scope<any>>();\n\nexport type ScopeType = 'scope' | 'read-only' | 'reactive' | 'reactive-control';\n\nexport function getScopeFor<S extends Scope<T>, T extends object>(ctx: T): S | undefined;\nexport function getScopeFor<T extends object>(ctx: T, type: 'scope', propertyKeys?: (keyof T)[]): Scope<T>;\nexport function getScopeFor<T extends object>(ctx: T, type: 'read-only', propertyKeys?: (keyof T)[]): ReadOnlyScope<T>;\nexport function getScopeFor<T extends object>(ctx: T, type: 'reactive', propertyKeys?: (keyof T)[]): ReactiveScope<T>;\nexport function getScopeFor<T extends object>(ctx: T, type: 'reactive-control', propertyKeys?: (keyof T)[]): ReactiveScopeControl<T>;\nexport function getScopeFor<S extends Scope<T>, T extends object>(ctx: T, type?: ScopeType, propertyKeys?: (keyof T)[]): S | undefined {\n\tif (pool.has(ctx)) {\n\t\treturn pool.get(ctx) as any;\n\t}\n\tif (!type) {\n\t\treturn;\n\t}\n\tlet scope: Scope<T>;\n\tswitch (type) {\n\t\tcase 'read-only':\n\t\t\tscope = ReadOnlyScope.for(ctx, propertyKeys);\n\t\t\tbreak;\n\t\tcase 'reactive':\n\t\t\tscope = ReactiveScope.for(ctx, propertyKeys);\n\t\t\tbreak;\n\t\tcase 'reactive-control':\n\t\t\tscope = ReactiveScopeControl.for(ctx, propertyKeys);\n\t\t\tbreak;\n\t\tdefault:\n\t\tcase 'scope':\n\t\t\tscope = Scope.for(ctx, propertyKeys);\n\t\t\tbreak;\n\t}\n\tpool.set(ctx, scope);\n\treturn scope as any as S;\n}\n"]}

package/scope/proxy.d.ts

@@ -1,16 +1,10 @@
-import type { Scope, ScopeContext } from './scope.js';
-export declare class FunctionProxyHandler<T extends Function> implements ProxyHandler<T> {
-    private thisContext;
-    constructor(thisContext: object);
-    apply(targetFunc: T, targetThisArg: any, argArray: any[]): any;
-    private computeThisArg;
-}
+import type { Scope, Context } from './scope.js';
+export declare function hasBindingHook<T>(ctx: T): boolean;
 /**
  * crete new proxy handler object as scoped context
  */
-export declare class ScopeProxyHandler<T extends ScopeContext> implements ProxyHandler<ScopeContext> {
+export declare class ScopeProxyHandler<T extends Context> implements ProxyHandler<Context> {
     private scope;
-    private functionHandler;
     constructor(scope: Scope<T>);
     has(model: T, propertyKey: PropertyKey): boolean;
     get(model: T, propertyKey: PropertyKey, receiver: any): any;

package/scope/proxy.js

@@ -1,30 +1,23 @@
-export class FunctionProxyHandler {
-    constructor(thisContext) {
-        this.thisContext = thisContext;
-    }
-    apply(targetFunc, targetThisArg, argArray) {
-        return targetFunc.apply(this.computeThisArg(targetThisArg), argArray);
-    }
-    computeThisArg(targetThisArg) {
-        switch (true) {
-            // exclude classes that have binding hook
-            case this.thisContext instanceof Map:
-            case this.thisContext instanceof Set:
-            case this.thisContext instanceof Date:
-            case this.thisContext instanceof WeakMap:
-            case this.thisContext instanceof WeakSet:
-            case this.thisContext instanceof Promise:
-            case this.thisContext instanceof HTMLElement:
-                return this.thisContext;
-            default:
-                return targetThisArg;
-        }
+export function hasBindingHook(ctx) {
+    switch (true) {
+        // exclude classes that have binding hook
+        case ctx instanceof Map:
+        case ctx instanceof Set:
+        case ctx instanceof Date:
+        case ctx instanceof WeakMap:
+        case ctx instanceof WeakSet:
+        case ctx instanceof Promise:
+        case HTMLElement && ctx instanceof HTMLElement:
+            return true;
+        default:
+            return false;
     }
 }
 /**
  * crete new proxy handler object as scoped context
  */
 export class ScopeProxyHandler {
+    // private functionHandler: FunctionProxyHandler<Function>;
     constructor(scope) {
         this.scope = scope;
     }
@@ -33,20 +26,14 @@ export class ScopeProxyHandler {
     }
     get(model, propertyKey, receiver) {
         const value = this.scope.get(propertyKey);
-        if (value == null) {
+        if (!(value && typeof value === 'object')) {
             return value;
         }
-        if (typeof value === 'object') {
-            const scope = this.scope.getScope(propertyKey);
-            if (scope) {
-                return new Proxy(value, new ScopeProxyHandler(scope));
-            }
-        }
-        else if (typeof value === 'function') {
-            return new Proxy(value, this.functionHandler
-                ?? (this.functionHandler = new FunctionProxyHandler(this.scope.getContext())));
+        const scope = this.scope.getInnerScope(propertyKey);
+        if (!scope) {
+            return value;
         }
-        return value;
+        return createProxyForContext(scope);
     }
     set(model, propertyKey, value, receiver) {
         return this.scope.set(propertyKey, value);

package/scope/proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../src/expressions/scope/proxy.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,oBAAoB;IAChC,YAAoB,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;IAAI,CAAC;IAC5C,KAAK,CAAC,UAAa,EAAE,aAAkB,EAAE,QAAe;QACvD,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;IACvE,CAAC;IAEO,cAAc,CAAC,aAAkB;QACxC,QAAQ,IAAI,EAAE;YACb,yCAAyC;YACzC,KAAK,IAAI,CAAC,WAAW,YAAY,GAAG,CAAC;YACrC,KAAK,IAAI,CAAC,WAAW,YAAY,GAAG,CAAC;YACrC,KAAK,IAAI,CAAC,WAAW,YAAY,IAAI,CAAC;YACtC,KAAK,IAAI,CAAC,WAAW,YAAY,OAAO,CAAC;YACzC,KAAK,IAAI,CAAC,WAAW,YAAY,OAAO,CAAC;YACzC,KAAK,IAAI,CAAC,WAAW,YAAY,OAAO,CAAC;YACzC,KAAK,IAAI,CAAC,WAAW,YAAY,WAAW;gBAC3C,OAAO,IAAI,CAAC,WAAW,CAAC;YACzB;gBACC,OAAO,aAAa,CAAC;SACtB;IACF,CAAC;CACD;AAED;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAE7B,YAAoB,KAAe;QAAf,UAAK,GAAL,KAAK,CAAU;IAAI,CAAC;IACxC,GAAG,CAAC,KAAQ,EAAE,WAAwB;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IACpC,CAAC;IACD,GAAG,CAAC,KAAQ,EAAE,WAAwB,EAAE,QAAa;QACpD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,IAAI,EAAE;YAClB,OAAO,KAAK,CAAC;SACb;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC/C,IAAI,KAAK,EAAE;gBACV,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;aACtD;SACD;aAAM,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE;YACvC,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,eAAe;mBACxC,CAAC,IAAI,CAAC,eAAe,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAC7E,CAAC;SACF;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IACD,GAAG,CAAC,KAAQ,EAAE,WAAwB,EAAE,KAAU,EAAE,QAAa;QAChE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,cAAc,CAAC,KAAQ,EAAE,WAA4B;QACpD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;CACD;AAOD,MAAM,UAAU,8BAA8B,CAAmB,OAAU,EAAE,KAAe;IAC3F,OAAO,KAAK,CAAC,SAAS,CAAI,OAAO,EAAE,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAmB,KAAe;IACtE,OAAO,IAAI,KAAK,CAAI,KAAK,CAAC,UAAU,EAAE,EAAE,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import type { Scope, ScopeContext } from './scope.js';\n\nexport class FunctionProxyHandler<T extends Function> implements ProxyHandler<T> {\n\tconstructor(private thisContext: object) { }\n\tapply(targetFunc: T, targetThisArg: any, argArray: any[]): any {\n\t\treturn targetFunc.apply(this.computeThisArg(targetThisArg), argArray);\n\t}\n\n\tprivate computeThisArg(targetThisArg: any): any {\n\t\tswitch (true) {\n\t\t\t// exclude classes that have binding hook\n\t\t\tcase this.thisContext instanceof Map:\n\t\t\tcase this.thisContext instanceof Set:\n\t\t\tcase this.thisContext instanceof Date:\n\t\t\tcase this.thisContext instanceof WeakMap:\n\t\t\tcase this.thisContext instanceof WeakSet:\n\t\t\tcase this.thisContext instanceof Promise:\n\t\t\tcase this.thisContext instanceof HTMLElement:\n\t\t\t\treturn this.thisContext;\n\t\t\tdefault:\n\t\t\t\treturn targetThisArg;\n\t\t}\n\t}\n}\n\n/**\n * crete new proxy handler object as scoped context\n */\nexport class ScopeProxyHandler<T extends ScopeContext> implements ProxyHandler<ScopeContext> {\n\tprivate functionHandler: FunctionProxyHandler<Function>;\n\tconstructor(private scope: Scope<T>) { }\n\thas(model: T, propertyKey: PropertyKey): boolean {\n\t\treturn this.scope.has(propertyKey);\n\t}\n\tget(model: T, propertyKey: PropertyKey, receiver: any): any {\n\t\tconst value = this.scope.get(propertyKey);\n\t\tif (value == null) {\n\t\t\treturn value;\n\t\t}\n\t\tif (typeof value === 'object') {\n\t\t\tconst scope = this.scope.getScope(propertyKey);\n\t\t\tif (scope) {\n\t\t\t\treturn new Proxy(value, new ScopeProxyHandler(scope));\n\t\t\t}\n\t\t} else if (typeof value === 'function') {\n\t\t\treturn new Proxy(value, this.functionHandler\n\t\t\t\t?? (this.functionHandler = new FunctionProxyHandler(this.scope.getContext()))\n\t\t\t);\n\t\t}\n\t\treturn value;\n\t}\n\tset(model: T, propertyKey: PropertyKey, value: any, receiver: any): boolean {\n\t\treturn this.scope.set(propertyKey, value);\n\t}\n\tdeleteProperty(model: T, propertyKey: string | symbol): boolean {\n\t\treturn this.scope.delete(propertyKey);\n\t}\n}\n\nexport type RevocableProxy<T> = {\n\tproxy: T;\n\trevoke: () => void;\n};\n\nexport function createRevocableProxyForContext<T extends object>(context: T, scope: Scope<T>): RevocableProxy<T> {\n\treturn Proxy.revocable<T>(context, new ScopeProxyHandler(scope));\n}\n\nexport function createProxyForContext<T extends object>(scope: Scope<T>): T {\n\treturn new Proxy<T>(scope.getContext(), new ScopeProxyHandler(scope));\n}\n"]}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../src/expressions/scope/proxy.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,cAAc,CAAI,GAAM;IACvC,QAAQ,IAAI,EAAE;QACb,yCAAyC;QACzC,KAAK,GAAG,YAAY,GAAG,CAAC;QACxB,KAAK,GAAG,YAAY,GAAG,CAAC;QACxB,KAAK,GAAG,YAAY,IAAI,CAAC;QACzB,KAAK,GAAG,YAAY,OAAO,CAAC;QAC5B,KAAK,GAAG,YAAY,OAAO,CAAC;QAC5B,KAAK,GAAG,YAAY,OAAO,CAAC;QAC5B,KAAK,WAAW,IAAI,GAAG,YAAY,WAAW;YAC7C,OAAO,IAAI,CAAC;QACb;YACC,OAAO,KAAK,CAAC;KACd;AACF,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAC7B,2DAA2D;IAC3D,YAAoB,KAAe;QAAf,UAAK,GAAL,KAAK,CAAU;IAAI,CAAC;IACxC,GAAG,CAAC,KAAQ,EAAE,WAAwB;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IACpC,CAAC;IACD,GAAG,CAAC,KAAQ,EAAE,WAAwB,EAAE,QAAa;QACpD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC1C,IAAI,CAAC,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,EAAE;YAC1C,OAAO,KAAK,CAAC;SACb;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,CAAC,KAAK,EAAE;YACX,OAAO,KAAK,CAAC;SACb;QACD,OAAO,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IACD,GAAG,CAAC,KAAQ,EAAE,WAAwB,EAAE,KAAU,EAAE,QAAa;QAChE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,cAAc,CAAC,KAAQ,EAAE,WAA4B;QACpD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;CACD;AAOD,MAAM,UAAU,8BAA8B,CAAmB,OAAU,EAAE,KAAe;IAC3F,OAAO,KAAK,CAAC,SAAS,CAAI,OAAO,EAAE,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAmB,KAAe;IACtE,OAAO,IAAI,KAAK,CAAI,KAAK,CAAC,UAAU,EAAE,EAAE,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import type { Scope, Context } from './scope.js';\n\nexport function hasBindingHook<T>(ctx: T) {\n\tswitch (true) {\n\t\t// exclude classes that have binding hook\n\t\tcase ctx instanceof Map:\n\t\tcase ctx instanceof Set:\n\t\tcase ctx instanceof Date:\n\t\tcase ctx instanceof WeakMap:\n\t\tcase ctx instanceof WeakSet:\n\t\tcase ctx instanceof Promise:\n\t\tcase HTMLElement && ctx instanceof HTMLElement:\n\t\t\treturn true;\n\t\tdefault:\n\t\t\treturn false;\n\t}\n}\n\n/**\n * crete new proxy handler object as scoped context\n */\nexport class ScopeProxyHandler<T extends Context> implements ProxyHandler<Context> {\n\t// private functionHandler: FunctionProxyHandler<Function>;\n\tconstructor(private scope: Scope<T>) { }\n\thas(model: T, propertyKey: PropertyKey): boolean {\n\t\treturn this.scope.has(propertyKey);\n\t}\n\tget(model: T, propertyKey: PropertyKey, receiver: any): any {\n\t\tconst value = this.scope.get(propertyKey);\n\t\tif (!(value && typeof value === 'object')) {\n\t\t\treturn value;\n\t\t}\n\t\tconst scope = this.scope.getInnerScope(propertyKey);\n\t\tif (!scope) {\n\t\t\treturn value;\n\t\t}\n\t\treturn createProxyForContext(scope);\n\t}\n\tset(model: T, propertyKey: PropertyKey, value: any, receiver: any): boolean {\n\t\treturn this.scope.set(propertyKey, value);\n\t}\n\tdeleteProperty(model: T, propertyKey: string | symbol): boolean {\n\t\treturn this.scope.delete(propertyKey);\n\t}\n}\n\nexport type RevocableProxy<T> = {\n\tproxy: T;\n\trevoke: () => void;\n};\n\nexport function createRevocableProxyForContext<T extends object>(context: T, scope: Scope<T>): RevocableProxy<T> {\n\treturn Proxy.revocable<T>(context, new ScopeProxyHandler(scope));\n}\n\nexport function createProxyForContext<T extends object>(scope: Scope<T>): T {\n\treturn new Proxy<T>(scope.getContext(), new ScopeProxyHandler(scope));\n}\n"]}

package/scope/scope.d.ts

@@ -1,8 +1,6 @@
 import { TypeOf } from '../api/utils.js';
-export declare type ScopeContext = {
-    [key: PropertyKey]: ScopeContext | any;
-};
-export interface Scope<T = ScopeContext> {
+export declare type Context = Record<PropertyKey, any>;
+export interface Scope<T = Context> {
     /**
      * get value of `propertyKey` in current context
      * @param propertyKey
@@ -39,30 +37,53 @@ export interface Scope<T = ScopeContext> {
      * if the current value is not type od `object`, will return `undefined`.
      * @param propertyKey the name of the property
      */
-    getScope<V extends ScopeContext>(propertyKey: keyof T): Scope<V> | undefined;
+    getInnerScope<S extends Scope<Context>>(propertyKey: keyof T): S | undefined;
     /**
-     * get a scope for an object named as `propertyKey` from cache map,
-     *
-     * if no scope found in the cache, will create a new one, add this one to the map, return a reference.
+     * create a scope with the same type of this scope
+     */
+    setInnerScope<S extends Scope<Context>>(propertyKey: keyof T): S;
+    /**
+     * sc
      * @param propertyKey
+     * @param scope
      */
-    getScopeOrCreat<V extends ScopeContext>(propertyKey: keyof T): Scope<V>;
-    getClass(): TypeOf<Scope<ScopeContext>>;
+    setInnerScope<S extends Scope<Context>>(propertyKey: keyof T, scope?: S): S;
+    getClass(): TypeOf<Scope<Context>>;
 }
-export declare class Scope<T extends ScopeContext> implements Scope<T> {
-    protected context: T;
-    static for<T extends ScopeContext>(context: T, propertyKeys?: (keyof T)[]): Scope<T>;
-    static blockScope<T extends ScopeContext>(propertyKeys?: (keyof T)[]): Scope<T>;
-    protected scopeMap: Map<keyof T, Scope<any>>;
-    protected propertyKeys?: (keyof T)[];
+export declare class Scope<T extends Context> implements Scope<T> {
+    protected _ctx: T;
+    protected _keys?: (keyof T)[] | undefined;
+    static for<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): Scope<T>;
+    static blockScope<T extends Context>(propertyKeys?: (keyof T)[]): Scope<T>;
+    protected _inners: Map<keyof T, Scope<any>>;
     constructor(context: T, propertyKeys?: (keyof T)[]);
 }
-export declare class ReadOnlyScope<T extends ScopeContext> extends Scope<T> {
-    static for<T extends ScopeContext>(context: T, propertyKeys?: (keyof T)[]): ReadOnlyScope<T>;
-    static blockScope<T extends ScopeContext>(propertyKeys?: (keyof T)[]): ReadOnlyScope<T>;
+/**
+ * a class scope used for class instance and private static properties
+ */
+export declare class ClassScope<T extends Context> extends Scope<T> {
+    private _pKeys?;
+    static for<T extends Context>(ctx: T, propertyKeys?: (keyof T)[], privateKeys?: (keyof T)[]): ClassScope<T>;
+    static blockScope<T extends Context>(propertyKeys?: (keyof T)[], privateKeys?: (keyof T)[]): ClassScope<T>;
+    static readOnlyScopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[], privateKeys?: (keyof T)[]): ReadOnlyScope<{
+        this: T;
+    }>;
+    protected _private: Context;
+    constructor(context: T, propertyKeys?: (keyof T)[], privateKeys?: (keyof T)[]);
+    getPrivateContext(): T;
+    get(key: keyof T): any;
+    set(key: keyof T, value: any, receiver?: any): boolean;
+    has(key: keyof T): boolean;
+    delete(key: keyof T): boolean;
+    protected isPrivateKey(key: keyof T): boolean;
+    getClass(): TypeOf<ReadOnlyScope<Context>>;
+}
+export declare class ReadOnlyScope<T extends Context> extends Scope<T> {
+    static for<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): ReadOnlyScope<T>;
+    static blockScope<T extends Context>(propertyKeys?: (keyof T)[]): ReadOnlyScope<T>;
     set(propertyKey: keyof T, value: any, receiver?: any): boolean;
     delete(propertyKey: keyof T): boolean;
-    getClass(): TypeOf<ReadOnlyScope<ScopeContext>>;
+    getClass(): TypeOf<ReadOnlyScope<Context>>;
 }
 export declare class ScopeSubscription<T> {
     private propertyKey;
@@ -74,39 +95,56 @@ export declare class ScopeSubscription<T> {
 }
 export declare type ValueChangedCallback = (newValue: any, oldValue?: any) => void;
 export declare class ValueChangeObserver<T> {
-    private subscribers;
-    private propertiesLock;
+    private _subscribers;
+    private _lock;
     emit(propertyKey: keyof T, newValue: any, oldValue?: any): void;
     subscribe(propertyKey: keyof T, callback: ValueChangedCallback): ScopeSubscription<T>;
     unsubscribe(propertyKey: keyof T, subscription?: ScopeSubscription<T>): void;
     pause(propertyKey: keyof T, subscription: ScopeSubscription<T>): void;
     resume(propertyKey: keyof T, subscription: ScopeSubscription<T>): void;
+    /**
+     * check if this Observer has any subscribers
+     */
+    hasSubscribers(): boolean;
+    /**
+     * check if there is any subscribers registered by the propertyKey.
+     *
+     * @param propertyKey
+     */
+    hasSubscribers(propertyKey: keyof T): boolean;
     /**
      * clear subscription maps
      */
     destroy(): void;
 }
-export declare class ReactiveScope<T extends ScopeContext> extends Scope<T> {
-    protected parent?: ReactiveScope<any> | undefined;
-    static for<T extends ScopeContext>(context: T, propertyKeys?: (keyof T)[]): ReactiveScope<T>;
-    static blockScope<T extends ScopeContext>(propertyKeys?: (keyof T)[]): ReactiveScope<T>;
-    protected observer: ValueChangeObserver<T>;
-    protected name?: string;
-    constructor(context: T, propertyKeys?: (keyof T)[]);
-    constructor(context: T, name: string, parent: ReactiveScope<any>, propertyKeys?: (keyof T)[]);
+export declare class ReactiveScope<T extends Context> extends Scope<T> {
+    protected _name?: keyof T | undefined;
+    protected _parent?: ReactiveScope<any> | undefined;
+    static for<T extends Context>(context: T, propertyKeys?: (keyof T)[]): ReactiveScope<T>;
+    static blockScope<T extends Context>(propertyKeys?: (keyof T)[]): ReactiveScope<T>;
+    static scopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): Scope<{
+        this: T;
+    }>;
+    static readOnlyScopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): ReadOnlyScope<{
+        this: T;
+    }>;
+    protected _clone: T;
+    protected _inners: Map<keyof T, ReactiveScope<any>>;
+    protected _observer: ValueChangeObserver<T>;
+    constructor(context: T, propertyKeys?: (keyof T)[], _name?: keyof T | undefined, _parent?: ReactiveScope<any> | undefined);
     set(propertyKey: keyof T, newValue: any, receiver?: any): boolean;
     delete(propertyKey: keyof T): boolean;
-    getScope<V extends ScopeContext>(propertyKey: keyof T): ReactiveScope<V> | undefined;
-    getScopeOrCreat<V extends ScopeContext>(propertyKey: keyof T): ReactiveScope<V>;
     emit(propertyKey: keyof T, newValue: any, oldValue?: any): void;
     subscribe(propertyKey: keyof T, callback: ValueChangedCallback): ScopeSubscription<T>;
     unsubscribe(propertyKey?: keyof T, subscription?: ScopeSubscription<T>): void;
-    getClass(): TypeOf<ReactiveScope<ScopeContext>>;
+    detectChanges(): void;
+    protected getPropertyKeys<V extends Record<PropertyKey, any>>(...objs: V[]): (keyof V)[];
+    getClass(): TypeOf<ReactiveScope<Context>>;
 }
 /**
  * used control/notify/pause scope about changes in current context
  */
-export interface ScopeControl<T extends ScopeContext> {
+export interface ScopeControl<T extends Context> {
     /**
      * get current stacte of applying change detection.
      */
@@ -128,18 +166,35 @@ export interface ScopeControl<T extends ScopeContext> {
      * @param propertyKey
      */
     emitChanges(propertyKey?: keyof T, propertyValue?: any): void;
+    /**
+     * throw error if any changes has been made
+     */
+    checkNoChanges(): void;
 }
-export declare class ReactiveScopeControl<T extends ScopeContext> extends ReactiveScope<T> implements ScopeControl<T> {
-    static for<T extends ScopeContext>(context: T, propertyKeys?: (keyof T)[]): ReactiveScopeControl<T>;
-    static blockScope<T extends ScopeContext>(propertyKeys?: (keyof T)[]): ReactiveScopeControl<T>;
-    protected attached: boolean;
-    protected marked: ScopeContext;
+export declare class ReactiveScopeControl<T extends Context> extends ReactiveScope<T> implements ScopeControl<T> {
+    static for<T extends Context>(context: T, propertyKeys?: (keyof T)[]): ReactiveScopeControl<T>;
+    static blockScope<T extends Context>(propertyKeys?: (keyof T)[]): ReactiveScopeControl<T>;
+    static scopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): Scope<{
+        this: T;
+    }>;
+    static readOnlyScopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): ReadOnlyScope<{
+        this: T;
+    }>;
+    static reactiveScopeForThis<T extends Context>(ctx: T, propertyKeys?: (keyof T)[]): Scope<{
+        this: T;
+    }>;
+    protected _attached: boolean;
+    protected _marked: {
+        [key: keyof Context]: [any, any];
+    };
     emit(propertyKey: keyof T, newValue: any, oldValue?: any): void;
     isAttached(): boolean;
     detach(): void;
     reattach(): void;
     emitChanges(propertyKey?: keyof T, propertyValue?: any): void;
-    getClass(): TypeOf<ReactiveScopeControl<ScopeContext>>;
+    detectChanges(): void;
+    checkNoChanges(): void;
+    getClass(): TypeOf<ReactiveScopeControl<Context>>;
 }
 interface ImportMeta {
     url: URL;
@@ -157,7 +212,7 @@ interface ImportMeta {
 export interface ModuleImport {
     meta: ImportMeta;
 }
-export interface ModuleContext extends ScopeContext {
+export interface ModuleContext extends Context {
     import: ModuleImport & ((path: string) => Promise<any>);
 }
 export declare class ModuleScope extends ReactiveScope<ModuleContext> {