Class AsyncPipeScope<T>

Type Parameters

Hierarchy (View Summary)

Constructors

constructor

Properties

_attached _clone _ctx _inners _keys? _marked _name? _observer _parent?

Methods

checkNoChanges delete detach detectChanges emit emitChanges get getClass getContext getContextProxy? getInnerScope getPropertyKeys has isAttached reattach set setInnerScope subscribe unsubscribe blockScope for reactiveScopeForThis readOnlyScopeForThis scopeForThis

Constructors

constructor

Properties

Protected_attached

_attached: boolean

Protected_clone

_clone: T

Protected_ctx

_ctx: T

Protected_inners

_inners: Map<keyof T, ReactiveScope<any>>

Protected Optional_keys

_keys?: (keyof T)[]

Protected_marked

_marked: { [key: string | number | symbol]: [any, any] }

Protected Optional_name

_name?: PropertyKey

Protected_observer

_observer: ValueChangeObserver<T>

Protected Optional_parent

_parent?: ReactiveScope<any>

Methods

checkNoChanges

  • checkNoChanges(): void

  • throw error if any changes has been made

    Returns void

delete

  • delete(propertyKey: keyof T): boolean

  • delete property from context

    Parameters

    • propertyKey: keyof T

    Returns boolean

detach

  • detach(): void

  • used when want to update ui-view like, you want to replace an array with another without reflect changes on view until reattached again.

    Returns void

detectChanges

  • detectChanges(): void

  • Returns void

emit

  • emit(propertyKey: keyof T, newValue: any, oldValue?: any): void

  • Parameters

    • propertyKey: keyof T
    • newValue: any
    • OptionaloldValue: any

    Returns void

emitChanges

  • emitChanges(propertyKey?: keyof T, propertyValue?: any): 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

    Parameters

    • OptionalpropertyKey: keyof T
    • OptionalpropertyValue: any

    Returns void

get

  • get(propertyKey: keyof T): any

  • get value of propertyKey in current context

    Parameters

    • propertyKey: keyof T

    Returns any

getClass

getContext

  • getContext(): T

  • get current context object of this scope

    Returns T

OptionalgetContextProxy

  • getContextProxy(): T

  • get a proxy of the current context object if exists.

    Returns T

getInnerScope

  • getInnerScope<S extends Scope>(propertyKey: keyof T): undefined | S

  • get a scope for an object named as propertyKey from cache map,

    if the current value is not type od object, will return undefined.

    Type Parameters

    Parameters

    • propertyKey: keyof T

      the name of the property

    Returns undefined | S

ProtectedgetPropertyKeys

  • getPropertyKeys<V extends Record<PropertyKey, any>>(...objs: V[]): (keyof V)[]

  • Type Parameters

    • V extends Record<PropertyKey, any>

    Parameters

    • ...objs: V[]

    Returns (keyof V)[]

has

  • has(propertyKey: keyof T): boolean

  • is current context has propertyKey in hash map keys

    Parameters

    • propertyKey: keyof T

    Returns boolean

isAttached

  • isAttached(): boolean

  • get current stacte of applying change detection.

    Returns boolean

reattach

  • reattach(): void

  • apply all the not emitted changes, and continue emit in time.

    Returns void

set

  • set(
        propertyKey: keyof T,
        pipeClass: Type<AsyncPipeTransform<any, any>>,
        receiver?: any,
    ): boolean

  • Parameters

    Returns boolean

setInnerScope

  • setInnerScope<S extends Scope>(propertyKey: keyof T): S

  • create a scope with the same type of this scope

    Type Parameters

    Parameters

    • propertyKey: keyof T

    Returns S

  • setInnerScope<S extends Scope>(propertyKey: keyof T, scope?: S): S

  • sc

    Type Parameters

    Parameters

    • propertyKey: keyof T
    • Optionalscope: S

    Returns S

subscribe

unsubscribe

  • unsubscribe(propertyKey: keyof T, subscription?: ScopeSubscription<T>): void

  • Parameters

    Returns void

StaticblockScope

Staticfor

  • for<T extends Context>(
        context: T,
        propertyKeys?: (keyof T)[],
    ): ReactiveControlScope<T>

  • Type Parameters

    Parameters

    • context: T
    • OptionalpropertyKeys: (keyof T)[]

    Returns ReactiveControlScope<T>

StaticreactiveScopeForThis

  • reactiveScopeForThis<T extends Context>(
        ctx: T,
        propertyKeys?: (keyof T)[],
    ): Scope<{ this: T }>

  • Type Parameters

    Parameters

    • ctx: T
    • OptionalpropertyKeys: (keyof T)[]

    Returns Scope<{ this: T }>

StaticreadOnlyScopeForThis

  • readOnlyScopeForThis<T extends Context>(
        ctx: T,
        propertyKeys?: (keyof T)[],
    ): ReadOnlyScope<{ this: T }>

  • Type Parameters

    Parameters

    • ctx: T
    • OptionalpropertyKeys: (keyof T)[]

    Returns ReadOnlyScope<{ this: T }>

StaticscopeForThis

  • scopeForThis<T extends Context>(
        ctx: T,
        propertyKeys?: (keyof T)[],
    ): Scope<{ this: T }>

  • Type Parameters

    Parameters

    • ctx: T
    • OptionalpropertyKeys: (keyof T)[]

    Returns Scope<{ this: T }>

Settings

Member Visibility

On This Page

Constructors
Properties
Methods