@ibyar/expressions 0.5.4 → 0.6.0

package/scope/scope.d.ts

@@ -1,32 +1,89 @@
 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
+     */
     get(propertyKey: keyof T): any;
+    /**
+     * set the value of `propertyKey` in current context, could be instilled with `value`.
+     * @param propertyKey
+     * @param value
+     * @param receiver
+     */
     set(propertyKey: keyof T, value?: any, receiver?: any): boolean;
+    /**
+     * is current context has `propertyKey` in hash map keys
+     * @param propertyKey
+     */
     has(propertyKey: keyof T): boolean;
+    /**
+     * delete property from context
+     * @param propertyKey
+     */
     delete(propertyKey: keyof T): boolean;
+    /**
+     * get current context object of this scope
+     */
     getContext(): T;
+    /**
+     * get a proxy of the current context object if exists.
+     */
     getContextProxy?(): T;
-    getScope<V extends ScopeContext>(propertyKey: keyof T): Scope<V> | undefined;
-    getScopeOrCreat<V extends ScopeContext>(propertyKey: keyof T): Scope<V>;
-    getClass(): TypeOf<Scope<ScopeContext>>;
+    /**
+     * get a scope for an object named as `propertyKey` from cache map,
+     *
+     * if the current value is not type od `object`, will return `undefined`.
+     * @param propertyKey the name of the property
+     */
+    getInnerScope<S extends Scope<Context>>(propertyKey: keyof T): S | undefined;
+    /**
+     * create a scope with the same type of this scope
+     */
+    setInnerScope<S extends Scope<Context>>(propertyKey: keyof T): S;
+    /**
+     * sc
+     * @param propertyKey
+     * @param scope
+     */
+    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;
@@ -38,58 +95,124 @@ 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>>;
 }
-export interface ScopeControl<T extends ScopeContext> {
+/**
+ * used control/notify/pause scope about changes in current context
+ */
+export interface ScopeControl<T extends Context> {
+    /**
+     * get current stacte of applying change detection.
+     */
     isAttached(): boolean;
+    /**
+     * used when want to update ui-view like, you want to replace an array with another
+     * without reflect changes on view until reattached again.
+     */
     detach(): void;
+    /**
+     * apply all the not emitted changes, and continue emit in time.
+     */
     reattach(): void;
+    /**
+     * apply changes now,
+     * will not effect the state of the detector wither if attached ot not.
+     *
+     * if a propertyKey is provided, will emit this property only
+     * @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;
+    /**
+     *
+     * Provides a module-relative resolution function scoped to each module, returning
+     * the URL string.
+     *
+     * @param specified The module specifier to resolve relative to `parent`.
+     * @param parent The absolute parent module URL to resolve from. If none
+     * is specified, the value of `import.meta.url` is used as the default.
+     */
     resolve?(specified: string, parent?: string | URL): Promise<string>;
 }
 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> {