Class TraitAbstract

constructor

• new Trait(): Trait

• Returns Trait

Readonly key

Readonly model

Readonly nextTrait

Optional Readonly observerType

Readonly previousTrait

Static Readonly InsertChildFlags

Static Readonly InsertTraitFlags

Static Readonly MountFlags

Static Readonly ReinsertChildFlags

Static Readonly RemoveChildFlags

Static Readonly RemoveTraitFlags

Static Readonly StartConsumingFlags

Static Readonly StopConsumingFlags

analyzing

• get analyzing(): boolean

• Returns boolean

consuming

• get consuming(): boolean

• Returns boolean

firstChild

• get firstChild(): Model

• Returns Model

firstTrait

• get firstTrait(): Trait

• Returns Trait

hostUri

• get hostUri(): Property<this, Uri, [Uri]>

• Returns Property<this, Uri, [Uri]>

insertChildFlags

• get insertChildFlags(): number

• Returns number

insertTraitFlags

• get insertTraitFlags(): number

• Returns number

inserting

• get inserting(): boolean

• Returns boolean

laneUri

• get laneUri(): Property<this, Uri, [Uri]>

• Returns Property<this, Uri, [Uri]>

lastChild

• get lastChild(): Model

• Returns Model

lastTrait

• get lastTrait(): Trait

• Returns Trait

modelFlags

• get modelFlags(): number

• Returns number

mountFlags

• get mountFlags(): number

• Returns number

mounted

• get mounted(): boolean

• Returns boolean

nextSibling

• get nextSibling(): Model

• Returns Model

nodeUri

• get nodeUri(): Property<this, Uri, [Uri]>

• Returns Property<this, Uri, [Uri]>

parent

• get parent(): Model

• Returns Model

previousSibling

• get previousSibling(): Model

• Returns Model

refreshing

• get refreshing(): boolean

• Returns boolean

reinsertChildFlags

• get reinsertChildFlags(): number

• Returns number

removeChildFlags

• get removeChildFlags(): number

• Returns number

removeTraitFlags

• get removeTraitFlags(): number

• Returns number

removing

• get removing(): boolean

• Returns boolean

startConsumingFlags

• get startConsumingFlags(): number

• Returns number

stopConsumingFlags

• get stopConsumingFlags(): number

• Returns number

updateTime

• get updateTime(): number

• Returns number

updating

• get updating(): boolean

• Returns boolean

warpRef

• get warpRef(): Property<this, WarpRef, [WarpRef]>

• Returns Property<this, WarpRef, [WarpRef]>

appendChild

• appendChild<F>(childFactory, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Model>> & Creatable<Instance<F, Model>>

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

• appendChild<M>(child, key?): M

• Type Parameters

  • M extends Model

  Parameters

  • child: M | LikeType<M>

  • Optional key: string

  Returns M

• appendChild(child, key?): Model

• Parameters

  • child: Model | {
        create?() => Model;
    }

  • Optional key: string

  Returns Model

appendTrait

• appendTrait<F>(childFactory, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Trait>> & Creatable<Instance<F, Trait>>

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

• appendTrait<T>(trait, key?): T

• Type Parameters

  • T extends Trait

  Parameters

  • trait: T | LikeType<T>

  • Optional key: string

  Returns T

• appendTrait(trait, key?): Trait

• Parameters

  • trait: Trait | {
        create?() => Trait;
    }

  • Optional key: string

  Returns Trait

attachFastener

• attachFastener(fastener): void

• Parameters

  • fastener: Fastener<any, any, [any]>

  Returns void

authenticate

• authenticate(hostUri, credentials): void

• Parameters

  • hostUri: UriLike

  • credentials: ValueLike

  Returns void

• authenticate(credentials): void

• Parameters

  • credentials: ValueLike

  Returns void

callObservers

• callObservers<O, K>(this, key, ...args): void

• Type Parameters

  • O

  • K extends string | number | symbol

  Parameters

  • this: {
        observerType?: Class<O>;
    }

    • Optional Readonly observerType?: Class<O>

  • key: K

  • Rest ...args: ObserverParameters<O, K>

  Returns void

command

• command(hostUri, nodeUri, laneUri, body): void

• Parameters

  • hostUri: UriLike

  • nodeUri: UriLike

  • laneUri: UriLike

  • body: ValueLike

  Returns void

• command(nodeUri, laneUri, body): void

• Parameters

  • nodeUri: UriLike

  • laneUri: UriLike

  • body: ValueLike

  Returns void

• command(laneUri, body): void

• Parameters

  • laneUri: UriLike

  • body: ValueLike

  Returns void

• command(body): void

• Parameters

  • body: ValueLike

  Returns void

consume

• consume(consumer): void

• Parameters

  • consumer: unknown

  Returns void

decohereFastener

• decohereFastener(fastener): void

• Parameters

  • fastener: Fastener<any, any, [any]>

  Returns void

downlink

• downlink(template?): EventDownlink<WarpRef, any, [any]>

• Parameters

  • Optional template: ThisType<EventDownlink<WarpRef, any, [any]>> & EventDownlinkDescriptor<WarpRef> & Partial<Omit<EventDownlink<WarpRef, any, [any]>, keyof EventDownlinkDescriptor<WarpRef>>> & {
        inletKeys?: readonly (keyof WarpRef)[];
    }

  Returns EventDownlink<WarpRef, any, [any]>

downlinkList

• downlinkList<V>(template?): ListDownlink<WarpRef, V, [Iterable<V>]>

• Type Parameters

  • V = Value

  Parameters

  • Optional template: ThisType<ListDownlink<WarpRef, V, [Iterable<V>]>> & ListDownlinkDescriptor<WarpRef, V> & Partial<Omit<ListDownlink<WarpRef, V, [Iterable<V>]>, keyof ListDownlinkDescriptor<WarpRef, V>>> & {
        inletKeys?: readonly (keyof WarpRef)[];
    }

  Returns ListDownlink<WarpRef, V, [Iterable<V>]>

downlinkMap

• downlinkMap<K, V>(template?): MapDownlink<WarpRef, K, V, [Iterable<[K, V]>]>

• Type Parameters

  • K = Value

  • V = Value

  Parameters

  • Optional template: ThisType<MapDownlink<WarpRef, K, V, [Iterable<[K, V]>]>> & MapDownlinkDescriptor<WarpRef, K, V> & Partial<Omit<MapDownlink<WarpRef, K, V, [Iterable<[K, V]>]>, keyof MapDownlinkDescriptor<WarpRef, K, V>>> & {
        inletKeys?: readonly (keyof WarpRef)[];
    }

  Returns MapDownlink<WarpRef, K, V, [Iterable<[K, V]>]>

downlinkValue

• downlinkValue<V>(template?): ValueDownlink<WarpRef, V, [V]>

• Type Parameters

  • V = Value

  Parameters

  • Optional template: ThisType<ValueDownlink<WarpRef, V, [V]>> & ValueDownlinkDescriptor<WarpRef, V> & Partial<Omit<ValueDownlink<WarpRef, V, [V]>, keyof ValueDownlinkDescriptor<WarpRef, V>>> & {
        inletKeys?: readonly (keyof WarpRef)[];
    }

  Returns ValueDownlink<WarpRef, V, [V]>

equals

• equals(that): boolean

• Parameters

  • that: unknown

  Returns boolean

findTrait

• findTrait<F>(key, traitClass): InstanceType<F>

• Type Parameters

  • F extends Class<Trait>

  Parameters

  • key: string

  • traitClass: F

  Returns InstanceType<F>

• findTrait(key, traitClass): Trait

• Parameters

  • key: string

  • traitClass: Class<Trait>

  Returns Trait

forEachChild

• forEachChild<T>(callback): T

• Type Parameters

  • T

  Parameters

  • callback: ((child) => void | T)

    • • (child): void | T

      • Parameters

        • child: Model

        Returns void | T

  Returns T

• forEachChild<T, S>(callback, thisArg): T

• Type Parameters

  • T

  • S

  Parameters

  • callback: ((this, child) => void | T)

    • • (this, child): void | T

      • Parameters

        • this: S

        • child: Model

        Returns void | T

  • thisArg: S

  Returns T

forEachTrait

• forEachTrait<T>(callback): T

• Type Parameters

  • T

  Parameters

  • callback: ((trait) => void | T)

    • • (trait): void | T

      • Parameters

        • trait: Trait

        Returns void | T

  Returns T

• forEachTrait<T, S>(callback, thisArg): T

• Type Parameters

  • T

  • S

  Parameters

  • callback: ((this, trait) => void | T)

    • • (this, trait): void | T

      • Parameters

        • this: S

        • trait: Trait

        Returns void | T

  • thisArg: S

  Returns T

getAncestor

• getAncestor<F>(ancestorType): InstanceType<F>

• Type Parameters

  • F extends Class<Model>

  Parameters

  • ancestorType: F

  Returns InstanceType<F>

getAncestorTrait

• getAncestorTrait<F>(ancestorType): InstanceType<F>

• Type Parameters

  • F extends Class<Trait>

  Parameters

  • ancestorType: F

  Returns InstanceType<F>

getChild

• getChild<F>(key, childType): InstanceType<F>

• Type Parameters

  • F extends Class<Model>

  Parameters

  • key: string

  • childType: F

  Returns InstanceType<F>

• getChild(key, childType?): Model

• Parameters

  • key: string

  • Optional childType: Class<Model>

  Returns Model

getFastener

• getFastener<F>(fastenerName, fastenerType?, contextType?): F

• Type Parameters

  • F extends Fastener<any, any, [any]>

  Parameters

  • fastenerName: PropertyKey

  • Optional fastenerType: Proto<F>

  • Optional contextType: Proto<any>

  Returns F

getModel

• getModel(): Model

• Returns Model

getParentFastener

• getParentFastener<F>(fastenerName, fastenerType?, contextType?): F

• Type Parameters

  • F extends Fastener<any, any, [any]>

  Parameters

  • fastenerName: string

  • Optional fastenerType: Proto<F>

  • Optional contextType: Proto<any>

  Returns F

getRoot

• getRoot<F>(rootType): InstanceType<F>

• Type Parameters

  • F extends Class<Model>

  Parameters

  • rootType: F

  Returns InstanceType<F>

getRootTrait

• getRootTrait<F>(rootType): InstanceType<F>

• Type Parameters

  • F extends Class<Trait>

  Parameters

  • rootType: F

  Returns InstanceType<F>

getTargetChild

• getTargetChild(child, comparator): Model

• Parameters

  • child: Model

  • comparator: Comparator<Model>

  Returns Model

getTrait

• getTrait<F>(key, traitClass): InstanceType<F>

• Type Parameters

  • F extends Class<Trait>

  Parameters

  • key: string

  • traitClass: F

  Returns InstanceType<F>

• getTrait(key, traitClass?): Trait

• Parameters

  • key: string

  • Optional traitClass: Class<Trait>

  Returns Trait

• getTrait<F>(traitClass): InstanceType<F>

• Type Parameters

  • F extends Class<Trait>

  Parameters

  • traitClass: F

  Returns InstanceType<F>

hashCode

• hashCode(): number

• Returns number

hostRef

• hostRef(hostUri): WarpRef

• Parameters

  • hostUri: UriLike

  Returns WarpRef

insertChild

• insertChild<F>(childFactory, target, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Model>> & Creatable<Instance<F, Model>>

  Parameters

  • childFactory: F

  • target: Model

  • Optional key: string

  Returns InstanceType<F>

• insertChild<M>(child, target, key?): M

• Type Parameters

  • M extends Model

  Parameters

  • child: M | LikeType<M>

  • target: Model

  • Optional key: string

  Returns M

• insertChild(child, target, key?): Model

• Parameters

  • child: Model | {
        create?() => Model;
    }

  • target: Model

  • Optional key: string

  Returns Model

insertTrait

• insertTrait<F>(childFactory, target, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Trait>> & Creatable<Instance<F, Trait>>

  Parameters

  • childFactory: F

  • target: Trait

  • Optional key: string

  Returns InstanceType<F>

• insertTrait<T>(trait, target, key?): T

• Type Parameters

  • T extends Trait

  Parameters

  • trait: T | LikeType<T>

  • target: Trait

  • Optional key: string

  Returns T

• insertTrait(trait, target, key?): Trait

• Parameters

  • trait: Trait | {
        create?() => Trait;
    }

  • target: Trait

  • Optional key: string

  Returns Trait

laneRef

• laneRef(hostUri, nodeUri, laneUri): WarpRef

• Parameters

  • hostUri: UriLike

  • nodeUri: UriLike

  • laneUri: UriLike

  Returns WarpRef

• laneRef(nodeUri, laneUri): WarpRef

• Parameters

  • nodeUri: UriLike

  • laneUri: UriLike

  Returns WarpRef

• laneRef(laneUri): WarpRef

• Parameters

  • laneUri: UriLike

  Returns WarpRef

Optional likeType

• likeType(like): void

• Parameters

  • like: {
        create?() => Trait;
    }

    • create?:function

      • create(): Trait

      • Returns Trait

  Returns void

nodeRef

• nodeRef(hostUri, nodeUri): WarpRef

• Parameters

  • hostUri: UriLike

  • nodeUri: UriLike

  Returns WarpRef

• nodeRef(nodeUri): WarpRef

• Parameters

  • nodeUri: UriLike

  Returns WarpRef

observe

• observe(observer): void

• Parameters

  • observer: TraitObserver<Trait>

  Returns void

prependChild

• prependChild<F>(childFactory, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Model>> & Creatable<Instance<F, Model>>

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

• prependChild<M>(child, key?): M

• Type Parameters

  • M extends Model

  Parameters

  • child: M | LikeType<M>

  • Optional key: string

  Returns M

• prependChild(child, key?): Model

• Parameters

  • child: Model | {
        create?() => Model;
    }

  • Optional key: string

  Returns Model

prependTrait

• prependTrait<F>(childFactory, key?): InstanceType<F>

• Type Parameters

  • F extends Class<Instance<F, Trait>> & Creatable<Instance<F, Trait>>

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

• prependTrait<T>(trait, key?): T

• Type Parameters

  • T extends Trait

  Parameters

  • trait: T | LikeType<T>

  • Optional key: string

  Returns T

• prependTrait(trait, key?): Trait

• Parameters

  • trait: Trait | {
        create?() => Trait;
    }

  • Optional key: string

  Returns Trait

reinsertChild

• reinsertChild(child, target): void

• Parameters

  • child: Model

  • target: Model

  Returns void

remove

• remove(): void

• Returns void

removeChild

• removeChild<M>(child): M

• Type Parameters

  • M extends Model

  Parameters

  • child: M

  Returns M

• removeChild(key): Model

• Parameters

  • key: string | Model

  Returns Model

removeChildren

• removeChildren(): void

• Returns void

removeTrait

• removeTrait<T>(trait): T

• Type Parameters

  • T extends Trait

  Parameters

  • trait: T

  Returns T

• removeTrait(key): Trait

• Parameters

  • key: string | Trait

  Returns Trait

replaceChild

• replaceChild<M>(newChild, oldChild): M

• Type Parameters

  • M extends Model

  Parameters

  • newChild: Model

  • oldChild: M

  Returns M

• replaceChild<M>(newChild, oldChild): M

• Type Parameters

  • M extends Model

  Parameters

  • newChild: Model | {
        create?() => Model;
    }

  • oldChild: M

  Returns M

• replaceChild(newChild, oldChild): Model

• Parameters

  • newChild: Model | {
        create?() => Model;
    }

  • oldChild: Model

  Returns Model

replaceTrait

• replaceTrait<F>(newChildFactory, oldTrait): Trait

• Type Parameters

  • F extends Class<Instance<F, Trait>> & Creatable<Instance<F, Trait>>

  Parameters

  • newChildFactory: F

  • oldTrait: Trait

  Returns Trait

• replaceTrait<T>(newTrait, oldTrait): T

• Type Parameters

  • T extends Trait

  Parameters

  • newTrait: Trait | {
        create?() => Trait;
    }

  • oldTrait: T

  Returns T

• replaceTrait(newTrait, oldTrait): Trait

• Parameters

  • newTrait: Trait | {
        create?() => Trait;
    }

  • oldTrait: Trait

  Returns Trait

requestUpdate

• requestUpdate(target, updateFlags, immediate): void

• Parameters

  • target: Model

  • updateFlags: number

  • immediate: boolean

  Returns void

requireUpdate

• requireUpdate(updateFlags, immediate?): void

• Parameters

  • updateFlags: number

  • Optional immediate: boolean

  Returns void

set

• set<S>(this, properties, timing?): Trait

• Type Parameters

  • S

  Parameters

  • this: S

  • properties: {
        [K in string | number | symbol as S[K] extends {
                set(value) => any;
            }
            ? K
            : never]?: S[K] extends {
                set(value) => any;
            }
            ? T
            : never
    }

  • Optional timing: boolean | TimingLike

  Returns Trait

setChild

• setChild<F>(key, newChildFactory): Model

• Type Parameters

  • F extends Class<Instance<F, Model>> & Creatable<Instance<F, Model>>

  Parameters

  • key: string

  • newChildFactory: F

  Returns Model

• setChild(key, newChild): Model

• Parameters

  • key: string

  • newChild: Model | {
        create?() => Model;
    }

  Returns Model

setFlags

• setFlags(flags): void

• Parameters

  • flags: number

  Returns void

setIntrinsic

• setIntrinsic<S>(this, properties, timing?): Trait

• Type Parameters

  • S

  Parameters

  • this: S

  • properties: {
        [K in string | number | symbol as S[K] extends {
                setIntrinsic(value) => any;
            }
            ? K
            : never]?: S[K] extends {
                setIntrinsic(value) => any;
            }
            ? T
            : never
    }

  • Optional timing: boolean | TimingLike

  Returns Trait

setModelFlags

• setModelFlags(modelFlags): void

• Parameters

  • modelFlags: number

  Returns void

setTrait

• setTrait<F>(key, newChildFactory): Trait

• Type Parameters

  • F extends Class<Instance<F, Trait>> & Creatable<Instance<F, Trait>>

  Parameters

  • key: string

  • newChildFactory: F

  Returns Trait

• setTrait(key, newTrait): Trait

• Parameters

  • key: string

  • newTrait: Trait | {
        create?() => Trait;
    }

  Returns Trait